/*=============================================================================
                             xmlrpc_server_info
===============================================================================
  The xmlrpc_server_info class.

  By Bryan Henderson, San Jose CA 2007.10.17.

  Contributed to the public domain by its author

  The xmlrpc_server_info class was originally just supposed to be
  information about an HTTP server, hence the name.  But we think of it
  now as a generic carriage parameter, as in the C++ library.  In
  the future, it should be a union or maybe contain an opaque pointer
  to the carriage parameter for a particular kind of transport.  That
  way, the client XML transports can be more than just HTTP XML
  transports.
=============================================================================*/

#include "bool.h"
#include "mallocvar.h"

#include "xmlrpc-c/base.h"
#include "xmlrpc-c/base_int.h"
#include "xmlrpc-c/string_int.h"
#include "xmlrpc-c/client.h"
#include "xmlrpc-c/client_int.h"



xmlrpc_server_info *
xmlrpc_server_info_new(xmlrpc_env * const envP,
                       const char * const serverUrl) {
    
    xmlrpc_server_info * serverInfoP;

    XMLRPC_ASSERT_ENV_OK(envP);
    XMLRPC_ASSERT_PTR_OK(serverUrl);

    MALLOCVAR(serverInfoP);
    if (serverInfoP == NULL)
        xmlrpc_faultf(envP, "Couldn't allocate memory for xmlrpc_server_info");
    else {
        serverInfoP->serverUrl = strdup(serverUrl);
        if (serverInfoP->serverUrl == NULL)
            xmlrpc_faultf(envP, "Couldn't allocate memory for server URL");
        else {
            serverInfoP->allowedAuth.basic        = false;
            serverInfoP->allowedAuth.digest       = false;
            serverInfoP->allowedAuth.gssnegotiate = false;
            serverInfoP->allowedAuth.ntlm         = false;
            serverInfoP->userNamePw = NULL;
            serverInfoP->basicAuthHdrValue = NULL;
            if (envP->fault_occurred)
                xmlrpc_strfree(serverInfoP->serverUrl);
        }
        if (envP->fault_occurred)
            free(serverInfoP);
    }
    return serverInfoP;
}



static void
copyUserNamePw(xmlrpc_env *  const envP,
               const char *  const src,
               const char ** const dstP) { 
    
    if (src == NULL)
        *dstP = NULL;
    else {
        *dstP = strdup(src);
        if (*dstP == NULL)
            xmlrpc_faultf(envP, "Couldn't allocate memory for user name/pw");
    }
}



static void
freeIfNonNull(const char * const arg) {

    if (arg)
        xmlrpc_strfree(arg);
}



static void
copyBasicAuthHdrValue(xmlrpc_env *  const envP,
                      const char *  const src,
                      const char ** const dstP) { 
    
    if (src == NULL)
        *dstP = NULL;
    else {
        *dstP = strdup(src);
        if (*dstP == NULL)
            xmlrpc_faultf(envP, "Couldn't allocate memory "
                          "for authentication header value");
    }
}



static void
copyServerInfoContent(xmlrpc_env *               const envP,
                      xmlrpc_server_info *       const dstP,
                      const xmlrpc_server_info * const srcP) {
                              
    dstP->serverUrl = strdup(srcP->serverUrl);
    if (dstP->serverUrl == NULL)
        xmlrpc_faultf(envP, "Couldn't allocate memory for server URL");
    else {
        copyUserNamePw(envP, srcP->userNamePw, &dstP->userNamePw);

        if (!envP->fault_occurred) {
            copyBasicAuthHdrValue(envP, srcP->basicAuthHdrValue,
                                  &dstP->basicAuthHdrValue);

            if (!envP->fault_occurred) {
                dstP->allowedAuth.basic        =
                    srcP->allowedAuth.basic;
                dstP->allowedAuth.digest       =
                    srcP->allowedAuth.digest;
                dstP->allowedAuth.gssnegotiate =
                    srcP->allowedAuth.gssnegotiate;
                dstP->allowedAuth.ntlm         =
                    srcP->allowedAuth.ntlm;
                
                if (envP->fault_occurred)
                    freeIfNonNull(dstP->basicAuthHdrValue);
            }
            if (envP->fault_occurred)
                freeIfNonNull(dstP->userNamePw);
        }
        if (envP->fault_occurred)
            xmlrpc_strfree(dstP->serverUrl);
    }
}



xmlrpc_server_info *
xmlrpc_server_info_copy(xmlrpc_env *         const envP,
                        xmlrpc_server_info * const srcP) {

    xmlrpc_server_info * serverInfoP;

    XMLRPC_ASSERT_ENV_OK(envP);
    XMLRPC_ASSERT_PTR_OK(srcP);

    MALLOCVAR(serverInfoP);
    if (serverInfoP == NULL)
        xmlrpc_faultf(envP,
                      "Couldn't allocate memory for xmlrpc_server_info");
    else {
        copyServerInfoContent(envP, serverInfoP, srcP);

        if (envP->fault_occurred)
            free(serverInfoP);
    }
    return serverInfoP;
}



void
xmlrpc_server_info_free(xmlrpc_server_info * const serverInfoP) {

    XMLRPC_ASSERT_PTR_OK(serverInfoP);
    XMLRPC_ASSERT(serverInfoP->serverUrl != XMLRPC_BAD_POINTER);
    
    if (serverInfoP->userNamePw)
        xmlrpc_strfree(serverInfoP->userNamePw);
    serverInfoP->userNamePw = XMLRPC_BAD_POINTER;

    if (serverInfoP->basicAuthHdrValue)
        xmlrpc_strfree(serverInfoP->basicAuthHdrValue);
    serverInfoP->basicAuthHdrValue = XMLRPC_BAD_POINTER;

    xmlrpc_strfree(serverInfoP->serverUrl);
    serverInfoP->serverUrl = XMLRPC_BAD_POINTER;

    free(serverInfoP);
}



void 
xmlrpc_server_info_set_user(xmlrpc_env *         const envP,
                            xmlrpc_server_info * const serverInfoP,
                            const char *         const username,
                            const char *         const password) {

    const char * userNamePw;
    xmlrpc_mem_block * userNamePw64;

    XMLRPC_ASSERT_ENV_OK(envP);
    XMLRPC_ASSERT_PTR_OK(serverInfoP);
    XMLRPC_ASSERT_PTR_OK(username);
    XMLRPC_ASSERT_PTR_OK(password);

    xmlrpc_asprintf(&userNamePw, "%s:%s", username, password);

    userNamePw64 =
        xmlrpc_base64_encode_without_newlines(envP, 
                                              (unsigned char*) userNamePw,
                                              strlen(userNamePw));
    if (!envP->fault_occurred) {
        const char * const data = XMLRPC_MEMBLOCK_CONTENTS(char, userNamePw64);
        size_t       const len  = XMLRPC_MEMBLOCK_SIZE(char, userNamePw64);
        const char * const authType = "Basic ";

        char * hdrValue;

        hdrValue = malloc(strlen(authType) + len + 1);
        if (hdrValue == NULL)
            xmlrpc_faultf(envP, "Could not allocate memory to store "
                          "authorization header value.");
        else {
            strcpy(hdrValue, authType);
            strncat(hdrValue, data, len);

            if (serverInfoP->basicAuthHdrValue)
                xmlrpc_strfree(serverInfoP->basicAuthHdrValue);

            serverInfoP->basicAuthHdrValue = hdrValue;
        }
        XMLRPC_MEMBLOCK_FREE(char, userNamePw64);
    }
    serverInfoP->userNamePw = userNamePw;
}



void 
xmlrpc_server_info_set_basic_auth(xmlrpc_env *         const envP,
                                  xmlrpc_server_info * const serverInfoP,
                                  const char *         const username,
                                  const char *         const password) {

    xmlrpc_server_info_set_user(envP, serverInfoP, username, password);

    if (!envP->fault_occurred) {
        serverInfoP->allowedAuth.basic        = true;
        serverInfoP->allowedAuth.digest       = false;
        serverInfoP->allowedAuth.gssnegotiate = false;
        serverInfoP->allowedAuth.ntlm         = false;
    }
}



void
xmlrpc_server_info_allow_auth_basic(xmlrpc_env *         const envP,
                                    xmlrpc_server_info * const sP) {

    if (sP->userNamePw == NULL)
        xmlrpc_faultf(envP, "You must set username/password with "
                      "xmlrpc_server_info_set_user()");
    else
        sP->allowedAuth.basic = true;
}



void
xmlrpc_server_info_disallow_auth_basic(
    xmlrpc_env *         const envP ATTR_UNUSED,
    xmlrpc_server_info * const sP) {

    sP->allowedAuth.basic = false;
}



void
xmlrpc_server_info_allow_auth_digest(xmlrpc_env *         const envP,
                                     xmlrpc_server_info * const sP) {

    if (sP->userNamePw == NULL)
        xmlrpc_faultf(envP, "You must set username/password with "
                      "xmlrpc_server_info_set_user()");
    else
        sP->allowedAuth.digest = true;
}



void
xmlrpc_server_info_disallow_auth_digest(
    xmlrpc_env *         const envP ATTR_UNUSED,
    xmlrpc_server_info * const sP) {

    sP->allowedAuth.digest = false;
}



void
xmlrpc_server_info_allow_auth_negotiate(xmlrpc_env *         const envP,
                                        xmlrpc_server_info * const sP) {

    if (sP->userNamePw == NULL)
        xmlrpc_faultf(envP, "You must set username/password with "
                      "xmlrpc_server_info_set_user()");
    else
        sP->allowedAuth.gssnegotiate = true;
}



void
xmlrpc_server_info_disallow_auth_negotiate(
    xmlrpc_env *         const envP ATTR_UNUSED,
    xmlrpc_server_info * const sP) {

    sP->allowedAuth.gssnegotiate = false;
}



void
xmlrpc_server_info_allow_auth_ntlm(xmlrpc_env *         const envP,
                                   xmlrpc_server_info * const sP) {

    if (sP->userNamePw == NULL)
        xmlrpc_faultf(envP, "You must set username/password with "
                      "xmlrpc_server_info_set_user()");
    else
        sP->allowedAuth.ntlm = true;
}



void
xmlrpc_server_info_disallow_auth_ntlm(
    xmlrpc_env *         const envP ATTR_UNUSED,
    xmlrpc_server_info * const sP) {
    
    sP->allowedAuth.ntlm = true;
}