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