upnpapi.cpp

Go to the documentation of this file.

/*******************************************************************************
 *
 * Copyright (c) 2000-2003 Intel Corporation
 * All rights reserved.
 * Copyright (C) 2011-2012 France Telecom All rights reserved.
 * Copyright (C) 2021+ GPL 3 and higher by Ingo Höft, <Ingo@Hoeft-online.de>
 * Redistribution only with this Copyright remark. Last modified: 2025-06-08
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * - Neither name of Intel Corporation nor the names of its contributors
 * may be used to endorse or promote products derived from this software
 * without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "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 INTEL OR
 * CONTRIBUTORS 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 DAMAGE.
 *
 ******************************************************************************/
// Last compare with ./Pupnp source file on 2024-10-26, ver 1.14.20
#include <upnpapi.hpp>
 
#include <uuid.hpp>
#include <miniserver.hpp> // Needed for one of the compile options
#include <httpreadwrite.hpp>
#include <ssdp_ctrlpt.hpp>
#include <ssdp_device.hpp>
#include <soap_device.hpp>
#include <soap_ctrlpt.hpp>
 
#include <UPnPsdk/addrinfo.hpp>
#include <UPnPsdk/netadapter.hpp>
 
#ifdef _WIN32
#include <umock/iphlpapi.hpp>
#else
#include <umock/ifaddrs.hpp>
#include <umock/net_if.hpp>
#endif
#include <umock/stdio.hpp>
 
/* Needed for GENA */
#include <gena.hpp>
 
#ifdef COMPA_HAVE_WEBSERVER
#include <urlconfig.hpp>
#include <webserver.hpp>
#endif /* COMPA_HAVE_WEBSERVER */
 
#include <sys/stat.h>
 
#include <cassert>
#include <csignal>
#include <cstdlib>
#include <cstring>
 
#ifdef _WIN32
/* Do not include these files */
#else
#include <ifaddrs.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#endif
 
namespace compa {
namespace {
 
pthread_mutex_t sdkInit_mutex = PTHREAD_MUTEX_INITIALIZER;
 
Handle_Info* HandleTable[NUM_HANDLE];
 
 
int UpnpGetIfInfo(
    std::string_view a_iface = "") //
{
    TRACE("Executing compa::UpnpGetIfInfo()")
    UPnPsdk::CNetadapter nadaptObj;
    try {
        nadaptObj.get_first(); // May throw exception
 
        if (!nadaptObj.find_first(a_iface) &&
            !nadaptObj.find_first(
                static_cast<unsigned int>(std::stoi(std::string(a_iface))))) {
            UPnPsdk_LOGERR("MSG1033") "Local network interface \""
                << a_iface << "\" not found.\n";
            return UPNP_E_INVALID_INTERFACE;
        }
 
        // Get gIF_NAME and gIF_INDEX
        ::memset(gIF_NAME, 0, sizeof(gIF_NAME));
        ::strncpy(gIF_NAME, nadaptObj.name().c_str(), sizeof(gIF_NAME) - 1);
        gIF_INDEX = nadaptObj.index();
 
        // With default lookup restrict finding to the current selected adapter.
        if (a_iface.empty())
            nadaptObj.find_first(gIF_INDEX);
 
        ::memset(gIF_IPV6, 0, sizeof(gIF_IPV6));
        ::memset(gIF_IPV6_ULA_GUA, 0, sizeof(gIF_IPV6_ULA_GUA));
        ::memset(gIF_IPV4, 0, sizeof(gIF_IPV4));
        ::memset(gIF_IPV4_NETMASK, 0, sizeof(gIF_IPV4_NETMASK));
 
        UPnPsdk::SSockaddr saObj;
        do {
            nadaptObj.sockaddr(saObj);
            switch (saObj.ss.ss_family) {
            case AF_INET6:
                // The loopback address belongs to link-local unicast
                // addresses.
                if (gIF_IPV6[0] == '\0' &&
                    (IN6_IS_ADDR_LINKLOCAL(&saObj.sin6.sin6_addr) ||
                     IN6_IS_ADDR_LOOPBACK(&saObj.sin6.sin6_addr))) {
                    // Strip leading bracket on copying.
                    ::strncpy(gIF_IPV6, saObj.netaddr().c_str() + 1,
                              sizeof(gIF_IPV6) - 1);
                    // Strip trailing scope id if any.
                    if (char* chptr{::strchr(gIF_IPV6, '%')})
                        *chptr = '\0';
                    // Strip trailing bracket if any.
                    else if (char* chptr{::strchr(gIF_IPV6, ']')})
                        *chptr = '\0';
                    gIF_IPV6_PREFIX_LENGTH = nadaptObj.bitmask();
                } else if (gIF_IPV6_ULA_GUA[0] == '\0') {
                    // Strip leading bracket on copying.
                    ::strncpy(gIF_IPV6_ULA_GUA, saObj.netaddr().c_str() + 1,
                              sizeof(gIF_IPV6_ULA_GUA) - 1);
                    // Strip trailing scope id if any.
                    if (char* chptr{::strchr(gIF_IPV6, '%')})
                        *chptr = '\0';
                    // Strip trailing bracket if any.
                    else if (char* chptr{::strchr(gIF_IPV6_ULA_GUA, ']')})
                        *chptr = '\0';
                    gIF_IPV6_ULA_GUA_PREFIX_LENGTH = nadaptObj.bitmask();
                }
                break;
 
            case AF_INET:
                if (gIF_IPV4[0] == '\0') {
                    ::strncpy(gIF_IPV4, saObj.netaddr().c_str(),
                              sizeof(gIF_IPV4) - 1);
                    nadaptObj.socknetmask(saObj);
                    ::strncpy(gIF_IPV4_NETMASK, saObj.netaddr().c_str(),
                              sizeof(gIF_IPV4_NETMASK) - 1);
                }
                break;
 
            default:
                UPnPsdk_LOGCRIT("MSG1029") "Unsupported address family("
                    << saObj.ss.ss_family << "), only AF_INET6(" << AF_INET6
                    << ") or AF_INET(" << AF_INET << ") are valid.\n";
                return UPNP_E_INVALID_INTERFACE;
            } // switch
 
        } while (nadaptObj.find_next() &&
                 (gIF_IPV6[0] == '\0' || gIF_IPV6_ULA_GUA[0] == '\0' ||
                  gIF_IPV4[0] == '\0'));
 
    } catch (const std::exception& ex) {
        UPnPsdk_LOGCATCH("MSG1006") "catched next line...\n" << ex.what();
        return UPNP_E_INVALID_INTERFACE;
    }
 
    return UPNP_E_SUCCESS;
}
 
} // namespace
} // namespace compa
 
namespace { // anonymous namespace for file scoped old upnpapi items.
 
// Compatible call mainly used for Unit Tests.
[[maybe_unused]] int UpnpGetIfInfo(
    const char* a_IFace) {
    TRACE("Executing ::UpnpGetIfInfo()")
    return compa::UpnpGetIfInfo(a_IFace == nullptr ? "" : a_IFace);
}
 
} // anonymous namespace
 
 
#if !defined(ifr_netmask) || defined(DOXYGEN_RUN) // it's a define if exists
#define ifr_netmask ifr_addr
#endif
 
#if !defined(IN6_IS_ADDR_ULA) || defined(DOXYGEN_RUN)
#define IN6_IS_ADDR_ULA(a)                                                     \
    ((((__const uint32_t*)(a))[0] & htonl((uint32_t)0xfe000000)) ==            \
     htonl((uint32_t)0xfc000000))
#endif /* IN6_IS_ADDR_ULA */
 
struct VirtualDirCallbacks virtualDirCallback;
 
virtualDirList* pVirtualDirList;
 
pthread_rwlock_t GlobalHndRWLock;
 
TimerThread gTimerThread;
 
ThreadPool gSendThreadPool;
 
ThreadPool gRecvThreadPool;
 
ThreadPool gMiniServerThreadPool;
 
WebServerState bWebServerState = WEB_SERVER_DISABLED;
 
WebCallback_HostValidate gWebCallback_HostValidate = 0;
 
void* gWebCallback_HostValidateCookie = 0;
 
int gAllowLiteralHostRedirection = 0;
 
char gIF_NAME[LINE_SIZE] = {'\0'};
 
char gIF_IPV4[INET_ADDRSTRLEN] = {'\0'};
 
char gIF_IPV4_NETMASK[INET_ADDRSTRLEN] = {'\0'};
 
char gIF_IPV6[INET6_ADDRSTRLEN] = {'\0'};
 
unsigned gIF_IPV6_PREFIX_LENGTH = 0;
 
unsigned gIF_INDEX;
// unsigned gIF_INDEX = ~0u; // Use complement of 0 because 0 may be a used
// index.
 
char gIF_IPV6_ULA_GUA[INET6_ADDRSTRLEN] = {'\0'};
 
unsigned gIF_IPV6_ULA_GUA_PREFIX_LENGTH = 0;
 
in_port_t LOCAL_PORT_V4;
 
in_port_t LOCAL_PORT_V6;
 
in_port_t LOCAL_PORT_V6_ULA_GUA;
 
extern membuffer gWebserverCorsString;
 
size_t g_maxContentLength = DEFAULT_SOAP_CONTENT_LENGTH;
 
int g_UpnpSdkEQMaxLen = MAX_SUBSCRIPTION_QUEUED_EVENTS;
 
int g_UpnpSdkEQMaxAge = MAX_SUBSCRIPTION_EVENT_AGE;
 
int UpnpSdkInit = 0;
 
int UpnpSdkClientRegistered = 0;
 
int UpnpSdkDeviceRegisteredV4 = 0;
 
int UpnpSdkDeviceregisteredV6 = 0;
 
#ifdef COMPA_HAVE_OPTION_SSDP
Upnp_SID gUpnpSdkNLSuuid;
#endif
 
typedef union {
    struct {
        int handle;
        int eventId;
        void* Event;
    } advertise;
    struct UpnpNonblockParam action;
} job_arg;
 
#ifdef COMPA_HAVE_DEVICE_SSDP // Needed to compile with warings as errors --Ingo
static void free_advertise_arg(job_arg* arg) {
    if (arg->advertise.Event) {
        free(arg->advertise.Event);
    }
    free(arg);
}
#endif
 
#ifdef COMPA_HAVE_CTRLPT_SOAP
static void free_action_arg(job_arg* arg) {
    if (arg->action.Header) {
        ixmlDocument_free(arg->action.Header);
    }
    if (arg->action.Act) {
        ixmlDocument_free(arg->action.Act);
    }
    free(arg);
}
#endif
 
 
static int UpnpInitMutexes() {
#ifdef __CYGWIN__
    /* On Cygwin, pthread_mutex_init() fails without this memset. */
    /* TODO: Fix Cygwin so we don't need this memset(). */
    memset(&GlobalHndRWLock, 0, sizeof(GlobalHndRWLock));
#endif
    if (pthread_rwlock_init(&GlobalHndRWLock, NULL) != 0) {
        return UPNP_E_INIT_FAILED;
    }
#ifdef COMPA_HAVE_OPTION_SSDP
    // Mutex to synchronize the uuid creation process.
    uuidMutexInit();
#endif
    /* initialize subscribe mutex. */
#ifdef COMPA_HAVE_CTRLPT_GENA
    if (clientSubscribeMutexInit() != 0) {
        return UPNP_E_INIT_FAILED;
    }
#endif
    return UPNP_E_SUCCESS;
}
 
static int UpnpInitThreadPools() {
    int ret = UPNP_E_SUCCESS;
    ThreadPoolAttr attr;
 
    TPAttrInit(&attr);
    TPAttrSetMaxThreads(&attr, MAX_THREADS);
    TPAttrSetMinThreads(&attr, MIN_THREADS);
    TPAttrSetStackSize(&attr, THREAD_STACK_SIZE);
    TPAttrSetJobsPerThread(&attr, JOBS_PER_THREAD);
    TPAttrSetIdleTime(&attr, THREAD_IDLE_TIME);
    TPAttrSetMaxJobsTotal(&attr, maxJobsTotal);
 
    if (ThreadPoolInit(&gSendThreadPool, &attr) != UPNP_E_SUCCESS) {
        ret = UPNP_E_INIT_FAILED;
        goto exit_function;
    }
 
    if (ThreadPoolInit(&gRecvThreadPool, &attr) != UPNP_E_SUCCESS) {
        ret = UPNP_E_INIT_FAILED;
        goto exit_function;
    }
 
    if (ThreadPoolInit(&gMiniServerThreadPool, &attr) != UPNP_E_SUCCESS) {
        ret = UPNP_E_INIT_FAILED;
        goto exit_function;
    }
 
exit_function:
    if (ret != UPNP_E_SUCCESS) {
        UpnpSdkInit = 0;
        UpnpFinish();
    }
 
    return ret;
}
 
static int UpnpInitPreamble() {
    TRACE("Executing UpnpInitPreamble()")
    int retVal = UPNP_E_SUCCESS;
 
    /* needed by SSDP or other parts. */
    srand((unsigned int)time(NULL));
 
    /* Initialize debug output. */
    retVal = UpnpInitLog();
    if (retVal != UPNP_E_SUCCESS) {
        /* UpnpInitLog does not return a valid UPNP_E_*. */
        return UPNP_E_INIT_FAILED;
    }
 
    /* Initialize SDK global mutexes. */
    retVal = UpnpInitMutexes();
    if (retVal != UPNP_E_SUCCESS) {
        return retVal;
    }
 
#ifdef COMPA_HAVE_OPTION_SSDP
    /* Create the NLS uuid. */
    uuid_upnp nls_uuid;
    uuid_create(&nls_uuid);
    upnp_uuid_unpack(&nls_uuid, gUpnpSdkNLSuuid);
#endif
 
    /* Initializes the handle list. */
    HandleLock();
    for (int i{0}; i < NUM_HANDLE; ++i) {
        compa::HandleTable[i] = nullptr;
    }
    HandleUnlock();
 
    /* Initialize SDK global thread pools. */
    retVal = UpnpInitThreadPools();
    if (retVal != UPNP_E_SUCCESS) {
        return retVal;
    }
 
#ifdef COMPA_HAVE_DEVICE_SOAP
    SetSoapCallback(soap_device_callback);
#endif
 
#ifdef COMPA_HAVE_DEVICE_GENA
    SetGenaCallback(genaCallback);
#endif
 
    /* Initialize the SDK timer thread. */
    retVal = TimerThreadInit(&gTimerThread, &gSendThreadPool);
    if (retVal != UPNP_E_SUCCESS) {
        UpnpFinish();
 
        return retVal;
    }
 
    return UPNP_E_SUCCESS;
}
 
static int UpnpInitStartServers(
    [[maybe_unused]] in_port_t DestPort) {
    UPnPsdk_LOGINFO("MSG1061") "Executing...\n";
    int retVal;
 
#ifdef COMPA_HAVE_MINISERVER
    LOCAL_PORT_V4 = DestPort;
    LOCAL_PORT_V6 = DestPort;
    LOCAL_PORT_V6_ULA_GUA = DestPort;
    retVal =
        StartMiniServer(&LOCAL_PORT_V4, &LOCAL_PORT_V6, &LOCAL_PORT_V6_ULA_GUA);
    if (retVal != UPNP_E_SUCCESS) {
        UpnpPrintf(UPNP_CRITICAL, API, __FILE__, __LINE__,
                   "Miniserver failed to start\n");
        UpnpFinish();
        return retVal;
    }
#endif
 
    retVal = UpnpEnableWebserver(WEB_SERVER_ENABLED);
    if (retVal != UPNP_E_SUCCESS) {
        UpnpFinish();
        return retVal;
    }
 
    UPnPsdk_LOGINFO("MSG1066") "Finished.\n";
    return UPNP_E_SUCCESS;
}
 
int UpnpInit2(const char* IfName, unsigned short DestPort) {
    UPnPsdk_LOGINFO("MSG1096") "Executing...\n";
    int retVal;
 
    // The mutex must be initialized.
    if (pthread_mutex_lock(&compa::sdkInit_mutex) != 0) {
        retVal = UPNP_E_INIT_FAILED;
        goto exit_function;
    }
 
    /* Check if we're already initialized. */
    if (UpnpSdkInit == 1) {
        retVal = UPNP_E_INIT;
        goto exit_function;
    }
 
    /* Set the UpnpSdkInit flag to 1 to indicate we're successfully
     * initialized. */
    UpnpSdkInit = 1;
 
    /* Perform initialization preamble. */
    retVal = UpnpInitPreamble();
    if (retVal != UPNP_E_SUCCESS) {
        goto exit_function;
    }
 
    /* Retrieve interface information (Addresses, index, etc). */
    retVal = compa::UpnpGetIfInfo(IfName == nullptr ? "" : IfName);
    if (retVal != UPNP_E_SUCCESS) {
        goto exit_function;
    }
 
    /* Finish initializing the SDK. */
    retVal = UpnpInitStartServers(DestPort);
    if (retVal != UPNP_E_SUCCESS) {
        goto exit_function;
    }
 
exit_function:
    if (retVal != UPNP_E_SUCCESS && retVal != UPNP_E_INIT) {
        UpnpFinish();
    }
    pthread_mutex_unlock(&compa::sdkInit_mutex);
    return retVal;
}
 
#ifdef DEBUG
void PrintThreadPoolStats(
    ThreadPool* tp,          
    const char* DbgFileName, 
    int DbgLineNo,           
    const char* msg)  {
    ThreadPoolStats stats;
    ThreadPoolGetStats(tp, &stats);
    UpnpPrintf(UPNP_INFO, API, DbgFileName, DbgLineNo,
               "%s\n"
               "High Jobs pending: %d\n"
               "Med Jobs Pending: %d\n"
               "Low Jobs Pending: %d\n"
               "Average wait in High Q in milliseconds: %lf\n"
               "Average wait in Med Q in milliseconds: %lf\n"
               "Average wait in Low Q in milliseconds: %lf\n"
               "Max Threads Used: %d\n"
               "Worker Threads: %d\n"
               "Persistent Threads: %d\n"
               "Idle Threads: %d\n"
               "Total Threads: %d\n"
               "Total Work Time: %lf\n"
               "Total Idle Time: %lf\n",
               msg, stats.currentJobsHQ, stats.currentJobsMQ,
               stats.currentJobsLQ, stats.avgWaitHQ, stats.avgWaitMQ,
               stats.avgWaitLQ, stats.maxThreads, stats.workerThreads,
               stats.persistentThreads, stats.idleThreads, stats.totalThreads,
               stats.totalWorkTime, stats.totalIdleTime);
}
#else
#define PrintThreadPoolStats(tp, DbgFileName, DbgLineNo, msg)                  \
    do {                                                                       \
    } while (0)
#endif /* DEBUG */
 
int UpnpFinish() {
    TRACE("Executing UpnpFinish()")
    UpnpPrintf(UPNP_INFO, API, __FILE__, __LINE__,
               "Inside UpnpFinish: UpnpSdkInit is %d\n", UpnpSdkInit);
#ifdef COMPA_HAVE_DEVICE_SSDP
    UpnpDevice_Handle device_handle;
#endif
#ifdef COMPA_HAVE_CTRLPT_SSDP
    UpnpClient_Handle client_handle;
#endif
    [[maybe_unused]] struct Handle_Info* temp{nullptr};
#ifdef UPnPsdk_HAVE_OPENSSL
    freeSslCtx();
#endif
    if (UpnpSdkInit != 1)
        return UPNP_E_FINISH;
    UpnpPrintf(UPNP_INFO, API, __FILE__, __LINE__,
               "UpnpFinish: UpnpSdkInit is ONE\n");
    // May be usable for DEBUG:
    // PrintThreadPoolStats(&gSendThreadPool, __FILE__, __LINE__,
    //                      "Send Thread Pool");
    // PrintThreadPoolStats(&gRecvThreadPool, __FILE__, __LINE__,
    //                      "Recv Thread Pool");
    // PrintThreadPoolStats(&gMiniServerThreadPool, __FILE__, __LINE__,
    //                      "MiniServer Thread Pool");
#ifdef COMPA_HAVE_DEVICE_SSDP
    while (GetDeviceHandleInfo(0, AF_INET, &device_handle, &temp) ==
           HND_DEVICE) {
        UpnpUnRegisterRootDevice(device_handle);
    }
    while (GetDeviceHandleInfo(0, AF_INET6, &device_handle, &temp) ==
           HND_DEVICE) {
        UpnpUnRegisterRootDevice(device_handle);
    }
#endif
#ifdef COMPA_HAVE_CTRLPT_SSDP
    while (HND_CLIENT == GetClientHandleInfo(&client_handle, &temp)) {
        UpnpUnRegisterClient(client_handle);
    }
#endif
    TimerThreadShutdown(&gTimerThread);
#ifdef COMPA_HAVE_MINISERVER
    StopMiniServer();
#endif
#ifdef COMPA_HAVE_WEBSERVER
    web_server_destroy();
#endif
    ThreadPoolShutdown(&gMiniServerThreadPool);
    PrintThreadPoolStats(&gMiniServerThreadPool, __FILE__, __LINE__,
                         "MiniServer Thread Pool");
    ThreadPoolShutdown(&gRecvThreadPool);
    PrintThreadPoolStats(&gSendThreadPool, __FILE__, __LINE__,
                         "Send Thread Pool");
    ThreadPoolShutdown(&gSendThreadPool);
    PrintThreadPoolStats(&gRecvThreadPool, __FILE__, __LINE__,
                         "Recv Thread Pool");
#ifdef COMPA_HAVE_CTRLPT_GENA
    clientSubscribeMutexDestroy();
#endif
    pthread_rwlock_destroy(&GlobalHndRWLock);
#ifdef COMPA_HAVE_OPTION_SSDP
    uuidMutexDestroy(); // May fail but not checked due to compatibility.
#endif
    UpnpRemoveAllVirtualDirs(); /* remove all virtual dirs */
    UpnpSdkInit = 0;
    UpnpPrintf(UPNP_INFO, API, __FILE__, __LINE__,
               "Exiting UpnpFinish: UpnpSdkInit is :%d:\n", UpnpSdkInit);
    UpnpCloseLog();
 
    return UPNP_E_SUCCESS;
}
 
unsigned short UpnpGetServerPort() {
    if (UpnpSdkInit != 1)
        return 0u;
 
    return LOCAL_PORT_V4;
}
 
unsigned short UpnpGetServerPort6() {
#ifdef UPNP_ENABLE_IPV6
    if (UpnpSdkInit != 1)
        return 0u;
 
    return LOCAL_PORT_V6;
#else
    return 0u;
#endif
}
 
unsigned short UpnpGetServerUlaGuaPort6() {
#ifdef UPNP_ENABLE_IPV6
    if (UpnpSdkInit != 1)
        return 0u;
 
    return LOCAL_PORT_V6_ULA_GUA;
#else
    return 0u;
#endif
}
 
char* UpnpGetServerIpAddress() {
    if (UpnpSdkInit != 1)
        return NULL;
 
    return gIF_IPV4;
}
 
char* UpnpGetServerIp6Address() {
#ifdef UPNP_ENABLE_IPV6
    if (UpnpSdkInit != 1)
        return NULL;
 
    return gIF_IPV6;
#else
    return NULL;
#endif
}
 
char* UpnpGetServerUlaGuaIp6Address() {
#ifdef UPNP_ENABLE_IPV6
    if (UpnpSdkInit != 1)
        return NULL;
 
    return gIF_IPV6_ULA_GUA;
#else
    return NULL;
#endif
}
 
#if defined(COMPA_HAVE_DEVICE_SSDP) || defined(COMPA_HAVE_CTRLPT_SSDP)
static int GetFreeHandle() {
    // Handle 0 is not used as NULL translates to 0 when passed as a handle
    int i = 1;
 
    while (i < NUM_HANDLE && compa::HandleTable[i] != nullptr)
        ++i;
    if (i == NUM_HANDLE)
        return UPNP_E_OUTOF_HANDLE;
    else
        return i;
}
 
static int FreeHandle(
    int Upnp_Handle) {
    int ret = UPNP_E_INVALID_HANDLE;
 
    UpnpPrintf(UPNP_INFO, API, __FILE__, __LINE__,
               "FreeHandle: entering, Handle is %d\n", Upnp_Handle);
    if (Upnp_Handle < 1 || Upnp_Handle >= NUM_HANDLE) {
        UpnpPrintf(UPNP_CRITICAL, API, __FILE__, __LINE__,
                   "FreeHandle: Handle %d is out of range\n", Upnp_Handle);
    } else if (compa::HandleTable[Upnp_Handle] == nullptr) {
        UpnpPrintf(UPNP_CRITICAL, API, __FILE__, __LINE__,
                   "FreeHandle: compa::HandleTable[%d] is nullptr\n",
                   Upnp_Handle);
    } else {
        free(compa::HandleTable[Upnp_Handle]);
        compa::HandleTable[Upnp_Handle] = nullptr;
        ret = UPNP_E_SUCCESS;
    }
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "FreeHandle: exiting, ret = %d.\n", ret);
 
    return ret;
}
#endif // defined(COMPA_HAVE_DEVICE_SSDP) || defined(COMPA_HAVE_CTRLPT_SSDP)
 
#ifdef COMPA_HAVE_DEVICE_SSDP
int UpnpRegisterRootDevice(const char* const DescUrl, const Upnp_FunPtr Fun,
                           const void* const Cookie,
                           UpnpDevice_Handle* const Hnd) {
    struct Handle_Info* HInfo = NULL;
    int retVal = 0;
#ifdef COMPA_HAVE_DEVICE_GENA
    int hasServiceTable{0};
#endif
    HandleLock();
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpRegisterRootDevice\n");
 
    if (UpnpSdkInit != 1) {
        retVal = UPNP_E_FINISH;
        goto exit_function;
    }
 
    if (Hnd == NULL || Fun == NULL || DescUrl == NULL ||
        strlen(DescUrl) == (size_t)0) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
 
    *Hnd = GetFreeHandle();
    if (*Hnd == UPNP_E_OUTOF_HANDLE) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
 
    HInfo = (struct Handle_Info*)malloc(sizeof(struct Handle_Info));
    if (HInfo == NULL) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
    memset(HInfo, 0, sizeof(struct Handle_Info));
    compa::HandleTable[*Hnd] = HInfo;
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Root device URL is %s\n",
               DescUrl);
 
    HInfo->aliasInstalled = 0;
    HInfo->HType = HND_DEVICE;
    strncpy(HInfo->DescURL, DescUrl, sizeof(HInfo->DescURL) - 1);
    strncpy(HInfo->LowerDescURL, DescUrl, sizeof(HInfo->LowerDescURL) - 1);
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Following Root Device URL will be used when answering to "
               "legacy CPs %s\n",
               HInfo->LowerDescURL);
    HInfo->Callback = Fun;
    HInfo->Cookie = (char*)Cookie;
    HInfo->MaxAge = DEFAULT_MAXAGE;
    HInfo->DeviceList = NULL;
    HInfo->ServiceList = NULL;
    HInfo->DescDocument = NULL;
#ifdef COMPA_HAVE_CTRLPT_SSDP
    ListInit(&HInfo->SsdpSearchList, NULL, NULL);
    HInfo->ClientSubList = NULL;
#endif
    HInfo->MaxSubscriptions = UPNP_INFINITE;
    HInfo->MaxSubscriptionTimeOut = UPNP_INFINITE;
    HInfo->DeviceAf = AF_INET;
 
    retVal = UpnpDownloadXmlDoc(HInfo->DescURL, &(HInfo->DescDocument));
    if (retVal != UPNP_E_SUCCESS) {
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "UpnpRegisterRootDevice: error downloading Document: "
                   "%d\n",
                   retVal);
#ifdef COMPA_HAVE_CTRLPT_SSDP
        ListDestroy(&HInfo->SsdpSearchList, 0);
#endif
        FreeHandle(*Hnd);
        goto exit_function;
    }
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "UpnpRegisterRootDevice: Valid Description\n"
               "UpnpRegisterRootDevice: DescURL : %s\n",
               HInfo->DescURL);
 
    HInfo->DeviceList =
        ixmlDocument_getElementsByTagName(HInfo->DescDocument, "device");
    if (!HInfo->DeviceList) {
#ifdef COMPA_HAVE_CTRLPT_SSDP
        ListDestroy(&HInfo->SsdpSearchList, 0);
#endif
        ixmlDocument_free(HInfo->DescDocument);
        FreeHandle(*Hnd);
        UpnpPrintf(UPNP_CRITICAL, API, __FILE__, __LINE__,
                   "UpnpRegisterRootDevice: No devices found for "
                   "RootDevice\n");
        retVal = UPNP_E_INVALID_DESC;
        goto exit_function;
    }
 
    HInfo->ServiceList =
        ixmlDocument_getElementsByTagName(HInfo->DescDocument, "serviceList");
    if (!HInfo->ServiceList) {
        UpnpPrintf(UPNP_CRITICAL, API, __FILE__, __LINE__,
                   "UpnpRegisterRootDevice: No services found for "
                   "RootDevice\n");
    }
 
#ifdef COMPA_HAVE_DEVICE_GENA
    /*
     * GENA SET UP
     */
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "UpnpRegisterRootDevice: Gena Check\n");
    memset(&HInfo->ServiceTable, 0, sizeof(HInfo->ServiceTable));
    hasServiceTable = getServiceTable((IXML_Node*)HInfo->DescDocument,
                                      &HInfo->ServiceTable, HInfo->DescURL);
    if (hasServiceTable) {
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "UpnpRegisterRootDevice: GENA Service Table\n"
                   "Here are the known services:\n");
        printServiceTable(&HInfo->ServiceTable, UPNP_ALL, API);
    } else {
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "\nUpnpRegisterRootDevice: Empty service table\n");
    }
#endif // COMPA_HAVE_DEVICE_GENA
 
    UpnpSdkDeviceRegisteredV4 = 1;
 
    retVal = UPNP_E_SUCCESS;
 
exit_function:
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting RegisterRootDevice, return value == %d\n", retVal);
    HandleUnlock();
 
    return retVal;
}
#endif /* COMPA_HAVE_DEVICE_SSDP */
 
#ifdef COMPA_HAVE_DEVICE_DESCRIPTION
static int GetDescDocumentAndURL(
    /* [in] pointer to server address structure. */
    Upnp_DescType descriptionType,
    /* [in] . */
    char* description,
    /* [in] . */
    int config_baseURL,
    /* [in] . */
    int AddressFamily,
    /* [out] . */
    IXML_Document** xmlDoc,
    /* [out] . */
    char descURL[LINE_SIZE]);
 
int UpnpRegisterRootDevice2(const Upnp_DescType descriptionType,
                            const char* const description_const,
                            const size_t bufferLen, /* ignored */
                            const int config_baseURL, const Upnp_FunPtr Fun,
                            const void* const Cookie,
                            UpnpDevice_Handle* const Hnd) {
    struct Handle_Info* HInfo = NULL;
    int retVal = 0;
    char* description = (char*)description_const;
    (void)bufferLen;
#ifdef COMPA_HAVE_DEVICE_GENA
    int hasServiceTable{0};
#endif
    HandleLock();
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpRegisterRootDevice2\n");
 
    if (UpnpSdkInit != 1) {
        retVal = UPNP_E_FINISH;
        goto exit_function;
    }
 
    if (Hnd == NULL || Fun == NULL) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
 
    *Hnd = GetFreeHandle();
    if (*Hnd == UPNP_E_OUTOF_HANDLE) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
 
    HInfo = (struct Handle_Info*)malloc(sizeof(struct Handle_Info));
    if (HInfo == NULL) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
    memset(HInfo, 0, sizeof(struct Handle_Info));
    compa::HandleTable[*Hnd] = HInfo;
 
    /* prevent accidental removal of a non-existent alias */
    HInfo->aliasInstalled = 0;
 
    retVal =
        GetDescDocumentAndURL(descriptionType, description, config_baseURL,
                              AF_INET, &HInfo->DescDocument, HInfo->DescURL);
    if (retVal != UPNP_E_SUCCESS) {
        FreeHandle(*Hnd);
        goto exit_function;
    }
 
#ifdef UPNPLIB_PUPNP_BUG
    // Error if compiling old code with build type Release: output may be
    // truncated copying 179 bytes from a string of length 179
    // [-Werror=stringop-truncation]. We have to fix it here otherwise it won't
    // compile. --Ingo
    strncpy(HInfo->LowerDescURL, HInfo->DescURL,
            sizeof(HInfo->LowerDescURL) - 1);
#else
    strncpy(HInfo->LowerDescURL, HInfo->DescURL, sizeof(HInfo->LowerDescURL));
#endif
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Following Root Device URL will be used when answering to "
               "legacy CPs %s\n",
               HInfo->LowerDescURL);
    HInfo->aliasInstalled = config_baseURL != 0;
    HInfo->HType = HND_DEVICE;
    HInfo->Callback = Fun;
    HInfo->Cookie = (char*)Cookie;
    HInfo->MaxAge = DEFAULT_MAXAGE;
    HInfo->DeviceList = NULL;
    HInfo->ServiceList = NULL;
#ifdef COMPA_HAVE_CTRLPT_SSDP
    ListInit(&HInfo->SsdpSearchList, NULL, NULL);
    HInfo->ClientSubList = NULL;
#endif
    HInfo->MaxSubscriptions = UPNP_INFINITE;
    HInfo->MaxSubscriptionTimeOut = UPNP_INFINITE;
    HInfo->DeviceAf = AF_INET;
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "UpnpRegisterRootDevice2: Valid Description\n"
               "UpnpRegisterRootDevice2: DescURL : %s\n",
               HInfo->DescURL);
 
    HInfo->DeviceList =
        ixmlDocument_getElementsByTagName(HInfo->DescDocument, "device");
    if (!HInfo->DeviceList) {
#ifdef COMPA_HAVE_CTRLPT_SSDP
        ListDestroy(&HInfo->SsdpSearchList, 0);
#endif
        ixmlDocument_free(HInfo->DescDocument);
        FreeHandle(*Hnd);
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "UpnpRegisterRootDevice2: No devices found for "
                   "RootDevice\n");
        retVal = UPNP_E_INVALID_DESC;
        goto exit_function;
    }
 
    HInfo->ServiceList =
        ixmlDocument_getElementsByTagName(HInfo->DescDocument, "serviceList");
    if (!HInfo->ServiceList) {
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "UpnpRegisterRootDevice2: No services found for "
                   "RootDevice\n");
    }
 
#ifdef COMPA_HAVE_DEVICE_GENA
    /*
     * GENA SET UP
     */
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "UpnpRegisterRootDevice2: Gena Check\n");
    memset(&HInfo->ServiceTable, 0, sizeof(HInfo->ServiceTable));
    hasServiceTable = getServiceTable((IXML_Node*)HInfo->DescDocument,
                                      &HInfo->ServiceTable, HInfo->DescURL);
    if (hasServiceTable) {
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "UpnpRegisterRootDevice2: GENA Service Table\n"
                   "Here are the known services: \n");
        printServiceTable(&HInfo->ServiceTable, UPNP_ALL, API);
    } else {
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "\nUpnpRegisterRootDevice2: Empty service table\n");
    }
#endif // COMPA_HAVE_DEVICE_GENA
 
    UpnpSdkDeviceRegisteredV4 = 1;
 
    retVal = UPNP_E_SUCCESS;
 
exit_function:
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting RegisterRootDevice2, return value == %d\n", retVal);
    HandleUnlock();
 
    return retVal;
}
#endif // COMPA_HAVE_DEVICE_DESCRIPTION
 
#ifdef COMPA_HAVE_DEVICE_SSDP
 
namespace compa {
namespace {
int UpnpRegisterRootDevice3(const char* const DescUrl, const Upnp_FunPtr Fun,
                            const void* const Cookie,
                            UpnpDevice_Handle* const Hnd,
                            const int AddressFamily,
                            const char* const LowerDescUrl) {
    TRACE("Executing UpnpRegisterRootDevice3() (same as "
          "UpnpRegisterRootDevice4())")
    Handle_Info* HInfo;
    int retVal = 0;
#ifdef COMPA_HAVE_DEVICE_GENA
    int hasServiceTable{0};
#endif
    HandleLock();
 
    // Do some basic parameter checks.
    if (UpnpSdkInit != 1) {
        retVal = UPNP_E_FINISH;
        goto exit_function;
    }
    if (Hnd == nullptr || Fun == nullptr || DescUrl == nullptr ||
        strlen(DescUrl) == 0 ||
        (AddressFamily != AF_INET && AddressFamily != AF_INET6)) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
 
    // Get a UPnP Unit handle and initialize handle info for a UPnP Device.
    *Hnd = GetFreeHandle();
    if (*Hnd == UPNP_E_OUTOF_HANDLE) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
    HInfo = (Handle_Info*)malloc(sizeof(Handle_Info));
    if (HInfo == nullptr) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
    memset(HInfo, 0, sizeof(Handle_Info));
    compa::HandleTable[*Hnd] = HInfo;
 
    HInfo->HType = HND_DEVICE; // Set handle info to UPnP Device.
 
    strncpy(HInfo->DescURL, DescUrl, sizeof(HInfo->DescURL) - 1);
    if (LowerDescUrl == nullptr)
        strncpy(HInfo->LowerDescURL, DescUrl, sizeof(HInfo->LowerDescURL) - 1);
    else
        strncpy(HInfo->LowerDescURL, LowerDescUrl,
                sizeof(HInfo->LowerDescURL) - 1);
    UPnPsdk_LOGINFO(
        "MSG1050") "Following Root UDevice local URL will be used when "
                   "responding to requests from control points: "
        << HInfo->LowerDescURL << ".\n";
    HInfo->Callback = Fun;
    HInfo->Cookie = (char*)Cookie;
    HInfo->MaxAge = DEFAULT_MAXAGE;
    HInfo->DeviceList = nullptr;
    HInfo->ServiceList = nullptr;
    HInfo->DescDocument = nullptr;
#ifdef COMPA_HAVE_CTRLPT_SSDP
    ListInit(&HInfo->SsdpSearchList, NULL, NULL);
    HInfo->ClientSubList = nullptr;
#endif
    HInfo->MaxSubscriptions = UPNP_INFINITE;
    HInfo->MaxSubscriptionTimeOut = UPNP_INFINITE;
    HInfo->DeviceAf = AddressFamily;
 
    // Get own device description from local XML file.
    retVal = UpnpDownloadXmlDoc(HInfo->DescURL, &(HInfo->DescDocument));
    if (retVal != UPNP_E_SUCCESS) {
#ifdef COMPA_HAVE_CTRLPT_SSDP
        ListDestroy(&HInfo->SsdpSearchList, 0);
#endif
        FreeHandle(*Hnd);
        goto exit_function;
    }
    UPnPsdk_LOGINFO(
        "MSG1051") "UpnpRegisterRootDevice3(or 4): Valid Description\n"
                   "UpnpRegisterRootDevice3(or 4): DescURL = "
        << HInfo->DescURL << ".\n";
 
    HInfo->DeviceList =
        ixmlDocument_getElementsByTagName(HInfo->DescDocument, "device");
    if (!HInfo->DeviceList) {
#ifdef COMPA_HAVE_CTRLPT_SSDP
        ListDestroy(&HInfo->SsdpSearchList, 0);
#endif
        ixmlDocument_free(HInfo->DescDocument);
        FreeHandle(*Hnd);
        UPnPsdk_LOGCRIT("MSG1052") "UpnpRegisterRootDevice3(or 4): No devices "
                                   "found for RootDevice.\n";
        retVal = UPNP_E_INVALID_DESC;
        goto exit_function;
    }
 
    HInfo->ServiceList =
        ixmlDocument_getElementsByTagName(HInfo->DescDocument, "serviceList");
    if (!HInfo->ServiceList) {
        UPnPsdk_LOGCRIT(
            "MSG1054") "UpnpRegisterRootDevice3(or 4): No services found for "
                       "RootDevice.\n";
    }
 
#ifdef COMPA_HAVE_DEVICE_GENA
    /*
     * GENA SET UP
     */
    UPnPsdk_LOGINFO("MSG1055") "UpnpRegisterRootDevice3(or 4): Gena Check.\n";
    memset(&HInfo->ServiceTable, 0, sizeof(HInfo->ServiceTable));
    hasServiceTable = getServiceTable((IXML_Node*)HInfo->DescDocument,
                                      &HInfo->ServiceTable, HInfo->DescURL);
    if (hasServiceTable) {
        UPnPsdk_LOGINFO(
            "MSG1056") "UpnpRegisterRootDevice3(or 4): GENA Service Table\n"
                       "Here are the known services:\n";
        printServiceTable(&HInfo->ServiceTable, UPNP_ALL, API);
    } else {
        UPnPsdk_LOGINFO(
            "MSG1062") "\nUpnpRegisterRootDevice3(or 4): Empty service table\n";
    }
#endif // COMPA_HAVE_CTRLPT_GENA || COMPA_HAVE_DEVICE_GENA
 
    switch (AddressFamily) {
    case AF_INET:
        UpnpSdkDeviceRegisteredV4 = 1;
        break;
    default:
        UpnpSdkDeviceregisteredV6 = 1;
    }
 
    retVal = UPNP_E_SUCCESS;
 
exit_function:
    UPnPsdk_LOGINFO(
        "MSG1064") "Exiting UpnpRegisterRootDevice3(or 4), return value == "
        << retVal << ".\n";
    HandleUnlock();
 
    return retVal;
}
} // anonymous namespace
} // namespace compa
 
// UpnpRegisterRootDevice3() (without LowerDescUrl argument).
int UpnpRegisterRootDevice3(const char* const DescUrl, const Upnp_FunPtr Fun,
                            const void* const Cookie,
                            UpnpDevice_Handle* const Hnd,
                            const int AddressFamily) {
    return compa::UpnpRegisterRootDevice3(DescUrl, Fun, Cookie, Hnd,
                                          AddressFamily, nullptr);
}
 
// Same as UpnpRegisterRootDevice3() but with LowerDescUrl argument.
int UpnpRegisterRootDevice4(const char* const DescUrl, const Upnp_FunPtr Fun,
                            const void* const Cookie,
                            UpnpDevice_Handle* const Hnd,
                            const int AddressFamily,
                            const char* const LowerDescUrl) {
    return compa::UpnpRegisterRootDevice3(DescUrl, Fun, Cookie, Hnd,
                                          AddressFamily, LowerDescUrl);
}
#endif /* COMPA_HAVE_DEVICE_SSDP */
 
#ifdef COMPA_HAVE_DEVICE_SSDP
int UpnpUnRegisterRootDevice(UpnpDevice_Handle Hnd) {
    UpnpPrintf(UPNP_INFO, API, __FILE__, __LINE__,
               "Inside UpnpUnRegisterRootDevice\n");
    return UpnpUnRegisterRootDeviceLowPower(Hnd, -1, -1, -1);
}
 
int UpnpUnRegisterRootDeviceLowPower(UpnpDevice_Handle Hnd, int PowerState,
                                     int SleepPeriod, int RegistrationState) {
    int retVal = 0;
    struct Handle_Info* HInfo = NULL;
 
    if (UpnpSdkInit != 1)
        return UPNP_E_FINISH;
    UpnpPrintf(UPNP_INFO, API, __FILE__, __LINE__,
               "Inside UpnpUnRegisterRootDeviceLowPower\n");
#ifdef COMPA_HAVE_DEVICE_GENA
    if (genaUnregisterDevice(Hnd) != UPNP_E_SUCCESS)
        return UPNP_E_INVALID_HANDLE;
#endif
 
    HandleLock();
    switch (GetHandleInfo(Hnd, &HInfo)) {
    case HND_INVALID:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    default:
        break;
    }
    HInfo->PowerState = PowerState;
    if (SleepPeriod < 0)
        SleepPeriod = -1;
    HInfo->SleepPeriod = SleepPeriod;
    HInfo->RegistrationState = RegistrationState;
    HandleUnlock();
 
    retVal = AdvertiseAndReply(-1, Hnd, (enum SsdpSearchType)0,
                               (struct sockaddr*)NULL, (char*)NULL, (char*)NULL,
                               (char*)NULL, HInfo->MaxAge);
 
    HandleLock();
    switch (GetHandleInfo(Hnd, &HInfo)) {
    case HND_INVALID:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    default:
        break;
    }
    ixmlNodeList_free(HInfo->DeviceList);
    ixmlNodeList_free(HInfo->ServiceList);
    ixmlDocument_free(HInfo->DescDocument);
#ifdef COMPA_HAVE_CTRLPT_SSDP
    ListDestroy(&HInfo->SsdpSearchList, 0);
#endif
#ifdef COMPA_HAVE_WEBSERVER
    if (HInfo->aliasInstalled)
        web_server_set_alias(NULL, NULL, 0, 0);
#endif
    switch (HInfo->DeviceAf) {
    case AF_INET:
        UpnpSdkDeviceRegisteredV4 = 0;
        break;
    case AF_INET6:
        UpnpSdkDeviceregisteredV6 = 0;
        break;
    default:
        break;
    }
    FreeHandle(Hnd);
    HandleUnlock();
 
    UpnpPrintf(UPNP_INFO, API, __FILE__, __LINE__,
               "Exiting UpnpUnRegisterRootDeviceLowPower\n");
 
    return retVal;
}
#endif /* COMPA_HAVE_DEVICE_SSDP */
 
#ifdef COMPA_HAVE_CTRLPT_SSDP
int UpnpRegisterClient(Upnp_FunPtr Fun, const void* Cookie,
                       UpnpClient_Handle* Hnd) {
    struct Handle_Info* HInfo;
 
    if (UpnpSdkInit != 1)
        return UPNP_E_FINISH;
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpRegisterClient \n");
    if (Fun == NULL || Hnd == NULL)
        return UPNP_E_INVALID_PARAM;
 
    HandleLock();
    if ((NUM_HANDLE - 1) <=
        (UpnpSdkClientRegistered + UpnpSdkDeviceRegisteredV4 +
         UpnpSdkDeviceregisteredV6)) {
        HandleUnlock();
        return UPNP_E_ALREADY_REGISTERED;
    }
    if ((*Hnd = GetFreeHandle()) == UPNP_E_OUTOF_HANDLE) {
        HandleUnlock();
        return UPNP_E_OUTOF_MEMORY;
    }
    HInfo = (struct Handle_Info*)malloc(sizeof(struct Handle_Info));
    if (HInfo == NULL) {
        HandleUnlock();
        return UPNP_E_OUTOF_MEMORY;
    }
    HInfo->HType = HND_CLIENT;
    HInfo->Callback = Fun;
    HInfo->Cookie = (char*)Cookie;
    HInfo->ClientSubList = NULL;
    ListInit(&HInfo->SsdpSearchList, NULL, NULL);
#ifdef COMPA_HAVE_DEVICE_SSDP
    HInfo->MaxAge = 0;
    HInfo->MaxSubscriptions = UPNP_INFINITE;
    HInfo->MaxSubscriptionTimeOut = UPNP_INFINITE;
#endif
    compa::HandleTable[*Hnd] = HInfo;
    UpnpSdkClientRegistered += 1;
    HandleUnlock();
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpRegisterClient \n");
 
    return UPNP_E_SUCCESS;
}
#endif /* COMPA_HAVE_CTRLPT_SSDP */
 
#ifdef COMPA_HAVE_CTRLPT_SSDP
int UpnpUnRegisterClient(UpnpClient_Handle Hnd) {
    struct Handle_Info* HInfo;
    ListNode* node = NULL;
    SsdpSearchArg* searchArg = NULL;
 
    if (UpnpSdkInit != 1)
        return UPNP_E_FINISH;
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpUnRegisterClient \n");
 
    HandleLock();
    if (!UpnpSdkClientRegistered) {
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    HandleUnlock();
 
#ifdef COMPA_HAVE_CTRLPT_GENA
    if (genaUnregisterClient(Hnd) != UPNP_E_SUCCESS)
        return UPNP_E_INVALID_HANDLE;
#endif
    HandleLock();
    switch (GetHandleInfo(Hnd, &HInfo)) {
    case HND_INVALID:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    default:
        break;
    }
    /* clean up search list */
    node = ListHead(&HInfo->SsdpSearchList);
    while (node != NULL) {
        searchArg = (SsdpSearchArg*)node->item;
        if (searchArg) {
            free(searchArg->searchTarget);
            free(searchArg);
        }
        ListDelNode(&HInfo->SsdpSearchList, node, 0);
        node = ListHead(&HInfo->SsdpSearchList);
    }
    ListDestroy(&HInfo->SsdpSearchList, 0);
    FreeHandle(Hnd);
    UpnpSdkClientRegistered -= 1;
    HandleUnlock();
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpUnRegisterClient \n");
 
    return UPNP_E_SUCCESS;
}
#endif /* COMPA_HAVE_CTRLPT_SSDP */
 
#ifdef COMPA_HAVE_DEVICE_DESCRIPTION
static int GetNameForAlias(
    char* name,
    char** alias) {
    char* ext;
    char* al;
 
    ext = strrchr(name, '.');
    if (ext == NULL || strcasecmp(ext, ".xml") != 0) {
        return UPNP_E_EXT_NOT_XML;
    }
 
    al = strrchr(name, '/');
    if (al == NULL) {
        *alias = name;
    } else {
        *alias = al;
    }
 
    return UPNP_E_SUCCESS;
}
 
static void get_server_addr(
    struct sockaddr* serverAddr) {
    struct sockaddr_in* sa4 = (struct sockaddr_in*)serverAddr;
 
    memset(serverAddr, 0, sizeof(struct sockaddr_storage));
 
    sa4->sin_family = AF_INET;
    inet_pton(AF_INET, gIF_IPV4, &sa4->sin_addr);
    sa4->sin_port = htons(LOCAL_PORT_V4);
}
 
static void get_server_addr6(
    struct sockaddr* serverAddr) {
    struct sockaddr_in6* sa6 = (struct sockaddr_in6*)serverAddr;
 
    memset(serverAddr, 0, sizeof(struct sockaddr_storage));
 
    sa6->sin6_family = AF_INET6;
    inet_pton(AF_INET6, gIF_IPV6, &sa6->sin6_addr);
    sa6->sin6_port = htons(LOCAL_PORT_V6);
}
 
static int GetDescDocumentAndURL(Upnp_DescType descriptionType,
                                 char* description, int config_baseURL,
                                 int AddressFamily, IXML_Document** xmlDoc,
                                 char descURL[LINE_SIZE]) {
    int retVal = 0;
    char* membuf = NULL;
    char aliasStr[LINE_SIZE];
    char* temp_str = NULL;
    FILE* fp = NULL;
    int fd;
    size_t fileLen;
    size_t num_read;
    time_t last_modified{};
    struct stat file_info;
    struct sockaddr_storage serverAddr;
    int rc = UPNP_E_SUCCESS;
 
    memset(aliasStr, 0, sizeof(aliasStr));
    if (description == NULL)
        return UPNP_E_INVALID_PARAM;
    /* non-URL description must have configuration specified */
    if (descriptionType != (enum Upnp_DescType_e)UPNPREG_URL_DESC &&
        !config_baseURL)
        return UPNP_E_INVALID_PARAM;
    /* Get XML doc and last modified time */
    if (descriptionType == (enum Upnp_DescType_e)UPNPREG_URL_DESC) {
        retVal = UpnpDownloadXmlDoc(description, xmlDoc);
        if (retVal != UPNP_E_SUCCESS)
            return retVal;
        last_modified = time(NULL);
    } else if (descriptionType == (enum Upnp_DescType_e)UPNPREG_FILENAME_DESC) {
        int ret = 0;
 
#ifdef _WIN32
        umock::stdio_h.fopen_s(&fp, description, "rb");
#else
        fp = umock::stdio_h.fopen(description, "rb");
#endif
        if (!fp) {
            rc = UPNP_E_FILE_NOT_FOUND;
            ret = 1;
            goto exit_function1;
        }
        fd = fileno(fp);
        if (fd == -1) {
            rc = UPNP_E_FILE_NOT_FOUND;
            ret = 1;
            goto exit_function1;
        }
        retVal = fstat(fd, &file_info);
        if (retVal == -1) {
            rc = UPNP_E_FILE_NOT_FOUND;
            ret = 1;
            goto exit_function1;
        }
        fileLen = (size_t)file_info.st_size;
        last_modified = file_info.st_mtime;
        membuf = (char*)malloc(fileLen + (size_t)1);
        if (!membuf) {
            rc = UPNP_E_OUTOF_MEMORY;
            ret = 1;
            goto exit_function1;
        }
        num_read = umock::stdio_h.fread(membuf, (size_t)1, fileLen, fp);
        if (num_read != fileLen) {
            rc = UPNP_E_FILE_READ_ERROR;
            ret = 1;
            goto exit_function2;
        }
        membuf[fileLen] = 0;
        rc = ixmlParseBufferEx(membuf, xmlDoc);
    exit_function2:
        if (membuf) {
            free(membuf);
        }
    exit_function1:
        if (fp) {
            umock::stdio_h.fclose(fp);
        }
        if (ret) {
            return rc;
        }
    } else if (descriptionType == (enum Upnp_DescType_e)UPNPREG_BUF_DESC) {
        last_modified = time(NULL);
        rc = ixmlParseBufferEx(description, xmlDoc);
    } else {
        return UPNP_E_INVALID_PARAM;
    }
 
    if (rc != IXML_SUCCESS &&
        descriptionType != (enum Upnp_DescType_e)UPNPREG_URL_DESC) {
        if (rc == IXML_INSUFFICIENT_MEMORY)
            return UPNP_E_OUTOF_MEMORY;
        else
            return UPNP_E_INVALID_DESC;
    }
    /* Determine alias */
    if (config_baseURL) {
        if (descriptionType == (enum Upnp_DescType_e)UPNPREG_BUF_DESC) {
            strncpy(aliasStr, "description.xml", sizeof(aliasStr) - 1);
        } else {
            /* URL or filename */
            retVal = GetNameForAlias(description, &temp_str);
            if (retVal != UPNP_E_SUCCESS) {
                ixmlDocument_free(*xmlDoc);
                return retVal;
            }
            if (strlen(temp_str) > (LINE_SIZE - 1)) {
                ixmlDocument_free(*xmlDoc);
                return UPNP_E_URL_TOO_BIG;
            }
            strncpy(aliasStr, temp_str, sizeof(aliasStr) - 1);
        }
        if (AddressFamily == AF_INET) {
            get_server_addr((struct sockaddr*)&serverAddr);
        } else {
            get_server_addr6((struct sockaddr*)&serverAddr);
        }
 
        /* config */
        retVal = configure_urlbase(*xmlDoc, (struct sockaddr*)&serverAddr,
                                   aliasStr, last_modified, descURL);
        if (retVal != UPNP_E_SUCCESS) {
            ixmlDocument_free(*xmlDoc);
            return retVal;
        }
    } else {
        /* Manual */
        if (strlen(description) > LINE_SIZE - 1) {
            ixmlDocument_free(*xmlDoc);
            return UPNP_E_URL_TOO_BIG;
        }
        strncpy(descURL, description, LINE_SIZE - 1);
        descURL[LINE_SIZE - 1] = '\0';
    }
 
    assert(*xmlDoc != NULL);
 
    return UPNP_E_SUCCESS;
}
#endif // COMPA_HAVE_DEVICE_DESCRIPTION
 
/*******************************************************************************
 *
 *                                  SSDP interface
 *
 ******************************************************************************/
 
#ifdef COMPA_HAVE_DEVICE_SSDP
int UpnpSendAdvertisement(UpnpDevice_Handle Hnd, int Exp) {
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpSendAdvertisement \n");
    return UpnpSendAdvertisementLowPower(Hnd, Exp, -1, -1, -1);
}
 
int UpnpSendAdvertisementLowPower(UpnpDevice_Handle Hnd, int Exp,
                                  int PowerState, int SleepPeriod,
                                  int RegistrationState) {
    struct Handle_Info* SInfo = NULL;
    int retVal = 0, *ptrMx;
    job_arg* adEvent;
    ThreadPoolJob job;
 
    memset(&job, 0, sizeof(job));
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpSendAdvertisementLowPower \n");
 
    HandleLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_DEVICE:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    if (Exp < 1)
        Exp = DEFAULT_MAXAGE;
    if (Exp <= AUTO_ADVERTISEMENT_TIME * 2)
        Exp = (AUTO_ADVERTISEMENT_TIME + 1) * 2;
    SInfo->MaxAge = Exp;
    SInfo->PowerState = PowerState;
    if (SleepPeriod < 0)
        SleepPeriod = -1;
    SInfo->SleepPeriod = SleepPeriod;
    SInfo->RegistrationState = RegistrationState;
    HandleUnlock();
    retVal = AdvertiseAndReply(1, Hnd, (enum SsdpSearchType)0,
                               (struct sockaddr*)NULL, (char*)NULL, (char*)NULL,
                               (char*)NULL, Exp);
 
    if (retVal != UPNP_E_SUCCESS)
        return retVal;
    ptrMx = (int*)malloc(sizeof(int));
    if (ptrMx == NULL)
        return UPNP_E_OUTOF_MEMORY;
    adEvent = (job_arg*)malloc(sizeof(job_arg));
 
    if (adEvent == NULL) {
        free(ptrMx);
        return UPNP_E_OUTOF_MEMORY;
    }
    *ptrMx = Exp;
    adEvent->advertise.handle = Hnd;
    adEvent->advertise.Event = ptrMx;
 
    HandleLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_DEVICE:
        break;
    default:
        HandleUnlock();
        free(adEvent);
        free(ptrMx);
        return UPNP_E_INVALID_HANDLE;
    }
#ifdef SSDP_PACKET_DISTRIBUTE
    TPJobInit(&job, (UPnPsdk::start_routine)AutoAdvertise, adEvent);
    TPJobSetFreeFunction(&job, (free_routine)free_advertise_arg);
    TPJobSetPriority(&job, MED_PRIORITY);
    if ((retVal = TimerThreadSchedule(
             &gTimerThread, ((Exp / 2) - (AUTO_ADVERTISEMENT_TIME)), REL_SEC,
             &job, SHORT_TERM, &(adEvent->advertise.eventId))) !=
        UPNP_E_SUCCESS) {
        HandleUnlock();
        free_advertise_arg(adEvent);
        return retVal;
    }
#else
    TPJobInit(&job, (UPnPsdk::start_routine)AutoAdvertise, adEvent);
    TPJobSetFreeFunction(&job, (free_routine)free_advertise_arg);
    TPJobSetPriority(&job, MED_PRIORITY);
    if ((retVal = TimerThreadSchedule(
             &gTimerThread, Exp - AUTO_ADVERTISEMENT_TIME, REL_SEC, &job,
             SHORT_TERM, &(adEvent->advertise.eventId))) != UPNP_E_SUCCESS) {
        HandleUnlock();
        free_advertise_arg(adEvent);
        return retVal;
    }
#endif
 
    HandleUnlock();
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpSendAdvertisementLowPower \n");
 
    return retVal;
}
#endif /* COMPA_HAVE_DEVICE_SSDP */
 
#ifdef COMPA_HAVE_CTRLPT_SSDP
int UpnpSearchAsync(UpnpClient_Handle Hnd, int Mx, const char* Target_const,
                    const void* Cookie_const) {
    struct Handle_Info* SInfo = NULL;
    char* Target = (char*)Target_const;
    int retVal;
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Inside UpnpSearchAsync\n");
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    if (Mx < 1)
        Mx = DEFAULT_MX;
 
    if (Target == NULL) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
 
    HandleUnlock();
    retVal = SearchByTarget(Hnd, Mx, Target, (void*)Cookie_const);
    if (retVal != 1)
        return retVal;
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Exiting UpnpSearchAsync \n");
 
    return UPNP_E_SUCCESS;
}
#endif /* COMPA_HAVE_CTRLPT_SSDP */
 
/*******************************************************************************
 *
 *                                  GENA interface
 *
 ******************************************************************************/
 
#ifdef COMPA_HAVE_DEVICE_GENA
int UpnpSetMaxSubscriptions(UpnpDevice_Handle Hnd, int MaxSubscriptions) {
    struct Handle_Info* SInfo = NULL;
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpSetMaxSubscriptions \n");
 
    HandleLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_DEVICE:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    if ((MaxSubscriptions != UPNP_INFINITE) && (MaxSubscriptions < 0)) {
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    SInfo->MaxSubscriptions = MaxSubscriptions;
    HandleUnlock();
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpSetMaxSubscriptions \n");
 
    return UPNP_E_SUCCESS;
}
#endif /* COMPA_HAVE_DEVICE_GENA */
 
#ifdef COMPA_HAVE_DEVICE_GENA
int UpnpSetMaxSubscriptionTimeOut(UpnpDevice_Handle Hnd,
                                  int MaxSubscriptionTimeOut) {
    struct Handle_Info* SInfo = NULL;
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpSetMaxSubscriptionTimeOut\n");
 
    HandleLock();
 
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_DEVICE:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    if ((MaxSubscriptionTimeOut != UPNP_INFINITE) &&
        (MaxSubscriptionTimeOut < 0)) {
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
 
    SInfo->MaxSubscriptionTimeOut = MaxSubscriptionTimeOut;
    HandleUnlock();
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpSetMaxSubscriptionTimeOut\n");
 
    return UPNP_E_SUCCESS;
}
#endif /* COMPA_HAVE_DEVICE_GENA */
 
#ifdef COMPA_HAVE_CTRLPT_GENA
int UpnpSubscribeAsync(UpnpClient_Handle Hnd, const char* EvtUrl_const,
                       int TimeOut, Upnp_FunPtr Fun, const void* Cookie_const) {
    struct Handle_Info* SInfo = NULL;
    struct UpnpNonblockParam* Param;
    char* EvtUrl = (char*)EvtUrl_const;
    ThreadPoolJob job;
 
    memset(&job, 0, sizeof(job));
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpSubscribeAsync\n");
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    if (EvtUrl == NULL) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
    if (TimeOut != UPNP_INFINITE && TimeOut < 1) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
    if (Fun == NULL) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
    HandleUnlock();
 
    Param = (struct UpnpNonblockParam*)malloc(sizeof(struct UpnpNonblockParam));
    if (Param == NULL) {
        return UPNP_E_OUTOF_MEMORY;
    }
    memset(Param, 0, sizeof(struct UpnpNonblockParam));
 
    Param->FunName = SUBSCRIBE;
    Param->Handle = Hnd;
    strncpy(Param->Url, EvtUrl, sizeof(Param->Url) - 1);
    Param->TimeOut = TimeOut;
    Param->Fun = Fun;
    Param->Cookie = (char*)Cookie_const;
 
    TPJobInit(&job, (UPnPsdk::start_routine)UpnpThreadDistribution, Param);
    TPJobSetFreeFunction(&job, (free_routine)free);
    TPJobSetPriority(&job, MED_PRIORITY);
    if (ThreadPoolAdd(&gSendThreadPool, &job, NULL) != 0) {
        free(Param);
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpSubscribeAsync\n");
 
    return UPNP_E_SUCCESS;
}
#endif /* COMPA_HAVE_CTRLPT_GENA */
 
#ifdef COMPA_HAVE_CTRLPT_GENA
int UpnpSubscribe(UpnpClient_Handle Hnd, const char* EvtUrl_const, int* TimeOut,
                  Upnp_SID SubsId) {
    int retVal;
    struct Handle_Info* SInfo = NULL;
    UpnpString* EvtUrl = UpnpString_new();
    UpnpString* SubsIdTmp = UpnpString_new();
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Inside UpnpSubscribe\n");
 
    if (UpnpSdkInit != 1) {
        retVal = UPNP_E_FINISH;
        goto exit_function;
    }
 
    if (EvtUrl == NULL) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
    if (EvtUrl_const == NULL) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
    UpnpString_set_String(EvtUrl, EvtUrl_const);
 
    if (SubsIdTmp == NULL) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
    if (SubsId == NULL) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
    UpnpString_set_String(SubsIdTmp, SubsId);
 
    if (TimeOut == NULL) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        retVal = UPNP_E_INVALID_HANDLE;
        goto exit_function;
    }
    HandleUnlock();
 
    retVal = genaSubscribe(Hnd, EvtUrl, TimeOut, SubsIdTmp);
    memset(SubsId, 0, sizeof(Upnp_SID));
    strncpy(SubsId, UpnpString_get_String(SubsIdTmp), sizeof(Upnp_SID) - 1);
 
exit_function:
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpSubscribe, retVal=%d\n", retVal);
 
    UpnpString_delete(SubsIdTmp);
    UpnpString_delete(EvtUrl);
 
    return retVal;
}
#endif /* COMPA_HAVE_CTRLPT_GENA */
 
#ifdef COMPA_HAVE_CTRLPT_GENA
int UpnpUnSubscribe(UpnpClient_Handle Hnd, const Upnp_SID SubsId) {
    struct Handle_Info* SInfo = NULL;
    int retVal;
    UpnpString* SubsIdTmp = UpnpString_new();
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Inside UpnpUnSubscribe\n");
 
    if (UpnpSdkInit != 1) {
        retVal = UPNP_E_FINISH;
        goto exit_function;
    }
 
    if (SubsIdTmp == NULL) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
    if (SubsId == NULL) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
    UpnpString_set_String(SubsIdTmp, SubsId);
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        retVal = UPNP_E_INVALID_HANDLE;
        goto exit_function;
    }
    HandleUnlock();
 
    retVal = genaUnSubscribe(Hnd, SubsIdTmp);
 
exit_function:
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpUnSubscribe, retVal=%d\n", retVal);
 
    UpnpString_delete(SubsIdTmp);
 
    return retVal;
}
#endif /* COMPA_HAVE_CTRLPT_GENA */
 
#ifdef COMPA_HAVE_CTRLPT_GENA
int UpnpUnSubscribeAsync(UpnpClient_Handle Hnd, Upnp_SID SubsId,
                         Upnp_FunPtr Fun, const void* Cookie_const) {
    int retVal = UPNP_E_SUCCESS;
    ThreadPoolJob job;
    struct Handle_Info* SInfo = NULL;
    struct UpnpNonblockParam* Param;
 
    memset(&job, 0, sizeof(job));
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpUnSubscribeAsync\n");
 
    if (UpnpSdkInit != 1) {
        retVal = UPNP_E_FINISH;
        goto exit_function;
    }
 
    if (SubsId == NULL) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
    if (Fun == NULL) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        retVal = UPNP_E_INVALID_HANDLE;
        goto exit_function;
    }
    HandleUnlock();
 
    Param = (struct UpnpNonblockParam*)malloc(sizeof(struct UpnpNonblockParam));
    if (Param == NULL) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
    memset(Param, 0, sizeof(struct UpnpNonblockParam));
 
    Param->FunName = UNSUBSCRIBE;
    Param->Handle = Hnd;
    strncpy(Param->SubsId, SubsId, sizeof(Param->SubsId) - 1);
    Param->Fun = Fun;
    Param->Cookie = (char*)Cookie_const;
    TPJobInit(&job, (UPnPsdk::start_routine)UpnpThreadDistribution, Param);
    TPJobSetFreeFunction(&job, (free_routine)free);
    TPJobSetPriority(&job, MED_PRIORITY);
    if (ThreadPoolAdd(&gSendThreadPool, &job, NULL) != 0) {
        free(Param);
    }
 
exit_function:
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpUnSubscribeAsync\n");
 
    return retVal;
}
#endif /* COMPA_HAVE_CTRLPT_GENA */
 
#ifdef COMPA_HAVE_CTRLPT_GENA
int UpnpRenewSubscription(UpnpClient_Handle Hnd, int* TimeOut,
                          const Upnp_SID SubsId) {
    struct Handle_Info* SInfo = NULL;
    int retVal;
    UpnpString* SubsIdTmp = UpnpString_new();
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpRenewSubscription\n");
 
    if (UpnpSdkInit != 1) {
        retVal = UPNP_E_FINISH;
        goto exit_function;
    }
 
    if (SubsIdTmp == NULL) {
        retVal = UPNP_E_OUTOF_MEMORY;
        goto exit_function;
    }
    if (SubsId == NULL) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
    UpnpString_set_String(SubsIdTmp, SubsId);
 
    if (TimeOut == NULL) {
        retVal = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        retVal = UPNP_E_INVALID_HANDLE;
        goto exit_function;
    }
    HandleUnlock();
 
    retVal = genaRenewSubscription(Hnd, SubsIdTmp, TimeOut);
 
exit_function:
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpRenewSubscription, retVal=%d\n", retVal);
 
    UpnpString_delete(SubsIdTmp);
 
    return retVal;
}
#endif /* COMPA_HAVE_CTRLPT_GENA */
 
#ifdef COMPA_HAVE_CTRLPT_GENA
int UpnpRenewSubscriptionAsync(UpnpClient_Handle Hnd, int TimeOut,
                               Upnp_SID SubsId, Upnp_FunPtr Fun,
                               const void* Cookie_const) {
    ThreadPoolJob job;
    struct Handle_Info* SInfo = NULL;
    struct UpnpNonblockParam* Param;
 
    memset(&job, 0, sizeof(job));
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpRenewSubscriptionAsync\n");
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    if (TimeOut != UPNP_INFINITE && TimeOut < 1) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
    if (SubsId == NULL) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
    if (Fun == NULL) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
    HandleUnlock();
 
    Param = (struct UpnpNonblockParam*)malloc(sizeof(struct UpnpNonblockParam));
    if (Param == NULL) {
        return UPNP_E_OUTOF_MEMORY;
    }
    memset(Param, 0, sizeof(struct UpnpNonblockParam));
 
    Param->FunName = RENEW;
    Param->Handle = Hnd;
    strncpy(Param->SubsId, SubsId, sizeof(Param->SubsId) - 1);
    Param->Fun = Fun;
    Param->Cookie = (char*)Cookie_const;
    Param->TimeOut = TimeOut;
 
    TPJobInit(&job, (UPnPsdk::start_routine)UpnpThreadDistribution, Param);
    TPJobSetFreeFunction(&job, (free_routine)free);
    TPJobSetPriority(&job, MED_PRIORITY);
    if (ThreadPoolAdd(&gSendThreadPool, &job, NULL) != 0) {
        free(Param);
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpRenewSubscriptionAsync\n");
 
    return UPNP_E_SUCCESS;
}
#endif /* COMPA_HAVE_CTRLPT_GENA */
 
#ifdef COMPA_HAVE_DEVICE_GENA
int UpnpNotify(UpnpDevice_Handle Hnd, const char* DevID_const,
               const char* ServName_const, const char** VarName_const,
               const char** NewVal_const, int cVariables) {
    struct Handle_Info* SInfo = NULL;
    int retVal;
    char* DevID = (char*)DevID_const;
    char* ServName = (char*)ServName_const;
    char** VarName = (char**)VarName_const;
    char** NewVal = (char**)NewVal_const;
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Inside UpnpNotify\n");
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_DEVICE:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    if (DevID == NULL) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
    if (ServName == NULL) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
    if (VarName == NULL || NewVal == NULL || cVariables < 0) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
 
    HandleUnlock();
    retVal = genaNotifyAll(Hnd, DevID, ServName, VarName, NewVal, cVariables);
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Exiting UpnpNotify\n");
 
    return retVal;
}
 
int UpnpNotifyExt(UpnpDevice_Handle Hnd, const char* DevID_const,
                  const char* ServName_const, IXML_Document* PropSet) {
    struct Handle_Info* SInfo = NULL;
    int retVal;
    char* DevID = (char*)DevID_const;
    char* ServName = (char*)ServName_const;
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Inside UpnpNotify \n");
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_DEVICE:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    if (DevID == NULL) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
    if (ServName == NULL) {
        HandleUnlock();
        return UPNP_E_INVALID_PARAM;
    }
 
    HandleUnlock();
    retVal = genaNotifyAllExt(Hnd, DevID, ServName, PropSet);
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Exiting UpnpNotify \n");
 
    return retVal;
}
#endif /* COMPA_HAVE_DEVICE_GENA */
 
#ifdef COMPA_HAVE_DEVICE_GENA
int UpnpAcceptSubscription(UpnpDevice_Handle Hnd, const char* DevID_const,
                           const char* ServName_const,
                           const char** VarName_const,
                           const char** NewVal_const, int cVariables,
                           const Upnp_SID SubsId) {
    int ret = 0;
    int line = 0;
    struct Handle_Info* SInfo = NULL;
    char* DevID = (char*)DevID_const;
    char* ServName = (char*)ServName_const;
    char** VarName = (char**)VarName_const;
    char** NewVal = (char**)NewVal_const;
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpAcceptSubscription\n");
 
    if (UpnpSdkInit != 1) {
        line = __LINE__;
        ret = UPNP_E_FINISH;
        goto exit_function;
    }
 
    HandleReadLock();
 
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_DEVICE:
        break;
    default:
        HandleUnlock();
        line = __LINE__;
        ret = UPNP_E_INVALID_HANDLE;
        goto exit_function;
    }
    if (DevID == NULL) {
        HandleUnlock();
        line = __LINE__;
        ret = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
    if (ServName == NULL) {
        HandleUnlock();
        line = __LINE__;
        ret = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
    if (SubsId == NULL) {
        HandleUnlock();
        line = __LINE__;
        ret = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
/* Now accepts an empty state list, so the code below is
 * commented out */
#if 0
    if (VarName == NULL || NewVal == NULL || cVariables < 0) {
        HandleUnlock();
        line = __LINE__;
        ret = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
#endif
 
    HandleUnlock();
 
    line = __LINE__;
    ret = genaInitNotify(Hnd, DevID, ServName, VarName, NewVal, cVariables,
                         SubsId);
 
exit_function:
    UpnpPrintf(UPNP_ALL, API, __FILE__, line,
               "Exiting UpnpAcceptSubscription, ret = %d\n", ret);
 
    return ret;
}
 
int UpnpAcceptSubscriptionExt(UpnpDevice_Handle Hnd, const char* DevID_const,
                              const char* ServName_const,
                              IXML_Document* PropSet, const Upnp_SID SubsId) {
    int ret = 0;
    int line = 0;
    struct Handle_Info* SInfo = NULL;
    char* DevID = (char*)DevID_const;
    char* ServName = (char*)ServName_const;
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpAcceptSubscription\n");
 
    if (UpnpSdkInit != 1) {
        line = __LINE__;
        ret = UPNP_E_FINISH;
        goto exit_function;
    }
 
    HandleReadLock();
 
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_DEVICE:
        break;
    default:
        HandleUnlock();
        line = __LINE__;
        ret = UPNP_E_INVALID_HANDLE;
        goto exit_function;
    }
    if (DevID == NULL) {
        HandleUnlock();
        line = __LINE__;
        ret = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
    if (ServName == NULL) {
        HandleUnlock();
        line = __LINE__;
        ret = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
    if (SubsId == NULL) {
        HandleUnlock();
        line = __LINE__;
        ret = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
/* Now accepts an empty state list, so the code below is
 * commented out */
#if 0
    if (PropSet == NULL) {
        HandleUnlock();
        line = __LINE__;
        ret = UPNP_E_INVALID_PARAM;
        goto exit_function;
    }
#endif
 
    HandleUnlock();
 
    line = __LINE__;
    ret = genaInitNotifyExt(Hnd, DevID, ServName, PropSet, SubsId);
 
exit_function:
    UpnpPrintf(UPNP_ALL, API, __FILE__, line,
               "Exiting UpnpAcceptSubscription, ret = %d.\n", ret);
 
    return ret;
}
#endif /* COMPA_HAVE_DEVICE_GENA */
 
/*******************************************************************************
 *
 *                                  SOAP interface
 *
 ******************************************************************************/
 
#ifdef COMPA_HAVE_CTRLPT_SOAP
int UpnpSendAction(UpnpClient_Handle Hnd, const char* ActionURL_const,
                   const char* ServiceType_const, const char* DevUDN_const,
                   IXML_Document* Action, IXML_Document** RespNodePtr) {
    struct Handle_Info* SInfo = NULL;
    int retVal = 0;
    char* ActionURL = (char*)ActionURL_const;
    char* ServiceType = (char*)ServiceType_const;
    /* udn not used? */
    /*char *DevUDN = (char *)DevUDN_const;*/
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Inside UpnpSendAction\n");
    if (DevUDN_const != NULL) {
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "non NULL DevUDN is ignored\n");
    }
    DevUDN_const = NULL;
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    HandleUnlock();
 
    if (ActionURL == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
 
    if (ServiceType == NULL || Action == NULL || RespNodePtr == NULL ||
        DevUDN_const != NULL) {
 
        return UPNP_E_INVALID_PARAM;
    }
 
    retVal = SoapSendAction(ActionURL, ServiceType, Action, RespNodePtr);
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Exiting UpnpSendAction\n");
 
    return retVal;
}
 
int UpnpSendActionEx(UpnpClient_Handle Hnd, const char* ActionURL_const,
                     const char* ServiceType_const, const char* DevUDN_const,
                     IXML_Document* Header, IXML_Document* Action,
                     IXML_Document** RespNodePtr) {
    struct Handle_Info* SInfo = NULL;
    int retVal = 0;
    char* ActionURL = (char*)ActionURL_const;
    char* ServiceType = (char*)ServiceType_const;
    /* udn not used? */
    /*char *DevUDN = (char *)DevUDN_const;*/
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Inside UpnpSendActionEx\n");
 
    if (Header == NULL) {
        retVal = UpnpSendAction(Hnd, ActionURL_const, ServiceType_const,
                                DevUDN_const, Action, RespNodePtr);
        return retVal;
    }
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    HandleUnlock();
 
    if (ActionURL == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
    if (ServiceType == NULL || Action == NULL || RespNodePtr == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
 
    retVal =
        SoapSendActionEx(ActionURL, ServiceType, Header, Action, RespNodePtr);
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "Exiting UpnpSendAction \n");
 
    return retVal;
}
 
int UpnpSendActionAsync(UpnpClient_Handle Hnd, const char* ActionURL_const,
                        const char* ServiceType_const, const char* DevUDN_const,
                        IXML_Document* Act, Upnp_FunPtr Fun,
                        const void* Cookie_const) {
    int rc;
    ThreadPoolJob job;
    struct Handle_Info* SInfo = NULL;
    struct UpnpNonblockParam* Param;
    DOMString tmpStr;
    char* ActionURL = (char*)ActionURL_const;
    char* ServiceType = (char*)ServiceType_const;
    /* udn not used? */
    /*char *DevUDN = (char *)DevUDN_const;*/
 
    memset(&job, 0, sizeof(job));
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpSendActionAsync\n");
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    HandleUnlock();
 
    if (ActionURL == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
    if (ServiceType == NULL || Act == NULL || Fun == NULL ||
        DevUDN_const != NULL) {
        return UPNP_E_INVALID_PARAM;
    }
    tmpStr = ixmlPrintNode((IXML_Node*)Act);
    if (tmpStr == NULL) {
        return UPNP_E_INVALID_ACTION;
    }
 
    Param = (struct UpnpNonblockParam*)malloc(sizeof(struct UpnpNonblockParam));
 
    if (Param == NULL) {
        ixmlFreeDOMString(tmpStr);
        return UPNP_E_OUTOF_MEMORY;
    }
    memset(Param, 0, sizeof(struct UpnpNonblockParam));
 
    Param->FunName = ACTION;
    Param->Handle = Hnd;
    strncpy(Param->Url, ActionURL, sizeof(Param->Url) - 1);
    strncpy(Param->ServiceType, ServiceType, sizeof(Param->ServiceType) - 1);
 
    rc = ixmlParseBufferEx(tmpStr, &(Param->Act));
    if (rc != IXML_SUCCESS) {
        free(Param);
        ixmlFreeDOMString(tmpStr);
        if (rc == IXML_INSUFFICIENT_MEMORY) {
            return UPNP_E_OUTOF_MEMORY;
        } else {
            return UPNP_E_INVALID_ACTION;
        }
    }
    ixmlFreeDOMString(tmpStr);
    Param->Cookie = (char*)Cookie_const;
    Param->Fun = Fun;
 
    TPJobInit(&job, (UPnPsdk::start_routine)UpnpThreadDistribution, Param);
    TPJobSetFreeFunction(&job, (free_routine)free_action_arg);
 
    TPJobSetPriority(&job, MED_PRIORITY);
    if (ThreadPoolAdd(&gSendThreadPool, &job, NULL) != 0) {
        free_action_arg((job_arg*)Param);
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpSendActionAsync \n");
 
    return UPNP_E_SUCCESS;
}
 
int UpnpSendActionExAsync(UpnpClient_Handle Hnd, const char* ActionURL_const,
                          const char* ServiceType_const,
                          const char* DevUDN_const, IXML_Document* Header,
                          IXML_Document* Act, Upnp_FunPtr Fun,
                          const void* Cookie_const) {
    struct Handle_Info* SInfo = NULL;
    struct UpnpNonblockParam* Param;
    DOMString tmpStr;
    DOMString headerStr = NULL;
    char* ActionURL = (char*)ActionURL_const;
    char* ServiceType = (char*)ServiceType_const;
    ThreadPoolJob job;
    int retVal = 0;
 
    memset(&job, 0, sizeof(job));
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpSendActionExAsync\n");
 
    if (Header == NULL) {
        retVal = UpnpSendActionAsync(Hnd, ActionURL_const, ServiceType_const,
                                     DevUDN_const, Act, Fun, Cookie_const);
        return retVal;
    }
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    HandleUnlock();
 
    if (ActionURL == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
    if (ServiceType == NULL || Act == NULL || Fun == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
 
    headerStr = ixmlPrintNode((IXML_Node*)Header);
 
    tmpStr = ixmlPrintNode((IXML_Node*)Act);
    if (tmpStr == NULL) {
        ixmlFreeDOMString(headerStr);
        return UPNP_E_INVALID_ACTION;
    }
 
    Param = (struct UpnpNonblockParam*)malloc(sizeof(struct UpnpNonblockParam));
    if (Param == NULL) {
        ixmlFreeDOMString(tmpStr);
        ixmlFreeDOMString(headerStr);
        return UPNP_E_OUTOF_MEMORY;
    }
    memset(Param, 0, sizeof(struct UpnpNonblockParam));
 
    Param->FunName = ACTION;
    Param->Handle = Hnd;
    strncpy(Param->Url, ActionURL, sizeof(Param->Url) - 1);
    strncpy(Param->ServiceType, ServiceType, sizeof(Param->ServiceType) - 1);
    retVal = ixmlParseBufferEx(headerStr, &(Param->Header));
    if (retVal != IXML_SUCCESS) {
        free(Param);
        ixmlFreeDOMString(tmpStr);
        ixmlFreeDOMString(headerStr);
        if (retVal == IXML_INSUFFICIENT_MEMORY) {
            return UPNP_E_OUTOF_MEMORY;
        } else {
            return UPNP_E_INVALID_ACTION;
        }
    }
 
    retVal = ixmlParseBufferEx(tmpStr, &(Param->Act));
    if (retVal != IXML_SUCCESS) {
        ixmlDocument_free(Param->Header);
        free(Param);
        ixmlFreeDOMString(tmpStr);
        ixmlFreeDOMString(headerStr);
        if (retVal == IXML_INSUFFICIENT_MEMORY) {
            return UPNP_E_OUTOF_MEMORY;
        } else {
            return UPNP_E_INVALID_ACTION;
        }
    }
 
    ixmlFreeDOMString(tmpStr);
    ixmlFreeDOMString(headerStr);
 
    Param->Cookie = (char*)Cookie_const;
    Param->Fun = Fun;
 
    TPJobInit(&job, (UPnPsdk::start_routine)UpnpThreadDistribution, Param);
    TPJobSetFreeFunction(&job, (free_routine)free_action_arg);
 
    TPJobSetPriority(&job, MED_PRIORITY);
    if (ThreadPoolAdd(&gSendThreadPool, &job, NULL) != 0) {
        free_action_arg((job_arg*)Param);
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpSendActionAsync\n");
 
    return UPNP_E_SUCCESS;
}
 
// Deprecated
int UpnpGetServiceVarStatusAsync(UpnpClient_Handle Hnd,
                                 const char* ActionURL_const,
                                 const char* VarName_const, Upnp_FunPtr Fun,
                                 const void* Cookie_const) {
    ThreadPoolJob job;
    struct Handle_Info* SInfo = NULL;
    struct UpnpNonblockParam* Param;
    char* ActionURL = (char*)ActionURL_const;
    char* VarName = (char*)VarName_const;
 
    memset(&job, 0, sizeof(job));
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpGetServiceVarStatusAsync\n");
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    HandleUnlock();
 
    if (ActionURL == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
    if (VarName == NULL || Fun == NULL)
        return UPNP_E_INVALID_PARAM;
 
    Param = (struct UpnpNonblockParam*)malloc(sizeof(struct UpnpNonblockParam));
    if (Param == NULL) {
        return UPNP_E_OUTOF_MEMORY;
    }
    memset(Param, 0, sizeof(struct UpnpNonblockParam));
 
    Param->FunName = STATUS;
    Param->Handle = Hnd;
    strncpy(Param->Url, ActionURL, sizeof(Param->Url) - 1);
    strncpy(Param->VarName, VarName, sizeof(Param->VarName) - 1);
    Param->Fun = Fun;
    Param->Cookie = (char*)Cookie_const;
 
    TPJobInit(&job, (UPnPsdk::start_routine)UpnpThreadDistribution, Param);
    TPJobSetFreeFunction(&job, (free_routine)free);
 
    TPJobSetPriority(&job, MED_PRIORITY);
 
    if (ThreadPoolAdd(&gSendThreadPool, &job, NULL) != 0) {
        free(Param);
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpGetServiceVarStatusAsync\n");
 
    return UPNP_E_SUCCESS;
}
 
// Deprecated
int UpnpGetServiceVarStatus(UpnpClient_Handle Hnd, const char* ActionURL_const,
                            const char* VarName_const, DOMString* StVar) {
    struct Handle_Info* SInfo = NULL;
    int retVal = 0;
    char* StVarPtr;
    char* ActionURL = (char*)ActionURL_const;
    char* VarName = (char*)VarName_const;
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpGetServiceVarStatus\n");
 
    HandleReadLock();
    switch (GetHandleInfo(Hnd, &SInfo)) {
    case HND_CLIENT:
        break;
    default:
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
 
    HandleUnlock();
 
    if (ActionURL == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
    if (VarName == NULL || StVar == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
 
    retVal = SoapGetServiceVarStatus(ActionURL, VarName, &StVarPtr);
    *StVar = StVarPtr;
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpGetServiceVarStatus \n");
 
    return retVal;
}
#endif /* COMPA_HAVE_CTRLPT_SOAP */
 
/*******************************************************************************
 *
 *                             Client API
 *
 ******************************************************************************/
#ifdef COMPA_HAVE_WEBSERVER
int UpnpOpenHttpPost(const char* url, void** handle, const char* contentType,
                     int contentLength, int timeout) {
    int status = http_OpenHttpConnection(url, handle, timeout);
    if (status == UPNP_E_SUCCESS) {
        return http_MakeHttpRequest(UPNP_HTTPMETHOD_POST, url, handle, NULL,
                                    contentType, contentLength, timeout);
    }
    return status;
}
 
int UpnpWriteHttpPost(void* handle, char* buf, size_t* size, int timeout) {
    return http_WriteHttpRequest(handle, buf, size, timeout);
}
 
int UpnpCloseHttpPost(void* handle, int* httpStatus, int timeout) {
    int status = http_EndHttpRequest(handle, timeout);
    if (status == UPNP_E_SUCCESS) {
        /* status = */ http_GetHttpResponse(handle, NULL, NULL, NULL,
                                            httpStatus, timeout);
    }
    status = http_CloseHttpConnection(handle);
    return status;
}
 
int UpnpOpenHttpGet(const char* url, void** handle, char** contentType,
                    int* contentLength, int* httpStatus, int timeout) {
    int status = UpnpOpenHttpConnection(url, handle, timeout);
    if (status == UPNP_E_SUCCESS) {
        status = UpnpMakeHttpRequest(UPNP_HTTPMETHOD_GET, url, *handle, NULL,
                                     NULL, 0, timeout);
    }
    if (status == UPNP_E_SUCCESS) {
        status = UpnpEndHttpRequest(*handle, timeout);
    }
    if (status == UPNP_E_SUCCESS) {
        status = UpnpGetHttpResponse(*handle, NULL, contentType, contentLength,
                                     httpStatus, timeout);
    }
    return status;
}
 
int UpnpOpenHttpGetProxy(const char* url, const char* proxy_str, void** handle,
                         char** contentType, int* contentLength,
                         int* httpStatus, int timeout) {
    int status = UpnpOpenHttpConnection(proxy_str, handle, timeout);
    if (status == UPNP_E_SUCCESS) {
        status = UpnpMakeHttpRequest(UPNP_HTTPMETHOD_GET, url, *handle, NULL,
                                     NULL, 0, timeout);
    }
    if (status == UPNP_E_SUCCESS) {
        status = UpnpEndHttpRequest(*handle, timeout);
    }
    if (status == UPNP_E_SUCCESS) {
        status = UpnpGetHttpResponse(*handle, NULL, contentType, contentLength,
                                     httpStatus, timeout);
    }
    return status;
}
 
int UpnpOpenHttpGetEx(const char* url_str, void** Handle, char** contentType,
                      int* contentLength, int* httpStatus, int lowRange,
                      int highRange, int timeout) {
    return http_OpenHttpGetEx(url_str, Handle, contentType, contentLength,
                              httpStatus, lowRange, highRange, timeout);
}
 
int UpnpCancelHttpGet(void* Handle) { return http_CancelHttpGet(Handle); }
 
int UpnpCloseHttpGet(void* Handle) { return UpnpCloseHttpConnection(Handle); }
 
int UpnpReadHttpGet(void* Handle, char* buf, size_t* size, int timeout) {
    return http_ReadHttpResponse(Handle, buf, size, timeout);
}
 
int UpnpHttpGetProgress(void* Handle, size_t* length, size_t* total) {
    return http_HttpGetProgress(Handle, length, total);
}
 
int UpnpOpenHttpConnection(const char* url, void** handle, int timeout) {
    return http_OpenHttpConnection(url, handle, timeout);
}
 
int UpnpMakeHttpRequest(Upnp_HttpMethod method, const char* url, void* handle,
                        UpnpString* headers, const char* contentType,
                        int contentLength, int timeout) {
    return http_MakeHttpRequest(method, url, handle, headers, contentType,
                                contentLength, timeout);
}
 
int UpnpWriteHttpRequest(void* handle, char* buf, size_t* size, int timeout) {
    return http_WriteHttpRequest(handle, buf, size, timeout);
}
 
int UpnpEndHttpRequest(void* handle, int timeout) {
    return http_EndHttpRequest(handle, timeout);
}
 
int UpnpGetHttpResponse(void* handle, UpnpString* headers, char** contentType,
                        int* contentLength, int* httpStatus, int timeout) {
    return http_GetHttpResponse(handle, headers, contentType, contentLength,
                                httpStatus, timeout);
}
 
int UpnpReadHttpResponse(void* handle, char* buf, size_t* size, int timeout) {
    return http_ReadHttpResponse(handle, buf, size, timeout);
}
 
int UpnpCloseHttpConnection(void* handle) {
    return http_CloseHttpConnection(handle);
}
#endif // COMPA_HAVE_WEBSERVER
 
#ifdef COMPA_HAVE_WEBSERVER
int UpnpDownloadUrlItem(const char* url, char** outBuf, char* contentType) {
    int ret_code;
    size_t doc_length;
 
    if (url == nullptr || outBuf == nullptr || contentType == nullptr)
        return UPNP_E_INVALID_PARAM;
    ret_code = http_Download(url, HTTP_DEFAULT_TIMEOUT, outBuf, &doc_length,
                             contentType);
    if (ret_code > 0)
        /* error reply was received */
        ret_code = UPNP_E_INVALID_URL;
 
    return ret_code;
}
#else
int UpnpDownloadUrlItem([[maybe_unused]] const char* url,
                        [[maybe_unused]] char** outBuf,
                        [[maybe_unused]] char* contentType) {
    return UPNP_E_INVALID_PARAM;
}
#endif
 
int UpnpDownloadXmlDoc(const char* url, IXML_Document** xmlDoc) {
    TRACE("Executing UpnpDownloadXmlDoc()")
    if (url == nullptr || xmlDoc == nullptr) {
        return UPNP_E_INVALID_PARAM;
    }
 
    char* xml_buf;
    char content_type[LINE_SIZE];
    int ret_code = UpnpDownloadUrlItem(url, &xml_buf, content_type);
    if (ret_code != UPNP_E_SUCCESS) {
        UpnpPrintf(UPNP_CRITICAL, API, __FILE__, __LINE__,
                   "Error downloading document, retCode: %d\n", ret_code);
        return ret_code;
    }
 
    if (strncasecmp(content_type, "text/xml", strlen("text/xml"))) {
        UpnpPrintf(UPNP_INFO, API, __FILE__, __LINE__, "Not text/xml\n");
        /* Linksys WRT54G router returns
         * "CONTENT-TYPE: application/octet-stream".
         * Let's be nice to Linksys and try to parse document anyway.
         * If the data sended is not a xml file, ixmlParseBufferEx
         * will fail and the function will return UPNP_E_INVALID_DESC
         * too. */
#if 0
        free(xml_buf);
        return UPNP_E_INVALID_DESC;
#endif
    }
 
    ret_code = ixmlParseBufferEx(xml_buf, xmlDoc);
    free(xml_buf);
    if (ret_code != IXML_SUCCESS) {
        if (ret_code == IXML_INSUFFICIENT_MEMORY) {
            UpnpPrintf(UPNP_CRITICAL, API, __FILE__, __LINE__,
                       "Out of memory, ixml error code: %d\n", ret_code);
            return UPNP_E_OUTOF_MEMORY;
        } else {
            UpnpPrintf(UPNP_CRITICAL, API, __FILE__, __LINE__,
                       "Invalid Description, ixml error code: %d\n", ret_code);
            return UPNP_E_INVALID_DESC;
        }
    } else {
#ifdef DEBUG
        xml_buf = ixmlPrintNode((IXML_Node*)*xmlDoc);
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "Printing the Parsed xml document \n %s\n", xml_buf);
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "****************** END OF Parsed XML Doc "
                   "*****************\n");
        ixmlFreeDOMString(xml_buf);
#endif
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "Exiting UpnpDownloadXmlDoc\n");
 
        return UPNP_E_SUCCESS;
    }
}
 
#if defined(COMPA_HAVE_CTRLPT_SOAP) || defined(COMPA_HAVE_CTRLPT_GENA)
void UpnpThreadDistribution(struct UpnpNonblockParam* Param) {
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Inside UpnpThreadDistribution \n");
 
    switch (Param->FunName) {
#ifdef COMPA_HAVE_CTRLPT_GENA
    case SUBSCRIBE: {
        UpnpEventSubscribe* evt = UpnpEventSubscribe_new();
        UpnpString* Sid = UpnpString_new();
 
        UpnpEventSubscribe_strcpy_PublisherUrl(evt, Param->Url);
        int errCode = genaSubscribe(Param->Handle,
                                    UpnpEventSubscribe_get_PublisherUrl(evt),
                                    (int*)&Param->TimeOut, Sid);
        UpnpEventSubscribe_set_ErrCode(evt, errCode);
        UpnpEventSubscribe_set_TimeOut(evt, Param->TimeOut);
        UpnpEventSubscribe_set_SID(evt, Sid);
        Param->Fun(UPNP_EVENT_SUBSCRIBE_COMPLETE, evt, Param->Cookie);
        UpnpString_delete(Sid);
        UpnpEventSubscribe_delete(evt);
        free(Param);
        break;
    }
    case UNSUBSCRIBE: {
        UpnpEventSubscribe* evt = UpnpEventSubscribe_new();
        UpnpEventSubscribe_strcpy_SID(evt, Param->SubsId);
        int errCode =
            genaUnSubscribe(Param->Handle, UpnpEventSubscribe_get_SID(evt));
        UpnpEventSubscribe_set_ErrCode(evt, errCode);
        UpnpEventSubscribe_strcpy_PublisherUrl(evt, "");
        UpnpEventSubscribe_set_TimeOut(evt, 0);
        Param->Fun(UPNP_EVENT_UNSUBSCRIBE_COMPLETE, evt, Param->Cookie);
        UpnpEventSubscribe_delete(evt);
        free(Param);
        break;
    }
    case RENEW: {
        UpnpEventSubscribe* evt = UpnpEventSubscribe_new();
        UpnpEventSubscribe_strcpy_SID(evt, Param->SubsId);
        int errCode = genaRenewSubscription(
            Param->Handle, UpnpEventSubscribe_get_SID(evt), &Param->TimeOut);
        UpnpEventSubscribe_set_ErrCode(evt, errCode);
        UpnpEventSubscribe_set_TimeOut(evt, Param->TimeOut);
        Param->Fun(UPNP_EVENT_RENEWAL_COMPLETE, evt, Param->Cookie);
        UpnpEventSubscribe_delete(evt);
        free(Param);
        break;
    }
#endif /* COMPA_HAVE_CTRLPT_GENA */
#ifdef COMPA_HAVE_CTRLPT_SOAP
    case ACTION: {
        UpnpActionComplete* Evt = UpnpActionComplete_new();
        IXML_Document* actionResult = NULL;
        int errCode;
        if (Param->Header) {
            errCode =
                SoapSendActionEx(Param->Url, Param->ServiceType, Param->Header,
                                 Param->Act, &actionResult);
        } else {
            errCode = SoapSendAction(Param->Url, Param->ServiceType, Param->Act,
                                     &actionResult);
        }
        UpnpActionComplete_set_ErrCode(Evt, errCode);
        UpnpActionComplete_set_ActionRequest(Evt, Param->Act);
        UpnpActionComplete_set_ActionResult(Evt, actionResult);
        UpnpActionComplete_strcpy_CtrlUrl(Evt, Param->Url);
        Param->Fun(UPNP_CONTROL_ACTION_COMPLETE, Evt, Param->Cookie);
        UpnpActionComplete_delete(Evt);
        ixmlDocument_free(actionResult);
        free_action_arg((job_arg*)Param);
        break;
    }
    case STATUS: {
        UpnpStateVarComplete* Evt = UpnpStateVarComplete_new();
        DOMString currentVal = NULL;
        int errCode =
            SoapGetServiceVarStatus(Param->Url, Param->VarName, &currentVal);
        UpnpStateVarComplete_set_ErrCode(Evt, errCode);
        UpnpStateVarComplete_strcpy_CtrlUrl(Evt, Param->Url);
        UpnpStateVarComplete_strcpy_StateVarName(Evt, Param->VarName);
        UpnpStateVarComplete_set_CurrentVal(Evt, currentVal);
        Param->Fun(UPNP_CONTROL_GET_VAR_COMPLETE, Evt, Param->Cookie);
        free(Param);
        UpnpStateVarComplete_delete(Evt);
        break;
    }
#endif /* COMPA_HAVE_CTRLPT_SOAP */
    default:
        break;
    }
 
    UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
               "Exiting UpnpThreadDistribution\n");
}
#endif /* COMPA_HAVE_CTRLPT_SOAP || COMPA_HAVE_CTRLPT_GENA */
 
Upnp_FunPtr GetCallBackFn(UpnpClient_Handle Hnd) {
    return ((struct Handle_Info*)compa::HandleTable[Hnd])->Callback;
}
 
/* Assumes at most one client */
Upnp_Handle_Type GetClientHandleInfo(UpnpClient_Handle* client_handle_out,
                                     struct Handle_Info** HndInfo) {
    UpnpClient_Handle client;
 
    for (client = 1; client < NUM_HANDLE; client++) {
        switch (GetHandleInfo(client, HndInfo)) {
        case HND_TABLE_INVALID:
            goto exit_loop;
        case HND_CLIENT:
            *client_handle_out = client;
            return HND_CLIENT;
        default:;
        }
    }
exit_loop:
    *client_handle_out = -1;
    return HND_INVALID;
}
 
Upnp_Handle_Type
GetDeviceHandleInfo([[maybe_unused]] UpnpDevice_Handle start,
                    [[maybe_unused]] int AddressFamily,
                    UpnpDevice_Handle* device_handle_out,
                    [[maybe_unused]] struct Handle_Info** HndInfo) {
#ifdef COMPA_HAVE_DEVICE_SSDP
    /* Check if we've got a registered device of the address family
     * specified. */
    if ((AddressFamily == AF_INET && UpnpSdkDeviceRegisteredV4 == 0) ||
        (AddressFamily == AF_INET6 && UpnpSdkDeviceregisteredV6 == 0)) {
        *device_handle_out = -1;
        return HND_INVALID;
    }
    if (start < 0 || start >= NUM_HANDLE - 1) {
        *device_handle_out = -1;
        return HND_INVALID;
    }
    ++start;
    /* Find it. */
    for (*device_handle_out = start; *device_handle_out < NUM_HANDLE;
         (*device_handle_out)++) {
        switch (GetHandleInfo(*device_handle_out, HndInfo)) {
        case HND_DEVICE:
            if ((*HndInfo)->DeviceAf == AddressFamily) {
                return HND_DEVICE;
            }
            break;
        default:
            break;
        }
    }
#endif /* COMPA_HAVE_DEVICE_SSDP */
 
    *device_handle_out = -1;
    return HND_INVALID;
}
 
Upnp_Handle_Type
GetDeviceHandleInfoForPath([[maybe_unused]] const char* path,
                           [[maybe_unused]] int AddressFamily,
                           UpnpDevice_Handle* device_handle_out,
                           [[maybe_unused]] struct Handle_Info** HndInfo,
                           [[maybe_unused]] service_info** serv_info) {
#ifdef COMPA_HAVE_DEVICE_SSDP
    /* Check if we've got a registered device of the address family
     * specified. */
    if ((AddressFamily == AF_INET && UpnpSdkDeviceRegisteredV4 == 0) ||
        (AddressFamily == AF_INET6 && UpnpSdkDeviceregisteredV6 == 0)) {
        *device_handle_out = -1;
        return HND_INVALID;
    }
    /* Find it. */
    for (*device_handle_out = 1; *device_handle_out < NUM_HANDLE;
         (*device_handle_out)++) {
        switch (GetHandleInfo(*device_handle_out, HndInfo)) {
        case HND_DEVICE:
            if ((*HndInfo)->DeviceAf == AddressFamily) {
                if (((*serv_info = FindServiceControlURLPath(
                          &(*HndInfo)->ServiceTable, path)) != 0) ||
                    ((*serv_info = FindServiceEventURLPath(
                          &(*HndInfo)->ServiceTable, path)) != 0)) {
                    return HND_DEVICE;
                }
            }
            break;
        default:
            break;
        }
    }
#endif /* COMPA_HAVE_DEVICE_SSDP */
 
    *device_handle_out = -1;
    return HND_INVALID;
}
 
Upnp_Handle_Type GetHandleInfo(UpnpClient_Handle Hnd, Handle_Info** HndInfo) {
    // This function expects an initialized global compa::HandleTable HndInfo,
    // at least with nullptr.
    Upnp_Handle_Type ret{HND_TABLE_INVALID};
 
    if (HndInfo == nullptr) {
        UPnPsdk_LOGERR("MSG1097") "No output variable for handle info "
                                  "available (HndInfo==nullptr).\n";
    } else if (Hnd < 1 || Hnd >= NUM_HANDLE) {
        UPnPsdk_LOGERR("MSG1130") "Handle(" << Hnd << ") out of range.\n";
        ret = HND_INVALID;
    } else if (compa::HandleTable[Hnd] == nullptr) {
        // When scanning the whole handle info table we have a lot of empty
        // entries. That seems not to be an error.
        ret = HND_INVALID;
    } else {
        *HndInfo = compa::HandleTable[Hnd];
        ret = (*HndInfo)->HType;
    }
    return ret;
}
 
int PrintHandleInfo(UpnpClient_Handle Hnd) {
    struct Handle_Info* HndInfo;
    if (compa::HandleTable[Hnd] != nullptr) {
        HndInfo = compa::HandleTable[Hnd];
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__,
                   "Printing information for Handle_%d\n", Hnd);
        UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "HType_%d\n",
                   HndInfo->HType);
#ifdef COMPA_HAVE_DEVICE_SSDP
        switch (HndInfo->HType) {
        case HND_CLIENT:
            break;
        default:
            UpnpPrintf(UPNP_ALL, API, __FILE__, __LINE__, "DescURL_%s\n",
                       HndInfo->DescURL);
        }
#endif
    } else {
        return UPNP_E_INVALID_HANDLE;
    }
 
    return UPNP_E_SUCCESS;
}
 
#ifdef COMPA_HAVE_DEVICE_SSDP
void AutoAdvertise(void* input) {
    job_arg* arg = (job_arg*)input;
 
    UpnpSendAdvertisement(arg->advertise.handle, *((int*)arg->advertise.Event));
    free_advertise_arg(arg);
}
#endif
 
#ifdef COMPA_HAVE_WEBSERVER
int UpnpSetWebServerRootDir(const char* rootDir) {
    TRACE("Executing UpnpSetWebServerRootDir()")
    if (UpnpSdkInit == 0)
        return UPNP_E_FINISH;
    if ((rootDir == nullptr) || (strlen(rootDir) == 0)) {
        return UPNP_E_INVALID_PARAM;
    }
 
    membuffer_destroy(&gDocumentRootDir);
 
    return web_server_set_root_dir(rootDir);
}
 
int UpnpSetWebServerCorsString(const char* corsString) {
    if (UpnpSdkInit == 0)
        return UPNP_E_FINISH;
    if ((corsString == NULL) || (strlen(corsString) == 0)) {
        return UPNP_E_INVALID_PARAM;
    }
 
    membuffer_destroy(&gWebserverCorsString);
 
    return web_server_set_cors(corsString);
}
#endif /* COMPA_HAVE_WEBSERVER */
 
int UpnpAddVirtualDir(const char* newDirName, const void* cookie,
                      const void** oldcookie) {
    virtualDirList* pNewVirtualDir;
    virtualDirList* pLast;
    virtualDirList* pCurVirtualDir;
    char dirName[NAME_SIZE];
 
    memset(dirName, 0, sizeof(dirName));
    if (UpnpSdkInit != 1) {
        /* SDK is not initialized */
        return UPNP_E_FINISH;
    }
 
    if ((newDirName == NULL) || (strlen(newDirName) == (size_t)0)) {
        return UPNP_E_INVALID_PARAM;
    }
 
    if (*newDirName != '/') {
        if (strlen(newDirName) > sizeof(dirName) - 2)
            return UPNP_E_INVALID_PARAM;
        dirName[0] = '/';
        strncpy(dirName + 1, newDirName, sizeof(dirName) - 2);
    } else {
        if (strlen(newDirName) > sizeof(dirName) - 1)
            return UPNP_E_INVALID_PARAM;
        strncpy(dirName, newDirName, sizeof(dirName) - 1);
    }
 
    pCurVirtualDir = pVirtualDirList;
    while (pCurVirtualDir != NULL) {
        /* already has this entry */
        if (strcmp(pCurVirtualDir->dirName, dirName) == 0) {
            if (oldcookie != NULL)
                *oldcookie = pCurVirtualDir->cookie;
            pCurVirtualDir->cookie = cookie;
            return UPNP_E_SUCCESS;
        }
 
        pCurVirtualDir = pCurVirtualDir->next;
    }
 
    pNewVirtualDir = (virtualDirList*)malloc(sizeof(virtualDirList));
    if (pNewVirtualDir == NULL) {
        return UPNP_E_OUTOF_MEMORY;
    }
    pNewVirtualDir->next = NULL;
    if (oldcookie != NULL)
        *oldcookie = NULL;
    pNewVirtualDir->cookie = cookie;
    memset(pNewVirtualDir->dirName, 0, sizeof(pNewVirtualDir->dirName));
#ifdef UPNPLIB_PUPNP_BUG
    // Error if compiling old code with build type Release: output may be
    // truncated copying 255 bytes from a string of length 255
    // [-Werror=stringop-truncation]. We have to fix it here otherwise it won't
    // compile. --Ingo
    strncpy(pNewVirtualDir->dirName, dirName,
            sizeof(pNewVirtualDir->dirName) - 1);
#else
    strncpy(pNewVirtualDir->dirName, dirName, sizeof(pNewVirtualDir->dirName));
#endif
    *(pNewVirtualDir->dirName + strlen(dirName)) = 0;
 
    if (pVirtualDirList == NULL) { /* first virtual dir */
        pVirtualDirList = pNewVirtualDir;
    } else {
        pLast = pVirtualDirList;
        while (pLast->next != NULL) {
            pLast = pLast->next;
        }
        pLast->next = pNewVirtualDir;
    }
 
    return UPNP_E_SUCCESS;
}
 
int UpnpRemoveVirtualDir(const char* dirName) {
    virtualDirList* pPrev;
    virtualDirList* pCur;
    int found = 0;
 
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
 
    if (dirName == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
 
    if (pVirtualDirList == NULL) {
        return UPNP_E_INVALID_PARAM;
    }
    /* Handle the special case where the directory that we are */
    /* removing is the first in the list. */
    if (strcmp(pVirtualDirList->dirName, dirName) == 0) {
        pPrev = pVirtualDirList;
        pVirtualDirList = pVirtualDirList->next;
        free(pPrev);
        return UPNP_E_SUCCESS;
    }
 
    pCur = pVirtualDirList->next;
    pPrev = pVirtualDirList;
 
    while (pCur != NULL) {
        if (strcmp(pCur->dirName, dirName) == 0) {
            pPrev->next = pCur->next;
            free(pCur);
            found = 1;
            break;
        } else {
            pPrev = pCur;
            pCur = pCur->next;
        }
    }
 
    if (found == 1)
        return UPNP_E_SUCCESS;
    else
        return UPNP_E_INVALID_PARAM;
}
 
void UpnpRemoveAllVirtualDirs() {
    virtualDirList* pCur;
    virtualDirList* pNext;
 
    if (UpnpSdkInit != 1) {
        return;
    }
 
    pCur = pVirtualDirList;
 
    while (pCur != NULL) {
        pNext = pCur->next;
        free(pCur);
 
        pCur = pNext;
    }
 
    pVirtualDirList = NULL;
}
 
int UpnpEnableWebserver([[maybe_unused]] int enable) {
    TRACE("Executing UpnpEnableWebserver()")
    if (UpnpSdkInit != 1) {
        return UPNP_E_FINISH;
    }
#ifdef COMPA_HAVE_WEBSERVER
    if (enable)
        web_server_init();
    else
        web_server_destroy();
    return UPNP_E_SUCCESS;
#else  /* Internal web server disabled */
    return UPNP_E_NO_WEB_SERVER;
#endif /* COMPA_HAVE_WEBSERVER */
}
 
int UpnpIsWebserverEnabled() {
    if (UpnpSdkInit != 1) {
        return 0;
    }
 
    return bWebServerState == (WebServerState)WEB_SERVER_ENABLED;
}
 
void UpnpSetHostValidateCallback(WebCallback_HostValidate callback,
                                 void* cookie) {
    gWebCallback_HostValidate = callback;
    gWebCallback_HostValidateCookie = cookie;
}
 
void UpnpSetAllowLiteralHostRedirection(int enable) {
    gAllowLiteralHostRedirection = enable;
}
 
int UpnpVirtualDir_set_GetInfoCallback(VDCallback_GetInfo callback) {
    int ret = UPNP_E_SUCCESS;
    if (!callback) {
        ret = UPNP_E_INVALID_PARAM;
    } else {
        virtualDirCallback.get_info = callback;
    }
 
    return ret;
}
 
int UpnpVirtualDir_set_OpenCallback(VDCallback_Open callback) {
    int ret = UPNP_E_SUCCESS;
    if (!callback) {
        ret = UPNP_E_INVALID_PARAM;
    } else {
        virtualDirCallback.open = callback;
    }
 
    return ret;
}
 
int UpnpVirtualDir_set_ReadCallback(VDCallback_Read callback) {
    int ret = UPNP_E_SUCCESS;
    if (!callback) {
        ret = UPNP_E_INVALID_PARAM;
    } else {
        virtualDirCallback.read = callback;
    }
 
    return ret;
}
 
int UpnpVirtualDir_set_WriteCallback(VDCallback_Write callback) {
    int ret = UPNP_E_SUCCESS;
    if (!callback) {
        ret = UPNP_E_INVALID_PARAM;
    } else {
        virtualDirCallback.write = callback;
    }
 
    return ret;
}
 
int UpnpVirtualDir_set_SeekCallback(VDCallback_Seek callback) {
    int ret = UPNP_E_SUCCESS;
    if (!callback) {
        ret = UPNP_E_INVALID_PARAM;
    } else {
        virtualDirCallback.seek = callback;
    }
 
    return ret;
}
 
int UpnpVirtualDir_set_CloseCallback(VDCallback_Close callback) {
    int ret = UPNP_E_SUCCESS;
    if (!callback) {
        ret = UPNP_E_INVALID_PARAM;
    } else {
        virtualDirCallback.close = callback;
    }
 
    return ret;
}
 
// Deprecated
int UpnpSetContentLength(UpnpClient_Handle Hnd, size_t contentLength) {
    int errCode = UPNP_E_SUCCESS;
    struct Handle_Info* HInfo = NULL;
 
    do {
        if (UpnpSdkInit != 1) {
            errCode = UPNP_E_FINISH;
            break;
        }
 
        HandleLock();
 
        switch (GetHandleInfo(Hnd, &HInfo)) {
        case HND_DEVICE:
            break;
        default:
            HandleUnlock();
            return UPNP_E_INVALID_HANDLE;
        }
        if (contentLength > MAX_SOAP_CONTENT_LENGTH) {
            errCode = UPNP_E_OUTOF_BOUNDS;
            break;
        }
        g_maxContentLength = contentLength;
    } while (0);
 
    HandleUnlock();
    return errCode;
}
 
int UpnpSetMaxContentLength(size_t contentLength) {
    int errCode = UPNP_E_SUCCESS;
 
    do {
        if (UpnpSdkInit != 1) {
            errCode = UPNP_E_FINISH;
            break;
        }
        g_maxContentLength = contentLength;
    } while (0);
 
    return errCode;
}