home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / comm / tcp / amitcp-sdk / src / rpclib / clnt_perror.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-29  |  5.4 KB  |  280 lines
  1. /*
  2.  *      $Id: clnt_perror.c,v 4.2 1994/09/29 23:48:50 jraja Exp $
  3.  *
  4.  *      Copyright © 1994 AmiTCP/IP Group,
  5.  *                       Network Solutions Development Inc.
  6.  *                       All rights reserved. 
  7.  */
  8.  
  9. /* @(#)clnt_perror.c    2.1 88/07/29 4.0 RPCSRC */
  10. #if !defined(lint) && defined(SCCSIDS)
  11. static char sccsid[] = "@(#)clnt_perror.c 1.15 87/10/07 Copyr 1984 Sun Micro";
  12. #endif
  13.  
  14. /*
  15.  * Copyright (C) 1984, Sun Microsystems, Inc.
  16.  */
  17. #include <sys/param.h>
  18. #include <rpc/types.h>
  19. #include <rpc/xdr.h>
  20. #include <rpc/auth.h>
  21. #include <rpc/clnt.h>
  22. #include <stdio.h>
  23. #include <errno.h>
  24.  
  25.  
  26. static char *auth_errmsg(enum auth_stat stat);
  27.  
  28. static char *buf;
  29.  
  30. static char *
  31. _buf(void)
  32. {
  33.  
  34.     if (buf == 0)
  35.         buf = (char *)mem_alloc(256);
  36.     return (buf);
  37. }
  38.  
  39. /*
  40.  * Print reply error info
  41.  */
  42. char *
  43. clnt_sperror(rpch, s)
  44.     CLIENT *rpch;
  45.     char *s;
  46. {
  47.     struct rpc_err e;
  48.     void clnt_perrno();
  49.     char *err;
  50.     char *str = _buf();
  51.     char *strstart = str;
  52.  
  53.     if (str == 0)
  54.         return (0);
  55.     CLNT_GETERR(rpch, &e);
  56.  
  57.     (void) sprintf(str, "%s: ", s);  
  58.     str += strlen(str);
  59.  
  60.     (void) strcpy(str, clnt_sperrno(e.re_status));  
  61.     str += strlen(str);
  62.  
  63.     switch (e.re_status) {
  64.     case RPC_SUCCESS:
  65.     case RPC_CANTENCODEARGS:
  66.     case RPC_CANTDECODERES:
  67.     case RPC_TIMEDOUT:     
  68.     case RPC_PROGUNAVAIL:
  69.     case RPC_PROCUNAVAIL:
  70.     case RPC_CANTDECODEARGS:
  71.     case RPC_SYSTEMERROR:
  72.     case RPC_UNKNOWNHOST:
  73.     case RPC_UNKNOWNPROTO:
  74.     case RPC_PMAPFAILURE:
  75.     case RPC_PROGNOTREGISTERED:
  76.     case RPC_FAILED:
  77.         break;
  78.  
  79.     case RPC_CANTSEND:
  80.     case RPC_CANTRECV:
  81.         (void) sprintf(str, "; errno = %s",
  82.             strerror(e.re_errno)); 
  83.         str += strlen(str);
  84.         break;
  85.  
  86.     case RPC_VERSMISMATCH:
  87.         (void) sprintf(str,
  88.             "; low version = %lu, high version = %lu", 
  89.             e.re_vers.low, e.re_vers.high);
  90.         str += strlen(str);
  91.         break;
  92.  
  93.     case RPC_AUTHERROR:
  94.         err = auth_errmsg(e.re_why);
  95.         (void) sprintf(str,"; why = ");
  96.         str += strlen(str);
  97.         if (err != NULL) {
  98.             (void) sprintf(str, "%s",err);
  99.         } else {
  100.             (void) sprintf(str,
  101.                 "(unknown authentication error - %ld)",
  102.                 (int) e.re_why);
  103.         }
  104.         str += strlen(str);
  105.         break;
  106.  
  107.     case RPC_PROGVERSMISMATCH:
  108.         (void) sprintf(str, 
  109.             "; low version = %lu, high version = %lu", 
  110.             e.re_vers.low, e.re_vers.high);
  111.         str += strlen(str);
  112.         break;
  113.  
  114.     default:    /* unknown */
  115.         (void) sprintf(str, 
  116.             "; s1 = %lu, s2 = %lu", 
  117.             e.re_lb.s1, e.re_lb.s2);
  118.         str += strlen(str);
  119.         break;
  120.     }
  121.     (void) sprintf(str, "\n");
  122.     return(strstart) ;
  123. }
  124.  
  125. void
  126. clnt_perror(rpch, s)
  127.     CLIENT *rpch;
  128.     char *s;
  129. {
  130.     (void) fprintf(stderr,"%s",clnt_sperror(rpch,s));
  131. }
  132.  
  133.  
  134. struct rpc_errtab {
  135.     enum clnt_stat status;
  136.     char *message;
  137. };
  138.  
  139. static struct rpc_errtab  rpc_errlist[] = {
  140.     { RPC_SUCCESS, 
  141.         "RPC: Success" }, 
  142.     { RPC_CANTENCODEARGS, 
  143.         "RPC: Can't encode arguments" },
  144.     { RPC_CANTDECODERES, 
  145.         "RPC: Can't decode result" },
  146.     { RPC_CANTSEND, 
  147.         "RPC: Unable to send" },
  148.     { RPC_CANTRECV, 
  149.         "RPC: Unable to receive" },
  150.     { RPC_TIMEDOUT, 
  151.         "RPC: Timed out" },
  152.     { RPC_VERSMISMATCH, 
  153.         "RPC: Incompatible versions of RPC" },
  154.     { RPC_AUTHERROR, 
  155.         "RPC: Authentication error" },
  156.     { RPC_PROGUNAVAIL, 
  157.         "RPC: Program unavailable" },
  158.     { RPC_PROGVERSMISMATCH, 
  159.         "RPC: Program/version mismatch" },
  160.     { RPC_PROCUNAVAIL, 
  161.         "RPC: Procedure unavailable" },
  162.     { RPC_CANTDECODEARGS, 
  163.         "RPC: Server can't decode arguments" },
  164.     { RPC_SYSTEMERROR, 
  165.         "RPC: Remote system error" },
  166.     { RPC_UNKNOWNHOST, 
  167.         "RPC: Unknown host" },
  168.     { RPC_UNKNOWNPROTO,
  169.         "RPC: Unknown protocol" },
  170.     { RPC_PMAPFAILURE, 
  171.         "RPC: Port mapper failure" },
  172.     { RPC_PROGNOTREGISTERED, 
  173.         "RPC: Program not registered"},
  174.     { RPC_FAILED, 
  175.         "RPC: Failed (unspecified error)"}
  176. };
  177.  
  178.  
  179. /*
  180.  * This interface for use by clntrpc
  181.  */
  182. char *
  183. clnt_sperrno(stat)
  184.     enum clnt_stat stat;
  185. {
  186.     int i;
  187.  
  188.     for (i = 0; i < sizeof(rpc_errlist)/sizeof(struct rpc_errtab); i++) {
  189.         if (rpc_errlist[i].status == stat) {
  190.             return (rpc_errlist[i].message);
  191.         }
  192.     }
  193.     return ("RPC: (unknown error code)");
  194. }
  195.  
  196. void
  197. clnt_perrno(num)
  198.     enum clnt_stat num;
  199. {
  200.     (void) fprintf(stderr,"%s",clnt_sperrno(num));
  201. }
  202.  
  203.  
  204. char *
  205. clnt_spcreateerror(s)
  206.     char *s;
  207. {
  208.     char *str = _buf();
  209.  
  210.     if (str == 0)
  211.         return(0);
  212.     (void) sprintf(str, "%s: ", s);
  213.     (void) strcat(str, clnt_sperrno(rpc_createerr.cf_stat));
  214.     switch (rpc_createerr.cf_stat) {
  215.     case RPC_PMAPFAILURE:
  216.         (void) strcat(str, " - ");
  217.         (void) strcat(str,
  218.             clnt_sperrno(rpc_createerr.cf_error.re_status));
  219.         break;
  220.  
  221.     case RPC_SYSTEMERROR:
  222.         (void) strcat(str, " - ");
  223.         if (rpc_createerr.cf_error.re_errno > 0
  224.             && rpc_createerr.cf_error.re_errno < __sys_nerr)
  225.             (void) strcat(str,
  226.                 strerror(rpc_createerr.cf_error.re_errno));
  227.         else
  228.             (void) sprintf(&str[strlen(str)], "Error %ld",
  229.                 rpc_createerr.cf_error.re_errno);
  230.         break;
  231.     }
  232.     (void) strcat(str, "\n");
  233.     return (str);
  234. }
  235.  
  236. void
  237. clnt_pcreateerror(s)
  238.     char *s;
  239. {
  240.     (void) fprintf(stderr,"%s",clnt_spcreateerror(s));
  241. }
  242.  
  243. struct auth_errtab {
  244.     enum auth_stat status;    
  245.     char *message;
  246. };
  247.  
  248. static struct auth_errtab auth_errlist[] = {
  249.     { AUTH_OK,
  250.         "Authentication OK" },
  251.     { AUTH_BADCRED,
  252.         "Invalid client credential" },
  253.     { AUTH_REJECTEDCRED,
  254.         "Server rejected credential" },
  255.     { AUTH_BADVERF,
  256.         "Invalid client verifier" },
  257.     { AUTH_REJECTEDVERF,
  258.         "Server rejected verifier" },
  259.     { AUTH_TOOWEAK,
  260.         "Client credential too weak" },
  261.     { AUTH_INVALIDRESP,
  262.         "Invalid server verifier" },
  263.     { AUTH_FAILED,
  264.         "Failed (unspecified error)" },
  265. };
  266.  
  267. static char *
  268. auth_errmsg(stat)
  269.     enum auth_stat stat;
  270. {
  271.     int i;
  272.  
  273.     for (i = 0; i < sizeof(auth_errlist)/sizeof(struct auth_errtab); i++) {
  274.         if (auth_errlist[i].status == stat) {
  275.             return(auth_errlist[i].message);
  276.         }
  277.     }
  278.     return(NULL);
  279. }
  280.