/*
 * Copyright 2012, 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.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * 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);
}