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/types.h>
  57 #include <rpc/auth.h>
  58 #include <rpc/clnt.h>
  59
  60 #ifndef WIN32
  61 extern char *sys_errlist[];
  62 #ifdef NEED_SPRINTF
  63 extern char *sprintf();
  64 #endif
  65 #endif
  66 static char *auth_errmsg();
  67
  68 extern char *strcpy();
  69
  70 static char *buf;
  71
  72 static char *
  73 _buf()
  74 {
  75
  76         if (buf == 0)
  77                 buf = (char *)malloc(256);
  78         return (buf);
  79 }
  80
  81 /*
  82  * Print reply error info
  83  */
  84 char *
  85 clnt_sperror(rpch, s)
  86         CLIENT *rpch;
  87         char *s;
  88 {
  89         struct rpc_err e;
  90         void clnt_perrno();
  91         char *err;
  92         char *str = _buf();
  93         char *strstart = str;
  94
  95         if (str == 0)
  96                 return (0);
  97         CLNT_GETERR(rpch, &e);
  98
  99         (void) sprintf(str, "%s: ", s);
 100         str += strlen(str);
 101
 102         (void) strcpy(str, clnt_sperrno(e.re_status));
 103         str += strlen(str);
 104
 105         switch (e.re_status) {
 106         case RPC_SUCCESS:
 107         case RPC_CANTENCODEARGS:
 108         case RPC_CANTDECODERES:
 109         case RPC_TIMEDOUT:
 110         case RPC_PROGUNAVAIL:
 111         case RPC_PROCUNAVAIL:
 112         case RPC_CANTDECODEARGS:
 113         case RPC_SYSTEMERROR:
 114         case RPC_UNKNOWNHOST:
 115         case RPC_UNKNOWNPROTO:
 116         case RPC_PMAPFAILURE:
 117         case RPC_PROGNOTREGISTERED:
 118         case RPC_FAILED:
 119                 break;
 120
 121         case RPC_CANTSEND:
 122         case RPC_CANTRECV:
 123 #ifdef WIN32
 124                 if (e.re_errno < sys_nerr)
 125 #endif
 126                         (void) sprintf(str, "; errno = %s",
 127                             sys_errlist[e.re_errno]);
 128 #ifdef WIN32
 129                 else
 130                         (void) sprintf(str, "Error %d, ", e.re_errno);
 131 #endif
 132                 str += strlen(str);
 133                 break;
 134
 135         case RPC_VERSMISMATCH:
 136                 (void) sprintf(str,
 137                         "; low version = %lu, high version = %lu",
 138                         e.re_vers.low, e.re_vers.high);
 139                 str += strlen(str);
 140                 break;
 141
 142         case RPC_AUTHERROR:
 143                 err = auth_errmsg(e.re_why);
 144                 (void) sprintf(str,"; why = ");
 145                 str += strlen(str);
 146                 if (err != NULL) {
 147                         (void) sprintf(str, "%s",err);
 148                 } else {
 149                         (void) sprintf(str,
 150                                 "(unknown authentication error - %d)",
 151                                 (int) e.re_why);
 152                 }
 153                 str += strlen(str);
 154                 break;
 155
 156         case RPC_PROGVERSMISMATCH:
 157                 (void) sprintf(str,
 158                         "; low version = %lu, high version = %lu",
 159                         e.re_vers.low, e.re_vers.high);
 160                 str += strlen(str);
 161                 break;
 162
 163         default:        /* unknown */
 164                 (void) sprintf(str,
 165                         "; s1 = %lu, s2 = %lu",
 166                         e.re_lb.s1, e.re_lb.s2);
 167                 str += strlen(str);
 168                 break;
 169         }
 170         (void) sprintf(str, "\n");
 171         return(strstart) ;
 172 }
 173
 174 void
 175 clnt_perror(rpch, s)
 176         CLIENT *rpch;
 177         char *s;
 178 {
 179 #ifdef WIN32
 180         nt_rpc_report(clnt_sperror(rpch,s));
 181 #else
 182         (void) fprintf(stderr,"%s",clnt_sperror(rpch,s));
 183 #endif
 184 }
 185
 186
 187 struct rpc_errtab {
 188         enum clnt_stat status;
 189         char *message;
 190 };
 191
 192 static struct rpc_errtab  rpc_errlist[] = {
 193         { RPC_SUCCESS,
 194                 "RPC: Success" },
 195         { RPC_CANTENCODEARGS,
 196                 "RPC: Can't encode arguments" },
 197         { RPC_CANTDECODERES,
 198                 "RPC: Can't decode result" },
 199         { RPC_CANTSEND,
 200                 "RPC: Unable to send" },
 201         { RPC_CANTRECV,
 202                 "RPC: Unable to receive" },
 203         { RPC_TIMEDOUT,
 204                 "RPC: Timed out" },
 205         { RPC_VERSMISMATCH,
 206                 "RPC: Incompatible versions of RPC" },
 207         { RPC_AUTHERROR,
 208                 "RPC: Authentication error" },
 209         { RPC_PROGUNAVAIL,
 210                 "RPC: Program unavailable" },
 211         { RPC_PROGVERSMISMATCH,
 212                 "RPC: Program/version mismatch" },
 213         { RPC_PROCUNAVAIL,
 214                 "RPC: Procedure unavailable" },
 215         { RPC_CANTDECODEARGS,
 216                 "RPC: Server can't decode arguments" },
 217         { RPC_SYSTEMERROR,
 218                 "RPC: Remote system error" },
 219         { RPC_UNKNOWNHOST,
 220                 "RPC: Unknown host" },
 221         { RPC_UNKNOWNPROTO,
 222                 "RPC: Unknown protocol" },
 223         { RPC_PMAPFAILURE,
 224                 "RPC: Port mapper failure" },
 225         { RPC_PROGNOTREGISTERED,
 226                 "RPC: Program not registered"},
 227         { RPC_FAILED,
 228                 "RPC: Failed (unspecified error)"}
 229 };
 230
 231
 232 /*
 233  * This interface for use by clntrpc
 234  */
 235 char *
 236 clnt_sperrno(stat)
 237         enum clnt_stat stat;
 238 {
 239         int i;
 240
 241         for (i = 0; i < sizeof(rpc_errlist)/sizeof(struct rpc_errtab); i++) {
 242                 if (rpc_errlist[i].status == stat) {
 243                         return (rpc_errlist[i].message);
 244                 }
 245         }
 246         return ("RPC: (unknown error code)");
 247 }
 248
 249 void
 250 clnt_perrno(num)
 251         enum clnt_stat num;
 252 {
 253 #ifdef WIN32
 254         nt_rpc_report(clnt_sperrno(num));
 255 #else
 256         (void) fprintf(stderr,"%s",clnt_sperrno(num));
 257 #endif
 258 }
 259
 260
 261 char *
 262 clnt_spcreateerror(s)
 263         char *s;
 264 {
 265         extern int sys_nerr;
 266 #ifndef WIN32
 267         extern char *sys_errlist[];
 268 #endif
 269         char *str = _buf();
 270
 271         if (str == 0)
 272                 return(0);
 273         (void) sprintf(str, "%s: ", s);
 274         (void) strcat(str, clnt_sperrno(rpc_createerr.cf_stat));
 275         switch (rpc_createerr.cf_stat) {
 276         case RPC_PMAPFAILURE:
 277                 (void) strcat(str, " - ");
 278                 (void) strcat(str,
 279                     clnt_sperrno(rpc_createerr.cf_error.re_status));
 280                 break;
 281
 282         case RPC_SYSTEMERROR:
 283                 (void) strcat(str, " - ");
 284                 if (rpc_createerr.cf_error.re_errno > 0
 285                     && rpc_createerr.cf_error.re_errno < sys_nerr)
 286                         (void) strcat(str,
 287 #ifdef WIN32
 288                             "internal rpc error");
 289 #else
 290                             sys_errlist[rpc_createerr.cf_error.re_errno]);
 291 #endif
 292                 else
 293                         (void) sprintf(&str[strlen(str)], "Error %d",
 294                             rpc_createerr.cf_error.re_errno);
 295                 break;
 296         }
 297         (void) strcat(str, "\n");
 298         return (str);
 299 }
 300
 301 void
 302 clnt_pcreateerror(s)
 303         char *s;
 304 {
 305 #ifdef WIN32
 306         nt_rpc_report(clnt_spcreateerror(s));
 307 #else
 308         (void) fprintf(stderr,"%s",clnt_spcreateerror(s));
 309 #endif
 310 }
 311
 312 struct auth_errtab {
 313         enum auth_stat status;
 314         char *message;
 315 };
 316
 317 static struct auth_errtab auth_errlist[] = {
 318         { AUTH_OK,
 319                 "Authentication OK" },
 320         { AUTH_BADCRED,
 321                 "Invalid client credential" },
 322         { AUTH_REJECTEDCRED,
 323                 "Server rejected credential" },
 324         { AUTH_BADVERF,
 325                 "Invalid client verifier" },
 326         { AUTH_REJECTEDVERF,
 327                 "Server rejected verifier" },
 328         { AUTH_TOOWEAK,
 329                 "Client credential too weak" },
 330         { AUTH_INVALIDRESP,
 331                 "Invalid server verifier" },
 332         { AUTH_FAILED,
 333                 "Failed (unspecified error)" },
 334 };
 335
 336 static char *
 337 auth_errmsg(stat)
 338         enum auth_stat stat;
 339 {
 340         int i;
 341
 342         for (i = 0; i < sizeof(auth_errlist)/sizeof(struct auth_errtab); i++) {
 343                 if (auth_errlist[i].status == stat) {
 344                         return(auth_errlist[i].message);
 345                 }
 346         }
 347         return(NULL);
 348 }