libportable to adapt L header functions.
Change-Id: Ie15c321ee3b1b21f264b12641bc064ee33dec418
This commit is contained in:
WenHan Gu
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2012, The Android Open Source Project
|
||||
* Copyright 2014, The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -14,357 +14,4 @@
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include <portability.h>
|
||||
#include <pthread.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <errno_portable.h>
|
||||
|
||||
#define PORTABLE_TAG "errno_portable"
|
||||
#include <log_portable.h>
|
||||
|
||||
#if ENAMETOOLONG==ENAMETOOLONG_PORTABLE
|
||||
#error Bad build environment
|
||||
#endif
|
||||
|
||||
__hidden int errno_ntop(int native_errno)
|
||||
{
|
||||
switch (native_errno) {
|
||||
case ENAMETOOLONG: return ENAMETOOLONG_PORTABLE;
|
||||
case ENOLCK: return ENOLCK_PORTABLE;
|
||||
case ENOSYS: return ENOSYS_PORTABLE;
|
||||
case ENOTEMPTY: return ENOTEMPTY_PORTABLE;
|
||||
case ELOOP: return ELOOP_PORTABLE;
|
||||
case EWOULDBLOCK: return EWOULDBLOCK_PORTABLE;
|
||||
case ENOMSG: return ENOMSG_PORTABLE;
|
||||
case EIDRM: return EIDRM_PORTABLE;
|
||||
case ECHRNG: return ECHRNG_PORTABLE;
|
||||
case EL2NSYNC: return EL2NSYNC_PORTABLE;
|
||||
case EL3HLT: return EL3HLT_PORTABLE;
|
||||
case EL3RST: return EL3RST_PORTABLE;
|
||||
case ELNRNG: return ELNRNG_PORTABLE;
|
||||
case EUNATCH: return EUNATCH_PORTABLE;
|
||||
case ENOCSI: return ENOCSI_PORTABLE;
|
||||
case EL2HLT: return EL2HLT_PORTABLE;
|
||||
case EBADE: return EBADE_PORTABLE;
|
||||
case EBADR: return EBADR_PORTABLE;
|
||||
case EXFULL: return EXFULL_PORTABLE;
|
||||
case ENOANO: return ENOANO_PORTABLE;
|
||||
case EBADRQC: return EBADRQC_PORTABLE;
|
||||
case EBADSLT: return EBADSLT_PORTABLE;
|
||||
case EDEADLOCK: return EDEADLOCK_PORTABLE;
|
||||
case EBFONT: return EBFONT_PORTABLE;
|
||||
case ENOSTR: return ENOSTR_PORTABLE;
|
||||
case ENODATA: return ENODATA_PORTABLE;
|
||||
case ETIME: return ETIME_PORTABLE;
|
||||
case ENOSR: return ENOSR_PORTABLE;
|
||||
case ENONET: return ENONET_PORTABLE;
|
||||
case ENOPKG: return ENOPKG_PORTABLE;
|
||||
case EREMOTE: return EREMOTE_PORTABLE;
|
||||
case ENOLINK: return ENOLINK_PORTABLE;
|
||||
case EADV: return EADV_PORTABLE;
|
||||
case ESRMNT: return ESRMNT_PORTABLE;
|
||||
case ECOMM: return ECOMM_PORTABLE;
|
||||
case EPROTO: return EPROTO_PORTABLE;
|
||||
case EMULTIHOP: return EMULTIHOP_PORTABLE;
|
||||
case EDOTDOT: return EDOTDOT_PORTABLE;
|
||||
case EBADMSG: return EBADMSG_PORTABLE;
|
||||
case EOVERFLOW: return EOVERFLOW_PORTABLE;
|
||||
case ENOTUNIQ: return ENOTUNIQ_PORTABLE;
|
||||
case EBADFD: return EBADFD_PORTABLE;
|
||||
case EREMCHG: return EREMCHG_PORTABLE;
|
||||
case ELIBACC: return ELIBACC_PORTABLE;
|
||||
case ELIBBAD: return ELIBBAD_PORTABLE;
|
||||
case ELIBSCN: return ELIBSCN_PORTABLE;
|
||||
case ELIBMAX: return ELIBMAX_PORTABLE;
|
||||
case ELIBEXEC: return ELIBEXEC_PORTABLE;
|
||||
case EILSEQ: return EILSEQ_PORTABLE;
|
||||
case ERESTART: return ERESTART_PORTABLE;
|
||||
case ESTRPIPE: return ESTRPIPE_PORTABLE;
|
||||
case EUSERS: return EUSERS_PORTABLE;
|
||||
case ENOTSOCK: return ENOTSOCK_PORTABLE;
|
||||
case EDESTADDRREQ: return EDESTADDRREQ_PORTABLE;
|
||||
case EMSGSIZE: return EMSGSIZE_PORTABLE;
|
||||
case EPROTOTYPE: return EPROTOTYPE_PORTABLE;
|
||||
case ENOPROTOOPT: return ENOPROTOOPT_PORTABLE;
|
||||
case EPROTONOSUPPORT: return EPROTONOSUPPORT_PORTABLE;
|
||||
case ESOCKTNOSUPPORT: return ESOCKTNOSUPPORT_PORTABLE;
|
||||
case EOPNOTSUPP: return EOPNOTSUPP_PORTABLE;
|
||||
case EPFNOSUPPORT: return EPFNOSUPPORT_PORTABLE;
|
||||
case EAFNOSUPPORT: return EAFNOSUPPORT_PORTABLE;
|
||||
case EADDRINUSE: return EADDRINUSE_PORTABLE;
|
||||
case EADDRNOTAVAIL: return EADDRNOTAVAIL_PORTABLE;
|
||||
case ENETDOWN: return ENETDOWN_PORTABLE;
|
||||
case ENETUNREACH: return ENETUNREACH_PORTABLE;
|
||||
case ENETRESET: return ENETRESET_PORTABLE;
|
||||
case ECONNABORTED: return ECONNABORTED_PORTABLE;
|
||||
case ECONNRESET: return ECONNRESET_PORTABLE;
|
||||
case ENOBUFS: return ENOBUFS_PORTABLE;
|
||||
case EISCONN: return EISCONN_PORTABLE;
|
||||
case ENOTCONN: return ENOTCONN_PORTABLE;
|
||||
case ESHUTDOWN: return ESHUTDOWN_PORTABLE;
|
||||
case ETOOMANYREFS: return ETOOMANYREFS_PORTABLE;
|
||||
case ETIMEDOUT: return ETIMEDOUT_PORTABLE;
|
||||
case ECONNREFUSED: return ECONNREFUSED_PORTABLE;
|
||||
case EHOSTDOWN: return EHOSTDOWN_PORTABLE;
|
||||
case EHOSTUNREACH: return EHOSTUNREACH_PORTABLE;
|
||||
case EALREADY: return EALREADY_PORTABLE;
|
||||
case EINPROGRESS: return EINPROGRESS_PORTABLE;
|
||||
case ESTALE: return ESTALE_PORTABLE;
|
||||
case EUCLEAN: return EUCLEAN_PORTABLE;
|
||||
case ENOTNAM: return ENOTNAM_PORTABLE;
|
||||
case ENAVAIL: return ENAVAIL_PORTABLE;
|
||||
case EISNAM: return EISNAM_PORTABLE;
|
||||
case EREMOTEIO: return EREMOTEIO_PORTABLE;
|
||||
case EDQUOT: return EDQUOT_PORTABLE;
|
||||
case ENOMEDIUM: return ENOMEDIUM_PORTABLE;
|
||||
case EMEDIUMTYPE: return EMEDIUMTYPE_PORTABLE;
|
||||
case ECANCELED: return ECANCELED_PORTABLE;
|
||||
case ENOKEY: return ENOKEY_PORTABLE;
|
||||
case EKEYEXPIRED: return EKEYEXPIRED_PORTABLE;
|
||||
case EKEYREVOKED: return EKEYREVOKED_PORTABLE;
|
||||
case EKEYREJECTED: return EKEYREJECTED_PORTABLE;
|
||||
case EOWNERDEAD: return EOWNERDEAD_PORTABLE;
|
||||
case ENOTRECOVERABLE: return ENOTRECOVERABLE_PORTABLE;
|
||||
}
|
||||
return native_errno;
|
||||
}
|
||||
|
||||
__hidden int errno_pton(int portable_errno)
|
||||
{
|
||||
switch (portable_errno) {
|
||||
case ENAMETOOLONG_PORTABLE: return ENAMETOOLONG;
|
||||
case ENOLCK_PORTABLE: return ENOLCK;
|
||||
case ENOSYS_PORTABLE: return ENOSYS;
|
||||
case ENOTEMPTY_PORTABLE: return ENOTEMPTY;
|
||||
case ELOOP_PORTABLE: return ELOOP;
|
||||
case EWOULDBLOCK_PORTABLE: return EWOULDBLOCK;
|
||||
case ENOMSG_PORTABLE: return ENOMSG;
|
||||
case EIDRM_PORTABLE: return EIDRM;
|
||||
case ECHRNG_PORTABLE: return ECHRNG;
|
||||
case EL2NSYNC_PORTABLE: return EL2NSYNC;
|
||||
case EL3HLT_PORTABLE: return EL3HLT;
|
||||
case EL3RST_PORTABLE: return EL3RST;
|
||||
case ELNRNG_PORTABLE: return ELNRNG;
|
||||
case EUNATCH_PORTABLE: return EUNATCH;
|
||||
case ENOCSI_PORTABLE: return ENOCSI;
|
||||
case EL2HLT_PORTABLE: return EL2HLT;
|
||||
case EBADE_PORTABLE: return EBADE;
|
||||
case EBADR_PORTABLE: return EBADR;
|
||||
case EXFULL_PORTABLE: return EXFULL;
|
||||
case ENOANO_PORTABLE: return ENOANO;
|
||||
case EBADRQC_PORTABLE: return EBADRQC;
|
||||
case EBADSLT_PORTABLE: return EBADSLT;
|
||||
case EDEADLOCK_PORTABLE: return EDEADLOCK;
|
||||
case EBFONT_PORTABLE: return EBFONT;
|
||||
case ENOSTR_PORTABLE: return ENOSTR;
|
||||
case ENODATA_PORTABLE: return ENODATA;
|
||||
case ETIME_PORTABLE: return ETIME;
|
||||
case ENOSR_PORTABLE: return ENOSR;
|
||||
case ENONET_PORTABLE: return ENONET;
|
||||
case ENOPKG_PORTABLE: return ENOPKG;
|
||||
case EREMOTE_PORTABLE: return EREMOTE;
|
||||
case ENOLINK_PORTABLE: return ENOLINK;
|
||||
case EADV_PORTABLE: return EADV;
|
||||
case ESRMNT_PORTABLE: return ESRMNT;
|
||||
case ECOMM_PORTABLE: return ECOMM;
|
||||
case EPROTO_PORTABLE: return EPROTO;
|
||||
case EMULTIHOP_PORTABLE: return EMULTIHOP;
|
||||
case EDOTDOT_PORTABLE: return EDOTDOT;
|
||||
case EBADMSG_PORTABLE: return EBADMSG;
|
||||
case EOVERFLOW_PORTABLE: return EOVERFLOW;
|
||||
case ENOTUNIQ_PORTABLE: return ENOTUNIQ;
|
||||
case EBADFD_PORTABLE: return EBADFD;
|
||||
case EREMCHG_PORTABLE: return EREMCHG;
|
||||
case ELIBACC_PORTABLE: return ELIBACC;
|
||||
case ELIBBAD_PORTABLE: return ELIBBAD;
|
||||
case ELIBSCN_PORTABLE: return ELIBSCN;
|
||||
case ELIBMAX_PORTABLE: return ELIBMAX;
|
||||
case ELIBEXEC_PORTABLE: return ELIBEXEC;
|
||||
case EILSEQ_PORTABLE: return EILSEQ;
|
||||
case ERESTART_PORTABLE: return ERESTART;
|
||||
case ESTRPIPE_PORTABLE: return ESTRPIPE;
|
||||
case EUSERS_PORTABLE: return EUSERS;
|
||||
case ENOTSOCK_PORTABLE: return ENOTSOCK;
|
||||
case EDESTADDRREQ_PORTABLE: return EDESTADDRREQ;
|
||||
case EMSGSIZE_PORTABLE: return EMSGSIZE;
|
||||
case EPROTOTYPE_PORTABLE: return EPROTOTYPE;
|
||||
case ENOPROTOOPT_PORTABLE: return ENOPROTOOPT;
|
||||
case EPROTONOSUPPORT_PORTABLE: return EPROTONOSUPPORT;
|
||||
case ESOCKTNOSUPPORT_PORTABLE: return ESOCKTNOSUPPORT;
|
||||
case EOPNOTSUPP_PORTABLE: return EOPNOTSUPP;
|
||||
case EPFNOSUPPORT_PORTABLE: return EPFNOSUPPORT;
|
||||
case EAFNOSUPPORT_PORTABLE: return EAFNOSUPPORT;
|
||||
case EADDRINUSE_PORTABLE: return EADDRINUSE;
|
||||
case EADDRNOTAVAIL_PORTABLE: return EADDRNOTAVAIL;
|
||||
case ENETDOWN_PORTABLE: return ENETDOWN;
|
||||
case ENETUNREACH_PORTABLE: return ENETUNREACH;
|
||||
case ENETRESET_PORTABLE: return ENETRESET;
|
||||
case ECONNABORTED_PORTABLE: return ECONNABORTED;
|
||||
case ECONNRESET_PORTABLE: return ECONNRESET;
|
||||
case ENOBUFS_PORTABLE: return ENOBUFS;
|
||||
case EISCONN_PORTABLE: return EISCONN;
|
||||
case ENOTCONN_PORTABLE: return ENOTCONN;
|
||||
case ESHUTDOWN_PORTABLE: return ESHUTDOWN;
|
||||
case ETOOMANYREFS_PORTABLE: return ETOOMANYREFS;
|
||||
case ETIMEDOUT_PORTABLE: return ETIMEDOUT;
|
||||
case ECONNREFUSED_PORTABLE: return ECONNREFUSED;
|
||||
case EHOSTDOWN_PORTABLE: return EHOSTDOWN;
|
||||
case EHOSTUNREACH_PORTABLE: return EHOSTUNREACH;
|
||||
case EALREADY_PORTABLE: return EALREADY;
|
||||
case EINPROGRESS_PORTABLE: return EINPROGRESS;
|
||||
case ESTALE_PORTABLE: return ESTALE;
|
||||
case EUCLEAN_PORTABLE: return EUCLEAN;
|
||||
case ENOTNAM_PORTABLE: return ENOTNAM;
|
||||
case ENAVAIL_PORTABLE: return ENAVAIL;
|
||||
case EISNAM_PORTABLE: return EISNAM;
|
||||
case EREMOTEIO_PORTABLE: return EREMOTEIO;
|
||||
case EDQUOT_PORTABLE: return EDQUOT;
|
||||
case ENOMEDIUM_PORTABLE: return ENOMEDIUM;
|
||||
case EMEDIUMTYPE_PORTABLE: return EMEDIUMTYPE;
|
||||
case ECANCELED_PORTABLE: return ECANCELED;
|
||||
case ENOKEY_PORTABLE: return ENOKEY;
|
||||
case EKEYEXPIRED_PORTABLE: return EKEYEXPIRED;
|
||||
case EKEYREVOKED_PORTABLE: return EKEYREVOKED;
|
||||
case EKEYREJECTED_PORTABLE: return EKEYREJECTED;
|
||||
case EOWNERDEAD_PORTABLE: return EOWNERDEAD;
|
||||
case ENOTRECOVERABLE_PORTABLE: return ENOTRECOVERABLE;
|
||||
}
|
||||
return portable_errno;
|
||||
}
|
||||
|
||||
/* Key for the thread-specific portable errno */
|
||||
static pthread_key_t errno_key;
|
||||
|
||||
/* Once-only initialisation of the key */
|
||||
static pthread_once_t errno_key_once = PTHREAD_ONCE_INIT;
|
||||
|
||||
/* Free the thread-specific portable errno */
|
||||
static void errno_key_destroy(void *buf)
|
||||
{
|
||||
if (buf)
|
||||
free(buf);
|
||||
}
|
||||
|
||||
/* Allocate the key */
|
||||
static void errno_key_create(void)
|
||||
{
|
||||
pthread_key_create(&errno_key, errno_key_destroy);
|
||||
}
|
||||
|
||||
struct errno_state {
|
||||
int pshadow; /* copy of last portable errno */
|
||||
int perrno; /* portable errno that may be modified by app */
|
||||
};
|
||||
|
||||
/* Return the thread-specific portable errno */
|
||||
static struct errno_state *errno_key_data(void)
|
||||
{
|
||||
struct errno_state *data;
|
||||
static struct errno_state errno_state;
|
||||
|
||||
pthread_once(&errno_key_once, errno_key_create);
|
||||
data = (struct errno_state *)pthread_getspecific(errno_key);
|
||||
if (data == NULL) {
|
||||
data = malloc(sizeof(struct errno_state));
|
||||
pthread_setspecific(errno_key, data);
|
||||
}
|
||||
if (data == NULL)
|
||||
data = &errno_state;
|
||||
return data;
|
||||
}
|
||||
|
||||
/*
|
||||
* Attempt to return a thread specific location containnig the portable errno.
|
||||
* This can be assigned to without affecting the native errno. If the key
|
||||
* allocation fails fall back to using the native errno location.
|
||||
*/
|
||||
volatile int* WRAP(__errno)()
|
||||
{
|
||||
struct errno_state *p;
|
||||
int save_errno;
|
||||
|
||||
/* pthread_* calls may modify errno so use a copy */
|
||||
save_errno = *REAL(__errno)();
|
||||
|
||||
p = errno_key_data();
|
||||
|
||||
ALOGV(" ");
|
||||
ALOGV("%s(): { save_errno = errno:%d, (p:%p)->{pshadow:%d, perrno:%d}", __func__,
|
||||
save_errno, p, p->pshadow, p->perrno);
|
||||
|
||||
if (save_errno == 0 && p->pshadow != p->perrno) {
|
||||
/*
|
||||
* portable errno has changed but native hasn't
|
||||
* - copy portable error back to native
|
||||
*/
|
||||
p->pshadow = p->perrno;
|
||||
save_errno = errno_pton(p->perrno);
|
||||
}
|
||||
else if (save_errno != 0 && p->pshadow == p->perrno) {
|
||||
/*
|
||||
* Native errno has changed but portable hasn't
|
||||
* - copy native error to portable.
|
||||
*/
|
||||
p->pshadow = p->perrno = errno_ntop(save_errno);
|
||||
save_errno = 0;
|
||||
}
|
||||
else if (save_errno != 0 && p->pshadow != p->perrno) {
|
||||
/*
|
||||
* Both native and portable errno values have changed
|
||||
* so give priority to native errno
|
||||
* - copy native error to portable
|
||||
*/
|
||||
p->pshadow = p->perrno = errno_ntop(save_errno);
|
||||
save_errno = 0;
|
||||
}
|
||||
|
||||
ALOGV("%s: new save_errno:%d p:%p->{pshadow:%d, perrno:%d}", __func__,
|
||||
save_errno, p, p->pshadow, p->perrno);
|
||||
|
||||
*REAL(__errno)() = save_errno;
|
||||
|
||||
ALOGV("%s: return (&p->perrno):%p; }", __func__, &p->perrno);
|
||||
|
||||
/* return pointer to the modifiable portable errno value */
|
||||
return &p->perrno;
|
||||
}
|
||||
|
||||
|
||||
/* set portable errno */
|
||||
void WRAP(__set_errno)(int portable_errno)
|
||||
{
|
||||
struct errno_state *p;
|
||||
int save_errno;
|
||||
|
||||
/* pthread_* calls may modify errno so use a copy */
|
||||
save_errno = *REAL(__errno)();
|
||||
|
||||
p = errno_key_data();
|
||||
|
||||
ALOGV("%s(): { save_errno = errno:%d, p:%p->{pshadow:%d, perrno:%d}", __func__,
|
||||
save_errno, p, p->pshadow, p->perrno);
|
||||
|
||||
p->pshadow = p->perrno = portable_errno;
|
||||
|
||||
save_errno = errno_pton(portable_errno);
|
||||
|
||||
ALOGV("%s: new save_errno:%d, p:%p->{pshadow:%d, perrno:%d}", __func__,
|
||||
save_errno, p, p->pshadow, p->perrno);
|
||||
|
||||
*REAL(__errno)() = save_errno;
|
||||
|
||||
ALOGV("%s: return; }", __func__);
|
||||
}
|
||||
|
||||
extern char* REAL(strerror)(int);
|
||||
char *WRAP(strerror)(int errnum)
|
||||
{
|
||||
return REAL(strerror)(errno_pton(errnum));
|
||||
}
|
||||
|
||||
/* BSD style strerror_r */
|
||||
int WRAP(strerror_r)(int errnum, char *buf, size_t buflen)
|
||||
{
|
||||
return REAL(strerror_r)(errno_pton(errnum), buf, buflen);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user