自学教程：C++ ClearNameValueList函数代码示例

/* 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 */intUPNP_GetSpecificPortMappingEntry(const char * controlURL,                                 const char * servicetype,                                 const char * extPort,                                 const char * proto,                                 char * intClient,                                 char * intPort){    struct NameValueParserData pdata;    struct UPNParg * GetPortMappingArgs;    char buffer[4096];    int bufsize = 4096;    char * p;    int ret = UPNPCOMMAND_UNKNOWN_ERROR;    if(!intPort || !intClient || !extPort || !proto)        return UPNPCOMMAND_INVALID_ARGS;    GetPortMappingArgs = calloc(4, sizeof(struct UPNParg));    GetPortMappingArgs[0].elt = "NewRemoteHost";    GetPortMappingArgs[1].elt = "NewExternalPort";    GetPortMappingArgs[1].val = extPort;    GetPortMappingArgs[2].elt = "NewProtocol";    GetPortMappingArgs[2].val = proto;    simpleUPnPcommand(-1, controlURL, servicetype,                      "GetSpecificPortMappingEntry",                      GetPortMappingArgs, buffer, &bufsize);    /*fd = simpleUPnPcommand(fd, controlURL, data.servicetype, "GetSpecificPortMappingEntry", AddPortMappingArgs, buffer, &bufsize); */    /*DisplayNameValueList(buffer, bufsize);*/    ParseNameValue(buffer, bufsize, &pdata);    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, "errorCode");    if(p) {        ret = UPNPCOMMAND_UNKNOWN_ERROR;        sscanf(p, "%d", &ret);    }    ClearNameValueList(&pdata);    free(GetPortMappingArgs);    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 */LIBSPEC intUPNP_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(-1, controlURL, servicetype,	                                "GetCommonLinkProperties", 0, &bufsize))) {	                              /*"GetLinkLayerMaxBitRates", 0, &bufsize);*/		return UPNPCOMMAND_HTTP_ERROR;	}	/*DisplayNameValueList(buffer, bufsize);*/	ParseNameValue(buffer, bufsize, &pdata);	free(buffer); buffer = NULL;	/*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);		else			*bitrateDown = 0;	}	if(bitrateUp) {		if(up)			sscanf(up,"%u",bitrateUp);		else			*bitrateUp = 0;	}	p = GetValueFromNameValueList(&pdata, "errorCode");	if(p) {		ret = UPNPCOMMAND_UNKNOWN_ERROR;		sscanf(p, "%d", &ret);	}	ClearNameValueList(&pdata);	return ret;}

LIBSPEC intUPNP_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;    char * buffer;    int bufsize;    struct NameValueParserData pdata;    const char * resVal;    char * p;    int ret;    if(!intPort || !intClient || !proto || !remotePort || !remoteHost)        return UPNPCOMMAND_INVALID_ARGS;    GetOutboundPinholeTimeoutArgs = calloc(6, sizeof(struct UPNParg));    GetOutboundPinholeTimeoutArgs[0].elt = "RemoteHost";    GetOutboundPinholeTimeoutArgs[0].val = remoteHost;    GetOutboundPinholeTimeoutArgs[1].elt = "RemotePort";    GetOutboundPinholeTimeoutArgs[1].val = remotePort;    GetOutboundPinholeTimeoutArgs[2].elt = "Protocol";    GetOutboundPinholeTimeoutArgs[2].val = proto;    GetOutboundPinholeTimeoutArgs[3].elt = "InternalPort";    GetOutboundPinholeTimeoutArgs[3].val = intPort;    GetOutboundPinholeTimeoutArgs[4].elt = "InternalClient";    GetOutboundPinholeTimeoutArgs[4].val = intClient;    buffer = simpleUPnPcommand(-1, controlURL, servicetype,                               "GetOutboundPinholeTimeout", GetOutboundPinholeTimeoutArgs, &bufsize);    if(!buffer)        return UPNPCOMMAND_HTTP_ERROR;    ParseNameValue(buffer, bufsize, &pdata);    free(buffer);    buffer = NULL;    resVal = GetValueFromNameValueList(&pdata, "errorCode");    if(resVal)    {        ret = UPNPCOMMAND_UNKNOWN_ERROR;        sscanf(resVal, "%d", &ret);    }    else    {        ret = UPNPCOMMAND_SUCCESS;        p = GetValueFromNameValueList(&pdata, "OutboundPinholeTimeout");        if(p)            *opTimeout = my_atoui(p);    }    ClearNameValueList(&pdata);    free(GetOutboundPinholeTimeoutArgs);    return ret;}

void upnpc_event_conn_req(struct evhttp_request * req, void * data){	size_t len;	char * xml_data;	struct evbuffer * input_buffer;	struct evkeyvalq * headers;	const char * sid;	const char * nts;	const char * nt;	const char * seq;	struct NameValueParserData parsed_data;	struct NameValue * nv;	upnpc_device_t * d = (upnpc_device_t *)data;	debug_printf("%s(%p, %p)/n", __func__, req, d);	headers = evhttp_request_get_input_headers(req);	input_buffer = evhttp_request_get_input_buffer(req);	len = evbuffer_get_length(input_buffer);	sid = evhttp_find_header(headers, "sid");	nts = evhttp_find_header(headers, "nts");	nt = evhttp_find_header(headers, "nt");	seq = evhttp_find_header(headers, "seq");	if(len == 0 || nts == NULL || nt == NULL) {		/* 400 Bad request :		 * The NT or NTS header field is missing		 * or the request is malformed. */		evhttp_send_reply(req, 400, "Bad Request", NULL);		return;	}	debug_printf("SID=%s NTS=%s SEQ=%s/n", sid, nts, seq);	if(sid == NULL || 0 != strcmp(sid, d->event_conn_sid)	   || 0 != strcmp(nt, "upnp:event") || 0 != strcmp(nts, "upnp:propchange")) {		/* 412 Precondition Failed :		 *  An SID does not correspond to a known, un-expired subscription		 *  or the NT header field does not equal upnp:event		 *  or the NTS header field does not equal upnp:propchange		 *  or the SID header field is missing or empty.  */		evhttp_send_reply(req, 412, "Precondition Failed", NULL);		return;	}	xml_data = (char *)evbuffer_pullup(input_buffer, len);	/*debug_printf("%.*s/n", len, xml_data);*/	ParseNameValue(xml_data, len, &parsed_data);	for(nv = parsed_data.l_head; nv != NULL; nv = nv->l_next) {		if(d->parent->value_changed_cb) {			d->parent->value_changed_cb(d->parent, d, d->parent->cb_data, d->conn_service_type, nv->name, nv->value);		} else {			debug_printf("%s=%s/n", nv->name, nv->value);		}	}	ClearNameValueList(&parsed_data);	/* response : 200 OK */	evhttp_send_reply(req, 200, "OK", NULL);}

/* 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 */voidUPNP_GetSpecificPortMappingEntry(const char * controlURL,                                 const char * servicetype,                                 const char * extPort,							     const char * proto,                                 char * intClient,                                 char * intPort){	struct NameValueParserData pdata;	struct UPNParg * GetPortMappingArgs;	char buffer[4096];	int bufsize = 4096;	char * p;	if(!intPort && !intClient && !extPort)		return;	GetPortMappingArgs = calloc(4, sizeof(struct UPNParg));	GetPortMappingArgs[0].elt = "NewRemoteHost";	GetPortMappingArgs[1].elt = "NewExternalPort";	GetPortMappingArgs[1].val = extPort;	GetPortMappingArgs[2].elt = "NewProtocol";	GetPortMappingArgs[2].val = proto;	simpleUPnPcommand(-1, controlURL, servicetype,	                  "GetSpecificPortMappingEntry",					  GetPortMappingArgs, buffer, &bufsize);	/*fd = simpleUPnPcommand(fd, controlURL, data.servicetype, "GetSpecificPortMappingEntry", AddPortMappingArgs, buffer, &bufsize); */	/*DisplayNameValueList(buffer, bufsize);*/	ParseNameValue(buffer, bufsize, &pdata);	p = GetValueFromNameValueList(&pdata, "NewInternalClient");	if(intClient)	{		if(p){			strncpy(intClient, p, 16);			intClient[15] = '/0';		}else			intClient[0] = '/0';	}	p = GetValueFromNameValueList(&pdata, "NewInternalPort");	if(intPort)	{		if(p){			strncpy(intPort, p, 6);			intPort[5] = '/0';		}else			intPort[0] = '/0';	}	ClearNameValueList(&pdata);	free(GetPortMappingArgs);}

LIBSPEC intUPNP_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){	struct UPNParg * AddPortMappingArgs;	char buffer[4096];	int bufsize = 4096;	struct NameValueParserData pdata;	const char * resVal;	int ret;	if(!inPort || !inClient || !proto || !extPort)		return UPNPCOMMAND_INVALID_ARGS;	AddPortMappingArgs = calloc(9, sizeof(struct UPNParg));	AddPortMappingArgs[0].elt = "NewRemoteHost";	AddPortMappingArgs[0].val = remoteHost;	AddPortMappingArgs[1].elt = "NewExternalPort";	AddPortMappingArgs[1].val = extPort;	AddPortMappingArgs[2].elt = "NewProtocol";	AddPortMappingArgs[2].val = proto;	AddPortMappingArgs[3].elt = "NewInternalPort";	AddPortMappingArgs[3].val = inPort;	AddPortMappingArgs[4].elt = "NewInternalClient";	AddPortMappingArgs[4].val = inClient;	AddPortMappingArgs[5].elt = "NewEnabled";	AddPortMappingArgs[5].val = "1";	AddPortMappingArgs[6].elt = "NewPortMappingDescription";	AddPortMappingArgs[6].val = desc?desc:"libminiupnpc";	AddPortMappingArgs[7].elt = "NewLeaseDuration";	AddPortMappingArgs[7].val = "0";	simpleUPnPcommand(-1, controlURL, servicetype, "AddPortMapping", AddPortMappingArgs, buffer, &bufsize);	/*DisplayNameValueList(buffer, bufsize);*/	/*buffer[bufsize] = '/0';*/	/*puts(buffer);*/	ParseNameValue(buffer, bufsize, &pdata);	resVal = GetValueFromNameValueList(&pdata, "errorCode");	if(resVal) {		/*printf("AddPortMapping errorCode = '%s'/n", resVal); */		ret = UPNPCOMMAND_UNKNOWN_ERROR;		sscanf(resVal, "%d", &ret);	} else {		ret = UPNPCOMMAND_SUCCESS;	}	ClearNameValueList(&pdata);	free(AddPortMappingArgs);	return ret;}

voidDisplayNameValueList(char * buffer, int bufsize){    struct NameValueParserData pdata;    struct NameValue * nv;    ParseNameValue(buffer, bufsize, &pdata);    for(nv = pdata.head.lh_first;        nv != NULL;        nv = nv->entries.le_next)    {        printf("%s = %s/n", nv->name, nv->value);    }    ClearNameValueList(&pdata);}

intUPNP_AddPortMapping(const char * controlURL, const char * servicetype,                    const char * extPort,					const char * inPort,					const char * inClient,					const char * desc,					const char * proto){	struct UPNParg * AddPortMappingArgs;	char buffer[4096];	int bufsize = 4096;	struct NameValueParserData pdata;	const char * resVal;	int ret;	if(!inPort || !inClient)		return 0;	AddPortMappingArgs = calloc(9, sizeof(struct UPNParg));	AddPortMappingArgs[0].elt = "NewRemoteHost";	AddPortMappingArgs[1].elt = "NewExternalPort";	AddPortMappingArgs[1].val = extPort;	AddPortMappingArgs[2].elt = "NewProtocol";	AddPortMappingArgs[2].val = proto;	AddPortMappingArgs[3].elt = "NewInternalPort";	AddPortMappingArgs[3].val = inPort;	AddPortMappingArgs[4].elt = "NewInternalClient";	AddPortMappingArgs[4].val = inClient;	AddPortMappingArgs[5].elt = "NewEnabled";	AddPortMappingArgs[5].val = "1";	AddPortMappingArgs[6].elt = "NewPortMappingDescription";	AddPortMappingArgs[6].val = desc?desc:"libminiupnpc";	AddPortMappingArgs[7].elt = "NewLeaseDuration";	AddPortMappingArgs[7].val = "0";	simpleUPnPcommand(-1, controlURL, servicetype, "AddPortMapping", AddPortMappingArgs, buffer, &bufsize);	/*fd = simpleUPnPcommand(fd, controlURL, data.servicetype, "AddPortMapping", AddPortMappingArgs, buffer, &bufsize);*/	/*DisplayNameValueList(buffer, bufsize);*/	/*buffer[bufsize] = '/0';*/	/*puts(buffer);*/	ParseNameValue(buffer, bufsize, &pdata);	resVal = GetValueFromNameValueList(&pdata, "errorCode");	ret = resVal?0:1;	/* Do something with resVal if not null ! */	/*printf("AddPortMapping errorCode = '%s'/n", resVal); */	ClearNameValueList(&pdata);	free(AddPortMappingArgs);	return ret;}

LIBSPEC UNSIGNED_INTEGERUPNP_GetTotalPacketsReceived(const char * controlURL,						const char * servicetype){	struct NameValueParserData pdata;	char buffer[4096];	int bufsize = 4096;	unsigned int r = 0;	char * p;	simpleUPnPcommand(-1, controlURL, servicetype, "GetTotalPacketsReceived", 0, buffer, &bufsize);	ParseNameValue(buffer, bufsize, &pdata);	/*DisplayNameValueList(buffer, bufsize);*/	p = GetValueFromNameValueList(&pdata, "NewTotalPacketsReceived");	r = my_atoui(p);	ClearNameValueList(&pdata);	return r;}

unsigned intUPNP_GetTotalBytesSent(const char * controlURL,					const char * servicetype){	struct NameValueParserData pdata;	char buffer[4096];	int bufsize = 4096;	unsigned int r = 0;	char * p;	simpleUPnPcommand(-1, controlURL, servicetype, "GetTotalBytesSent", 0, buffer, &bufsize);	ParseNameValue(buffer, bufsize, &pdata);	/*DisplayNameValueList(buffer, bufsize);*/	p = GetValueFromNameValueList(&pdata, "NewTotalBytesSent");	if(p)		r = my_atoui(p);	ClearNameValueList(&pdata);	return r;}

/* IGD:2, functions for service WANIPv6FirewallControl:1 */LIBSPEC intUPNP_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(-1, controlURL, servicetype,                               "GetFirewallStatus", 0, &bufsize);    if(!buffer) {        return UPNPCOMMAND_HTTP_ERROR;    }    ParseNameValue(buffer, bufsize, &pdata);    free(buffer);    buffer = NULL;    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)    {        ret = UPNPCOMMAND_UNKNOWN_ERROR;        sscanf(p, "%d", &ret);    }    ClearNameValueList(&pdata);    return ret;}

void UPNP_GetPortMappingNumberOfEntries(const char * controlURL, const char * servicetype, unsigned int * numEntries){ 	struct NameValueParserData pdata; 	char buffer[4096]; 	int bufsize = 4096; 	char* p; 	simpleUPnPcommand(-1, controlURL, servicetype, "GetPortMappingNumberOfEntries", 0, buffer, &bufsize);#ifndef NDEBUG	DisplayNameValueList(buffer, bufsize);#endif 	ParseNameValue(buffer, bufsize, &pdata); 	p = GetValueFromNameValueList(&pdata, "NewPortMappingNumberOfEntries");  	if(numEntries && p) 	{ 		sscanf(p,"%u",numEntries); 	} 	ClearNameValueList(&pdata);}

inttest_parsing(const char * buf, int len, FILE * f){	char line[1024];	struct NameValueParserData pdata;	int ok = 1;	ParseNameValue(buf, len, &pdata);	/* check result */	if(f != NULL)	{		while(fgets(line, sizeof(line), f))		{			char * value;			char * equal;			char * parsedvalue;			int l;			l = strlen(line);			while((l > 0) && ((line[l-1] == '/r') || (line[l-1] == '/n')))				line[--l] = '/0';			/* skip empty lines */			if(l == 0)				continue;			equal = strchr(line, '=');			if(equal == NULL)			{				fprintf(stderr, "Warning, line does not contain '=' : %s/n", line);				continue;			}			*equal = '/0';			value = equal + 1;			parsedvalue = GetValueFromNameValueList(&pdata, line);			if((parsedvalue == NULL) || (strcmp(parsedvalue, value) != 0))			{				fprintf(stderr, "Element <%s> : expecting value '%s', got '%s'/n",				        line, value, parsedvalue ? parsedvalue : "<null string>");				ok = 0;			}		}	}	ClearNameValueList(&pdata);	return ok;}

static void upnpc_soap_response(struct evhttp_request * req, void * pvoid){	size_t len;	unsigned char * data;	struct evbuffer * input_buffer;	upnpc_device_t * d = (upnpc_device_t *)pvoid;	int code;	if(req == NULL) {		debug_printf("%s(%p, %p) NULL argument !/n", __func__, req, pvoid);		return;	}	code = evhttp_request_get_response_code(req);	input_buffer = evhttp_request_get_input_buffer(req);	len = evbuffer_get_length(input_buffer);	data = evbuffer_pullup(input_buffer, len);	debug_printf("%s %d (%d bytes)/n", __func__, code, (int)len);	debug_printf("%.*s/n", (int)len, (char *)data);	if(data == NULL)		return;	ClearNameValueList(&d->soap_response_data);	ParseNameValue((char *)data, (int)len, 	               &d->soap_response_data);	d->state &= ~UPNPC_DEVICE_SOAP_REQ;	if(d->state & UPNPC_DEVICE_READY) {		d->parent->soap_cb(code, d->parent, d, d->parent->cb_data);	} else if(d->state & UPNPC_DEVICE_GETSTATUS) {		const char * connection_status;		d->state &= ~UPNPC_DEVICE_GETSTATUS;		connection_status = GetValueFromNameValueList(&d->soap_response_data, "NewConnectionStatus");		d->state |= UPNPC_DEVICE_READY;		if((code == 200) && connection_status && (0 == strcmp("Connected", connection_status))) {			d->parent->ready_cb(code, d->parent, d, d->parent->cb_data);			d->state |= UPNPC_DEVICE_CONNECTED;			event_del(d->parent->ev_ssdp_recv);		} else {			d->parent->ready_cb(UPNPC_ERR_NOT_CONNECTED, d->parent, d, d->parent->cb_data);		}	}}

/* 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 */void UPNP_GetLinkLayerMaxBitRates(const char * controlURL, const char * servicetype, unsigned int * bitrateDown, unsigned int* bitrateUp){	struct NameValueParserData pdata;	char buffer[4096];	int bufsize = 4096;	char * down;	char* up;	if(!bitrateDown && !bitrateUp)		return;	/* shouldn't we use GetCommonLinkProperties ? */	simpleUPnPcommand(-1, controlURL, servicetype,	                  "GetCommonLinkProperties", 0, buffer, &bufsize);	                  /*"GetLinkLayerMaxBitRates", 0, buffer, &bufsize);*/	/*DisplayNameValueList(buffer, bufsize);*/	ParseNameValue(buffer, bufsize, &pdata);	/*down = GetValueFromNameValueList(&pdata, "NewDownstreamMaxBitRate");*/	/*up = GetValueFromNameValueList(&pdata, "NewUpstreamMaxBitRate");*/	down = GetValueFromNameValueList(&pdata, "NewLayer1DownstreamMaxBitRate");	up = GetValueFromNameValueList(&pdata, "NewLayer1UpstreamMaxBitRate");	/*GetValueFromNameValueList(&pdata, "NewWANAccessType");*/	/*GetValueFromNameValueList(&pdata, "NewPhysicalLinkSatus");*/	if(bitrateDown)	{		if(down)			sscanf(down,"%u",bitrateDown);		else			*bitrateDown = 0;	}	if(bitrateUp)	{		if(up)			sscanf(up,"%u",bitrateUp);		else			*bitrateUp = 0;	}	ClearNameValueList(&pdata);}

/* 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. */LIBSPEC intUPNP_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(-1, controlURL, servicetype,                                    "GetExternalIPAddress", 0, &bufsize))) {        return UPNPCOMMAND_HTTP_ERROR;    }    /*DisplayNameValueList(buffer, bufsize);*/    ParseNameValue(buffer, bufsize, &pdata);    free(buffer);    buffer = NULL;    /*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) {        ret = UPNPCOMMAND_UNKNOWN_ERROR;        sscanf(p, "%d", &ret);    }    ClearNameValueList(&pdata);    return ret;}

/* UPNP_GetConnectionTypeInfo() call the corresponding UPNP method * returns the connection type */LIBSPEC intUPNP_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(-1, controlURL, servicetype,                                    "GetConnectionTypeInfo", 0, &bufsize))) {        return UPNPCOMMAND_HTTP_ERROR;    }    ParseNameValue(buffer, bufsize, &pdata);    free(buffer);    buffer = NULL;    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) {        ret = UPNPCOMMAND_UNKNOWN_ERROR;        sscanf(p, "%d", &ret);    }    ClearNameValueList(&pdata);    return ret;}

LIBSPEC intUPNP_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(-1, controlURL, servicetype,                                    "GetPortMappingNumberOfEntries", 0,                                    &bufsize))) {        return UPNPCOMMAND_HTTP_ERROR;    }#ifdef DEBUG    DisplayNameValueList(buffer, bufsize);#endif    ParseNameValue(buffer, bufsize, &pdata);    free(buffer);    buffer = NULL;    p = GetValueFromNameValueList(&pdata, "NewPortMappingNumberOfEntries");    if(numEntries && p) {        *numEntries = 0;        sscanf(p, "%u", numEntries);        ret = UPNPCOMMAND_SUCCESS;    }    p = GetValueFromNameValueList(&pdata, "errorCode");    if(p) {        ret = UPNPCOMMAND_UNKNOWN_ERROR;        sscanf(p, "%d", &ret);    }    ClearNameValueList(&pdata);    return ret;}

/* UPNP_GetStatusInfo() call the corresponding UPNP method * returns the current status and uptime */void UPNP_GetStatusInfo(const char * controlURL,												const char * servicetype,												char * status, 												unsigned int * uptime){	struct NameValueParserData pdata;	char buffer[4096];	int bufsize = 4096;	char * p;	char* up;	if(!status && !uptime)		return;	simpleUPnPcommand(-1, controlURL, servicetype, "GetStatusInfo", 0, buffer, &bufsize);	ParseNameValue(buffer, bufsize, &pdata);	/*DisplayNameValueList(buffer, bufsize);*/	up = GetValueFromNameValueList(&pdata, "NewUptime");	p = GetValueFromNameValueList(&pdata, "NewConnectionStatus");	if(status)	{		if(p){			strncpy(status, p, 64 );			status[63] = '/0';		}else			status[0]= '/0';	}	if(uptime){		if(p)			sscanf(up,"%u",uptime);		else			uptime = 0;	}	ClearNameValueList(&pdata);}