1 /* $OpenBSD: clnt_perror.c,v 1.23 2010/09/01 14:43:34 millert Exp $ */ 2 3 /* 4 * Copyright (c) 2010, Oracle America, Inc. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are 8 * met: 9 * 10 * * Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * * Redistributions in binary form must reproduce the above 13 * copyright notice, this list of conditions and the following 14 * disclaimer in the documentation and/or other materials 15 * provided with the distribution. 16 * * Neither the name of the "Oracle America, Inc." nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 24 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 27 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 29 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <string.h> 37 #include <rpc/rpc.h> 38 #include <rpc/types.h> 39 #include <rpc/auth.h> 40 #include <rpc/clnt.h> 41 42 static char *auth_errmsg(enum auth_stat stat); 43 #define CLNT_PERROR_BUFLEN 256 44 45 static char buf[CLNT_PERROR_BUFLEN]; 46 47 /* 48 * Print reply error info 49 */ 50 char * 51 clnt_sperror(CLIENT *rpch, char *s) 52 { 53 char *err, *str = buf; 54 struct rpc_err e; 55 int ret, len = CLNT_PERROR_BUFLEN; 56 57 CLNT_GETERR(rpch, &e); 58 59 ret = snprintf(str, len, "%s: %s", s, clnt_sperrno(e.re_status)); 60 if (ret == -1) 61 ret = 0; 62 else if (ret >= len) 63 goto truncated; 64 str += ret; 65 len -= ret; 66 67 switch (e.re_status) { 68 case RPC_SUCCESS: 69 case RPC_CANTENCODEARGS: 70 case RPC_CANTDECODERES: 71 case RPC_TIMEDOUT: 72 case RPC_PROGUNAVAIL: 73 case RPC_PROCUNAVAIL: 74 case RPC_CANTDECODEARGS: 75 case RPC_SYSTEMERROR: 76 case RPC_UNKNOWNHOST: 77 case RPC_UNKNOWNPROTO: 78 case RPC_PMAPFAILURE: 79 case RPC_PROGNOTREGISTERED: 80 case RPC_FAILED: 81 break; 82 83 case RPC_CANTSEND: 84 case RPC_CANTRECV: 85 ret = snprintf(str, len, "; errno = %s", strerror(e.re_errno)); 86 if (ret == -1 || ret >= len) 87 goto truncated; 88 break; 89 90 case RPC_VERSMISMATCH: 91 ret = snprintf(str, len, 92 "; low version = %u, high version = %u", 93 e.re_vers.low, e.re_vers.high); 94 if (ret == -1 || ret >= len) 95 goto truncated; 96 break; 97 98 case RPC_AUTHERROR: 99 ret = snprintf(str, len, "; why = "); 100 if (ret == -1) 101 ret = 0; 102 else if (ret >= len) 103 goto truncated; 104 str += ret; 105 len -= ret; 106 err = auth_errmsg(e.re_why); 107 if (err != NULL) { 108 ret = snprintf(str, len, "%s", err); 109 if (ret == -1 || ret >= len) 110 goto truncated; 111 } else { 112 ret = snprintf(str, len, 113 "(unknown authentication error - %d)", 114 (int) e.re_why); 115 if (ret == -1 || ret >= len) 116 goto truncated; 117 } 118 break; 119 120 case RPC_PROGVERSMISMATCH: 121 ret = snprintf(str, len, 122 "; low version = %u, high version = %u", 123 e.re_vers.low, e.re_vers.high); 124 if (ret == -1 || ret >= len) 125 goto truncated; 126 break; 127 128 default: /* unknown */ 129 ret = snprintf(str, len, "; s1 = %u, s2 = %u", 130 e.re_lb.s1, e.re_lb.s2); 131 if (ret == -1 || ret >= len) 132 goto truncated; 133 break; 134 } 135 if (strlcat(buf, "\n", CLNT_PERROR_BUFLEN) >= CLNT_PERROR_BUFLEN) 136 goto truncated; 137 return (buf); 138 139 truncated: 140 snprintf(buf + CLNT_PERROR_BUFLEN - 5, 5, "...\n"); 141 return (buf); 142 } 143 144 void 145 clnt_perror(CLIENT *rpch, char *s) 146 { 147 (void) fprintf(stderr, "%s", clnt_sperror(rpch, s)); 148 } 149 150 static const char *const rpc_errlist[] = { 151 "RPC: Success", /* 0 - RPC_SUCCESS */ 152 "RPC: Can't encode arguments", /* 1 - RPC_CANTENCODEARGS */ 153 "RPC: Can't decode result", /* 2 - RPC_CANTDECODERES */ 154 "RPC: Unable to send", /* 3 - RPC_CANTSEND */ 155 "RPC: Unable to receive", /* 4 - RPC_CANTRECV */ 156 "RPC: Timed out", /* 5 - RPC_TIMEDOUT */ 157 "RPC: Incompatible versions of RPC", /* 6 - RPC_VERSMISMATCH */ 158 "RPC: Authentication error", /* 7 - RPC_AUTHERROR */ 159 "RPC: Program unavailable", /* 8 - RPC_PROGUNAVAIL */ 160 "RPC: Program/version mismatch", /* 9 - RPC_PROGVERSMISMATCH */ 161 "RPC: Procedure unavailable", /* 10 - RPC_PROCUNAVAIL */ 162 "RPC: Server can't decode arguments", /* 11 - RPC_CANTDECODEARGS */ 163 "RPC: Remote system error", /* 12 - RPC_SYSTEMERROR */ 164 "RPC: Unknown host", /* 13 - RPC_UNKNOWNHOST */ 165 "RPC: Port mapper failure", /* 14 - RPC_PMAPFAILURE */ 166 "RPC: Program not registered", /* 15 - RPC_PROGNOTREGISTERED */ 167 "RPC: Failed (unspecified error)", /* 16 - RPC_FAILED */ 168 "RPC: Unknown protocol" /* 17 - RPC_UNKNOWNPROTO */ 169 }; 170 171 172 /* 173 * This interface for use by clntrpc 174 */ 175 char * 176 clnt_sperrno(enum clnt_stat stat) 177 { 178 unsigned int errnum = stat; 179 180 if (errnum < (sizeof(rpc_errlist)/sizeof(rpc_errlist[0]))) 181 return (char *)rpc_errlist[errnum]; 182 183 return ("RPC: (unknown error code)"); 184 } 185 186 void 187 clnt_perrno(enum clnt_stat num) 188 { 189 (void) fprintf(stderr, "%s\n", clnt_sperrno(num)); 190 } 191 192 193 char * 194 clnt_spcreateerror(char *s) 195 { 196 switch (rpc_createerr.cf_stat) { 197 case RPC_PMAPFAILURE: 198 (void) snprintf(buf, CLNT_PERROR_BUFLEN, "%s: %s - %s\n", s, 199 clnt_sperrno(rpc_createerr.cf_stat), 200 clnt_sperrno(rpc_createerr.cf_error.re_status)); 201 break; 202 203 case RPC_SYSTEMERROR: 204 (void) snprintf(buf, CLNT_PERROR_BUFLEN, "%s: %s - %s\n", s, 205 clnt_sperrno(rpc_createerr.cf_stat), 206 strerror(rpc_createerr.cf_error.re_errno)); 207 break; 208 209 default: 210 (void) snprintf(buf, CLNT_PERROR_BUFLEN, "%s: %s\n", s, 211 clnt_sperrno(rpc_createerr.cf_stat)); 212 break; 213 } 214 buf[CLNT_PERROR_BUFLEN-2] = '\n'; 215 buf[CLNT_PERROR_BUFLEN-1] = '\0'; 216 return (buf); 217 } 218 219 void 220 clnt_pcreateerror(char *s) 221 { 222 fprintf(stderr, "%s", clnt_spcreateerror(s)); 223 } 224 225 static const char *const auth_errlist[] = { 226 "Authentication OK", /* 0 - AUTH_OK */ 227 "Invalid client credential", /* 1 - AUTH_BADCRED */ 228 "Server rejected credential", /* 2 - AUTH_REJECTEDCRED */ 229 "Invalid client verifier", /* 3 - AUTH_BADVERF */ 230 "Server rejected verifier", /* 4 - AUTH_REJECTEDVERF */ 231 "Client credential too weak", /* 5 - AUTH_TOOWEAK */ 232 "Invalid server verifier", /* 6 - AUTH_INVALIDRESP */ 233 "Failed (unspecified error)" /* 7 - AUTH_FAILED */ 234 }; 235 236 static char * 237 auth_errmsg(enum auth_stat stat) 238 { 239 unsigned int errnum = stat; 240 241 if (errnum < (sizeof(auth_errlist)/sizeof(auth_errlist[0]))) 242 return (char *)auth_errlist[errnum]; 243 244 return (NULL); 245 } 246