Annotation of embedaddon/miniupnpd/miniupnpc-async/upnpreplyparse.c, revision 1.1.1.1
1.1 misho 1: /* $Id: upnpreplyparse.c,v 1.20 2017/12/12 11:26:25 nanard Exp $ */
2: /* vim: tabstop=4 shiftwidth=4 noexpandtab
3: * MiniUPnP project
4: * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
5: * (c) 2006-2019 Thomas Bernard
6: * This software is subject to the conditions detailed
7: * in the LICENCE file provided within the distribution */
8:
9: #include <stdlib.h>
10: #include <string.h>
11: #include <stdio.h>
12:
13: #include "upnpreplyparse.h"
14: #include "minixml.h"
15:
16: static void
17: NameValueParserStartElt(void * d, const char * name, int l)
18: {
19: struct NameValueParserData * data = (struct NameValueParserData *)d;
20: data->topelt = 1;
21: if(l>63)
22: l = 63;
23: memcpy(data->curelt, name, l);
24: data->curelt[l] = '\0';
25: data->cdata = NULL;
26: data->cdatalen = 0;
27: }
28:
29: static void
30: NameValueParserEndElt(void * d, const char * name, int namelen)
31: {
32: struct NameValueParserData * data = (struct NameValueParserData *)d;
33: struct NameValue * nv;
34: (void)name;
35: (void)namelen;
36: if(!data->topelt)
37: return;
38: if(strcmp(data->curelt, "NewPortListing") != 0)
39: {
40: int l;
41: /* standard case. Limited to n chars strings */
42: l = data->cdatalen;
43: nv = malloc(sizeof(struct NameValue));
44: if(nv == NULL)
45: {
46: /* malloc error */
47: #ifdef DEBUG
48: fprintf(stderr, "%s: error allocating memory",
49: "NameValueParserEndElt");
50: #endif /* DEBUG */
51: return;
52: }
53: if(l>=(int)sizeof(nv->value))
54: l = sizeof(nv->value) - 1;
55: strncpy(nv->name, data->curelt, 64);
56: nv->name[63] = '\0';
57: if(data->cdata != NULL)
58: {
59: memcpy(nv->value, data->cdata, l);
60: nv->value[l] = '\0';
61: }
62: else
63: {
64: nv->value[0] = '\0';
65: }
66: nv->l_next = data->l_head; /* insert in list */
67: data->l_head = nv;
68: }
69: data->cdata = NULL;
70: data->cdatalen = 0;
71: data->topelt = 0;
72: }
73:
74: static void
75: NameValueParserGetData(void * d, const char * datas, int l)
76: {
77: struct NameValueParserData * data = (struct NameValueParserData *)d;
78: if(strcmp(data->curelt, "NewPortListing") == 0)
79: {
80: /* specific case for NewPortListing which is a XML Document */
81: free(data->portListing);
82: data->portListing = malloc(l + 1);
83: if(!data->portListing)
84: {
85: /* malloc error */
86: #ifdef DEBUG
87: fprintf(stderr, "%s: error allocating memory",
88: "NameValueParserGetData");
89: #endif /* DEBUG */
90: return;
91: }
92: memcpy(data->portListing, datas, l);
93: data->portListing[l] = '\0';
94: data->portListingLength = l;
95: }
96: else
97: {
98: /* standard case. */
99: data->cdata = datas;
100: data->cdatalen = l;
101: }
102: }
103:
104: void
105: ParseNameValue(const char * buffer, int bufsize,
106: struct NameValueParserData * data)
107: {
108: struct xmlparser parser;
109: memset(data, 0, sizeof(struct NameValueParserData));
110: /* init xmlparser object */
111: parser.xmlstart = buffer;
112: parser.xmlsize = bufsize;
113: parser.data = data;
114: parser.starteltfunc = NameValueParserStartElt;
115: parser.endeltfunc = NameValueParserEndElt;
116: parser.datafunc = NameValueParserGetData;
117: parser.attfunc = 0;
118: parsexml(&parser);
119: }
120:
121: void
122: ClearNameValueList(struct NameValueParserData * pdata)
123: {
124: struct NameValue * nv;
125: if(pdata->portListing)
126: {
127: free(pdata->portListing);
128: pdata->portListing = NULL;
129: pdata->portListingLength = 0;
130: }
131: while((nv = pdata->l_head) != NULL)
132: {
133: pdata->l_head = nv->l_next;
134: free(nv);
135: }
136: }
137:
138: char *
139: GetValueFromNameValueList(struct NameValueParserData * pdata,
140: const char * Name)
141: {
142: struct NameValue * nv;
143: char * p = NULL;
144: for(nv = pdata->l_head;
145: (nv != NULL) && (p == NULL);
146: nv = nv->l_next)
147: {
148: if(strcmp(nv->name, Name) == 0)
149: p = nv->value;
150: }
151: return p;
152: }
153:
154: #if 0
155: /* useless now that minixml ignores namespaces by itself */
156: char *
157: GetValueFromNameValueListIgnoreNS(struct NameValueParserData * pdata,
158: const char * Name)
159: {
160: struct NameValue * nv;
161: char * p = NULL;
162: char * pname;
163: for(nv = pdata->head.lh_first;
164: (nv != NULL) && (p == NULL);
165: nv = nv->entries.le_next)
166: {
167: pname = strrchr(nv->name, ':');
168: if(pname)
169: pname++;
170: else
171: pname = nv->name;
172: if(strcmp(pname, Name)==0)
173: p = nv->value;
174: }
175: return p;
176: }
177: #endif
178:
179: /* debug all-in-one function
180: * do parsing then display to stdout */
181: #ifdef DEBUG
182: void
183: DisplayNameValueList(char * buffer, int bufsize)
184: {
185: struct NameValueParserData pdata;
186: struct NameValue * nv;
187: ParseNameValue(buffer, bufsize, &pdata);
188: for(nv = pdata.l_head;
189: nv != NULL;
190: nv = nv->l_next)
191: {
192: printf("%s = %s\n", nv->name, nv->value);
193: }
194: ClearNameValueList(&pdata);
195: }
196: #endif /* DEBUG */
197:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to upnpreplyparse.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpd / miniupnpc-async