source: trunk/third-party/miniupnp/minixml.c @ 12593

Last change on this file since 12593 was 12593, checked in by livings124, 10 years ago

#4387 Update miniupnpc to 1.6

File size: 5.3 KB
Line 
1/* $Id: minixml.c,v 1.9 2011/02/07 13:44:57 nanard Exp $ */
2/* minixml.c : the minimum size a xml parser can be ! */
3/* Project : miniupnp
4 * webpage: http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
5 * Author : Thomas Bernard
6
7Copyright (c) 2005-2011, Thomas BERNARD
8All rights reserved.
9
10Redistribution and use in source and binary forms, with or without
11modification, are permitted provided that the following conditions are met:
12
13    * Redistributions of source code must retain the above copyright notice,
14      this list of conditions and the following disclaimer.
15    * Redistributions in binary form must reproduce the above copyright notice,
16      this list of conditions and the following disclaimer in the documentation
17      and/or other materials provided with the distribution.
18    * The name of the author may not be used to endorse or promote products
19          derived from this software without specific prior written permission.
20
21THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
25LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31POSSIBILITY OF SUCH DAMAGE.
32*/
33#include <string.h>
34#include "minixml.h"
35
36/* parseatt : used to parse the argument list
37 * return 0 (false) in case of success and -1 (true) if the end
38 * of the xmlbuffer is reached. */
39static int parseatt(struct xmlparser * p)
40{
41        const char * attname;
42        int attnamelen;
43        const char * attvalue;
44        int attvaluelen;
45        while(p->xml < p->xmlend)
46        {
47                if(*p->xml=='/' || *p->xml=='>')
48                        return 0;
49                if( !IS_WHITE_SPACE(*p->xml) )
50                {
51                        char sep;
52                        attname = p->xml;
53                        attnamelen = 0;
54                        while(*p->xml!='=' && !IS_WHITE_SPACE(*p->xml) )
55                        {
56                                attnamelen++; p->xml++;
57                                if(p->xml >= p->xmlend)
58                                        return -1;
59                        }
60                        while(*(p->xml++) != '=')
61                        {
62                                if(p->xml >= p->xmlend)
63                                        return -1;
64                        }
65                        while(IS_WHITE_SPACE(*p->xml))
66                        {
67                                p->xml++;
68                                if(p->xml >= p->xmlend)
69                                        return -1;
70                        }
71                        sep = *p->xml;
72                        if(sep=='\'' || sep=='\"')
73                        {
74                                p->xml++;
75                                if(p->xml >= p->xmlend)
76                                        return -1;
77                                attvalue = p->xml;
78                                attvaluelen = 0;
79                                while(*p->xml != sep)
80                                {
81                                        attvaluelen++; p->xml++;
82                                        if(p->xml >= p->xmlend)
83                                                return -1;
84                                }
85                        }
86                        else
87                        {
88                                attvalue = p->xml;
89                                attvaluelen = 0;
90                                while(   !IS_WHITE_SPACE(*p->xml)
91                                          && *p->xml != '>' && *p->xml != '/')
92                                {
93                                        attvaluelen++; p->xml++;
94                                        if(p->xml >= p->xmlend)
95                                                return -1;
96                                }
97                        }
98                        /*printf("%.*s='%.*s'\n",
99                               attnamelen, attname, attvaluelen, attvalue);*/
100                        if(p->attfunc)
101                                p->attfunc(p->data, attname, attnamelen, attvalue, attvaluelen);
102                }
103                p->xml++;
104        }
105        return -1;
106}
107
108/* parseelt parse the xml stream and
109 * call the callback functions when needed... */
110static void parseelt(struct xmlparser * p)
111{
112        int i;
113        const char * elementname;
114        while(p->xml < (p->xmlend - 1))
115        {
116                if((p->xml)[0]=='<' && (p->xml)[1]!='?')
117                {
118                        i = 0; elementname = ++p->xml;
119                        while( !IS_WHITE_SPACE(*p->xml)
120                                  && (*p->xml!='>') && (*p->xml!='/')
121                                 )
122                        {
123                                i++; p->xml++;
124                                if (p->xml >= p->xmlend)
125                                        return;
126                                /* to ignore namespace : */
127                                if(*p->xml==':')
128                                {
129                                        i = 0;
130                                        elementname = ++p->xml;
131                                }
132                        }
133                        if(i>0)
134                        {
135                                if(p->starteltfunc)
136                                        p->starteltfunc(p->data, elementname, i);
137                                if(parseatt(p))
138                                        return;
139                                if(*p->xml!='/')
140                                {
141                                        const char * data;
142                                        i = 0; data = ++p->xml;
143                                        if (p->xml >= p->xmlend)
144                                                return;
145                                        while( IS_WHITE_SPACE(*p->xml) )
146                                        {
147                                                i++; p->xml++;
148                                                if (p->xml >= p->xmlend)
149                                                        return;
150                                        }
151                                        if(memcmp(p->xml, "<![CDATA[", 9) == 0)
152                                        { 
153                                                /* CDATA handling */
154                                                p->xml += 9;
155                                                data = p->xml;
156                                                i = 0;
157                                                while(memcmp(p->xml, "]]>", 3) != 0)
158                                                {
159                                                        i++; p->xml++;
160                                                        if ((p->xml + 3) >= p->xmlend)
161                                                                return;
162                                                }
163                                                if(i>0 && p->datafunc)
164                                                        p->datafunc(p->data, data, i);
165                                                while(*p->xml!='<')
166                                                {
167                                                        p->xml++;
168                                                        if (p->xml >= p->xmlend)
169                                                                return;
170                                                }
171                                        }
172                                        else
173                                        {
174                                                while(*p->xml!='<')
175                                                {
176                                                        i++; p->xml++;
177                                                        if ((p->xml + 1) >= p->xmlend)
178                                                                return;
179                                                }
180                                                if(i>0 && p->datafunc && *(p->xml + 1) == '/')
181                                                        p->datafunc(p->data, data, i);
182                                        }
183                                }
184                        }
185                        else if(*p->xml == '/')
186                        {
187                                i = 0; elementname = ++p->xml;
188                                if (p->xml >= p->xmlend)
189                                        return;
190                                while((*p->xml != '>'))
191                                {
192                                        i++; p->xml++;
193                                        if (p->xml >= p->xmlend)
194                                                return;
195                                }
196                                if(p->endeltfunc)
197                                        p->endeltfunc(p->data, elementname, i);
198                                p->xml++;
199                        }
200                }
201                else
202                {
203                        p->xml++;
204                }
205        }
206}
207
208/* the parser must be initialized before calling this function */
209void parsexml(struct xmlparser * parser)
210{
211        parser->xml = parser->xmlstart;
212        parser->xmlend = parser->xmlstart + parser->xmlsize;
213        parseelt(parser);
214}
215
216
Note: See TracBrowser for help on using the repository browser.