upnpcommands.c

/* $Id: upnpcommands.c,v 1.56 2025/03/29 18:08:59 nanard Exp $ */
/* vim: tabstop=4 shiftwidth=4 noexpandtab
 * Project : miniupnp
 * Author : Thomas Bernard
 * Copyright (c) 2005-2025 Thomas Bernard
 * This software is subject to the conditions detailed in the
 * LICENCE file provided in this distribution.
 * */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "upnpcommands.h"
#include "miniupnpc.h"
#include "portlistingparse.h"
#include "upnpreplyparse.h"

/*! \file upnpcommands.c
 * \brief Internet Gateway Device methods implementations
 * \def STRTOUI
 * \brief strtoull() if available, strtol() if not
 */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define STRTOUI	strtoull
#else
#define STRTOUI	strtoul
#endif

static UNSIGNED_INTEGER
my_atoui(const char * s)
{
	return s ? ((UNSIGNED_INTEGER)STRTOUI(s, NULL, 0)) : 0;
}

/*
 * */
MINIUPNP_LIBSPEC UNSIGNED_INTEGER
UPNP_GetTotalBytesSent(const char * controlURL,
					const char * servicetype)
{
	struct NameValueParserData pdata;
	char * buffer;
	int bufsize;
	unsigned int r = 0;
	char * p;
	if(!(buffer = simpleUPnPcommand(controlURL, servicetype,
	                                "GetTotalBytesSent", 0, &bufsize))) {
		return (UNSIGNED_INTEGER)UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	/*DisplayNameValueList(buffer, bufsize);*/
	free(buffer);
	p = GetValueFromNameValueList(&pdata, "NewTotalBytesSent");
	r = my_atoui(p);
	ClearNameValueList(&pdata);
	return r;
}

/*
 * */
MINIUPNP_LIBSPEC UNSIGNED_INTEGER
UPNP_GetTotalBytesReceived(const char * controlURL,
						const char * servicetype)
{
	struct NameValueParserData pdata;
	char * buffer;
	int bufsize;
	unsigned int r = 0;
	char * p;
	if(!(buffer = simpleUPnPcommand(controlURL, servicetype,
	                                "GetTotalBytesReceived", 0, &bufsize))) {
		return (UNSIGNED_INTEGER)UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	/*DisplayNameValueList(buffer, bufsize);*/
	free(buffer);
	p = GetValueFromNameValueList(&pdata, "NewTotalBytesReceived");
	r = my_atoui(p);
	ClearNameValueList(&pdata);
	return r;
}

/*
 * */
MINIUPNP_LIBSPEC UNSIGNED_INTEGER
UPNP_GetTotalPacketsSent(const char * controlURL,
						const char * servicetype)
{
	struct NameValueParserData pdata;
	char * buffer;
	int bufsize;
	unsigned int r = 0;
	char * p;
	if(!(buffer = simpleUPnPcommand(controlURL, servicetype,
	                                "GetTotalPacketsSent", 0, &bufsize))) {
		return (UNSIGNED_INTEGER)UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	/*DisplayNameValueList(buffer, bufsize);*/
	free(buffer);
	p = GetValueFromNameValueList(&pdata, "NewTotalPacketsSent");
	r = my_atoui(p);
	ClearNameValueList(&pdata);
	return r;
}

/*
 * */
MINIUPNP_LIBSPEC UNSIGNED_INTEGER
UPNP_GetTotalPacketsReceived(const char * controlURL,
						const char * servicetype)
{
	struct NameValueParserData pdata;
	char * buffer;
	int bufsize;
	unsigned int r = 0;
	char * p;
	if(!(buffer = simpleUPnPcommand(controlURL, servicetype,
	                                "GetTotalPacketsReceived", 0, &bufsize))) {
		return (UNSIGNED_INTEGER)UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	/*DisplayNameValueList(buffer, bufsize);*/
	free(buffer);
	p = GetValueFromNameValueList(&pdata, "NewTotalPacketsReceived");
	r = my_atoui(p);
	ClearNameValueList(&pdata);
	return r;
}

/* UPNP_GetStatusInfo() call the corresponding UPNP method
 * returns the current status and uptime */
MINIUPNP_LIBSPEC int
UPNP_GetStatusInfo(const char * controlURL,
				const char * servicetype,
				char * status,
				unsigned int * uptime,
				char * lastconnerror)
{
	struct NameValueParserData pdata;
	char * buffer;
	int bufsize;
	char * p;
	char * up;
	char * err;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;

	if(!status && !uptime)
		return UPNPCOMMAND_INVALID_ARGS;

	if(!(buffer = simpleUPnPcommand(controlURL, servicetype,
	                                "GetStatusInfo", 0, &bufsize))) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	/*DisplayNameValueList(buffer, bufsize);*/
	free(buffer);
	up = GetValueFromNameValueList(&pdata, "NewUptime");
	p = GetValueFromNameValueList(&pdata, "NewConnectionStatus");
	err = GetValueFromNameValueList(&pdata, "NewLastConnectionError");
	if(p && up)
	  ret = UPNPCOMMAND_SUCCESS;

	if(status) {
		if(p){
			strncpy(status, p, 64 );
			status[63] = '\0';
		}else
			status[0]= '\0';
	}

	if(uptime) {
		if(!up || sscanf(up,"%u",uptime) != 1)
			*uptime = 0;
	}

	if(lastconnerror) {
		if(err) {
			strncpy(lastconnerror, err, 64 );
			lastconnerror[63] = '\0';
		} else
			lastconnerror[0] = '\0';
	}

	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p) {
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}
	ClearNameValueList(&pdata);
	return ret;
}

/* UPNP_GetConnectionTypeInfo() call the corresponding UPNP method
 * returns the connection type */
MINIUPNP_LIBSPEC int
UPNP_GetConnectionTypeInfo(const char * controlURL,
                           const char * servicetype,
                           char * connectionType)
{
	struct NameValueParserData pdata;
	char * buffer;
	int bufsize;
	char * p;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;

	if(!connectionType)
		return UPNPCOMMAND_INVALID_ARGS;

	if(!(buffer = simpleUPnPcommand(controlURL, servicetype,
	                                "GetConnectionTypeInfo", 0, &bufsize))) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	p = GetValueFromNameValueList(&pdata, "NewConnectionType");
	/*p = GetValueFromNameValueList(&pdata, "NewPossibleConnectionTypes");*/
	/* PossibleConnectionTypes will have several values.... */
	if(p) {
		strncpy(connectionType, p, 64 );
		connectionType[63] = '\0';
		ret = UPNPCOMMAND_SUCCESS;
	} else
		connectionType[0] = '\0';
	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p) {
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}
	ClearNameValueList(&pdata);
	return ret;
}

/* UPNP_GetLinkLayerMaxBitRate() call the corresponding UPNP method.
 * Returns 2 values: Downloadlink bandwidth and Uplink bandwidth.
 * One of the values can be null
 * Note : GetLinkLayerMaxBitRates belongs to WANPPPConnection:1 only
 * We can use the GetCommonLinkProperties from WANCommonInterfaceConfig:1 */
MINIUPNP_LIBSPEC int
UPNP_GetLinkLayerMaxBitRates(const char * controlURL,
                             const char * servicetype,
                             unsigned int * bitrateDown,
                             unsigned int * bitrateUp)
{
	struct NameValueParserData pdata;
	char * buffer;
	int bufsize;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;
	char * down;
	char * up;
	char * p;

	if(!bitrateDown && !bitrateUp)
		return UPNPCOMMAND_INVALID_ARGS;

	/* shouldn't we use GetCommonLinkProperties ? */
	if(!(buffer = simpleUPnPcommand(controlURL, servicetype,
	                                "GetCommonLinkProperties", 0, &bufsize))) {
	                              /*"GetLinkLayerMaxBitRates", 0, &bufsize);*/
		return UPNPCOMMAND_HTTP_ERROR;
	}
	/*DisplayNameValueList(buffer, bufsize);*/
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	/*down = GetValueFromNameValueList(&pdata, "NewDownstreamMaxBitRate");*/
	/*up = GetValueFromNameValueList(&pdata, "NewUpstreamMaxBitRate");*/
	down = GetValueFromNameValueList(&pdata, "NewLayer1DownstreamMaxBitRate");
	up = GetValueFromNameValueList(&pdata, "NewLayer1UpstreamMaxBitRate");
	/*GetValueFromNameValueList(&pdata, "NewWANAccessType");*/
	/*GetValueFromNameValueList(&pdata, "NewPhysicalLinkStatus");*/
	if(down && up)
		ret = UPNPCOMMAND_SUCCESS;

	if(bitrateDown) {
		if(!down || sscanf(down,"%u",bitrateDown) != 1)
			*bitrateDown = 0;
	}

	if(bitrateUp) {
		if(!up || sscanf(up,"%u",bitrateUp) != 1)
			*bitrateUp = 0;
	}
	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p) {
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}
	ClearNameValueList(&pdata);
	return ret;
}


/* UPNP_GetExternalIPAddress() call the corresponding UPNP method.
 * if the third arg is not null the value is copied to it.
 * at least 16 bytes must be available
 *
 * Return values :
 * 0 : SUCCESS
 * NON ZERO : ERROR Either an UPnP error code or an unknown error.
 *
 * 402 Invalid Args - See UPnP Device Architecture section on Control.
 * 501 Action Failed - See UPnP Device Architecture section on Control.
 */
MINIUPNP_LIBSPEC int
UPNP_GetExternalIPAddress(const char * controlURL,
                          const char * servicetype,
                          char * extIpAdd)
{
	struct NameValueParserData pdata;
	char * buffer;
	int bufsize;
	char * p;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;

	if(!extIpAdd || !controlURL || !servicetype)
		return UPNPCOMMAND_INVALID_ARGS;

	if(!(buffer = simpleUPnPcommand(controlURL, servicetype,
	                                "GetExternalIPAddress", 0, &bufsize))) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
	/*DisplayNameValueList(buffer, bufsize);*/
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	/*printf("external ip = %s\n", GetValueFromNameValueList(&pdata, "NewExternalIPAddress") );*/
	p = GetValueFromNameValueList(&pdata, "NewExternalIPAddress");
	if(p) {
		strncpy(extIpAdd, p, 16 );
		extIpAdd[15] = '\0';
		ret = UPNPCOMMAND_SUCCESS;
	} else
		extIpAdd[0] = '\0';

	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p) {
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}

	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_AddPortMapping(const char * controlURL, const char * servicetype,
		    const char * extPort,
		    const char * inPort,
		    const char * inClient,
		    const char * desc,
		    const char * proto,
		    const char * remoteHost,
		    const char * leaseDuration)
{
	struct UPNParg AddPortMappingArgs[] = {
		{"NewRemoteHost", remoteHost},
		{"NewExternalPort", extPort},
		{"NewProtocol", proto},
		{"NewInternalPort", inPort},
		{"NewInternalClient", inClient},
		{"NewEnabled", "1"},
		{"NewPortMappingDescription", desc?desc:"libminiupnpc"},
		{"NewLeaseDuration", leaseDuration?leaseDuration:"0"},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	struct NameValueParserData pdata;
	const char * resVal;
	int ret;

	if(!inPort || !inClient || !proto || !extPort)
		return UPNPCOMMAND_INVALID_ARGS;

	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "AddPortMapping", AddPortMappingArgs,
	                           &bufsize);
	if(!buffer) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
	/*DisplayNameValueList(buffer, bufsize);*/
	/*buffer[bufsize] = '\0';*/
	/*puts(buffer);*/
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	resVal = GetValueFromNameValueList(&pdata, "errorCode");
	if(resVal) {
		/*printf("AddPortMapping errorCode = '%s'\n", resVal); */
		if(sscanf(resVal, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	} else {
		ret = UPNPCOMMAND_SUCCESS;
	}
	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_AddAnyPortMapping(const char * controlURL, const char * servicetype,
		       const char * extPort,
		       const char * inPort,
		       const char * inClient,
		       const char * desc,
		       const char * proto,
		       const char * remoteHost,
		       const char * leaseDuration,
		       char * reservedPort)
{
	struct UPNParg AddAnyPortMappingArgs[] = {
		{"NewRemoteHost", remoteHost},
		{"NewExternalPort", extPort},
		{"NewProtocol", proto},
		{"NewInternalPort", inPort},
		{"NewInternalClient", inClient},
		{"NewEnabled", "1"},
		{"NewPortMappingDescription", desc?desc:"libminiupnpc"},
		{"NewLeaseDuration", leaseDuration?leaseDuration:"0"},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	struct NameValueParserData pdata;
	const char * resVal;
	int ret;

	if(!inPort || !inClient || !proto || !extPort || !reservedPort)
		return UPNPCOMMAND_INVALID_ARGS;
	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "AddAnyPortMapping", AddAnyPortMappingArgs,
	                           &bufsize);
	if(!buffer) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	resVal = GetValueFromNameValueList(&pdata, "errorCode");
	if(resVal) {
		if(sscanf(resVal, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	} else {
		char *p;

		p = GetValueFromNameValueList(&pdata, "NewReservedPort");
		if(p) {
			strncpy(reservedPort, p, 6);
			reservedPort[5] = '\0';
			ret = UPNPCOMMAND_SUCCESS;
		} else {
			ret = UPNPCOMMAND_INVALID_RESPONSE;
		}
	}
	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_DeletePortMapping(const char * controlURL, const char * servicetype,
                       const char * extPort, const char * proto,
                       const char * remoteHost)
{
	/*struct NameValueParserData pdata;*/
	struct UPNParg DeletePortMappingArgs[] = {
		{"NewRemoteHost", remoteHost},
		{"NewExternalPort", extPort},
		{"NewProtocol", proto},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	struct NameValueParserData pdata;
	const char * resVal;
	int ret;

	if(!extPort || !proto)
		return UPNPCOMMAND_INVALID_ARGS;

	buffer = simpleUPnPcommand(controlURL, servicetype,
	                          "DeletePortMapping",
	                          DeletePortMappingArgs, &bufsize);
	if(!buffer) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
	/*DisplayNameValueList(buffer, bufsize);*/
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	resVal = GetValueFromNameValueList(&pdata, "errorCode");
	if(resVal) {
		if(sscanf(resVal, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	} else {
		ret = UPNPCOMMAND_SUCCESS;
	}
	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_DeletePortMappingRange(const char * controlURL, const char * servicetype,
                            const char * extPortStart, const char * extPortEnd,
                            const char * proto,
                            const char * manage)
{
	struct UPNParg DeletePortMappingRangeArgs[] = {
		{"NewStartPort", extPortStart},
		{"NewEndPort", extPortEnd},
		{"NewProtocol", proto},
		{"NewManage", manage},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	struct NameValueParserData pdata;
	const char * resVal;
	int ret;

	if(!extPortStart || !extPortEnd || !proto || !manage)
		return UPNPCOMMAND_INVALID_ARGS;


	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "DeletePortMappingRange",
	                           DeletePortMappingRangeArgs, &bufsize);
	if(!buffer) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	resVal = GetValueFromNameValueList(&pdata, "errorCode");
	if(resVal) {
		if(sscanf(resVal, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	} else {
		ret = UPNPCOMMAND_SUCCESS;
	}
	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_GetGenericPortMappingEntry(const char * controlURL,
                                const char * servicetype,
                                const char * index,
                                char * extPort,
                                char * intClient,
                                char * intPort,
                                char * protocol,
                                char * desc,
                                char * enabled,
                                char * rHost,
                                char * duration)
{
	return UPNP_GetGenericPortMappingEntryExt(controlURL, servicetype, index,
	                                          extPort, intClient, intPort,
	                                          protocol, desc, 80, enabled,
	                                          rHost, 64, duration);
}

MINIUPNP_LIBSPEC int
UPNP_GetGenericPortMappingEntryExt(const char * controlURL,
                                   const char * servicetype,
                                   const char * index,
                                   char * extPort,
                                   char * intClient,
                                   char * intPort,
                                   char * protocol,
                                   char * desc,
                                   size_t desclen,
                                   char * enabled,
                                   char * rHost,
                                   size_t rHostlen,
                                   char * duration)
{
	struct NameValueParserData pdata;
	struct UPNParg GetPortMappingArgs[] = {
		{"NewPortMappingIndex", index},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	char * p;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;
	if(!index || !extPort || !intClient || !intPort || !protocol)
		return UPNPCOMMAND_INVALID_ARGS;
	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "GetGenericPortMappingEntry",
	                           GetPortMappingArgs, &bufsize);
	if(!buffer) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);

	p = GetValueFromNameValueList(&pdata, "NewRemoteHost");
	if(p && rHost)
	{
		strncpy(rHost, p, rHostlen);
		rHost[rHostlen-1] = '\0';
	}
	p = GetValueFromNameValueList(&pdata, "NewExternalPort");
	if(p)
	{
		strncpy(extPort, p, 6);
		extPort[5] = '\0';
		ret = UPNPCOMMAND_SUCCESS;
	}
	else
	{
		extPort[0] = '\0';
	}
	p = GetValueFromNameValueList(&pdata, "NewProtocol");
	if(p)
	{
		strncpy(protocol, p, 4);
		protocol[3] = '\0';
	}
	else
	{
		protocol[0] = '\0';
	}
	p = GetValueFromNameValueList(&pdata, "NewInternalClient");
	if(p)
	{
		strncpy(intClient, p, 16);
		intClient[15] = '\0';
		ret = 0;
	}
	else
	{
		intClient[0] = '\0';
	}
	p = GetValueFromNameValueList(&pdata, "NewInternalPort");
	if(p)
	{
		strncpy(intPort, p, 6);
		intPort[5] = '\0';
	}
	else
	{
		intPort[0] = '\0';
	}
	p = GetValueFromNameValueList(&pdata, "NewEnabled");
	if(p && enabled)
	{
		strncpy(enabled, p, 4);
		enabled[3] = '\0';
	}
	p = GetValueFromNameValueList(&pdata, "NewPortMappingDescription");
	if(p && desc)
	{
		strncpy(desc, p, desclen);
		desc[desclen-1] = '\0';
	}
	p = GetValueFromNameValueList(&pdata, "NewLeaseDuration");
	if(p && duration)
	{
		strncpy(duration, p, 16);
		duration[15] = '\0';
	}
	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p) {
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}
	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_GetPortMappingNumberOfEntries(const char * controlURL,
                                   const char * servicetype,
                                   unsigned int * numEntries)
{
	struct NameValueParserData pdata;
	char * buffer;
	int bufsize;
	char* p;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;
	if(!(buffer = simpleUPnPcommand(controlURL, servicetype,
	                                "GetPortMappingNumberOfEntries", 0,
	                                &bufsize))) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
#ifdef DEBUG
	DisplayNameValueList(buffer, bufsize);
#endif
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);

	p = GetValueFromNameValueList(&pdata, "NewPortMappingNumberOfEntries");
	if(numEntries && p) {
		*numEntries = 0;
		sscanf(p, "%u", numEntries);
		ret = UPNPCOMMAND_SUCCESS;
	}

	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p) {
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}

	ClearNameValueList(&pdata);
	return ret;
}

/* UPNP_GetSpecificPortMappingEntry retrieves an existing port mapping
 * the result is returned in the intClient and intPort strings
 * please provide 16 and 6 bytes of data */
MINIUPNP_LIBSPEC int
UPNP_GetSpecificPortMappingEntry(const char * controlURL,
                                 const char * servicetype,
                                 const char * extPort,
                                 const char * proto,
                                 const char * remoteHost,
                                 char * intClient,
                                 char * intPort,
                                 char * desc,
                                 char * enabled,
                                 char * leaseDuration)
{
	return UPNP_GetSpecificPortMappingEntryExt(controlURL, servicetype,
	                                           extPort, proto, remoteHost,
	                                           intClient, intPort,
	                                           desc, 80, enabled,
	                                           leaseDuration);
}

MINIUPNP_LIBSPEC int
UPNP_GetSpecificPortMappingEntryExt(const char * controlURL,
                                    const char * servicetype,
                                    const char * extPort,
                                    const char * proto,
                                    const char * remoteHost,
                                    char * intClient,
                                    char * intPort,
                                    char * desc,
                                    size_t desclen,
                                    char * enabled,
                                    char * leaseDuration)
{
	struct NameValueParserData pdata;
	struct UPNParg GetPortMappingArgs[] = {
		{"NewRemoteHost", remoteHost},
		{"NewExternalPort", extPort},
		{"NewProtocol", proto},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	char * p;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;

	if(!intPort || !intClient || !extPort || !proto)
		return UPNPCOMMAND_INVALID_ARGS;

	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "GetSpecificPortMappingEntry",
	                           GetPortMappingArgs, &bufsize);
	if(!buffer) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
	/*DisplayNameValueList(buffer, bufsize);*/
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);

	p = GetValueFromNameValueList(&pdata, "NewInternalClient");
	if(p) {
		strncpy(intClient, p, 16);
		intClient[15] = '\0';
		ret = UPNPCOMMAND_SUCCESS;
	} else
		intClient[0] = '\0';

	p = GetValueFromNameValueList(&pdata, "NewInternalPort");
	if(p) {
		strncpy(intPort, p, 6);
		intPort[5] = '\0';
	} else
		intPort[0] = '\0';

	p = GetValueFromNameValueList(&pdata, "NewEnabled");
	if(p && enabled) {
		strncpy(enabled, p, 4);
		enabled[3] = '\0';
	}

	p = GetValueFromNameValueList(&pdata, "NewPortMappingDescription");
	if(p && desc) {
		strncpy(desc, p, desclen);
		desc[desclen-1] = '\0';
	}

	p = GetValueFromNameValueList(&pdata, "NewLeaseDuration");
	if(p && leaseDuration)
	{
		strncpy(leaseDuration, p, 16);
		leaseDuration[15] = '\0';
	}

	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p) {
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}

	ClearNameValueList(&pdata);
	return ret;
}

/* UPNP_GetListOfPortMappings()
 *
 * Possible UPNP Error codes :
 * 606 Action not Authorized
 * 730 PortMappingNotFound - no port mapping is found in the specified range.
 * 733 InconsistantParameters - NewStartPort and NewEndPort values are not
 *                              consistent.
 */
MINIUPNP_LIBSPEC int
UPNP_GetListOfPortMappings(const char * controlURL,
                           const char * servicetype,
                           const char * startPort,
                           const char * endPort,
                           const char * protocol,
                           const char * numberOfPorts,
                           struct PortMappingParserData * data)
{
	struct NameValueParserData pdata;
	struct UPNParg GetListOfPortMappingsArgs[] = {
		{"NewStartPort", startPort},
		{"NewEndPort", endPort},
		{"NewProtocol", protocol},
		{"NewManage", "1"},
		{"NewNumberOfPorts", numberOfPorts?numberOfPorts:"1000"},
		{NULL, NULL}
	};
	const char * p;
	char * buffer;
	int bufsize;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;

	if(!startPort || !endPort || !protocol)
		return UPNPCOMMAND_INVALID_ARGS;

	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "GetListOfPortMappings",
	                           GetListOfPortMappingsArgs, &bufsize);
	if(!buffer) {
		return UPNPCOMMAND_HTTP_ERROR;
	}

	/*DisplayNameValueList(buffer, bufsize);*/
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);

	/*p = GetValueFromNameValueList(&pdata, "NewPortListing");*/
	/*if(p) {
		printf("NewPortListing : %s\n", p);
	}*/
	/*printf("NewPortListing(%d chars) : %s\n",
	       pdata.portListingLength, pdata.portListing);*/
	if(pdata.portListing)
	{
		/*struct PortMapping * pm;
		int i = 0;*/
		ParsePortListing(pdata.portListing, pdata.portListingLength,
		                 data);
		ret = UPNPCOMMAND_SUCCESS;
		/*
		for(pm = data->head.lh_first; pm != NULL; pm = pm->entries.le_next)
		{
			printf("%2d %s %5hu->%s:%-5hu '%s' '%s'\n",
			       i, pm->protocol, pm->externalPort, pm->internalClient,
			       pm->internalPort,
			       pm->description, pm->remoteHost);
			i++;
		}
		*/
		/*FreePortListing(&data);*/
	}

	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p) {
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}
	ClearNameValueList(&pdata);

	/*printf("%.*s", bufsize, buffer);*/

	return ret;
}

/* IGD:2, functions for service WANIPv6FirewallControl:1 */
MINIUPNP_LIBSPEC int
UPNP_GetFirewallStatus(const char * controlURL,
				const char * servicetype,
				int * firewallEnabled,
				int * inboundPinholeAllowed)
{
	struct NameValueParserData pdata;
	char * buffer;
	int bufsize;
	char * fe, *ipa, *p;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;

	if(!firewallEnabled || !inboundPinholeAllowed)
		return UPNPCOMMAND_INVALID_ARGS;

	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "GetFirewallStatus", 0, &bufsize);
	if(!buffer) {
		return UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	fe = GetValueFromNameValueList(&pdata, "FirewallEnabled");
	ipa = GetValueFromNameValueList(&pdata, "InboundPinholeAllowed");
	if(ipa && fe)
		ret = UPNPCOMMAND_SUCCESS;
	if(fe)
		*firewallEnabled = my_atoui(fe);
	/*else
		*firewallEnabled = 0;*/
	if(ipa)
		*inboundPinholeAllowed = my_atoui(ipa);
	/*else
		*inboundPinholeAllowed = 0;*/
	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p)
	{
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}
	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_GetOutboundPinholeTimeout(const char * controlURL, const char * servicetype,
                    const char * remoteHost,
                    const char * remotePort,
                    const char * intClient,
                    const char * intPort,
                    const char * proto,
                    int * opTimeout)
{
	struct UPNParg GetOutboundPinholeTimeoutArgs[] = {
		{"RemoteHost", remoteHost},
		{"RemotePort", remotePort},
		{"Protocol", proto},
		{"InternalPort", intPort},
		{"InternalClient", intClient},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	struct NameValueParserData pdata;
	const char * resVal;
	int ret;

	if(!intPort || !intClient || !proto || !remotePort || !remoteHost)
		return UPNPCOMMAND_INVALID_ARGS;

	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "GetOutboundPinholeTimeout", GetOutboundPinholeTimeoutArgs, &bufsize);
	if(!buffer)
		return UPNPCOMMAND_HTTP_ERROR;
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	resVal = GetValueFromNameValueList(&pdata, "errorCode");
	if(resVal)
	{
		if(sscanf(resVal, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}
	else
	{
		const char * p = GetValueFromNameValueList(&pdata, "OutboundPinholeTimeout");
		if(p)
			*opTimeout = my_atoui(p);
		ret = UPNPCOMMAND_SUCCESS;
	}
	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_AddPinhole(const char * controlURL, const char * servicetype,
                    const char * remoteHost,
                    const char * remotePort,
                    const char * intClient,
                    const char * intPort,
                    const char * proto,
                    const char * leaseTime,
                    char * uniqueID)
{
	struct UPNParg AddPinholeArgs[] = {
		{"RemoteHost", ""},
		{"RemotePort", remotePort},
		{"Protocol", proto},
		{"InternalPort", intPort},
		{"InternalClient", ""},
		{"LeaseTime", leaseTime},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	struct NameValueParserData pdata;
	const char * resVal;
	char * p;
	int ret;

	if(!intPort || !intClient || !proto || !remoteHost || !remotePort || !leaseTime)
		return UPNPCOMMAND_INVALID_ARGS;

	/* RemoteHost and InternalClient can be wilcarded
	 * accept both the empty string and "empty" as wildcard */
	if(strncmp(remoteHost, "empty", 5) != 0)
		AddPinholeArgs[0].val = remoteHost;
	if(strncmp(intClient, "empty", 5) != 0)
		AddPinholeArgs[4].val = intClient;
	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "AddPinhole", AddPinholeArgs, &bufsize);
	if(!buffer)
		return UPNPCOMMAND_HTTP_ERROR;
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	p = GetValueFromNameValueList(&pdata, "UniqueID");
	if(p)
	{
		strncpy(uniqueID, p, 8);
		uniqueID[7] = '\0';
	}
	resVal = GetValueFromNameValueList(&pdata, "errorCode");
	if(resVal)
	{
		/*printf("AddPortMapping errorCode = '%s'\n", resVal);*/
		if(sscanf(resVal, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}
	else
	{
		ret = UPNPCOMMAND_SUCCESS;
	}
	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_UpdatePinhole(const char * controlURL, const char * servicetype,
                    const char * uniqueID,
                    const char * leaseTime)
{
	struct UPNParg UpdatePinholeArgs[] = {
		{"UniqueID", uniqueID},
		{"NewLeaseTime", leaseTime},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	struct NameValueParserData pdata;
	const char * resVal;
	int ret;

	if(!uniqueID || !leaseTime)
		return UPNPCOMMAND_INVALID_ARGS;

	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "UpdatePinhole", UpdatePinholeArgs, &bufsize);
	if(!buffer)
		return UPNPCOMMAND_HTTP_ERROR;
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	resVal = GetValueFromNameValueList(&pdata, "errorCode");
	if(resVal)
	{
		/*printf("AddPortMapping errorCode = '%s'\n", resVal); */
		if(sscanf(resVal, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}
	else
	{
		ret = UPNPCOMMAND_SUCCESS;
	}
	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_DeletePinhole(const char * controlURL, const char * servicetype, const char * uniqueID)
{
	/*struct NameValueParserData pdata;*/
	struct UPNParg DeletePinholeArgs[] = {
		{"UniqueID", uniqueID},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	struct NameValueParserData pdata;
	const char * resVal;
	int ret;

	if(!uniqueID)
		return UPNPCOMMAND_INVALID_ARGS;

	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "DeletePinhole", DeletePinholeArgs, &bufsize);
	if(!buffer)
		return UPNPCOMMAND_HTTP_ERROR;
	/*DisplayNameValueList(buffer, bufsize);*/
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);
	resVal = GetValueFromNameValueList(&pdata, "errorCode");
	if(resVal)
	{
		if(sscanf(resVal, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}
	else
	{
		ret = UPNPCOMMAND_SUCCESS;
	}
	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_CheckPinholeWorking(const char * controlURL, const char * servicetype,
                                 const char * uniqueID, int * isWorking)
{
	struct NameValueParserData pdata;
	struct UPNParg CheckPinholeWorkingArgs[] = {
		{"UniqueID", uniqueID},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	char * p;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;

	if(!uniqueID)
		return UPNPCOMMAND_INVALID_ARGS;

	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "CheckPinholeWorking", CheckPinholeWorkingArgs, &bufsize);
	if(!buffer)
	{
		return UPNPCOMMAND_HTTP_ERROR;
	}
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);

	p = GetValueFromNameValueList(&pdata, "IsWorking");
	if(p)
	{
		*isWorking=my_atoui(p);
		ret = UPNPCOMMAND_SUCCESS;
	}
	else
		*isWorking = 0;

	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p)
	{
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}

	ClearNameValueList(&pdata);
	return ret;
}

MINIUPNP_LIBSPEC int
UPNP_GetPinholePackets(const char * controlURL, const char * servicetype,
                                 const char * uniqueID, int * packets)
{
	struct NameValueParserData pdata;
	struct UPNParg GetPinholePacketsArgs[] = {
		{"UniqueID", uniqueID},
		{NULL, NULL}
	};
	char * buffer;
	int bufsize;
	char * p;
	int ret = UPNPCOMMAND_UNKNOWN_ERROR;

	if(!uniqueID)
		return UPNPCOMMAND_INVALID_ARGS;

	buffer = simpleUPnPcommand(controlURL, servicetype,
	                           "GetPinholePackets", GetPinholePacketsArgs, &bufsize);
	if(!buffer)
		return UPNPCOMMAND_HTTP_ERROR;
	ParseNameValue(buffer, bufsize, &pdata);
	free(buffer);

	p = GetValueFromNameValueList(&pdata, "PinholePackets");
	if(p)
	{
		*packets=my_atoui(p);
		ret = UPNPCOMMAND_SUCCESS;
	}

	p = GetValueFromNameValueList(&pdata, "errorCode");
	if(p)
	{
		if(sscanf(p, "%d", &ret) != 1)
			ret = UPNPCOMMAND_UNKNOWN_ERROR;
	}

	ClearNameValueList(&pdata);
	return ret;
}