[thirdparty/glibc.git] / sunrpc / clnt_perr.c

/* @(#)clnt_perror.c	2.1 88/07/29 4.0 RPCSRC */
/*
 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
 * unrestricted use provided that this legend is included on all tape
 * media and as a part of the software program in whole or part.  Users
 * may copy or modify Sun RPC without charge, but are not authorized
 * to license or distribute it to anyone else except as part of a product or
 * program developed by the user.
 *
 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
 *
 * Sun RPC is provided with no support and without any obligation on the
 * part of Sun Microsystems, Inc. to assist in its use, correction,
 * modification or enhancement.
 *
 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
 * OR ANY PART THEREOF.
 *
 * In no event will Sun Microsystems, Inc. be liable for any lost revenue
 * or profits or other special, indirect and consequential damages, even if
 * Sun has been advised of the possibility of such damages.
 *
 * Sun Microsystems, Inc.
 * 2550 Garcia Avenue
 * Mountain View, California  94043
 */
#if !defined(lint) && defined(SCCSIDS)
static char sccsid[] = "@(#)clnt_perror.c 1.15 87/10/07 Copyr 1984 Sun Micro";
#endif

/*
 * clnt_perror.c
 *
 * Copyright (C) 1984, Sun Microsystems, Inc.
 *
 */
#include <stdio.h>
#include <string.h>
#include <libintl.h>
#include <rpc/rpc.h>

#ifdef USE_IN_LIBIO
# include <wchar.h>
# include <libio/iolibio.h>
#endif

static char *auth_errmsg (enum auth_stat stat) internal_function;

#ifdef _RPC_THREAD_SAFE_
/*
 * Making buf a preprocessor macro requires renaming the local
 * buf variable in a few functions.  Overriding a global variable
 * with a local variable of the same name is a bad idea, anyway.
 */
#define buf RPC_THREAD_VARIABLE(clnt_perr_buf_s)
#else
static char *buf;
#endif

static char *
_buf (void)
{
  if (buf == NULL)
    buf = (char *) malloc (256);
  return buf;
}

/*
 * Print reply error info
 */
char *
clnt_sperror (CLIENT * rpch, const char *msg)
{
  char chrbuf[1024];
  struct rpc_err e;
  char *err;
  char *str = _buf ();
  char *strstart = str;
  int len;

  if (str == NULL)
    return NULL;
  CLNT_GETERR (rpch, &e);

  len = sprintf (str, "%s: ", msg);
  str += len;

  str = stpcpy (str, clnt_sperrno (e.re_status));

  switch (e.re_status)
    {
    case RPC_SUCCESS:
    case RPC_CANTENCODEARGS:
    case RPC_CANTDECODERES:
    case RPC_TIMEDOUT:
    case RPC_PROGUNAVAIL:
    case RPC_PROCUNAVAIL:
    case RPC_CANTDECODEARGS:
    case RPC_SYSTEMERROR:
    case RPC_UNKNOWNHOST:
    case RPC_UNKNOWNPROTO:
    case RPC_PMAPFAILURE:
    case RPC_PROGNOTREGISTERED:
    case RPC_FAILED:
      break;

    case RPC_CANTSEND:
    case RPC_CANTRECV:
      len = sprintf (str, "; errno = %s", __strerror_r (e.re_errno,
							chrbuf, sizeof chrbuf));
      str += len;
      break;

    case RPC_VERSMISMATCH:
      len= sprintf (str, _("; low version = %lu, high version = %lu"),
		    e.re_vers.low, e.re_vers.high);
      str += len;
      break;

    case RPC_AUTHERROR:
      err = auth_errmsg (e.re_why);
      str = stpcpy (str, _ ("; why = "));
      if (err != NULL)
	{
	  str = stpcpy (str, err);
	}
      else
	{
	  len = sprintf (str, _("(unknown authentication error - %d)"),
			 (int) e.re_why);
	  str += len;
	}
      break;

    case RPC_PROGVERSMISMATCH:
      len = sprintf (str, _("; low version = %lu, high version = %lu"),
		     e.re_vers.low, e.re_vers.high);
      str += len;
      break;

    default:			/* unknown */
      len = sprintf (str, "; s1 = %lu, s2 = %lu", e.re_lb.s1, e.re_lb.s2);
      str += len;
      break;
    }
  *str = '\n';
  *++str = '\0';
  return (strstart);
}
libc_hidden_def (clnt_sperror)

void
clnt_perror (CLIENT * rpch, const char *msg)
{
  (void) __fxprintf (NULL, "%s", clnt_sperror (rpch, msg));
}
libc_hidden_def (clnt_perror)


struct rpc_errtab
{
  enum clnt_stat status;
  unsigned int message_off;
};

static const char rpc_errstr[] =
{
#define RPC_SUCCESS_IDX		0
  N_("RPC: Success")
  "\0"
#define RPC_CANTENCODEARGS_IDX	(RPC_SUCCESS_IDX + sizeof "RPC: Success")
  N_("RPC: Can't encode arguments")
  "\0"
#define RPC_CANTDECODERES_IDX	(RPC_CANTENCODEARGS_IDX \
				 + sizeof "RPC: Can't encode arguments")
  N_("RPC: Can't decode result")
  "\0"
#define RPC_CANTSEND_IDX	(RPC_CANTDECODERES_IDX \
				 + sizeof "RPC: Can't decode result")
  N_("RPC: Unable to send")
  "\0"
#define RPC_CANTRECV_IDX	(RPC_CANTSEND_IDX \
				 + sizeof "RPC: Unable to send")
  N_("RPC: Unable to receive")
  "\0"
#define RPC_TIMEDOUT_IDX	(RPC_CANTRECV_IDX \
				 + sizeof "RPC: Unable to receive")
  N_("RPC: Timed out")
  "\0"
#define RPC_VERSMISMATCH_IDX	(RPC_TIMEDOUT_IDX \
				 + sizeof "RPC: Timed out")
  N_("RPC: Incompatible versions of RPC")
  "\0"
#define RPC_AUTHERROR_IDX	(RPC_VERSMISMATCH_IDX \
				 + sizeof "RPC: Incompatible versions of RPC")
  N_("RPC: Authentication error")
  "\0"
#define RPC_PROGUNAVAIL_IDX		(RPC_AUTHERROR_IDX \
				 + sizeof "RPC: Authentication error")
  N_("RPC: Program unavailable")
  "\0"
#define RPC_PROGVERSMISMATCH_IDX (RPC_PROGUNAVAIL_IDX \
				  + sizeof "RPC: Program unavailable")
  N_("RPC: Program/version mismatch")
  "\0"
#define RPC_PROCUNAVAIL_IDX	(RPC_PROGVERSMISMATCH_IDX \
				 + sizeof "RPC: Program/version mismatch")
  N_("RPC: Procedure unavailable")
  "\0"
#define RPC_CANTDECODEARGS_IDX	(RPC_PROCUNAVAIL_IDX \
				 + sizeof "RPC: Procedure unavailable")
  N_("RPC: Server can't decode arguments")
  "\0"
#define RPC_SYSTEMERROR_IDX	(RPC_CANTDECODEARGS_IDX \
				 + sizeof "RPC: Server can't decode arguments")
  N_("RPC: Remote system error")
  "\0"
#define RPC_UNKNOWNHOST_IDX	(RPC_SYSTEMERROR_IDX \
				 + sizeof "RPC: Remote system error")
  N_("RPC: Unknown host")
  "\0"
#define RPC_UNKNOWNPROTO_IDX	(RPC_UNKNOWNHOST_IDX \
				 + sizeof "RPC: Unknown host")
  N_("RPC: Unknown protocol")
  "\0"
#define RPC_PMAPFAILURE_IDX	(RPC_UNKNOWNPROTO_IDX \
				 + sizeof "RPC: Unknown protocol")
  N_("RPC: Port mapper failure")
  "\0"
#define RPC_PROGNOTREGISTERED_IDX (RPC_PMAPFAILURE_IDX \
				   + sizeof "RPC: Port mapper failure")
  N_("RPC: Program not registered")
  "\0"
#define RPC_FAILED_IDX		(RPC_PROGNOTREGISTERED_IDX \
				 + sizeof "RPC: Program not registered")
  N_("RPC: Failed (unspecified error)")
};

static const struct rpc_errtab rpc_errlist[] =
{
  { RPC_SUCCESS, RPC_SUCCESS_IDX },
  { RPC_CANTENCODEARGS, RPC_CANTENCODEARGS_IDX },
  { RPC_CANTDECODERES, RPC_CANTDECODERES_IDX },
  { RPC_CANTSEND, RPC_CANTSEND_IDX },
  { RPC_CANTRECV, RPC_CANTRECV_IDX },
  { RPC_TIMEDOUT, RPC_TIMEDOUT_IDX },
  { RPC_VERSMISMATCH, RPC_VERSMISMATCH_IDX },
  { RPC_AUTHERROR, RPC_AUTHERROR_IDX },
  { RPC_PROGUNAVAIL, RPC_PROGUNAVAIL_IDX },
  { RPC_PROGVERSMISMATCH, RPC_PROGVERSMISMATCH_IDX },
  { RPC_PROCUNAVAIL, RPC_PROCUNAVAIL_IDX },
  { RPC_CANTDECODEARGS, RPC_CANTDECODEARGS_IDX },
  { RPC_SYSTEMERROR, RPC_SYSTEMERROR_IDX },
  { RPC_UNKNOWNHOST, RPC_UNKNOWNHOST_IDX },
  { RPC_UNKNOWNPROTO, RPC_UNKNOWNPROTO_IDX },
  { RPC_PMAPFAILURE, RPC_PMAPFAILURE_IDX },
  { RPC_PROGNOTREGISTERED, RPC_PROGNOTREGISTERED_IDX },
  { RPC_FAILED, RPC_FAILED_IDX }
};


/*
 * This interface for use by clntrpc
 */
char *
clnt_sperrno (enum clnt_stat stat)
{
  size_t i;

  for (i = 0; i < sizeof (rpc_errlist) / sizeof (struct rpc_errtab); i++)
    {
      if (rpc_errlist[i].status == stat)
	{
	  return _(rpc_errstr + rpc_errlist[i].message_off);
	}
    }
  return _("RPC: (unknown error code)");
}
libc_hidden_def (clnt_sperrno)

void
clnt_perrno (enum clnt_stat num)
{
  (void) __fxprintf (NULL, "%s", clnt_sperrno (num));
}


char *
clnt_spcreateerror (const char *msg)
{
  char chrbuf[1024];
  char *str = _buf ();
  char *cp;
  int len;
  struct rpc_createerr *ce;

  if (str == NULL)
    return NULL;
  ce = &get_rpc_createerr ();
  len = sprintf (str, "%s: ", msg);
  cp = str + len;
  cp = stpcpy (cp, clnt_sperrno (ce->cf_stat));
  switch (ce->cf_stat)
    {
    case RPC_PMAPFAILURE:
      cp = stpcpy (stpcpy (cp, " - "),
		   clnt_sperrno (ce->cf_error.re_status));
      break;

    case RPC_SYSTEMERROR:
      cp = stpcpy (stpcpy (cp, " - "),
		   __strerror_r (ce->cf_error.re_errno,
				 chrbuf, sizeof chrbuf));
      break;
    default:
      break;
    }
  *cp = '\n';
  *++cp = '\0';
  return str;
}
libc_hidden_def (clnt_spcreateerror)

void
clnt_pcreateerror (const char *msg)
{
  (void) __fxprintf (NULL, "%s", clnt_spcreateerror (msg));
}

struct auth_errtab
{
  enum auth_stat status;
  unsigned int message_off;
};

static const char auth_errstr[] =
{
#define AUTH_OK_IDX		0
   N_("Authentication OK")
   "\0"
#define AUTH_BADCRED_IDX	(AUTH_OK_IDX + sizeof "Authentication OK")
   N_("Invalid client credential")
   "\0"
#define AUTH_REJECTEDCRED_IDX	(AUTH_BADCRED_IDX \
				 + sizeof "Invalid client credential")
   N_("Server rejected credential")
   "\0"
#define AUTH_BADVERF_IDX	(AUTH_REJECTEDCRED_IDX \
				 + sizeof "Server rejected credential")
   N_("Invalid client verifier")
   "\0"
#define AUTH_REJECTEDVERF_IDX	(AUTH_BADVERF_IDX \
				 + sizeof "Invalid client verifier")
   N_("Server rejected verifier")
   "\0"
#define AUTH_TOOWEAK_IDX	(AUTH_REJECTEDVERF_IDX \
				 + sizeof "Server rejected verifier")
   N_("Client credential too weak")
   "\0"
#define AUTH_INVALIDRESP_IDX	(AUTH_TOOWEAK_IDX \
				 + sizeof "Client credential too weak")
   N_("Invalid server verifier")
   "\0"
#define AUTH_FAILED_IDX		(AUTH_INVALIDRESP_IDX \
				 + sizeof "Invalid server verifier")
   N_("Failed (unspecified error)")
};

static const struct auth_errtab auth_errlist[] =
{
  { AUTH_OK, AUTH_OK_IDX },
  { AUTH_BADCRED, AUTH_BADCRED_IDX },
  { AUTH_REJECTEDCRED, AUTH_REJECTEDCRED_IDX },
  { AUTH_BADVERF, AUTH_BADVERF_IDX },
  { AUTH_REJECTEDVERF, AUTH_REJECTEDVERF_IDX },
  { AUTH_TOOWEAK, AUTH_TOOWEAK_IDX },
  { AUTH_INVALIDRESP, AUTH_INVALIDRESP_IDX },
  { AUTH_FAILED, AUTH_FAILED_IDX }
};

static char *
internal_function
auth_errmsg (enum auth_stat stat)
{
  size_t i;

  for (i = 0; i < sizeof (auth_errlist) / sizeof (struct auth_errtab); i++)
    {
      if (auth_errlist[i].status == stat)
	{
	  return _(auth_errstr + auth_errlist[i].message_off);
	}
    }
  return NULL;
}


libc_freeres_fn (free_mem)
{
  /* Not libc_freeres_ptr, since buf is a macro.  */
  free (buf);
}
Commit	Line	Data
28f540f4 RM	1	/* @(#)clnt_perror.c 2.1 88/07/29 4.0 RPCSRC */
	2	/*
	3	* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
	4	* unrestricted use provided that this legend is included on all tape
	5	* media and as a part of the software program in whole or part. Users
	6	* may copy or modify Sun RPC without charge, but are not authorized
	7	* to license or distribute it to anyone else except as part of a product or
	8	* program developed by the user.
cbd3dceb	9	*
28f540f4 RM	10	* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
	11	* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
	12	* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
cbd3dceb	13	*
28f540f4 RM	14	* Sun RPC is provided with no support and without any obligation on the
	15	* part of Sun Microsystems, Inc. to assist in its use, correction,
	16	* modification or enhancement.
cbd3dceb	17	*
28f540f4 RM	18	* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
	19	* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
	20	* OR ANY PART THEREOF.
cbd3dceb	21	*
28f540f4 RM	22	* In no event will Sun Microsystems, Inc. be liable for any lost revenue
	23	* or profits or other special, indirect and consequential damages, even if
	24	* Sun has been advised of the possibility of such damages.
cbd3dceb	25	*
28f540f4 RM	26	* Sun Microsystems, Inc.
	27	* 2550 Garcia Avenue
	28	* Mountain View, California 94043
	29	*/
	30	#if !defined(lint) && defined(SCCSIDS)
	31	static char sccsid[] = "@(#)clnt_perror.c 1.15 87/10/07 Copyr 1984 Sun Micro";
	32	#endif
	33
	34	/*
	35	* clnt_perror.c
	36	*
	37	* Copyright (C) 1984, Sun Microsystems, Inc.
	38	*
	39	*/
	40	#include <stdio.h>
e7fd8a39	41	#include <string.h>
4360eafd	42	#include <libintl.h>
f1e4a4a4	43	#include <rpc/rpc.h>
28f540f4	44
50304ef0	45	#ifdef USE_IN_LIBIO
51028f34	46	# include <wchar.h>
50304ef0	47	# include <libio/iolibio.h>
50304ef0 UD	48	#endif
50304ef0 UD	49
dfd2257a	50	static char *auth_errmsg (enum auth_stat stat) internal_function;
28f540f4	51
f1e4a4a4 UD	52	#ifdef _RPC_THREAD_SAFE_
	53	/*
	54	* Making buf a preprocessor macro requires renaming the local
	55	* buf variable in a few functions. Overriding a global variable
	56	* with a local variable of the same name is a bad idea, anyway.
	57	*/
1bc1a2b9	58	#define buf RPC_THREAD_VARIABLE(clnt_perr_buf_s)
f1e4a4a4	59	#else
28f540f4	60	static char *buf;
f1e4a4a4	61	#endif
28f540f4 RM	62
28f540f4 RM	63	static char *
e7fd8a39	64	_buf (void)
28f540f4	65	{
e7fd8a39 UD	66	if (buf == NULL)
	67	buf = (char *) malloc (256);
	68	return buf;
28f540f4 RM	69	}
	70
	71	/*
	72	* Print reply error info
	73	*/
	74	char *
e7fd8a39	75	clnt_sperror (CLIENT * rpch, const char *msg)
28f540f4	76	{
f1e4a4a4	77	char chrbuf[1024];
e7fd8a39 UD	78	struct rpc_err e;
	79	char *err;
	80	char *str = _buf ();
	81	char *strstart = str;
	82	int len;
	83
	84	if (str == NULL)
	85	return NULL;
	86	CLNT_GETERR (rpch, &e);
	87
	88	len = sprintf (str, "%s: ", msg);
	89	str += len;
	90
	91	str = stpcpy (str, clnt_sperrno (e.re_status));
	92
	93	switch (e.re_status)
	94	{
	95	case RPC_SUCCESS:
	96	case RPC_CANTENCODEARGS:
	97	case RPC_CANTDECODERES:
	98	case RPC_TIMEDOUT:
	99	case RPC_PROGUNAVAIL:
	100	case RPC_PROCUNAVAIL:
	101	case RPC_CANTDECODEARGS:
	102	case RPC_SYSTEMERROR:
	103	case RPC_UNKNOWNHOST:
	104	case RPC_UNKNOWNPROTO:
	105	case RPC_PMAPFAILURE:
	106	case RPC_PROGNOTREGISTERED:
	107	case RPC_FAILED:
	108	break;
	109
	110	case RPC_CANTSEND:
	111	case RPC_CANTRECV:
50304ef0	112	len = sprintf (str, "; errno = %s", __strerror_r (e.re_errno,
f1e4a4a4	113	chrbuf, sizeof chrbuf));
e7fd8a39 UD	114	str += len;
	115	break;
	116
	117	case RPC_VERSMISMATCH:
	118	len= sprintf (str, _("; low version = %lu, high version = %lu"),
	119	e.re_vers.low, e.re_vers.high);
	120	str += len;
	121	break;
	122
	123	case RPC_AUTHERROR:
	124	err = auth_errmsg (e.re_why);
	125	str = stpcpy (str, _ ("; why = "));
	126	if (err != NULL)
	127	{
	128	str = stpcpy (str, err);
	129	}
	130	else
	131	{
	132	len = sprintf (str, _("(unknown authentication error - %d)"),
	133	(int) e.re_why);
	134	str += len;
28f540f4	135	}
e7fd8a39 UD	136	break;
	137
	138	case RPC_PROGVERSMISMATCH:
	139	len = sprintf (str, _("; low version = %lu, high version = %lu"),
	140	e.re_vers.low, e.re_vers.high);
	141	str += len;
	142	break;
	143
	144	default: /* unknown */
	145	len = sprintf (str, "; s1 = %lu, s2 = %lu", e.re_lb.s1, e.re_lb.s2);
	146	str += len;
	147	break;
	148	}
	149	*str = '\n';
af6f3906	150	*++str = '\0';
e7fd8a39	151	return (strstart);
28f540f4	152	}
8784cc18	153	libc_hidden_def (clnt_sperror)
28f540f4 RM	154
28f540f4 RM	155	void
e7fd8a39	156	clnt_perror (CLIENT * rpch, const char *msg)
28f540f4	157	{
0ecb606c	158	(void) __fxprintf (NULL, "%s", clnt_sperror (rpch, msg));
28f540f4	159	}
8784cc18	160	libc_hidden_def (clnt_perror)
28f540f4 RM	161
28f540f4 RM	162
e7fd8a39 UD	163	struct rpc_errtab
	164	{
	165	enum clnt_stat status;
c4563d2d UD	166	unsigned int message_off;
	167	};
	168
	169	static const char rpc_errstr[] =
	170	{
	171	#define RPC_SUCCESS_IDX 0
	172	N_("RPC: Success")
	173	"\0"
	174	#define RPC_CANTENCODEARGS_IDX (RPC_SUCCESS_IDX + sizeof "RPC: Success")
	175	N_("RPC: Can't encode arguments")
	176	"\0"
	177	#define RPC_CANTDECODERES_IDX (RPC_CANTENCODEARGS_IDX \
	178	+ sizeof "RPC: Can't encode arguments")
	179	N_("RPC: Can't decode result")
	180	"\0"
	181	#define RPC_CANTSEND_IDX (RPC_CANTDECODERES_IDX \
	182	+ sizeof "RPC: Can't decode result")
	183	N_("RPC: Unable to send")
	184	"\0"
	185	#define RPC_CANTRECV_IDX (RPC_CANTSEND_IDX \
	186	+ sizeof "RPC: Unable to send")
	187	N_("RPC: Unable to receive")
	188	"\0"
	189	#define RPC_TIMEDOUT_IDX (RPC_CANTRECV_IDX \
	190	+ sizeof "RPC: Unable to receive")
	191	N_("RPC: Timed out")
	192	"\0"
	193	#define RPC_VERSMISMATCH_IDX (RPC_TIMEDOUT_IDX \
	194	+ sizeof "RPC: Timed out")
	195	N_("RPC: Incompatible versions of RPC")
	196	"\0"
	197	#define RPC_AUTHERROR_IDX (RPC_VERSMISMATCH_IDX \
	198	+ sizeof "RPC: Incompatible versions of RPC")
	199	N_("RPC: Authentication error")
	200	"\0"
	201	#define RPC_PROGUNAVAIL_IDX (RPC_AUTHERROR_IDX \
	202	+ sizeof "RPC: Authentication error")
	203	N_("RPC: Program unavailable")
	204	"\0"
	205	#define RPC_PROGVERSMISMATCH_IDX (RPC_PROGUNAVAIL_IDX \
	206	+ sizeof "RPC: Program unavailable")
	207	N_("RPC: Program/version mismatch")
	208	"\0"
	209	#define RPC_PROCUNAVAIL_IDX (RPC_PROGVERSMISMATCH_IDX \
	210	+ sizeof "RPC: Program/version mismatch")
	211	N_("RPC: Procedure unavailable")
	212	"\0"
	213	#define RPC_CANTDECODEARGS_IDX (RPC_PROCUNAVAIL_IDX \
	214	+ sizeof "RPC: Procedure unavailable")
	215	N_("RPC: Server can't decode arguments")
	216	"\0"
	217	#define RPC_SYSTEMERROR_IDX (RPC_CANTDECODEARGS_IDX \
	218	+ sizeof "RPC: Server can't decode arguments")
	219	N_("RPC: Remote system error")
	220	"\0"
	221	#define RPC_UNKNOWNHOST_IDX (RPC_SYSTEMERROR_IDX \
	222	+ sizeof "RPC: Remote system error")
	223	N_("RPC: Unknown host")
	224	"\0"
	225	#define RPC_UNKNOWNPROTO_IDX (RPC_UNKNOWNHOST_IDX \
	226	+ sizeof "RPC: Unknown host")
	227	N_("RPC: Unknown protocol")
	228	"\0"
	229	#define RPC_PMAPFAILURE_IDX (RPC_UNKNOWNPROTO_IDX \
230	+ sizeof "RPC: Unknown protocol")
231	N_("RPC: Port mapper failure")
232	"\0"
233	#define RPC_PROGNOTREGISTERED_IDX (RPC_PMAPFAILURE_IDX \
234	+ sizeof "RPC: Port mapper failure")
235	N_("RPC: Program not registered")
236	"\0"
237	#define RPC_FAILED_IDX (RPC_PROGNOTREGISTERED_IDX \
238	+ sizeof "RPC: Program not registered")
239	N_("RPC: Failed (unspecified error)")
28f540f4 RM	240	};
28f540f4 RM	241
e7fd8a39 UD	242	static const struct rpc_errtab rpc_errlist[] =
e7fd8a39 UD	243	{
c4563d2d UD	244	{ RPC_SUCCESS, RPC_SUCCESS_IDX },
	245	{ RPC_CANTENCODEARGS, RPC_CANTENCODEARGS_IDX },
	246	{ RPC_CANTDECODERES, RPC_CANTDECODERES_IDX },
	247	{ RPC_CANTSEND, RPC_CANTSEND_IDX },
	248	{ RPC_CANTRECV, RPC_CANTRECV_IDX },
	249	{ RPC_TIMEDOUT, RPC_TIMEDOUT_IDX },
	250	{ RPC_VERSMISMATCH, RPC_VERSMISMATCH_IDX },
	251	{ RPC_AUTHERROR, RPC_AUTHERROR_IDX },
	252	{ RPC_PROGUNAVAIL, RPC_PROGUNAVAIL_IDX },
0b9fbf00	253	{ RPC_PROGVERSMISMATCH, RPC_PROGVERSMISMATCH_IDX },
c4563d2d UD	254	{ RPC_PROCUNAVAIL, RPC_PROCUNAVAIL_IDX },
	255	{ RPC_CANTDECODEARGS, RPC_CANTDECODEARGS_IDX },
	256	{ RPC_SYSTEMERROR, RPC_SYSTEMERROR_IDX },
	257	{ RPC_UNKNOWNHOST, RPC_UNKNOWNHOST_IDX },
	258	{ RPC_UNKNOWNPROTO, RPC_UNKNOWNPROTO_IDX },
	259	{ RPC_PMAPFAILURE, RPC_PMAPFAILURE_IDX },
	260	{ RPC_PROGNOTREGISTERED, RPC_PROGNOTREGISTERED_IDX },
	261	{ RPC_FAILED, RPC_FAILED_IDX }
28f540f4 RM	262	};
	263
	264
	265	/*
	266	* This interface for use by clntrpc
	267	*/
	268	char *
e7fd8a39	269	clnt_sperrno (enum clnt_stat stat)
28f540f4	270	{
bfbc5754	271	size_t i;
28f540f4	272
e7fd8a39 UD	273	for (i = 0; i < sizeof (rpc_errlist) / sizeof (struct rpc_errtab); i++)
	274	{
	275	if (rpc_errlist[i].status == stat)
	276	{
c4563d2d	277	return _(rpc_errstr + rpc_errlist[i].message_off);
28f540f4	278	}
e7fd8a39 UD	279	}
e7fd8a39 UD	280	return _("RPC: (unknown error code)");
28f540f4	281	}
8784cc18	282	libc_hidden_def (clnt_sperrno)
28f540f4 RM	283
28f540f4 RM	284	void
e7fd8a39	285	clnt_perrno (enum clnt_stat num)
28f540f4	286	{
0ecb606c	287	(void) __fxprintf (NULL, "%s", clnt_sperrno (num));
28f540f4 RM	288	}
	289
	290
	291	char *
e7fd8a39	292	clnt_spcreateerror (const char *msg)
28f540f4	293	{
f1e4a4a4	294	char chrbuf[1024];
e7fd8a39 UD	295	char *str = _buf ();
	296	char *cp;
	297	int len;
543cf8a9	298	struct rpc_createerr *ce;
e7fd8a39 UD	299
	300	if (str == NULL)
	301	return NULL;
543cf8a9	302	ce = &get_rpc_createerr ();
e7fd8a39 UD	303	len = sprintf (str, "%s: ", msg);
e7fd8a39 UD	304	cp = str + len;
543cf8a9 UD	305	cp = stpcpy (cp, clnt_sperrno (ce->cf_stat));
543cf8a9 UD	306	switch (ce->cf_stat)
e7fd8a39 UD	307	{
e7fd8a39 UD	308	case RPC_PMAPFAILURE:
50304ef0	309	cp = stpcpy (stpcpy (cp, " - "),
543cf8a9	310	clnt_sperrno (ce->cf_error.re_status));
e7fd8a39 UD	311	break;
	312
	313	case RPC_SYSTEMERROR:
50304ef0	314	cp = stpcpy (stpcpy (cp, " - "),
543cf8a9	315	__strerror_r (ce->cf_error.re_errno,
f1e4a4a4	316	chrbuf, sizeof chrbuf));
e7fd8a39 UD	317	break;
	318	default:
	319	break;
	320	}
	321	*cp = '\n';
af6f3906	322	*++cp = '\0';
e7fd8a39	323	return str;
28f540f4	324	}
8784cc18	325	libc_hidden_def (clnt_spcreateerror)
28f540f4 RM	326
28f540f4 RM	327	void
e7fd8a39	328	clnt_pcreateerror (const char *msg)
28f540f4	329	{
0ecb606c	330	(void) __fxprintf (NULL, "%s", clnt_spcreateerror (msg));
28f540f4 RM	331	}
28f540f4 RM	332
e7fd8a39 UD	333	struct auth_errtab
	334	{
	335	enum auth_stat status;
c4563d2d UD	336	unsigned int message_off;
	337	};
	338
	339	static const char auth_errstr[] =
	340	{
	341	#define AUTH_OK_IDX 0
	342	N_("Authentication OK")
	343	"\0"
	344	#define AUTH_BADCRED_IDX (AUTH_OK_IDX + sizeof "Authentication OK")
	345	N_("Invalid client credential")
	346	"\0"
	347	#define AUTH_REJECTEDCRED_IDX (AUTH_BADCRED_IDX \
	348	+ sizeof "Invalid client credential")
	349	N_("Server rejected credential")
	350	"\0"
	351	#define AUTH_BADVERF_IDX (AUTH_REJECTEDCRED_IDX \
	352	+ sizeof "Server rejected credential")
	353	N_("Invalid client verifier")
	354	"\0"
	355	#define AUTH_REJECTEDVERF_IDX (AUTH_BADVERF_IDX \
	356	+ sizeof "Invalid client verifier")
	357	N_("Server rejected verifier")
	358	"\0"
	359	#define AUTH_TOOWEAK_IDX (AUTH_REJECTEDVERF_IDX \
	360	+ sizeof "Server rejected verifier")
	361	N_("Client credential too weak")
	362	"\0"
	363	#define AUTH_INVALIDRESP_IDX (AUTH_TOOWEAK_IDX \
	364	+ sizeof "Client credential too weak")
	365	N_("Invalid server verifier")
	366	"\0"
	367	#define AUTH_FAILED_IDX (AUTH_INVALIDRESP_IDX \
	368	+ sizeof "Invalid server verifier")
	369	N_("Failed (unspecified error)")
28f540f4 RM	370	};
28f540f4 RM	371
e7fd8a39 UD	372	static const struct auth_errtab auth_errlist[] =
e7fd8a39 UD	373	{
c4563d2d UD	374	{ AUTH_OK, AUTH_OK_IDX },
	375	{ AUTH_BADCRED, AUTH_BADCRED_IDX },
	376	{ AUTH_REJECTEDCRED, AUTH_REJECTEDCRED_IDX },
	377	{ AUTH_BADVERF, AUTH_BADVERF_IDX },
	378	{ AUTH_REJECTEDVERF, AUTH_REJECTEDVERF_IDX },
	379	{ AUTH_TOOWEAK, AUTH_TOOWEAK_IDX },
	380	{ AUTH_INVALIDRESP, AUTH_INVALIDRESP_IDX },
	381	{ AUTH_FAILED, AUTH_FAILED_IDX }
28f540f4 RM	382	};
	383
	384	static char *
dfd2257a	385	internal_function
e7fd8a39	386	auth_errmsg (enum auth_stat stat)
28f540f4	387	{
e7fd8a39	388	size_t i;
28f540f4	389
e7fd8a39 UD	390	for (i = 0; i < sizeof (auth_errlist) / sizeof (struct auth_errtab); i++)
	391	{
	392	if (auth_errlist[i].status == stat)
	393	{
c4563d2d	394	return _(auth_errstr + auth_errlist[i].message_off);
28f540f4	395	}
e7fd8a39 UD	396	}
e7fd8a39 UD	397	return NULL;
28f540f4	398	}
c81459e7 UD	399
c81459e7 UD	400
c877418f	401	libc_freeres_fn (free_mem)
c81459e7	402	{
c877418f	403	/* Not libc_freeres_ptr, since buf is a macro. */
c81459e7 UD	404	free (buf);
c81459e7 UD	405	}