Ignore:
Timestamp:
Feb 23, 2008, 3:31:39 PM (14 years ago)
Author:
charles
Message:

update to miniupnpc-1.0

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/third-party/miniupnp/upnpcommands.c

    r4251 r5094  
    1 /* $Id: upnpcommands.c,v 1.18 2007/12/19 14:56:14 nanard Exp $ */
     1/* $Id: upnpcommands.c,v 1.19 2008/02/18 13:27:23 nanard Exp $ */
    22/* Project : miniupnp
    33 * Author : Thomas Bernard
     
    1515my_atoui(const char * s)
    1616{
    17         return (unsigned int)strtoul(s, NULL, 0);
     17        return s ? ((unsigned int)strtoul(s, NULL, 0)) : 0;
    1818}
    1919
     
    3333        /*DisplayNameValueList(buffer, bufsize);*/
    3434        p = GetValueFromNameValueList(&pdata, "NewTotalBytesSent");
    35         if(p)
    36                 r = my_atoui(p);
     35        r = my_atoui(p);
    3736        ClearNameValueList(&pdata);
    3837        return r;
     
    5453        /*DisplayNameValueList(buffer, bufsize);*/
    5554        p = GetValueFromNameValueList(&pdata, "NewTotalBytesReceived");
    56         if(p)
    57                 r = my_atoui(p);
     55        r = my_atoui(p);
    5856        ClearNameValueList(&pdata);
    5957        return r;
     
    7573        /*DisplayNameValueList(buffer, bufsize);*/
    7674        p = GetValueFromNameValueList(&pdata, "NewTotalPacketsSent");
    77         if(p)
    78                 r = my_atoui(p);
     75        r = my_atoui(p);
    7976        ClearNameValueList(&pdata);
    8077        return r;
     
    9693        /*DisplayNameValueList(buffer, bufsize);*/
    9794        p = GetValueFromNameValueList(&pdata, "NewTotalPacketsReceived");
    98         if(p)
    99                 r = my_atoui(p);
     95        r = my_atoui(p);
    10096        ClearNameValueList(&pdata);
    10197        return r;
     
    104100/* UPNP_GetStatusInfo() call the corresponding UPNP method
    105101 * returns the current status and uptime */
    106 void UPNP_GetStatusInfo(const char * controlURL,
    107                                                                                                 const char * servicetype,
    108                                                                                                 char * status,
    109                                                                                                 unsigned int * uptime)
    110 {
    111         struct NameValueParserData pdata;
    112         char buffer[4096];
    113         int bufsize = 4096;
    114         char * p;
    115         char* up;
     102int UPNP_GetStatusInfo(const char * controlURL,
     103                                        const char * servicetype,
     104                                        char * status,
     105                                        unsigned int * uptime,
     106                                        char * lastconnerror)
     107{
     108        struct NameValueParserData pdata;
     109        char buffer[4096];
     110        int bufsize = 4096;
     111        char * p;
     112        char * up;
     113        char * err;
     114        int ret = UPNPCOMMAND_UNKNOWN_ERROR;
    116115
    117116        if(!status && !uptime)
    118                 return;
     117                return UPNPCOMMAND_INVALID_ARGS;
    119118
    120119        simpleUPnPcommand(-1, controlURL, servicetype, "GetStatusInfo", 0, buffer, &bufsize);
     
    123122        up = GetValueFromNameValueList(&pdata, "NewUptime");
    124123        p = GetValueFromNameValueList(&pdata, "NewConnectionStatus");
    125 
    126         if(status)
    127         {
     124        err = GetValueFromNameValueList(&pdata, "NewLastConnectionError");
     125        if(p && up)
     126          ret = UPNPCOMMAND_SUCCESS;
     127
     128        if(status) {
    128129                if(p){
    129130                        strncpy(status, p, 64 );
     
    133134        }
    134135
    135         if(uptime){
     136        if(uptime) {
    136137                if(up)
    137138                        sscanf(up,"%u",uptime);
     
    140141        }
    141142
    142         ClearNameValueList(&pdata);
     143        if(lastconnerror) {
     144                if(err) {
     145                        strncpy(lastconnerror, err, 64 );
     146                        lastconnerror[63] = '\0';
     147                } else
     148                        lastconnerror[0] = '\0';
     149        }
     150
     151        p = GetValueFromNameValueList(&pdata, "errorCode");
     152        if(p) {
     153                ret = UPNPCOMMAND_UNKNOWN_ERROR;
     154                sscanf(p, "%d", &ret);
     155        }
     156        ClearNameValueList(&pdata);
     157        return ret;
    143158}
    144159
    145160/* UPNP_GetConnectionTypeInfo() call the corresponding UPNP method
    146161 * returns the connection type */
    147 void UPNP_GetConnectionTypeInfo(const char * controlURL,
    148                                 const char * servicetype,
    149                                                                 char * connectionType)
    150 {
    151         struct NameValueParserData pdata;
    152         char buffer[4096];
    153         int bufsize = 4096;
    154         char * p;
     162int UPNP_GetConnectionTypeInfo(const char * controlURL,
     163                               const char * servicetype,
     164                               char * connectionType)
     165{
     166        struct NameValueParserData pdata;
     167        char buffer[4096];
     168        int bufsize = 4096;
     169        char * p;
     170        int ret = UPNPCOMMAND_UNKNOWN_ERROR;
    155171
    156172        if(!connectionType)
    157                 return;
    158 
     173                return UPNPCOMMAND_INVALID_ARGS;
    159174
    160175        simpleUPnPcommand(-1, controlURL, servicetype,
     
    164179        /*p = GetValueFromNameValueList(&pdata, "NewPossibleConnectionTypes");*/
    165180        /* PossibleConnectionTypes will have several values.... */
    166         if(connectionType)
    167         {
    168                 if(p){
    169                         strncpy(connectionType, p, 64 );
    170                         connectionType[63] = '\0';
    171                 }       else
    172                         connectionType[0] = '\0';
    173         }
    174         ClearNameValueList(&pdata);
     181        if(p) {
     182                strncpy(connectionType, p, 64 );
     183                connectionType[63] = '\0';
     184                ret = UPNPCOMMAND_SUCCESS;
     185        } else
     186                connectionType[0] = '\0';
     187        p = GetValueFromNameValueList(&pdata, "errorCode");
     188        if(p) {
     189                ret = UPNPCOMMAND_UNKNOWN_ERROR;
     190                sscanf(p, "%d", &ret);
     191        }
     192        ClearNameValueList(&pdata);
     193        return ret;
    175194}
    176195
     
    180199 * Note : GetLinkLayerMaxBitRates belongs to WANPPPConnection:1 only
    181200 * We can use the GetCommonLinkProperties from WANCommonInterfaceConfig:1 */
    182 void UPNP_GetLinkLayerMaxBitRates(const char * controlURL, const char * servicetype, unsigned int * bitrateDown, unsigned int* bitrateUp)
    183 {
    184         struct NameValueParserData pdata;
    185         char buffer[4096];
    186         int bufsize = 4096;
     201int UPNP_GetLinkLayerMaxBitRates(const char * controlURL, const char * servicetype, unsigned int * bitrateDown, unsigned int* bitrateUp)
     202{
     203        struct NameValueParserData pdata;
     204        char buffer[4096];
     205        int bufsize = 4096;
     206        int ret = UPNPCOMMAND_UNKNOWN_ERROR;
    187207        char * down;
    188         char* up;
     208        char * up;
     209        char * p;
    189210
    190211        if(!bitrateDown && !bitrateUp)
    191                 return;
     212                return UPNPCOMMAND_INVALID_ARGS;
    192213
    193214        /* shouldn't we use GetCommonLinkProperties ? */
     
    203224        /*GetValueFromNameValueList(&pdata, "NewWANAccessType");*/
    204225        /*GetValueFromNameValueList(&pdata, "NewPhysicalLinkSatus");*/
     226        if(down && up)
     227                ret = UPNPCOMMAND_SUCCESS;
    205228
    206229        if(bitrateDown)
     
    219242                        *bitrateUp = 0;
    220243        }
    221         ClearNameValueList(&pdata);
     244        p = GetValueFromNameValueList(&pdata, "errorCode");
     245        if(p) {
     246                ret = UPNPCOMMAND_UNKNOWN_ERROR;
     247                sscanf(p, "%d", &ret);
     248        }
     249        ClearNameValueList(&pdata);
     250        return ret;
    222251}
    223252
     
    248277
    249278        simpleUPnPcommand(-1, controlURL, servicetype, "GetExternalIPAddress", 0, buffer, &bufsize);
    250         /*fd = simpleUPnPcommand(fd, controlURL, data.servicetype, "GetExternalIPAddress", 0, buffer, &bufsize);*/
    251279        /*DisplayNameValueList(buffer, bufsize);*/
    252280        ParseNameValue(buffer, bufsize, &pdata);
     
    305333        AddPortMappingArgs[7].val = "0";
    306334        simpleUPnPcommand(-1, controlURL, servicetype, "AddPortMapping", AddPortMappingArgs, buffer, &bufsize);
    307         /*fd = simpleUPnPcommand(fd, controlURL, data.servicetype, "AddPortMapping", AddPortMappingArgs, buffer, &bufsize);*/
    308335        /*DisplayNameValueList(buffer, bufsize);*/
    309336        /*buffer[bufsize] = '\0';*/
Note: See TracChangeset for help on using the changeset viewer.