/***************************************************************************
 *                                  _   _ ____  _
 *  Project                     ___| | | |  _ \| |
 *                             / __| | | | |_) | |
 *                            | (__| |_| |  _ <| |___
 *                             \___|\___/|_| \_\_____|
 *
 * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
 *
 * This software is licensed as described in the file COPYING, which
 * you should have received as part of this distribution. The terms
 * are also available at https://curl.haxx.se/docs/copyright.html.
 *
 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
 * copies of the Software, and permit persons to whom the Software is
 * furnished to do so, under the terms of the COPYING file.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 *
 ***************************************************************************/

/* OS/400 additional support. */

#include <curl/curl.h>
#include "config-os400.h"  /* Not curl_setup.h: we only need some defines. */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>

#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <pthread.h>
#include <netdb.h>
#include <qadrt.h>
#include <errno.h>

#ifdef HAVE_ZLIB_H
#include <zlib.h>
#endif

#ifdef USE_GSKIT
#include <gskssl.h>
#include <qsoasync.h>
#endif

#ifdef HAVE_GSSAPI
#include <gssapi.h>
#endif

#ifndef CURL_DISABLE_LDAP
#include <ldap.h>
#endif

#include <netinet/in.h>
#include <arpa/inet.h>

#include "os400sys.h"


/**
***     QADRT OS/400 ASCII runtime defines only the most used procedures, but
***             but a lot of them are not supported. This module implements
***             ASCII wrappers for those that are used by libcurl, but not
***             defined by QADRT.
**/

#pragma convert(0)                              /* Restore EBCDIC. */


#define MIN_BYTE_GAIN   1024    /* Minimum gain when shortening a buffer. */

typedef struct {
    unsigned long   size;                   /* Buffer size. */
    char           *buf;                    /* Buffer address. */
}               buffer_t;


static char    *buffer_undef(localkey_t key, long size);
static char    *buffer_threaded(localkey_t key, long size);
static char    *buffer_unthreaded(localkey_t key, long size);

static pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_key_t    thdkey;
static buffer_t        *locbufs;

char   *(* Curl_thread_buffer)(localkey_t key, long size) = buffer_undef;


static void
thdbufdestroy(void *private)

{
    if (private) {
        buffer_t *p = (buffer_t *) private;
        localkey_t i;

        for (i = (localkey_t) 0; i < LK_LAST; i++) {
            free(p->buf);
            p++;
        }

        free(private);
    }
}


static void
terminate(void)

{
    if (Curl_thread_buffer == buffer_threaded) {
        locbufs = pthread_getspecific(thdkey);
        pthread_setspecific(thdkey, (void *) NULL);
        pthread_key_delete(thdkey);
    }

    if (Curl_thread_buffer != buffer_undef) {
        thdbufdestroy((void *) locbufs);
        locbufs = (buffer_t *) NULL;
    }

    Curl_thread_buffer = buffer_undef;
}


static char *
get_buffer(buffer_t *buf, long size)

{
    char *cp;

    /* If `size' >= 0, make sure buffer at `buf' is at least `size'-byte long.
       Return the buffer address. */

    if (size < 0) {
        return buf->buf;
    }

    if (!buf->buf) {
        buf->buf = malloc(size);
        if (buf->buf) {
            buf->size = size;
        }

        return buf->buf;
    }

    if ((unsigned long) size <= buf->size) {
        /* Shorten the buffer only if it frees a significant byte count. This
           avoids some realloc() overhead. */

        if (buf->size - size < MIN_BYTE_GAIN) {
            return buf->buf;
        }
    }

    /* Resize the buffer. */

    cp = realloc(buf->buf, size);
    if (cp) {
        buf->buf = cp;
        buf->size = size;
    } else if (size <= buf->size) {
        cp = buf->buf;
    }

    return cp;
}


static char *
buffer_unthreaded(localkey_t key, long size)

{
    return get_buffer(locbufs + key, size);
}


static char *
buffer_threaded(localkey_t key, long size)

{
    buffer_t *bufs;

    /* Get the buffer for the given local key in the current thread, and
       make sure it is at least `size'-byte long. Set `size' to < 0 to get
       its address only. */

    bufs = (buffer_t *) pthread_getspecific(thdkey);

    if (!bufs) {
        if (size < 0) {
            return (char *) NULL;    /* No buffer yet. */
        }

        /* Allocate buffer descriptors for the current thread. */

        bufs = calloc((size_t) LK_LAST, sizeof * bufs);
        if (!bufs) {
            return (char *) NULL;
        }

        if (pthread_setspecific(thdkey, (void *) bufs)) {
            free(bufs);
            return (char *) NULL;
        }
    }

    return get_buffer(bufs + key, size);
}


static char *
buffer_undef(localkey_t key, long size)

{
    /* Define the buffer system, get the buffer for the given local key in
       the current thread, and make sure it is at least `size'-byte long.
       Set `size' to < 0 to get its address only. */

    pthread_mutex_lock(&mutex);

    /* Determine if we can use pthread-specific data. */

    if (Curl_thread_buffer == buffer_undef) {     /* If unchanged during lock. */
        if (!pthread_key_create(&thdkey, thdbufdestroy)) {
            Curl_thread_buffer = buffer_threaded;
        } else if (!(locbufs = calloc((size_t) LK_LAST, sizeof * locbufs))) {
            pthread_mutex_unlock(&mutex);
            return (char *) NULL;
        } else {
            Curl_thread_buffer = buffer_unthreaded;
        }

        atexit(terminate);
    }

    pthread_mutex_unlock(&mutex);
    return Curl_thread_buffer(key, size);
}


static char *
set_thread_string(localkey_t key, const char *s)

{
    int i;
    char *cp;

    if (!s) {
        return (char *) NULL;
    }

    i = strlen(s) + 1;
    cp = Curl_thread_buffer(key, MAX_CONV_EXPANSION * i + 1);

    if (cp) {
        i = QadrtConvertE2A(cp, s, MAX_CONV_EXPANSION * i, i);
        cp[i] = '\0';
    }

    return cp;
}


int
Curl_getnameinfo_a(const struct sockaddr *sa, curl_socklen_t salen,
                   char *nodename, curl_socklen_t nodenamelen,
                   char *servname, curl_socklen_t servnamelen,
                   int flags)

{
    char *enodename;
    char *eservname;
    int status;
    int i;

    enodename = (char *) NULL;
    eservname = (char *) NULL;

    if (nodename && nodenamelen) {
        enodename = malloc(nodenamelen);
        if (!enodename) {
            return EAI_MEMORY;
        }
    }

    if (servname && servnamelen) {
        eservname = malloc(servnamelen);
        if (!eservname) {
            free(enodename);
            return EAI_MEMORY;
        }
    }

    status = getnameinfo(sa, salen, enodename, nodenamelen,
                         eservname, servnamelen, flags);

    if (!status) {
        if (enodename) {
            i = QadrtConvertE2A(nodename, enodename,
                                nodenamelen - 1, strlen(enodename));
            nodename[i] = '\0';
        }

        if (eservname) {
            i = QadrtConvertE2A(servname, eservname,
                                servnamelen - 1, strlen(eservname));
            servname[i] = '\0';
        }
    }

    free(enodename);
    free(eservname);
    return status;
}


int
Curl_getaddrinfo_a(const char *nodename, const char *servname,
                   const struct addrinfo *hints,
                   struct addrinfo * * res)

{
    char *enodename;
    char *eservname;
    int status;
    int i;

    enodename = (char *) NULL;
    eservname = (char *) NULL;

    if (nodename) {
        i = strlen(nodename);

        enodename = malloc(i + 1);
        if (!enodename) {
            return EAI_MEMORY;
        }

        i = QadrtConvertA2E(enodename, nodename, i, i);
        enodename[i] = '\0';
    }

    if (servname) {
        i = strlen(servname);

        eservname = malloc(i + 1);
        if (!eservname) {
            free(enodename);
            return EAI_MEMORY;
        }

        QadrtConvertA2E(eservname, servname, i, i);
        eservname[i] = '\0';
    }

    status = getaddrinfo(enodename, eservname, hints, res);
    free(enodename);
    free(eservname);
    return status;
}


#ifdef USE_GSKIT

/* ASCII wrappers for the GSKit procedures. */

/*
 * EBCDIC --> ASCII string mapping table.
 * Some strings returned by GSKit are dynamically allocated and automatically
 * released when closing the handle.
 * To provide the same functionality, we use a "private" handle that
 * holds the GSKit handle and a list of string mappings. This will allow
 * avoid conversion of already converted strings and releasing them upon
 * close time.
 */

struct gskstrlist {
    struct gskstrlist *next;
    const char *ebcdicstr;
    const char *asciistr;
};

struct Curl_gsk_descriptor {
    gsk_handle h;
    struct gskstrlist *strlist;
};


int
Curl_gsk_environment_open(gsk_handle *my_env_handle)

{
    struct Curl_gsk_descriptor *p;
    gsk_handle h;
    int rc;

    if (!my_env_handle) {
        return GSK_OS400_ERROR_INVALID_POINTER;
    }
    p = (struct Curl_gsk_descriptor *) malloc(sizeof * p);
    if (!p) {
        return GSK_INSUFFICIENT_STORAGE;
    }
    p->strlist = (struct gskstrlist *) NULL;
    rc = gsk_environment_open(&p->h);
    if (rc != GSK_OK) {
        free(p);
    } else {
        *my_env_handle = (gsk_handle) p;
    }
    return rc;
}


int
Curl_gsk_secure_soc_open(gsk_handle my_env_handle,
                         gsk_handle *my_session_handle)

{
    struct Curl_gsk_descriptor *p;
    gsk_handle h;
    int rc;

    if (!my_env_handle) {
        return GSK_INVALID_HANDLE;
    }
    if (!my_session_handle) {
        return GSK_OS400_ERROR_INVALID_POINTER;
    }
    h = ((struct Curl_gsk_descriptor *) my_env_handle)->h;
    p = (struct Curl_gsk_descriptor *) malloc(sizeof * p);
    if (!p) {
        return GSK_INSUFFICIENT_STORAGE;
    }
    p->strlist = (struct gskstrlist *) NULL;
    rc = gsk_secure_soc_open(h, &p->h);
    if (rc != GSK_OK) {
        free(p);
    } else {
        *my_session_handle = (gsk_handle) p;
    }
    return rc;
}


static void
gsk_free_handle(struct Curl_gsk_descriptor *p)

{
    struct gskstrlist *q;

    while ((q = p->strlist)) {
        p->strlist = q;
        free((void *) q->asciistr);
        free(q);
    }
    free(p);
}


int
Curl_gsk_environment_close(gsk_handle *my_env_handle)

{
    struct Curl_gsk_descriptor *p;
    int rc;

    if (!my_env_handle) {
        return GSK_OS400_ERROR_INVALID_POINTER;
    }
    if (!*my_env_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) *my_env_handle;
    rc = gsk_environment_close(&p->h);
    if (rc == GSK_OK) {
        gsk_free_handle(p);
        *my_env_handle = (gsk_handle) NULL;
    }
    return rc;
}


int
Curl_gsk_secure_soc_close(gsk_handle *my_session_handle)

{
    struct Curl_gsk_descriptor *p;
    int rc;

    if (!my_session_handle) {
        return GSK_OS400_ERROR_INVALID_POINTER;
    }
    if (!*my_session_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) *my_session_handle;
    rc = gsk_secure_soc_close(&p->h);
    if (rc == GSK_OK) {
        gsk_free_handle(p);
        *my_session_handle = (gsk_handle) NULL;
    }
    return rc;
}


int
Curl_gsk_environment_init(gsk_handle my_env_handle)

{
    struct Curl_gsk_descriptor *p;

    if (!my_env_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_env_handle;
    return gsk_environment_init(p->h);
}


int
Curl_gsk_secure_soc_init(gsk_handle my_session_handle)

{
    struct Curl_gsk_descriptor *p;

    if (!my_session_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_session_handle;
    return gsk_secure_soc_init(p->h);
}


int
Curl_gsk_attribute_set_buffer_a(gsk_handle my_gsk_handle, GSK_BUF_ID bufID,
                                const char *buffer, int bufSize)

{
    struct Curl_gsk_descriptor *p;
    char *ebcdicbuf;
    int rc;

    if (!my_gsk_handle) {
        return GSK_INVALID_HANDLE;
    }
    if (!buffer) {
        return GSK_OS400_ERROR_INVALID_POINTER;
    }
    if (bufSize < 0) {
        return GSK_ATTRIBUTE_INVALID_LENGTH;
    }
    p = (struct Curl_gsk_descriptor *) my_gsk_handle;
    if (!bufSize) {
        bufSize = strlen(buffer);
    }
    ebcdicbuf = malloc(bufSize + 1);
    if (!ebcdicbuf) {
        return GSK_INSUFFICIENT_STORAGE;
    }
    QadrtConvertA2E(ebcdicbuf, buffer, bufSize, bufSize);
    ebcdicbuf[bufSize] = '\0';
    rc = gsk_attribute_set_buffer(p->h, bufID, ebcdicbuf, bufSize);
    free(ebcdicbuf);
    return rc;
}


int
Curl_gsk_attribute_set_enum(gsk_handle my_gsk_handle, GSK_ENUM_ID enumID,
                            GSK_ENUM_VALUE enumValue)

{
    struct Curl_gsk_descriptor *p;

    if (!my_gsk_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_gsk_handle;
    return gsk_attribute_set_enum(p->h, enumID, enumValue);
}


int
Curl_gsk_attribute_set_numeric_value(gsk_handle my_gsk_handle,
                                     GSK_NUM_ID numID, int numValue)

{
    struct Curl_gsk_descriptor *p;

    if (!my_gsk_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_gsk_handle;
    return gsk_attribute_set_numeric_value(p->h, numID, numValue);
}


int
Curl_gsk_attribute_set_callback(gsk_handle my_gsk_handle,
                                GSK_CALLBACK_ID callBackID,
                                void *callBackAreaPtr)

{
    struct Curl_gsk_descriptor *p;

    if (!my_gsk_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_gsk_handle;
    return gsk_attribute_set_callback(p->h, callBackID, callBackAreaPtr);
}


static int
cachestring(struct Curl_gsk_descriptor *p,
            const char *ebcdicbuf, int bufsize, const char * * buffer)

{
    int rc;
    char *asciibuf;
    struct gskstrlist *sp;

    for (sp = p->strlist; sp; sp = sp->next)
        if (sp->ebcdicstr == ebcdicbuf) {
            break;
        }
    if (!sp) {
        sp = (struct gskstrlist *) malloc(sizeof * sp);
        if (!sp) {
            return GSK_INSUFFICIENT_STORAGE;
        }
        asciibuf = malloc(bufsize + 1);
        if (!asciibuf) {
            free(sp);
            return GSK_INSUFFICIENT_STORAGE;
        }
        QadrtConvertE2A(asciibuf, ebcdicbuf, bufsize, bufsize);
        asciibuf[bufsize] = '\0';
        sp->ebcdicstr = ebcdicbuf;
        sp->asciistr = asciibuf;
        sp->next = p->strlist;
        p->strlist = sp;
    }
    *buffer = sp->asciistr;
    return GSK_OK;
}


int
Curl_gsk_attribute_get_buffer_a(gsk_handle my_gsk_handle, GSK_BUF_ID bufID,
                                const char * * buffer, int *bufSize)

{
    struct Curl_gsk_descriptor *p;
    int rc;
    const char *mybuf;
    int mylen;

    if (!my_gsk_handle) {
        return GSK_INVALID_HANDLE;
    }
    if (!buffer || !bufSize) {
        return GSK_OS400_ERROR_INVALID_POINTER;
    }
    p = (struct Curl_gsk_descriptor *) my_gsk_handle;
    rc = gsk_attribute_get_buffer(p->h, bufID, &mybuf, &mylen);
    if (rc != GSK_OK) {
        return rc;
    }
    rc = cachestring(p, mybuf, mylen, buffer);
    if (rc == GSK_OK) {
        *bufSize = mylen;
    }
    return rc;
}


int
Curl_gsk_attribute_get_enum(gsk_handle my_gsk_handle, GSK_ENUM_ID enumID,
                            GSK_ENUM_VALUE *enumValue)

{
    struct Curl_gsk_descriptor *p;

    if (!my_gsk_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_gsk_handle;
    return gsk_attribute_get_enum(p->h, enumID, enumValue);
}


int
Curl_gsk_attribute_get_numeric_value(gsk_handle my_gsk_handle,
                                     GSK_NUM_ID numID, int *numValue)

{
    struct Curl_gsk_descriptor *p;

    if (!my_gsk_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_gsk_handle;
    return gsk_attribute_get_numeric_value(p->h, numID, numValue);
}


int
Curl_gsk_attribute_get_cert_info(gsk_handle my_gsk_handle,
                                 GSK_CERT_ID certID,
                                 const gsk_cert_data_elem * * certDataElem,
                                 int *certDataElementCount)

{
    struct Curl_gsk_descriptor *p;

    if (!my_gsk_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_gsk_handle;
    /* No need to convert code: text results are already in ASCII. */
    return gsk_attribute_get_cert_info(p->h, certID,
                                       certDataElem, certDataElementCount);
}


int
Curl_gsk_secure_soc_misc(gsk_handle my_session_handle, GSK_MISC_ID miscID)

{
    struct Curl_gsk_descriptor *p;

    if (!my_session_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_session_handle;
    return gsk_secure_soc_misc(p->h, miscID);
}


int
Curl_gsk_secure_soc_read(gsk_handle my_session_handle, char *readBuffer,
                         int readBufSize, int *amtRead)

{
    struct Curl_gsk_descriptor *p;

    if (!my_session_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_session_handle;
    return gsk_secure_soc_read(p->h, readBuffer, readBufSize, amtRead);
}


int
Curl_gsk_secure_soc_write(gsk_handle my_session_handle, char *writeBuffer,
                          int writeBufSize, int *amtWritten)

{
    struct Curl_gsk_descriptor *p;

    if (!my_session_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_session_handle;
    return gsk_secure_soc_write(p->h, writeBuffer, writeBufSize, amtWritten);
}


const char *
Curl_gsk_strerror_a(int gsk_return_value)

{
    return set_thread_string(LK_GSK_ERROR, gsk_strerror(gsk_return_value));
}

int
Curl_gsk_secure_soc_startInit(gsk_handle my_session_handle,
                              int IOCompletionPort,
                              Qso_OverlappedIO_t *communicationsArea)

{
    struct Curl_gsk_descriptor *p;

    if (!my_session_handle) {
        return GSK_INVALID_HANDLE;
    }
    p = (struct Curl_gsk_descriptor *) my_session_handle;
    return gsk_secure_soc_startInit(p->h, IOCompletionPort, communicationsArea);
}

#endif /* USE_GSKIT */



#ifdef HAVE_GSSAPI

/* ASCII wrappers for the GSSAPI procedures. */

static int
Curl_gss_convert_in_place(OM_uint32 *minor_status, gss_buffer_t buf)

{
    unsigned int i;
    char *t;

    /* Convert `buf' in place, from EBCDIC to ASCII.
       If error, release the buffer and return -1. Else return 0. */

    i = buf->length;

    if (i) {
        t = malloc(i);
        if (!t) {
            gss_release_buffer(minor_status, buf);

            if (minor_status) {
                *minor_status = ENOMEM;
            }

            return -1;
        }

        QadrtConvertE2A(t, buf->value, i, i);
        memcpy(buf->value, t, i);
        free(t);
    }

    return 0;
}


OM_uint32
Curl_gss_import_name_a(OM_uint32 *minor_status, gss_buffer_t in_name,
                       gss_OID in_name_type, gss_name_t *out_name)

{
    int rc;
    unsigned int i;
    gss_buffer_desc in;

    if (!in_name || !in_name->value || !in_name->length) {
        return gss_import_name(minor_status, in_name, in_name_type, out_name);
    }

    memcpy((char *) &in, (char *) in_name, sizeof in);
    i = in.length;

    in.value = malloc(i + 1);
    if (!in.value) {
        if (minor_status) {
            *minor_status = ENOMEM;
        }

        return GSS_S_FAILURE;
    }

    QadrtConvertA2E(in.value, in_name->value, i, i);
    ((char *) in.value)[i] = '\0';
    rc = gss_import_name(minor_status, &in, in_name_type, out_name);
    free(in.value);
    return rc;
}


OM_uint32
Curl_gss_display_status_a(OM_uint32 *minor_status, OM_uint32 status_value,
                          int status_type, gss_OID mech_type,
                          gss_msg_ctx_t *message_context, gss_buffer_t status_string)

{
    int rc;

    rc = gss_display_status(minor_status, status_value, status_type,
                            mech_type, message_context, status_string);

    if (rc != GSS_S_COMPLETE || !status_string ||
        !status_string->length || !status_string->value) {
        return rc;
    }

    /* No way to allocate a buffer here, because it will be released by
       gss_release_buffer(). The solution is to overwrite the EBCDIC buffer
       with ASCII to return it. */

    if (Curl_gss_convert_in_place(minor_status, status_string)) {
        return GSS_S_FAILURE;
    }

    return rc;
}


OM_uint32
Curl_gss_init_sec_context_a(OM_uint32 *minor_status,
                            gss_cred_id_t cred_handle,
                            gss_ctx_id_t *context_handle,
                            gss_name_t target_name, gss_OID mech_type,
                            gss_flags_t req_flags, OM_uint32 time_req,
                            gss_channel_bindings_t input_chan_bindings,
                            gss_buffer_t input_token,
                            gss_OID *actual_mech_type,
                            gss_buffer_t output_token, gss_flags_t *ret_flags,
                            OM_uint32 *time_rec)

{
    int rc;
    unsigned int i;
    gss_buffer_desc in;
    gss_buffer_t inp;

    in.value = NULL;
    inp = input_token;

    if (inp) {
        if (inp->length && inp->value) {
            i = inp->length;

            in.value = malloc(i + 1);
            if (!in.value) {
                if (minor_status) {
                    *minor_status = ENOMEM;
                }

                return GSS_S_FAILURE;
            }

            QadrtConvertA2E(in.value, input_token->value, i, i);
            ((char *) in.value)[i] = '\0';
            in.length = i;
            inp = &in;
        }
    }

    rc = gss_init_sec_context(minor_status, cred_handle, context_handle,
                              target_name, mech_type, req_flags, time_req,
                              input_chan_bindings, inp, actual_mech_type,
                              output_token, ret_flags, time_rec);
    free(in.value);

    if (rc != GSS_S_COMPLETE || !output_token ||
        !output_token->length || !output_token->value) {
        return rc;
    }

    /* No way to allocate a buffer here, because it will be released by
       gss_release_buffer(). The solution is to overwrite the EBCDIC buffer
       with ASCII to return it. */

    if (Curl_gss_convert_in_place(minor_status, output_token)) {
        return GSS_S_FAILURE;
    }

    return rc;
}


OM_uint32
Curl_gss_delete_sec_context_a(OM_uint32 *minor_status,
                              gss_ctx_id_t *context_handle,
                              gss_buffer_t output_token)

{
    int rc;

    rc = gss_delete_sec_context(minor_status, context_handle, output_token);

    if (rc != GSS_S_COMPLETE || !output_token ||
        !output_token->length || !output_token->value) {
        return rc;
    }

    /* No way to allocate a buffer here, because it will be released by
       gss_release_buffer(). The solution is to overwrite the EBCDIC buffer
       with ASCII to return it. */

    if (Curl_gss_convert_in_place(minor_status, output_token)) {
        return GSS_S_FAILURE;
    }

    return rc;
}

#endif /* HAVE_GSSAPI */


#ifndef CURL_DISABLE_LDAP

/* ASCII wrappers for the LDAP procedures. */

void *
Curl_ldap_init_a(char *host, int port)

{
    unsigned int i;
    char *ehost;
    void *result;

    if (!host) {
        return (void *) ldap_init(host, port);
    }

    i = strlen(host);

    ehost = malloc(i + 1);
    if (!ehost) {
        return (void *) NULL;
    }

    QadrtConvertA2E(ehost, host, i, i);
    ehost[i] = '\0';
    result = (void *) ldap_init(ehost, port);
    free(ehost);
    return result;
}


int
Curl_ldap_simple_bind_s_a(void *ld, char *dn, char *passwd)

{
    int i;
    char *edn;
    char *epasswd;

    edn = (char *) NULL;
    epasswd = (char *) NULL;

    if (dn) {
        i = strlen(dn);

        edn = malloc(i + 1);
        if (!edn) {
            return LDAP_NO_MEMORY;
        }

        QadrtConvertA2E(edn, dn, i, i);
        edn[i] = '\0';
    }

    if (passwd) {
        i = strlen(passwd);

        epasswd = malloc(i + 1);
        if (!epasswd) {
            free(edn);
            return LDAP_NO_MEMORY;
        }

        QadrtConvertA2E(epasswd, passwd, i, i);
        epasswd[i] = '\0';
    }

    i = ldap_simple_bind_s(ld, edn, epasswd);
    free(epasswd);
    free(edn);
    return i;
}


int
Curl_ldap_search_s_a(void *ld, char *base, int scope, char *filter,
                     char * * attrs, int attrsonly, LDAPMessage * * res)

{
    int i;
    int j;
    char *ebase;
    char *efilter;
    char * * eattrs;
    int status;

    ebase = (char *) NULL;
    efilter = (char *) NULL;
    eattrs = (char * *) NULL;
    status = LDAP_SUCCESS;

    if (base) {
        i = strlen(base);

        ebase = malloc(i + 1);
        if (!ebase) {
            status = LDAP_NO_MEMORY;
        } else {
            QadrtConvertA2E(ebase, base, i, i);
            ebase[i] = '\0';
        }
    }

    if (filter && status == LDAP_SUCCESS) {
        i = strlen(filter);

        efilter = malloc(i + 1);
        if (!efilter) {
            status = LDAP_NO_MEMORY;
        } else {
            QadrtConvertA2E(efilter, filter, i, i);
            efilter[i] = '\0';
        }
    }

    if (attrs && status == LDAP_SUCCESS) {
        for (i = 0; attrs[i++];)
            ;

        eattrs = calloc(i, sizeof * eattrs);
        if (!eattrs) {
            status = LDAP_NO_MEMORY;
        } else {
            for (j = 0; attrs[j]; j++) {
                i = strlen(attrs[j]);

                eattrs[j] = malloc(i + 1);
                if (!eattrs[j]) {
                    status = LDAP_NO_MEMORY;
                    break;
                }

                QadrtConvertA2E(eattrs[j], attrs[j], i, i);
                eattrs[j][i] = '\0';
            }
        }
    }

    if (status == LDAP_SUCCESS)
        status = ldap_search_s(ld, ebase ? ebase : "", scope,
                               efilter ? efilter : "(objectclass=*)",
                               eattrs, attrsonly, res);

    if (eattrs) {
        for (j = 0; eattrs[j]; j++) {
            free(eattrs[j]);
        }

        free(eattrs);
    }

    free(efilter);
    free(ebase);
    return status;
}


struct berval * *
Curl_ldap_get_values_len_a(void *ld, LDAPMessage *entry, const char *attr)

{
    char *cp;
    struct berval * * result;

    cp = (char *) NULL;

    if (attr) {
        int i = strlen(attr);

        cp = malloc(i + 1);
        if (!cp) {
            ldap_set_lderrno(ld, LDAP_NO_MEMORY, NULL,
                             ldap_err2string(LDAP_NO_MEMORY));
            return (struct berval * *) NULL;
        }

        QadrtConvertA2E(cp, attr, i, i);
        cp[i] = '\0';
    }

    result = ldap_get_values_len(ld, entry, cp);
    free(cp);

    /* Result data are binary in nature, so they haven't been
       converted to EBCDIC. Therefore do not convert. */

    return result;
}


char *
Curl_ldap_err2string_a(int error)

{
    return set_thread_string(LK_LDAP_ERROR, ldap_err2string(error));
}


char *
Curl_ldap_get_dn_a(void *ld, LDAPMessage *entry)

{
    int i;
    char *cp;
    char *cp2;

    cp = ldap_get_dn(ld, entry);

    if (!cp) {
        return cp;
    }

    i = strlen(cp);

    cp2 = malloc(i + 1);
    if (!cp2) {
        return cp2;
    }

    QadrtConvertE2A(cp2, cp, i, i);
    cp2[i] = '\0';

    /* No way to allocate a buffer here, because it will be released by
       ldap_memfree() and ldap_memalloc() does not exist. The solution is to
       overwrite the EBCDIC buffer with ASCII to return it. */

    strcpy(cp, cp2);
    free(cp2);
    return cp;
}


char *
Curl_ldap_first_attribute_a(void *ld,
                            LDAPMessage *entry, BerElement * * berptr)

{
    int i;
    char *cp;
    char *cp2;

    cp = ldap_first_attribute(ld, entry, berptr);

    if (!cp) {
        return cp;
    }

    i = strlen(cp);

    cp2 = malloc(i + 1);
    if (!cp2) {
        return cp2;
    }

    QadrtConvertE2A(cp2, cp, i, i);
    cp2[i] = '\0';

    /* No way to allocate a buffer here, because it will be released by
       ldap_memfree() and ldap_memalloc() does not exist. The solution is to
       overwrite the EBCDIC buffer with ASCII to return it. */

    strcpy(cp, cp2);
    free(cp2);
    return cp;
}


char *
Curl_ldap_next_attribute_a(void *ld,
                           LDAPMessage *entry, BerElement *berptr)

{
    int i;
    char *cp;
    char *cp2;

    cp = ldap_next_attribute(ld, entry, berptr);

    if (!cp) {
        return cp;
    }

    i = strlen(cp);

    cp2 = malloc(i + 1);
    if (!cp2) {
        return cp2;
    }

    QadrtConvertE2A(cp2, cp, i, i);
    cp2[i] = '\0';

    /* No way to allocate a buffer here, because it will be released by
       ldap_memfree() and ldap_memalloc() does not exist. The solution is to
       overwrite the EBCDIC buffer with ASCII to return it. */

    strcpy(cp, cp2);
    free(cp2);
    return cp;
}

#endif /* CURL_DISABLE_LDAP */


static int
convert_sockaddr(struct sockaddr_storage *dstaddr,
                 const struct sockaddr *srcaddr, int srclen)

{
    const struct sockaddr_un *srcu;
    struct sockaddr_un *dstu;
    unsigned int i;
    unsigned int dstsize;

    /* Convert a socket address into job CCSID, if needed. */

    if (!srcaddr || srclen < offsetof(struct sockaddr, sa_family) +
        sizeof srcaddr->sa_family || srclen > sizeof * dstaddr) {
        errno = EINVAL;
        return -1;
    }

    memcpy((char *) dstaddr, (char *) srcaddr, srclen);

    switch (srcaddr->sa_family) {

    case AF_UNIX:
        srcu = (const struct sockaddr_un *) srcaddr;
        dstu = (struct sockaddr_un *) dstaddr;
        dstsize = sizeof * dstaddr - offsetof(struct sockaddr_un, sun_path);
        srclen -= offsetof(struct sockaddr_un, sun_path);
        i = QadrtConvertA2E(dstu->sun_path, srcu->sun_path, dstsize - 1, srclen);
        dstu->sun_path[i] = '\0';
        i += offsetof(struct sockaddr_un, sun_path);
        srclen = i;
    }

    return srclen;
}


int
Curl_os400_connect(int sd, struct sockaddr *destaddr, int addrlen)

{
    int i;
    struct sockaddr_storage laddr;

    i = convert_sockaddr(&laddr, destaddr, addrlen);

    if (i < 0) {
        return -1;
    }

    return connect(sd, (struct sockaddr *) &laddr, i);
}


int
Curl_os400_bind(int sd, struct sockaddr *localaddr, int addrlen)

{
    int i;
    struct sockaddr_storage laddr;

    i = convert_sockaddr(&laddr, localaddr, addrlen);

    if (i < 0) {
        return -1;
    }

    return bind(sd, (struct sockaddr *) &laddr, i);
}


int
Curl_os400_sendto(int sd, char *buffer, int buflen, int flags,
                  struct sockaddr *dstaddr, int addrlen)

{
    int i;
    struct sockaddr_storage laddr;

    i = convert_sockaddr(&laddr, dstaddr, addrlen);

    if (i < 0) {
        return -1;
    }

    return sendto(sd, buffer, buflen, flags, (struct sockaddr *) &laddr, i);
}


int
Curl_os400_recvfrom(int sd, char *buffer, int buflen, int flags,
                    struct sockaddr *fromaddr, int *addrlen)

{
    int i;
    int rcvlen;
    int laddrlen;
    const struct sockaddr_un *srcu;
    struct sockaddr_un *dstu;
    struct sockaddr_storage laddr;

    if (!fromaddr || !addrlen || *addrlen <= 0) {
        return recvfrom(sd, buffer, buflen, flags, fromaddr, addrlen);
    }

    laddrlen = sizeof laddr;
    laddr.ss_family = AF_UNSPEC;          /* To detect if unused. */
    rcvlen = recvfrom(sd, buffer, buflen, flags,
                      (struct sockaddr *) &laddr, &laddrlen);

    if (rcvlen < 0) {
        return rcvlen;
    }

    switch (laddr.ss_family) {

    case AF_UNIX:
        srcu = (const struct sockaddr_un *) &laddr;
        dstu = (struct sockaddr_un *) fromaddr;
        i = *addrlen - offsetof(struct sockaddr_un, sun_path);
        laddrlen -= offsetof(struct sockaddr_un, sun_path);
        i = QadrtConvertE2A(dstu->sun_path, srcu->sun_path, i, laddrlen);
        laddrlen = i + offsetof(struct sockaddr_un, sun_path);

        if (laddrlen < *addrlen) {
            dstu->sun_path[i] = '\0';
        }

        break;

    case AF_UNSPEC:
        break;

    default:
        if (laddrlen > *addrlen) {
            laddrlen = *addrlen;
        }

        if (laddrlen) {
            memcpy((char *) fromaddr, (char *) &laddr, laddrlen);
        }

        break;
    }

    *addrlen = laddrlen;
    return rcvlen;
}


#ifdef HAVE_LIBZ
const char *
Curl_os400_zlibVersion(void)

{
    return set_thread_string(LK_ZLIB_VERSION, zlibVersion());
}


int
Curl_os400_inflateInit_(z_streamp strm, const char *version, int stream_size)

{
    z_const char *msgb4 = strm->msg;
    int ret;

    ret = inflateInit(strm);

    if (strm->msg != msgb4) {
        strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
    }

    return ret;
}


int
Curl_os400_inflateInit2_(z_streamp strm, int windowBits,
                         const char *version, int stream_size)

{
    z_const char *msgb4 = strm->msg;
    int ret;

    ret = inflateInit2(strm, windowBits);

    if (strm->msg != msgb4) {
        strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
    }

    return ret;
}


int
Curl_os400_inflate(z_streamp strm, int flush)

{
    z_const char *msgb4 = strm->msg;
    int ret;

    ret = inflate(strm, flush);

    if (strm->msg != msgb4) {
        strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
    }

    return ret;
}


int
Curl_os400_inflateEnd(z_streamp strm)

{
    z_const char *msgb4 = strm->msg;
    int ret;

    ret = inflateEnd(strm);

    if (strm->msg != msgb4) {
        strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
    }

    return ret;
}

#endif