wsock/wsock20/dllfunc.c

/*
 * dllfunc.c - wrapper functions
 */

/*
 * Copyright (c) 2000,2002 Japan Network Information Center.
 * All rights reserved.
 *
 * By using this file, you agree to the terms and conditions set forth bellow.
 *
 *          LICENSE TERMS AND CONDITIONS
 *
 * The following License Terms and Conditions apply, unless a different
 * license is obtained from Japan Network Information Center ("JPNIC"),
 * a Japanese association, Kokusai-Kougyou-Kanda Bldg 6F, 2-3-4 Uchi-Kanda,
 * Chiyoda-ku, Tokyo 101-0047, Japan.
 *
 * 1. Use, Modification and Redistribution (including distribution of any
 *    modified or derived work) in source and/or binary forms is permitted
 *    under this License Terms and Conditions.
 *
 * 2. Redistribution of source code must retain the copyright notices as they
 *    appear in each source code file, this License Terms and Conditions.
 *
 * 3. Redistribution in binary form must reproduce the Copyright Notice,
 *    this License Terms and Conditions, in the documentation and/or other
 *    materials provided with the distribution.  For the purposes of binary
 *    distribution the "Copyright Notice" refers to the following language:
 *    "Copyright (c) 2000-2002 Japan Network Information Center.  All rights reserved."
 *
 * 4. The name of JPNIC may not be used to endorse or promote products
 *    derived from this Software without specific prior written approval of
 *    JPNIC.
 *
 * 5. Disclaimer/Limitation of Liability: THIS SOFTWARE IS PROVIDED BY JPNIC
 *    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 *    PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL JPNIC BE LIABLE
 *    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 *    BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 *    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 *    OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 *    ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 */

#include <windows.h>
#include <svcguid.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <process.h>

#include "dlldef.h"

#ifndef EAI_MEMORY
#define EAI_MEMORY  WSA_NOT_ENOUGH_MEMORY
#endif
#ifndef EAI_FAIL
#define EAI_FAIL    WSANO_RECOVERY
#endif

static GUID guid_habn = SVCID_INET_HOSTADDRBYNAME;
static GUID guid_habis = SVCID_INET_HOSTADDRBYINETSTRING;

#define SVCID_IS_HABN(p) (memcmp(p, &guid_habn, sizeof(GUID)) == 0)
#define SVCID_IS_HABIS(p) (memcmp(p, &guid_habis, sizeof(GUID)) == 0)

/*
 * Rename addrinfo to my_addrinfo for avoiding possible name conflict.
 */
struct my_addrinfo {
    int     ai_flags;
    int     ai_family;
    int     ai_socktype;
    int     ai_protocol;
    size_t  ai_addrlen;
    char   *ai_canonname;
    struct sockaddr  *ai_addr;
    struct my_addrinfo  *ai_next;
};

typedef struct obj_lock {
    void *key;
    struct obj_lock *next;
} obj_lock_t;

#define OBJLOCKHASH_SIZE    127
static obj_lock_t *obj_lock_hash[OBJLOCKHASH_SIZE];

static int  obj_hash(void *key);
static int  obj_islocked(void *key);
static void obj_lock(void *key);
static void obj_unlock(void *key);
static char *decode_name_dynamic(const char *name, idn_resconf_t idnctx);
static struct my_addrinfo
        *copy_decode_addrinfo_dynamic(struct my_addrinfo *aip,
                          idn_resconf_t idnctx);
static void free_copied_addrinfo(struct my_addrinfo *aip);

WRAPPER_EXPORT int WSAAPI
gethostname(char FAR * name, int namelen) {
    int ret;

    TRACE("ENTER gethostname\n");
    ret = _org_gethostname(name, namelen);
    TRACE("LEAVE gethostname %d <%-.100s>\n", ret, name);

    return (ret);
}

WRAPPER_EXPORT struct hostent FAR * WSAAPI
gethostbyname(const char FAR * name) {
    struct hostent FAR *ret;
    char    nbuff[256];
    char    hbuff[256];
    BOOL    stat;
    idn_resconf_t   encodeCtx;

    TRACE("ENTER gethostbyname <%-.100s>\n",
          (name != NULL ? name : "NULL"));

    encodeCtx = idnGetContext();

    if (encodeCtx == NULL || name == NULL) {
        ret = _org_gethostbyname(name);
    } else {
        stat = idnConvReq(encodeCtx, name, nbuff, sizeof(nbuff));
        if (stat == FALSE) {
            TRACE("idnConvReq failed\n");
            ret = NULL;
        } else {
            TRACE("Converted Name <%s>\n",
                  dumpName(nbuff, hbuff, sizeof(hbuff)));
            ret = _org_gethostbyname(nbuff);
        }
    }

    if (ret != NULL && encodeCtx != NULL) {
        TRACE("Resulting Name <%s>\n",
              dumpName(ret->h_name, hbuff, sizeof(hbuff)));
        stat = idnConvRsp(encodeCtx, ret->h_name,
                  nbuff, sizeof(nbuff));
        if (stat == FALSE) {
            TRACE("Decoding failed - return the name verbatim\n");
        } else {
            TRACE("Converted Back <%s>\n",
                  dumpName(nbuff, hbuff, sizeof(hbuff)));
            strcpy(ret->h_name, nbuff);
        }
    }

    if (ret == NULL) {
        TRACE("LEAVE gethostbyname NULL\n");
    } else {
        TRACE("LEAVE gethostbyname <%s>\n",
              dumpHost(ret, hbuff, sizeof(hbuff)));
    }
    return (ret);
}

WRAPPER_EXPORT struct hostent FAR * WSAAPI
gethostbyaddr(const char FAR * addr, int len, int type) {
    struct hostent FAR *ret;
    char    nbuff[256];
    char    abuff[256];
    char    hbuff[256];
    BOOL    stat;
    idn_resconf_t   encodeCtx;

    TRACE("ENTER gethostbyaddr <%s>\n",
          dumpAddr(addr, len, abuff, sizeof(abuff)));

    encodeCtx = idnGetContext();

    ret = _org_gethostbyaddr(addr, len, type);

    if (ret != NULL && encodeCtx != NULL) {
        TRACE("Resulting Name <%s>\n",
              dumpName(ret->h_name, hbuff, sizeof(hbuff)));
        stat = idnConvRsp(encodeCtx, ret->h_name,
                  nbuff, sizeof(nbuff));
        if (stat == FALSE) {
            TRACE("Decoding failed - return the name verbatim\n");
        } else {
            TRACE("Converted Back <%s>\n",
                  dumpName(nbuff, hbuff, sizeof(hbuff)));
            strcpy(ret->h_name, nbuff);
        }
    }

    if (ret == NULL) {
        TRACE("LEAVE gethostbyaddr NULL\n");
    } else {
        TRACE("LEAVE gethostbyaddr <%s>\n",
              dumpHost(ret, hbuff, sizeof(hbuff)));
    }
    return (ret);
}

WRAPPER_EXPORT HANDLE WSAAPI
WSAAsyncGetHostByName(HWND hWnd, u_int wMsg,
              const char FAR * name, char FAR * buf, int buflen)
{
    HANDLE  ret;
    char    nbuff[256];
    char    hbuff[256];
    idn_resconf_t   encodeCtx;

    TRACE("ENTER WSAAsyncGetHostByName <%-.100s>\n", name);

    encodeCtx = idnGetContext();

    if (encodeCtx == NULL || name == NULL) {
        ret = _org_WSAAsyncGetHostByName(hWnd, wMsg,
                         name, buf, buflen);
    } else {
        idnHook(hWnd, wMsg, buf, encodeCtx);
        idnConvReq(encodeCtx, name, nbuff, sizeof(nbuff));
        TRACE("Converted Name <%s>\n",
              dumpName(nbuff, hbuff, sizeof(hbuff)));
        ret = _org_WSAAsyncGetHostByName(hWnd, wMsg, nbuff,
                         buf, buflen);
    }

    TRACE("LEAVE WSAAsyncGetHostByName HANDLE %08x\n", ret);

    return (ret);
}

WRAPPER_EXPORT HANDLE WSAAPI
WSAAsyncGetHostByAddr(HWND hWnd, u_int wMsg, const char FAR * addr,
              int len, int type, char FAR * buf, int buflen)
{
    HANDLE  ret;
    char    abuff[256];
    idn_resconf_t   encodeCtx;

    encodeCtx = idnGetContext();

    if (encodeCtx != NULL) {
        idnHook(hWnd, wMsg, buf, encodeCtx);
    }

    TRACE("ENTER WSAAsyncGetHostByAddr <%s>\n",
          dumpAddr(addr, len, abuff, sizeof(abuff)));
    ret = _org_WSAAsyncGetHostByAddr(hWnd, wMsg, addr, len, type,
                     buf, buflen);
    TRACE("LEAVE WSAAsyncGetHostByAddr HANDLE %08x\n", ret);

    return (ret);
}

WRAPPER_EXPORT INT WSAAPI
WSALookupServiceBeginA(LPWSAQUERYSETA lpqsRestrictions,
               DWORD dwControlFlags, LPHANDLE lphLookup)
{
    INT     ret;
    char    nbuff[256];
    char    hbuff[256];
    LPSTR   name = lpqsRestrictions->lpszServiceInstanceName;
    LPGUID  class = lpqsRestrictions->lpServiceClassId;
    idn_resconf_t   encodeCtx;

    TRACE("ENTER WSALookupServiceBeginA <%-.100s>\n",
          name == NULL ? "<NULL>" : name);

    encodeCtx = idnGetContext();

    if (name != NULL && encodeCtx != NULL && SVCID_IS_HABN(class) == 0) {
        idnConvReq(encodeCtx, name, nbuff, sizeof(nbuff));
        TRACE("Converted Name <%s>\n",
              dumpName(nbuff, hbuff, sizeof(hbuff)));
        /* strcpy(lpqsRestrictions->lpszQueryString, nbuff); */
        lpqsRestrictions->lpszServiceInstanceName = nbuff;
    }
    ret = _org_WSALookupServiceBeginA(lpqsRestrictions,
                      dwControlFlags, lphLookup);
    TRACE("LEAVE WSALookupServiceBeginA %d\n", ret);

    return (ret);
}

WRAPPER_EXPORT INT WSAAPI
WSALookupServiceNextA(HANDLE hLookup, DWORD dwControlFlags,
              LPDWORD lpdwBufferLength, LPWSAQUERYSETA lpqsResults)
{
    INT     ret;
    char    nbuff[256];
    char    hbuff[256];
    LPGUID  class;
    idn_resconf_t   encodeCtx;

    TRACE("ENTER WSALookupServiceNextA\n");

    encodeCtx = idnGetContext();

    ret = _org_WSALookupServiceNextA(hLookup, dwControlFlags,
                     lpdwBufferLength, lpqsResults);
    class = lpqsResults->lpServiceClassId;

    if (ret == 0 &&
        encodeCtx != NULL &&
        (dwControlFlags & LUP_RETURN_NAME) &&
        (SVCID_IS_HABN(class) || SVCID_IS_HABIS(class))) {
        TRACE("Resulting Name <%s>\n",
              dumpName(lpqsResults->lpszServiceInstanceName,
                   hbuff, sizeof(hbuff)));
        if (idnConvRsp(encodeCtx,
                   lpqsResults->lpszServiceInstanceName,
                   nbuff, sizeof(nbuff)) == FALSE) {
            TRACE("Decoding failed - return the name verbatim\n");
        } else {
            TRACE("Converted Back <%s>\n",
                  dumpName(nbuff, hbuff, sizeof(hbuff)));
            strcpy(lpqsResults->lpszServiceInstanceName, nbuff);
        }
    }
    TRACE("LEAVE WSALookupServiceNextA %d <%s>\n", ret, nbuff);

    return (ret);
}

WRAPPER_EXPORT INT WSAAPI
WSALookupServiceBeginW(LPWSAQUERYSETW lpqsRestrictions,
               DWORD dwControlFlags, LPHANDLE lphLookup)
{
    INT     ret;

    TRACE("ENTER WSALookupServiceBeginW\n");
    ret = _org_WSALookupServiceBeginW(lpqsRestrictions,
                      dwControlFlags,lphLookup);
    TRACE("LEAVE WSALookupServiceBeginW %d\n", ret);

    return (ret);
}

WRAPPER_EXPORT INT WSAAPI
WSALookupServiceNextW(HANDLE hLookup, DWORD dwControlFlags,
              LPDWORD lpdwBufferLength, LPWSAQUERYSETW lpqsResults)
{
    INT     ret;

    TRACE("ENTER WSALookupServiceNextW\n");
    ret = _org_WSALookupServiceNextW(hLookup, dwControlFlags,
                     lpdwBufferLength, lpqsResults);
    TRACE("LEAVE WSALookupServiceNextW %d\n", ret);

    return (ret);
}

WRAPPER_EXPORT INT WSAAPI
WSALookupServiceEnd(HANDLE  hLookup) {
    INT     ret;

    TRACE("ENTER WSALookupServiceEnd\n");
    ret = _org_WSALookupServiceEnd(hLookup);
    TRACE("LEAVE WSALookupServiceEnd %d\n", ret);

    return (ret);
}

static int
obj_hash(void *key) {
    /*
     * Hash function for obj_*.
     * 'key' is supposed to be an address.
     */
    unsigned long v = (unsigned long)key;

    return ((v >> 3) % OBJLOCKHASH_SIZE);
}

static int
obj_islocked(void *key)
{
    /*
     * Check if the object specified by 'key' is locked.
     * Return 1 if so, 0 otherwise.
     */
    int h = obj_hash(key);
    obj_lock_t *olp = obj_lock_hash[h];

    while (olp != NULL) {
        if (olp->key == key)
            return (1);
        olp = olp->next;
    }
    return (0);
}

static void
obj_lock(void *key)
{
    /*
     * Lock an object specified by 'key'.
     */
    int h = obj_hash(key);
    obj_lock_t *olp;

    olp = malloc(sizeof(obj_lock_t));
    if (olp != NULL) {
        olp->key = key;
        olp->next = obj_lock_hash[h];
        obj_lock_hash[h] = olp;
    }
}

static void
obj_unlock(void *key)
{
    /*
     * Unlock an object specified by 'key'.
     */
    int h = obj_hash(key);
    obj_lock_t *olp, *olp0;

    olp = obj_lock_hash[h];
    olp0 = NULL;
    while (olp != NULL) {
        if (olp->key == key) {
            if (olp0 == NULL)
                obj_lock_hash[h] = olp->next;
            else
                olp0->next = olp->next;
            free(olp);
            return;
        }
        olp0 = olp;
        olp = olp->next;
    }
}

static char *
decode_name_dynamic(const char *name, idn_resconf_t idnctx) {
    BOOL stat;
    char buf[256], tmp[256];
    char *s;

    if (idnConvRsp(idnctx, name, buf, sizeof(buf)) == TRUE) {
        TRACE("Converted Back <%s>\n",
              dumpName(buf, tmp, sizeof(tmp)));
        name = buf;
    } else {
        TRACE("Decoding failed - return the name verbatim\n");
    }
    s = malloc(strlen(name) + 1);
    if (s == NULL)
        return (NULL);
    else
        return (strcpy(s, name));
}

static struct my_addrinfo *
copy_decode_addrinfo_dynamic(struct my_addrinfo *aip, idn_resconf_t idnctx)
{
    struct my_addrinfo *newaip;

    if (aip == NULL)
        return (NULL);

    newaip = malloc(sizeof(struct my_addrinfo) + aip->ai_addrlen);
    if (newaip == NULL)
        return (NULL);

    *newaip = *aip;
    newaip->ai_addr = (struct sockaddr *)(newaip + 1);
    memcpy(newaip->ai_addr, aip->ai_addr, aip->ai_addrlen);

    if (newaip->ai_canonname != NULL)
        newaip->ai_canonname = decode_name_dynamic(aip->ai_canonname,
                               idnctx);

    newaip->ai_next = copy_decode_addrinfo_dynamic(aip->ai_next, idnctx);
    return (newaip);
}

static void
free_copied_addrinfo(struct my_addrinfo *aip) {
    while (aip != NULL) {
        struct my_addrinfo *next = aip->ai_next;

        if (aip->ai_canonname != NULL)
            free(aip->ai_canonname);
        free(aip);
        aip = next;
    }
}

WRAPPER_EXPORT int WSAAPI
getaddrinfo(const char *nodename, const char *servname,
        const struct my_addrinfo *hints, struct my_addrinfo **res)
{
    char namebuf[256];
    BOOL stat;
    struct my_addrinfo *aip;
    int err;
    idn_resconf_t   encodeCtx;

    TRACE("ENTER getaddrinfo <%-.100s>\n", nodename ? nodename : "NULL");

    encodeCtx = idnGetContext();

    if (nodename == NULL || encodeCtx == NULL) {
        TRACE("conversion unnecessary\n");
        err = _org_getaddrinfo(nodename, servname, hints, res);
    } else {
        stat = idnConvReq(encodeCtx, nodename,
                  namebuf, sizeof(namebuf));
        if (stat == TRUE) {
            nodename = namebuf;
            TRACE("Converted Name <%-.100s>\n", namebuf);
        }

        err = _org_getaddrinfo(nodename, servname, hints, &aip);
        if (err == 0 && aip != NULL) {
            *res = copy_decode_addrinfo_dynamic(aip, encodeCtx);
            if (*res == NULL)
                err = EAI_FAIL;
            else
                obj_lock(*res);
            if (aip != NULL)
                _org_freeaddrinfo(aip);
        }
    }

    TRACE("LEAVE getaddrinfo %d\n", err);
    return (err);
}

WRAPPER_EXPORT void WSAAPI
freeaddrinfo(struct my_addrinfo *aip) {
    TRACE("ENTER freeaddrinfo aip=%p\n", (void *)aip);

    if (obj_islocked(aip)) {
        /*
         * We allocated the data.
         */
        obj_unlock(aip);
        free_copied_addrinfo(aip);
    } else {
        /*
         * It was allocated the original getaddrinfo().
         */
        TRACE("Not allocated by the wrapper\n");
        _org_freeaddrinfo(aip);
    }
    TRACE("LEAVE freeaddrinfo\n");
}

WRAPPER_EXPORT int WSAAPI
getnameinfo(const struct sockaddr *sa, DWORD salen,
        char *host, DWORD hostlen, char *serv,
        DWORD servlen, int flags)
{
    char name[256];
    size_t namelen = sizeof(name);
    int code;
    BOOL stat;
    idn_resconf_t   encodeCtx;

    TRACE("ENTER getnameinfo\n");

    encodeCtx = idnGetContext();

    if (host == NULL || hostlen == 0 || encodeCtx == NULL) {
        TRACE("conversion unnecessary\n");
        code = _org_getnameinfo(sa, salen, host, hostlen,
                    serv, servlen, flags);
    } else {
        code = _org_getnameinfo(sa, salen, name, namelen,
                    serv, servlen, flags);
        if (code == 0 && name[0] != '\0') {
            stat = idnConvRsp(encodeCtx, name, host, hostlen);
            if (stat == FALSE) {
                TRACE("Decoding failed - return the name verbatim\n");
                if (strlen(name) >= hostlen) {
                    code = EAI_FAIL;
                } else {
                    strcpy(host, name);
                }
            } else {
                TRACE("Converted Back <%s>\n",
                      dumpName(host, name, sizeof(name)));
            }
        }
    }

    TRACE("LEAVE getnameinfo %d\n", code);
    return (code);
}