Return to portlistingparse.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpc

Annotation of embedaddon/miniupnpc/portlistingparse.c, revision 1.1

1.1     ! misho       1: /* $Id: portlistingparse.c,v 1.4 2011/03/18 11:02:17 nanard Exp $ */
        !             2: /* MiniUPnP project
        !             3:  * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
        !             4:  * (c) 2011 Thomas Bernard 
        !             5:  * This software is subject to the conditions detailed
        !             6:  * in the LICENCE file provided within the distribution */
        !             7: #include <string.h>
        !             8: #include <stdlib.h>
        !             9: #include "portlistingparse.h"
        !            10: #include "minixml.h"
        !            11: 
        !            12: /* list of the elements */
        !            13: static const struct {
        !            14:        const portMappingElt code;
        !            15:        const char * const str;
        !            16: } elements[] = {
        !            17:        { PortMappingEntry, "PortMappingEntry"},
        !            18:        { NewRemoteHost, "NewRemoteHost"},
        !            19:        { NewExternalPort, "NewExternalPort"},
        !            20:        { NewProtocol, "NewProtocol"},
        !            21:        { NewInternalPort, "NewInternalPort"},
        !            22:        { NewInternalClient, "NewInternalClient"},
        !            23:        { NewEnabled, "NewEnabled"},
        !            24:        { NewDescription, "NewDescription"},
        !            25:        { NewLeaseTime, "NewLeaseTime"},
        !            26:        { PortMappingEltNone, NULL}
        !            27: };
        !            28: 
        !            29: /* Helper function */
        !            30: static UNSIGNED_INTEGER
        !            31: atoui(const char * p, int l)
        !            32: {
        !            33:        UNSIGNED_INTEGER r = 0;
        !            34:        while(l > 0 && *p)
        !            35:        {
        !            36:                if(*p >= '0' && *p <= '9')
        !            37:                        r = r*10 + (*p - '0');
        !            38:                else
        !            39:                        break;
        !            40:                p++;
        !            41:                l--;
        !            42:        }
        !            43:        return r;
        !            44: }
        !            45: 
        !            46: /* Start element handler */
        !            47: static void
        !            48: startelt(void * d, const char * name, int l)
        !            49: {
        !            50:        int i;
        !            51:        struct PortMappingParserData * pdata = (struct PortMappingParserData *)d;
        !            52:        pdata->curelt = PortMappingEltNone;
        !            53:        for(i = 0; elements[i].str; i++)
        !            54:        {
        !            55:                if(memcmp(name, elements[i].str, l) == 0)
        !            56:                {
        !            57:                        pdata->curelt = elements[i].code;
        !            58:                        break;
        !            59:                }
        !            60:        }
        !            61:        if(pdata->curelt == PortMappingEntry)
        !            62:        {
        !            63:                struct PortMapping * pm;
        !            64:                pm = calloc(1, sizeof(struct PortMapping));
        !            65:                LIST_INSERT_HEAD( &(pdata->head), pm, entries);
        !            66:        }
        !            67: }
        !            68: 
        !            69: /* End element handler */
        !            70: static void
        !            71: endelt(void * d, const char * name, int l)
        !            72: {
        !            73:        struct PortMappingParserData * pdata = (struct PortMappingParserData *)d;
        !            74:        pdata->curelt = PortMappingEltNone;
        !            75: }
        !            76: 
        !            77: /* Data handler */
        !            78: static void
        !            79: data(void * d, const char * data, int l)
        !            80: {
        !            81:        struct PortMapping * pm;
        !            82:        struct PortMappingParserData * pdata = (struct PortMappingParserData *)d;
        !            83:        pm = pdata->head.lh_first;
        !            84:        if(!pm)
        !            85:                return;
        !            86:        if(l > 63)
        !            87:                l = 63;
        !            88:        switch(pdata->curelt)
        !            89:        {
        !            90:        case NewRemoteHost:
        !            91:                memcpy(pm->remoteHost, data, l);
        !            92:                pm->remoteHost[l] = '\0';
        !            93:                break;
        !            94:        case NewExternalPort:
        !            95:                pm->externalPort = (unsigned short)atoui(data, l);
        !            96:                break;
        !            97:        case NewProtocol:
        !            98:                if(l > 3)
        !            99:                        l = 3;
        !           100:                memcpy(pm->protocol, data, l);
        !           101:                pm->protocol[l] = '\0';
        !           102:                break;
        !           103:        case NewInternalPort:
        !           104:                pm->internalPort = (unsigned short)atoui(data, l);
        !           105:                break;
        !           106:        case NewInternalClient:
        !           107:                memcpy(pm->internalClient, data, l);
        !           108:                pm->internalClient[l] = '\0';
        !           109:                break;
        !           110:        case NewEnabled:
        !           111:                pm->enabled = (unsigned char)atoui(data, l);
        !           112:                break;
        !           113:        case NewDescription:
        !           114:                memcpy(pm->description, data, l);
        !           115:                pm->description[l] = '\0';
        !           116:                break;
        !           117:        case NewLeaseTime:
        !           118:                pm->leaseTime = atoui(data, l);
        !           119:                break;
        !           120:        default:
        !           121:                break;
        !           122:        }
        !           123: }
        !           124: 
        !           125: 
        !           126: /* Parse the PortMappingList XML document for IGD version 2
        !           127:  */
        !           128: void
        !           129: ParsePortListing(const char * buffer, int bufsize,
        !           130:                  struct PortMappingParserData * pdata)
        !           131: {
        !           132:        struct xmlparser parser;
        !           133: 
        !           134:        memset(pdata, 0, sizeof(struct PortMappingParserData));
        !           135:        LIST_INIT(&(pdata->head));
        !           136:        /* init xmlparser */
        !           137:        parser.xmlstart = buffer;
        !           138:        parser.xmlsize = bufsize;
        !           139:        parser.data = pdata;
        !           140:        parser.starteltfunc = startelt;
        !           141:        parser.endeltfunc = endelt;
        !           142:        parser.datafunc = data;
        !           143:        parser.attfunc = 0;
        !           144:        parsexml(&parser);
        !           145: }
        !           146: 
        !           147: void
        !           148: FreePortListing(struct PortMappingParserData * pdata)
        !           149: {
        !           150:        struct PortMapping * pm;
        !           151:        while((pm = pdata->head.lh_first) != NULL)
        !           152:        {
        !           153:                LIST_REMOVE(pm, entries);
        !           154:                free(pm);
        !           155:        }
        !           156: }
        !           157: