moved from ../osf1
[kopensolaris-gnu/glibc.git] / sunrpc / clnt_perr.c
1 /* @(#)clnt_perror.c    2.1 88/07/29 4.0 RPCSRC */
2 /*
3  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
4  * unrestricted use provided that this legend is included on all tape
5  * media and as a part of the software program in whole or part.  Users
6  * may copy or modify Sun RPC without charge, but are not authorized
7  * to license or distribute it to anyone else except as part of a product or
8  * program developed by the user.
9  * 
10  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
11  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
12  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
13  * 
14  * Sun RPC is provided with no support and without any obligation on the
15  * part of Sun Microsystems, Inc. to assist in its use, correction,
16  * modification or enhancement.
17  * 
18  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
19  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
20  * OR ANY PART THEREOF.
21  * 
22  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
23  * or profits or other special, indirect and consequential damages, even if
24  * Sun has been advised of the possibility of such damages.
25  * 
26  * Sun Microsystems, Inc.
27  * 2550 Garcia Avenue
28  * Mountain View, California  94043
29  */
30 #if !defined(lint) && defined(SCCSIDS)
31 static char sccsid[] = "@(#)clnt_perror.c 1.15 87/10/07 Copyr 1984 Sun Micro";
32 #endif
33
34 /*
35  * clnt_perror.c
36  *
37  * Copyright (C) 1984, Sun Microsystems, Inc.
38  *
39  */
40 #include <stdio.h>
41
42 #include <rpc/types.h>
43 #include <rpc/auth.h>
44 #include <rpc/clnt.h>
45
46 extern char *sys_errlist[];
47 /* extern char *sprintf(); --roland@gnu */
48 static char *auth_errmsg();
49
50 extern char *strcpy();
51
52 static char *buf;
53
54 static char *
55 _buf()
56 {
57
58         if (buf == 0)
59                 buf = (char *)malloc(256);
60         return (buf);
61 }
62
63 /*
64  * Print reply error info
65  */
66 char *
67 clnt_sperror(rpch, s)
68         CLIENT *rpch;
69         char *s;
70 {
71         struct rpc_err e;
72         void clnt_perrno();
73         char *err;
74         char *str = _buf();
75         char *strstart = str;
76
77         if (str == 0)
78                 return (0);
79         CLNT_GETERR(rpch, &e);
80
81         (void) sprintf(str, "%s: ", s);  
82         str += strlen(str);
83
84         (void) strcpy(str, clnt_sperrno(e.re_status));  
85         str += strlen(str);
86
87         switch (e.re_status) {
88         case RPC_SUCCESS:
89         case RPC_CANTENCODEARGS:
90         case RPC_CANTDECODERES:
91         case RPC_TIMEDOUT:     
92         case RPC_PROGUNAVAIL:
93         case RPC_PROCUNAVAIL:
94         case RPC_CANTDECODEARGS:
95         case RPC_SYSTEMERROR:
96         case RPC_UNKNOWNHOST:
97         case RPC_UNKNOWNPROTO:
98         case RPC_PMAPFAILURE:
99         case RPC_PROGNOTREGISTERED:
100         case RPC_FAILED:
101                 break;
102
103         case RPC_CANTSEND:
104         case RPC_CANTRECV:
105                 (void) sprintf(str, "; errno = %s",
106                     sys_errlist[e.re_errno]); 
107                 str += strlen(str);
108                 break;
109
110         case RPC_VERSMISMATCH:
111                 (void) sprintf(str,
112                         "; low version = %lu, high version = %lu", 
113                         e.re_vers.low, e.re_vers.high);
114                 str += strlen(str);
115                 break;
116
117         case RPC_AUTHERROR:
118                 err = auth_errmsg(e.re_why);
119                 (void) sprintf(str,"; why = ");
120                 str += strlen(str);
121                 if (err != NULL) {
122                         (void) sprintf(str, "%s",err);
123                 } else {
124                         (void) sprintf(str,
125                                 "(unknown authentication error - %d)",
126                                 (int) e.re_why);
127                 }
128                 str += strlen(str);
129                 break;
130
131         case RPC_PROGVERSMISMATCH:
132                 (void) sprintf(str, 
133                         "; low version = %lu, high version = %lu", 
134                         e.re_vers.low, e.re_vers.high);
135                 str += strlen(str);
136                 break;
137
138         default:        /* unknown */
139                 (void) sprintf(str, 
140                         "; s1 = %lu, s2 = %lu", 
141                         e.re_lb.s1, e.re_lb.s2);
142                 str += strlen(str);
143                 break;
144         }
145         (void) sprintf(str, "\n");
146         return(strstart) ;
147 }
148
149 void
150 clnt_perror(rpch, s)
151         CLIENT *rpch;
152         char *s;
153 {
154         (void) fprintf(stderr,"%s",clnt_sperror(rpch,s));
155 }
156
157
158 struct rpc_errtab {
159         enum clnt_stat status;
160         char *message;
161 };
162
163 static struct rpc_errtab  rpc_errlist[] = {
164         { RPC_SUCCESS, 
165                 "RPC: Success" }, 
166         { RPC_CANTENCODEARGS, 
167                 "RPC: Can't encode arguments" },
168         { RPC_CANTDECODERES, 
169                 "RPC: Can't decode result" },
170         { RPC_CANTSEND, 
171                 "RPC: Unable to send" },
172         { RPC_CANTRECV, 
173                 "RPC: Unable to receive" },
174         { RPC_TIMEDOUT, 
175                 "RPC: Timed out" },
176         { RPC_VERSMISMATCH, 
177                 "RPC: Incompatible versions of RPC" },
178         { RPC_AUTHERROR, 
179                 "RPC: Authentication error" },
180         { RPC_PROGUNAVAIL, 
181                 "RPC: Program unavailable" },
182         { RPC_PROGVERSMISMATCH, 
183                 "RPC: Program/version mismatch" },
184         { RPC_PROCUNAVAIL, 
185                 "RPC: Procedure unavailable" },
186         { RPC_CANTDECODEARGS, 
187                 "RPC: Server can't decode arguments" },
188         { RPC_SYSTEMERROR, 
189                 "RPC: Remote system error" },
190         { RPC_UNKNOWNHOST, 
191                 "RPC: Unknown host" },
192         { RPC_UNKNOWNPROTO,
193                 "RPC: Unknown protocol" },
194         { RPC_PMAPFAILURE, 
195                 "RPC: Port mapper failure" },
196         { RPC_PROGNOTREGISTERED, 
197                 "RPC: Program not registered"},
198         { RPC_FAILED, 
199                 "RPC: Failed (unspecified error)"}
200 };
201
202
203 /*
204  * This interface for use by clntrpc
205  */
206 char *
207 clnt_sperrno(stat)
208         enum clnt_stat stat;
209 {
210         int i;
211
212         for (i = 0; i < sizeof(rpc_errlist)/sizeof(struct rpc_errtab); i++) {
213                 if (rpc_errlist[i].status == stat) {
214                         return (rpc_errlist[i].message);
215                 }
216         }
217         return ("RPC: (unknown error code)");
218 }
219
220 void
221 clnt_perrno(num)
222         enum clnt_stat num;
223 {
224         (void) fprintf(stderr,"%s",clnt_sperrno(num));
225 }
226
227
228 char *
229 clnt_spcreateerror(s)
230         char *s;
231 {
232         extern int sys_nerr;
233         extern char *sys_errlist[];
234         char *str = _buf();
235
236         if (str == 0)
237                 return(0);
238         (void) sprintf(str, "%s: ", s);
239         (void) strcat(str, clnt_sperrno(rpc_createerr.cf_stat));
240         switch (rpc_createerr.cf_stat) {
241         case RPC_PMAPFAILURE:
242                 (void) strcat(str, " - ");
243                 (void) strcat(str,
244                     clnt_sperrno(rpc_createerr.cf_error.re_status));
245                 break;
246
247         case RPC_SYSTEMERROR:
248                 (void) strcat(str, " - ");
249                 if (rpc_createerr.cf_error.re_errno > 0
250                     && rpc_createerr.cf_error.re_errno < sys_nerr)
251                         (void) strcat(str,
252                             sys_errlist[rpc_createerr.cf_error.re_errno]);
253                 else
254                         (void) sprintf(&str[strlen(str)], "Error %d",
255                             rpc_createerr.cf_error.re_errno);
256                 break;
257         }
258         (void) strcat(str, "\n");
259         return (str);
260 }
261
262 void
263 clnt_pcreateerror(s)
264         char *s;
265 {
266         (void) fprintf(stderr,"%s",clnt_spcreateerror(s));
267 }
268
269 struct auth_errtab {
270         enum auth_stat status;  
271         char *message;
272 };
273
274 static struct auth_errtab auth_errlist[] = {
275         { AUTH_OK,
276                 "Authentication OK" },
277         { AUTH_BADCRED,
278                 "Invalid client credential" },
279         { AUTH_REJECTEDCRED,
280                 "Server rejected credential" },
281         { AUTH_BADVERF,
282                 "Invalid client verifier" },
283         { AUTH_REJECTEDVERF,
284                 "Server rejected verifier" },
285         { AUTH_TOOWEAK,
286                 "Client credential too weak" },
287         { AUTH_INVALIDRESP,
288                 "Invalid server verifier" },
289         { AUTH_FAILED,
290                 "Failed (unspecified error)" },
291 };
292
293 static char *
294 auth_errmsg(stat)
295         enum auth_stat stat;
296 {
297         int i;
298
299         for (i = 0; i < sizeof(auth_errlist)/sizeof(struct auth_errtab); i++) {
300                 if (auth_errlist[i].status == stat) {
301                         return(auth_errlist[i].message);
302                 }
303         }
304         return(NULL);
305 }