void
__assert_perror_fail (int errnum,
const char *file, unsigned int line,
const char *function)
{
char errbuf[1024];
char *buf;
#ifdef FATAL_PREPARE
FATAL_PREPARE;
#endif
if (__asprintf (&buf, _("%s%s%s:%u: %s%sUnexpected error: %s.\n"),
__progname, __progname[0] ? ": " : "",
file, line,
function ? function : "", function ? ": " : "",
__strerror_r (errnum, errbuf, sizeof errbuf)) >= 0)
{
/* Print the message. */
(void) __fxprintf (NULL, "%s", buf);
(void) fflush (stderr);
/* We have to free the buffer since the appplication might catch the
SIGABRT. */
free (buf);
}
else
{
/* At least print a minimal message. */
static const char errstr[] = "Unexpected error.\n";
__libc_write (STDERR_FILENO, errstr, sizeof (errstr) - 1);
}
abort ();
}
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;
}
char *
strerror (int errnum)
{
char *ret = __strerror_r (errnum, NULL, 0);
int saved_errno;
if (__glibc_likely (ret != NULL))
return ret;
saved_errno = errno;
if (buf == NULL)
buf = malloc (1024);
__set_errno (saved_errno);
if (buf == NULL)
return _("Unknown error");
return __strerror_r (errnum, buf, 1024);
}
static void
perror_internal (FILE *fp, const char *s, int errnum)
{
char buf[1024];
const char *colon;
const char *errstring;
if (s == NULL || *s == '\0')
s = colon = "";
else
colon = ": ";
errstring = __strerror_r (errnum, buf, sizeof buf);
(void) __fxprintf (fp, "%s%s%s\n", s, colon, errstring);
}
char*
getwd (char *buf)
{
char mybuf[PATH_MAX];
if (buf == NULL) {
__set_errno (EINVAL);
return NULL;
}
if (__getcwd (mybuf, PATH_MAX) == NULL) {
__strerror_r (errno, buf, PATH_MAX);
return NULL;
}
return strcpy (buf, mybuf); /* Ouch. */
}
/*
* 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);
}