oncrpc/clnt_per.c

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