char *
__dlerror (void)
{
char *buf = NULL;
struct dl_action_result *result;
# ifdef SHARED
if (__glibc_unlikely (_dlfcn_hook != NULL))
return _dlfcn_hook->dlerror ();
# endif
/* If we have not yet initialized the buffer do it now. */
__libc_once (once, init);
/* Get error string. */
result = (struct dl_action_result *) __libc_getspecific (key);
if (result == NULL)
result = &last_result;
/* Test whether we already returned the string. */
if (result->returned != 0)
{
/* We can now free the string. */
if (result->errstring != NULL)
{
if (strcmp (result->errstring, "out of memory") != 0)
free ((char *) result->errstring);
result->errstring = NULL;
}
}
else if (result->errstring != NULL)
{
buf = (char *) result->errstring;
int n;
if (result->errcode == 0)
n = __asprintf (&buf, "%s%s%s",
result->objname,
result->objname[0] == '\0' ? "" : ": ",
_(result->errstring));
else
n = __asprintf (&buf, "%s%s%s: %s",
result->objname,
result->objname[0] == '\0' ? "" : ": ",
_(result->errstring),
strerror (result->errcode));
if (n != -1)
{
/* We don't need the error string anymore. */
if (strcmp (result->errstring, "out of memory") != 0)
free ((char *) result->errstring);
result->errstring = buf;
}
/* Mark the error as returned. */
result->returned = 1;
}
return buf;
}
static void
universal (struct svc_req *rqstp, SVCXPRT *transp_l)
{
int prog, proc;
char *outdata;
char xdrbuf[UDPMSGSIZE];
struct proglst_ *pl;
char *buf = NULL;
/*
* enforce "procnum 0 is echo" convention
*/
if (rqstp->rq_proc == NULLPROC)
{
if (INTUSE(svc_sendreply) (transp_l, (xdrproc_t)INTUSE(xdr_void),
(char *) NULL) == FALSE)
{
__write (STDERR_FILENO, "xxx\n", 4);
exit (1);
}
return;
}
prog = rqstp->rq_prog;
proc = rqstp->rq_proc;
for (pl = proglst; pl != NULL; pl = pl->p_nxt)
if (pl->p_prognum == prog && pl->p_procnum == proc)
{
/* decode arguments into a CLEAN buffer */
__bzero (xdrbuf, sizeof (xdrbuf)); /* required ! */
if (!svc_getargs (transp_l, pl->p_inproc, xdrbuf))
{
INTUSE(svcerr_decode) (transp_l);
return;
}
outdata = (*(pl->p_progname)) (xdrbuf);
if (outdata == NULL && pl->p_outproc != (xdrproc_t)INTUSE(xdr_void))
/* there was an error */
return;
if (!INTUSE(svc_sendreply) (transp_l, pl->p_outproc, outdata))
{
if (__asprintf (&buf, _("trouble replying to prog %d\n"),
pl->p_prognum) < 0)
buf = NULL;
goto err_out2;
}
/* free the decoded arguments */
(void) svc_freeargs (transp_l, pl->p_inproc, xdrbuf);
return;
}
if (__asprintf (&buf, _("never registered prog %d\n"), prog) < 0)
buf = NULL;
err_out2:
if (buf == NULL)
exit (1);
__fxprintf (NULL, "%s", buf);
free (buf);
exit (1);
}
int
registerrpc (u_long prognum, u_long versnum, u_long procnum,
char *(*progname) (char *), xdrproc_t inproc, xdrproc_t outproc)
{
struct proglst_ *pl;
char *buf;
if (procnum == NULLPROC)
{
if (__asprintf (&buf, _("can't reassign procedure number %ld\n"),
NULLPROC) < 0)
buf = NULL;
goto err_out;
}
if (transp == 0)
{
transp = INTUSE(svcudp_create) (RPC_ANYSOCK);
if (transp == NULL)
{
buf = strdup (_("couldn't create an rpc server\n"));
goto err_out;
}
}
(void) pmap_unset ((u_long) prognum, (u_long) versnum);
if (!svc_register (transp, (u_long) prognum, (u_long) versnum,
universal, IPPROTO_UDP))
{
if (__asprintf (&buf, _("couldn't register prog %ld vers %ld\n"),
prognum, versnum) < 0)
buf = NULL;
goto err_out;
}
pl = (struct proglst_ *) malloc (sizeof (struct proglst_));
if (pl == NULL)
{
buf = strdup (_("registerrpc: out of memory\n"));
goto err_out;
}
pl->p_progname = progname;
pl->p_prognum = prognum;
pl->p_procnum = procnum;
pl->p_inproc = inproc;
pl->p_outproc = outproc;
pl->p_nxt = proglst;
proglst = pl;
return 0;
err_out:
if (buf == NULL)
return -1;
(void) __fxprintf (NULL, "%s", buf);
free (buf);
return -1;
}
/* Print out on stderr a line consisting of the test in S, a colon, a space,
a message describing the meaning of the signal number SIG and a newline.
If S is NULL or "", the colon and space are omitted. */
void
psignal (int sig, const char *s)
{
const char *colon, *desc;
if (s == NULL || *s == '\0')
s = colon = "";
else
colon = ": ";
if (sig >= 0 && sig < NSIG && (desc = _sys_siglist[sig]) != NULL)
(void) __fxprintf (NULL, "%s%s%s\n", s, colon, _(desc));
else
{
char *buf;
if (__asprintf (&buf, _("%s%sUnknown signal %d\n"), s, colon, sig) < 0)
(void) __fxprintf (NULL, "%s%s%s\n", s, colon, _("Unknown signal"));
else
{
(void) __fxprintf (NULL, "%s", buf);
free (buf);
}
}
}
void
__assert_fail (const char *assertion, const char *file, unsigned int line,
const char *function)
{
char *buf;
#ifdef FATAL_PREPARE
FATAL_PREPARE;
#endif
if (__asprintf (&buf, _("%s%s%s:%u: %s%sAssertion `%s' failed.\n"),
__progname, __progname[0] ? ": " : "",
file, line,
function ? function : "", function ? ": " : "",
assertion) >= 0)
{
/* Print the message. */
(void) __fxprintf (NULL, "%s", buf);
(void) fflush (stderr);
/* We have to free the old buffer since the application might
catch the SIGABRT signal. */
char *old = atomic_exchange_acq (&__abort_msg, buf);
free (old);
}
else
{
/* At least print a minimal message. */
static const char errstr[] = "Unexpected error.\n";
__libc_write (STDERR_FILENO, errstr, sizeof (errstr) - 1);
}
abort ();
}
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 ();
}
void
__assert_fail (const char *assertion, const char *file, unsigned int line,
const char *function)
{
char *buf;
#ifdef FATAL_PREPARE
FATAL_PREPARE;
#endif
(void) __asprintf (&buf, _("%s%s%s:%u: %s%sAssertion `%s' failed.\n"),
__progname, __progname[0] ? ": " : "",
file, line,
function ? function : "", function ? ": " : "",
assertion);
/* Print the message. */
#ifdef USE_IN_LIBIO
if (_IO_fwide (stderr, 0) > 0)
(void) __fwprintf (stderr, L"%s", buf);
else
#endif
(void) fputs (buf, stderr);
(void) fflush (stderr);
/* We have to free the buffer since the appplication might catch the
SIGABRT. */
free (buf);
abort ();
}
/* Return a string describing the errno code in ERRNUM. */
char *
strerror_l (int errnum, locale_t loc)
{
int system;
int sub;
int code;
const struct error_system *es;
extern void __mach_error_map_compat (int *);
__mach_error_map_compat (&errnum);
system = err_get_system (errnum);
sub = err_get_sub (errnum);
code = err_get_code (errnum);
if (system > err_max_system || ! __mach_error_systems[system].bad_sub)
{
free (last_value);
if (__asprintf (&last_value, "%s%X",
translate ("Error in unknown error system: ", loc),
errnum) == -1)
last_value = NULL;
return last_value;
}
es = &__mach_error_systems[system];
if (sub >= es->max_sub)
return (char *) translate (es->bad_sub, loc);
if (code >= es->subsystem[sub].max_code)
{
free (last_value);
if (__asprintf (&last_value, "%s%s %d",
translate ("Unknown error ", loc),
translate (es->subsystem[sub].subsys_name, loc),
errnum) == -1)
last_value = NULL;
return last_value;
}
return (char *) translate (es->subsystem[sub].codes[code], loc);
}
void
__assert_fail_base (const char *fmt, const char *assertion, const char *file,
unsigned int line, const char *function)
{
char *str;
#ifdef FATAL_PREPARE
FATAL_PREPARE;
#endif
int total;
if (__asprintf (&str, fmt,
__progname, __progname[0] ? ": " : "",
file, line,
function ? function : "", function ? ": " : "",
assertion, &total) >= 0)
{
/* Print the message. */
(void) __fxprintf (NULL, "%s", str);
(void) fflush (stderr);
total = (total + 1 + GLRO(dl_pagesize) - 1) & ~(GLRO(dl_pagesize) - 1);
struct abort_msg_s *buf = __mmap (NULL, total, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, -1, 0);
if (__builtin_expect (buf != MAP_FAILED, 1))
{
buf->size = total;
strcpy (buf->msg, str);
/* We have to free the old buffer since the application might
catch the SIGABRT signal. */
struct abort_msg_s *old = atomic_exchange_acq (&__abort_msg, buf);
if (old != NULL)
__munmap (old, old->size);
}
free (str);
}
else
{
/* At least print a minimal message. */
static const char errstr[] = "Unexpected error.\n";
__libc_write (STDERR_FILENO, errstr, sizeof (errstr) - 1);
}
abort ();
}
static int lock_mem_block (struct _LOCK_FOR_POOL * pstGlue, const char * pcName, struct _MEM_PTR * pstPtr) {
int err = SUCCESS;
char * pcLockName = NULL;
struct _MEM_LOCK stNewLock, *pstExistingLock = NULL;
if (pcName) {
for (__list_start_iterator(pstGlue->stLockList.pData, 0); __list_has_next(pstGlue->stLockList.pData); pstExistingLock = NULL) {
pstExistingLock = (struct _MEM_LOCK *)__list_next(pstGlue->stLockList.pData, NULL, NULL);
if (!strcmp(pstExistingLock->pcName, pcName)) {
break;
}
}
} else {
pstExistingLock = (struct _MEM_LOCK *)__list_get(pstGlue->stLockList.pData, 0, NULL);
}
if (!pstExistingLock) {
if (pcName) {
if (!(pcLockName = __asprintf("%s%s", pcName, SHARED_MEM_LOCK_SUFFIX))) {
err = MEM_POOL_LOCK_ERROR;
goto error;
}
} // Create the lock first then add to the list / tree
if (!__semaphore_create(&stNewLock.pLockHandle, pcLockName, 1)) {
err = MEM_POOL_LOCK_ERROR;
goto error;
}
if (err = __semaphore_acquire(stNewLock.pLockHandle, SHARED_MEM_LOCK_TIMEOUT)) {
__semaphore_destroy(stNewLock.pLockHandle);
goto error;
}
stNewLock.pcName = (pcName ? pcName : "");
if (!__list_insert(pstGlue->stLockList.pData, 0, 0, &stNewLock)) {
err = MEM_POOL_LOCK_ERROR;
__semaphore_release(stNewLock.pLockHandle);
__semaphore_destroy(stNewLock.pLockHandle);
}
} else {
if (err = __semaphore_acquire(pstExistingLock->pLockHandle, SHARED_MEM_LOCK_TIMEOUT)) {
goto error;
}
}
error:
free(pstExistingLock);
free(pcLockName);
return err;
}
/* Return a string describing the errno code in ERRNUM. */
char *
strerror_l (int errnum, locale_t loc)
{
if (__builtin_expect (errnum < 0 || errnum >= _sys_nerr_internal
|| _sys_errlist_internal[errnum] == NULL, 0))
{
free (last_value);
if (__asprintf (&last_value, "%s%d",
translate ("Unknown error ", loc), errnum) == -1)
last_value = NULL;
return last_value;
}
return (char *) translate (_sys_errlist_internal[errnum], loc);
}
void
__assert_fail (const char *assertion, const char *file, unsigned int line,
const char *function)
{
char *buf;
#ifdef FATAL_PREPARE
FATAL_PREPARE;
#endif
if (__asprintf (&buf, _("%s%s%s:%u: %s%sAssertion `%s' failed.\n"),
__progname, __progname[0] ? ": " : "",
file, line,
function ? function : "", function ? ": " : "",
assertion) >= 0)
{
/* Print the message. */
#ifdef USE_IN_LIBIO
if (_IO_fwide (stderr, 0) > 0)
(void) __fwprintf (stderr, L"%s", buf);
else
#endif
(void) fputs (buf, stderr);
(void) fflush (stderr);
/* We have to free the buffer since the application 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 ();
}
static int lock_mem_pool (struct _LOCK_FOR_POOL * pstGlue) {
struct _MEM_POOL * pstPool = (struct _MEM_POOL *)pstGlue->pPool;
char * pcLockName = NULL;
int err = SUCCESS;
if (!pstGlue->poolLock) {
if (pstPool->pcID) {
if (!(pcLockName = __asprintf("%s%s", pstPool->pcID, SHARED_MEM_LOCK_SUFFIX))) {
err = MEM_POOL_LOCK_ERROR;
goto error;
}
}
if (!__semaphore_create(&pstGlue->poolLock, pcLockName, 1)) {
err = MEM_POOL_LOCK_ERROR;
goto error;
}
}
if (err = __semaphore_acquire(pstGlue->poolLock, SHARED_MEM_LOCK_TIMEOUT)) {
goto error;
}
error:
free(pcLockName), pcLockName = NULL;
return err;
}
/* If we run out of memory, we don't give already allocated memory
free. The overhead for bringing getnames back in a safe state to
free it is to big. */
nis_name *
nis_getnames (const_nis_name name)
{
const char *local_domain = nis_local_directory ();
size_t local_domain_len = strlen (local_domain);
size_t name_len = strlen (name);
char *path;
int pos = 0;
char *saveptr = NULL;
int have_point;
const char *cp;
const char *cp2;
int count = 2;
nis_name *getnames = malloc ((count + 1) * sizeof (char *));
if (__glibc_unlikely (getnames == NULL))
return NULL;
/* Do we have a fully qualified NIS+ name ? If yes, give it back */
if (name[name_len - 1] == '.')
{
if ((getnames[0] = strdup (name)) == NULL)
{
free_null:
while (pos-- > 0)
free (getnames[pos]);
free (getnames);
return NULL;
}
getnames[1] = NULL;
return getnames;
}
/* If the passed NAME is shared a suffix (the latter of course with
a final dot) with each other we pass back NAME with a final
dot. */
if (local_domain_len > 2)
{
have_point = 0;
cp = &local_domain[local_domain_len - 2];
cp2 = &name[name_len - 1];
while (*cp == *cp2)
{
if (*cp == '.')
have_point = 1;
--cp;
--cp2;
if (cp < local_domain)
{
have_point = cp2 < name || *cp2 == '.';
break;
}
if (cp2 < name)
{
have_point = *cp == '.';
break;
}
}
if (have_point)
{
getnames[0] = malloc (name_len + 2);
if (getnames[0] == NULL)
goto free_null;
strcpy (stpcpy (getnames[0], name), ".");
++pos;
}
}
/* Get the search path, where we have to search "name" */
path = getenv ("NIS_PATH");
if (path == NULL)
path = strdupa ("$");
else
path = strdupa (path);
have_point = strchr (name, '.') != NULL;
cp = __strtok_r (path, ":", &saveptr);
while (cp)
{
if (strcmp (cp, "$") == 0)
{
const char *cptr = local_domain;
char *tmp;
while (*cptr != '\0' && count_dots (cptr) >= 2)
{
if (pos >= count)
{
count += 5;
nis_name *newp = realloc (getnames,
(count + 1) * sizeof (char *));
if (__glibc_unlikely (newp == NULL))
goto free_null;
getnames = newp;
}
tmp = malloc (strlen (cptr) + local_domain_len + name_len + 2);
if (__glibc_unlikely (tmp == NULL))
goto free_null;
getnames[pos] = tmp;
tmp = stpcpy (tmp, name);
*tmp++ = '.';
if (cptr[1] != '\0')
stpcpy (tmp, cptr);
else
++cptr;
++pos;
while (*cptr != '.' && *cptr != '\0')
++cptr;
if (cptr[0] != '\0' && cptr[1] != '\0')
/* If we have only ".", don't remove the "." */
++cptr;
}
}
else
{
char *tmp;
size_t cplen = strlen (cp);
if (cp[cplen - 1] == '$')
{
char *p;
tmp = malloc (cplen + local_domain_len + name_len + 2);
if (__glibc_unlikely (tmp == NULL))
goto free_null;
p = __stpcpy (tmp, name);
*p++ = '.';
p = __mempcpy (p, cp, cplen);
--p;
if (p[-1] != '.')
*p++ = '.';
__stpcpy (p, local_domain);
}
else
{
char *p;
tmp = malloc (cplen + name_len + 3);
if (__glibc_unlikely (tmp == NULL))
goto free_null;
p = __mempcpy (tmp, name, name_len);
*p++ = '.';
p = __mempcpy (p, cp, cplen);
if (p[-1] != '.')
*p++ = '.';
*p = '\0';
}
if (pos >= count)
{
count += 5;
nis_name *newp = realloc (getnames,
(count + 1) * sizeof (char *));
if (__glibc_unlikely (newp == NULL))
goto free_null;
getnames = newp;
}
getnames[pos] = tmp;
++pos;
}
cp = __strtok_r (NULL, ":", &saveptr);
}
if (pos == 0
&& __asprintf (&getnames[pos++], "%s%s%s%s",
name, name[name_len - 1] == '.' ? "" : ".",
local_domain,
local_domain[local_domain_len - 1] == '.' ? "" : ".") < 0)
goto free_null;
getnames[pos] = NULL;
return getnames;
}
