"Fossies" - the Fresh Open Source Software Archive

Member "minidlna-1.3.0/minixml.c" (24 Nov 2020, 4864 Bytes) of package /linux/privat/minidlna-1.3.0.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "minixml.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 1.2.1_vs_1.3.0.

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