Return to upnpreplyparse.c CVS log

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

Annotation of embedaddon/miniupnpd/upnpreplyparse.c, revision 1.1.1.1

1.1       misho       1: /* $Id: upnpreplyparse.c,v 1.10 2008/02/21 13:05:27 nanard Exp $ */
                      2: /* MiniUPnP project
                      3:  * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
                      4:  * (c) 2006 Thomas Bernard 
                      5:  * This software is subject to the conditions detailed
                      6:  * in the LICENCE file provided within the distribution */
                      7: 
                      8: #include <stdlib.h>
                      9: #include <string.h>
                     10: #include <stdio.h>
                     11: 
                     12: #include "upnpreplyparse.h"
                     13: #include "minixml.h"
                     14: 
                     15: static void
                     16: NameValueParserStartElt(void * d, const char * name, int l)
                     17: {
                     18:     struct NameValueParserData * data = (struct NameValueParserData *)d;
                     19:     if(l>63)
                     20:         l = 63;
                     21:     memcpy(data->curelt, name, l);
                     22:     data->curelt[l] = '\0';
                     23: }
                     24: 
                     25: static void
                     26: NameValueParserGetData(void * d, const char * datas, int l)
                     27: {
                     28:     struct NameValueParserData * data = (struct NameValueParserData *)d;
                     29:     struct NameValue * nv;
                     30:     nv = malloc(sizeof(struct NameValue));
                     31:     if(l>63)
                     32:         l = 63;
                     33:     strncpy(nv->name, data->curelt, 64);
                     34:        nv->name[63] = '\0';
                     35:     memcpy(nv->value, datas, l);
                     36:     nv->value[l] = '\0';
                     37:     LIST_INSERT_HEAD( &(data->head), nv, entries);
                     38: }
                     39: 
                     40: void
                     41: ParseNameValue(const char * buffer, int bufsize,
                     42:                     struct NameValueParserData * data)
                     43: {
                     44:     struct xmlparser parser;
                     45:     LIST_INIT(&(data->head));
                     46:     /* init xmlparser object */
                     47:     parser.xmlstart = buffer;
                     48:     parser.xmlsize = bufsize;
                     49:     parser.data = data;
                     50:     parser.starteltfunc = NameValueParserStartElt;
                     51:     parser.endeltfunc = 0;
                     52:     parser.datafunc = NameValueParserGetData;
                     53:        parser.attfunc = 0;
                     54:     parsexml(&parser);
                     55: }
                     56: 
                     57: void
                     58: ClearNameValueList(struct NameValueParserData * pdata)
                     59: {
                     60:     struct NameValue * nv;
                     61:     while((nv = pdata->head.lh_first) != NULL)
                     62:     {
                     63:         LIST_REMOVE(nv, entries);
                     64:         free(nv);
                     65:     }
                     66: }
                     67: 
                     68: char * 
                     69: GetValueFromNameValueList(struct NameValueParserData * pdata,
                     70:                           const char * Name)
                     71: {
                     72:     struct NameValue * nv;
                     73:     char * p = NULL;
                     74:     for(nv = pdata->head.lh_first;
                     75:         (nv != NULL) && (p == NULL);
                     76:         nv = nv->entries.le_next)
                     77:     {
                     78:         if(strcmp(nv->name, Name) == 0)
                     79:             p = nv->value;
                     80:     }
                     81:     return p;
                     82: }
                     83: 
                     84: #if 0
                     85: /* useless now that minixml ignores namespaces by itself */
                     86: char *
                     87: GetValueFromNameValueListIgnoreNS(struct NameValueParserData * pdata,
                     88:                                   const char * Name)
                     89: {
                     90:        struct NameValue * nv;
                     91:        char * p = NULL;
                     92:        char * pname;
                     93:        for(nv = pdata->head.lh_first;
                     94:            (nv != NULL) && (p == NULL);
                     95:                nv = nv->entries.le_next)
                     96:        {
                     97:                pname = strrchr(nv->name, ':');
                     98:                if(pname)
                     99:                        pname++;
                    100:                else
                    101:                        pname = nv->name;
                    102:                if(strcmp(pname, Name)==0)
                    103:                        p = nv->value;
                    104:        }
                    105:        return p;
                    106: }
                    107: #endif
                    108: 
                    109: /* debug all-in-one function 
                    110:  * do parsing then display to stdout */
                    111: #ifdef DEBUG
                    112: void
                    113: DisplayNameValueList(char * buffer, int bufsize)
                    114: {
                    115:     struct NameValueParserData pdata;
                    116:     struct NameValue * nv;
                    117:     ParseNameValue(buffer, bufsize, &pdata);
                    118:     for(nv = pdata.head.lh_first;
                    119:         nv != NULL;
                    120:         nv = nv->entries.le_next)
                    121:     {
                    122:         printf("%s = %s\n", nv->name, nv->value);
                    123:     }
                    124:     ClearNameValueList(&pdata);
                    125: }
                    126: #endif
                    127: