PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/soap - php_xml.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 144 162 88.9 %
Date: 2015-07-26 Functions: 15 16 93.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :   +----------------------------------------------------------------------+
       3             :   | PHP Version 7                                                        |
       4             :   +----------------------------------------------------------------------+
       5             :   | Copyright (c) 1997-2015 The PHP Group                                |
       6             :   +----------------------------------------------------------------------+
       7             :   | This source file is subject to version 3.01 of the PHP license,      |
       8             :   | that is bundled with this package in the file LICENSE, and is        |
       9             :   | available through the world-wide-web at the following url:           |
      10             :   | http://www.php.net/license/3_01.txt                                  |
      11             :   | If you did not receive a copy of the PHP license and are unable to   |
      12             :   | obtain it through the world-wide-web, please send a note to          |
      13             :   | license@php.net so we can mail you a copy immediately.               |
      14             :   +----------------------------------------------------------------------+
      15             :   | Authors: Brad Lafountain <rodif_bl@yahoo.com>                        |
      16             :   |          Shane Caraveo <shane@caraveo.com>                           |
      17             :   |          Dmitry Stogov <dmitry@zend.com>                             |
      18             :   +----------------------------------------------------------------------+
      19             : */
      20             : /* $Id$ */
      21             : 
      22             : #include "php_soap.h"
      23             : #include "ext/libxml/php_libxml.h"
      24             : #include "libxml/parser.h"
      25             : #include "libxml/parserInternals.h"
      26             : 
      27             : /* Channel libxml file io layer through the PHP streams subsystem.
      28             :  * This allows use of ftps:// and https:// urls */
      29             : 
      30         507 : static int is_blank(const xmlChar* str)
      31             : {
      32        1783 :         while (*str != '\0') {
      33        1059 :                 if (*str != ' '  && *str != 0x9 && *str != 0xa && *str != 0xd) {
      34         290 :                         return 0;
      35             :                 }
      36         769 :                 str++;
      37             :         }
      38         217 :         return 1;
      39             : }
      40             : 
      41             : /* removes all empty text, comments and other insignoficant nodes */
      42       69552 : static void cleanup_xml_node(xmlNodePtr node)
      43             : {
      44             :         xmlNodePtr trav;
      45       69552 :         xmlNodePtr del = NULL;
      46             : 
      47       69552 :         trav = node->children;
      48      277924 :         while (trav != NULL) {
      49      138820 :                 if (del != NULL) {
      50           2 :                         xmlUnlinkNode(del);
      51           2 :                         xmlFreeNode(del);
      52           2 :                         del = NULL;
      53             :                 }
      54      138820 :                 if (trav->type == XML_TEXT_NODE) {
      55         507 :                         if (is_blank(trav->content)) {
      56         217 :                                 del = trav;
      57             :                         }
      58      138317 :                 } else if ((trav->type != XML_ELEMENT_NODE) &&
      59           2 :                            (trav->type != XML_CDATA_SECTION_NODE)) {
      60           2 :                         del = trav;
      61      138311 :                 } else if (trav->children != NULL) {
      62       68819 :                         cleanup_xml_node(trav);
      63             :                 }
      64      138820 :                 trav = trav->next;
      65             :         }
      66       69552 :         if (del != NULL) {
      67         217 :                 xmlUnlinkNode(del);
      68         217 :                 xmlFreeNode(del);
      69             :         }
      70       69552 : }
      71             : 
      72      213174 : static void soap_ignorableWhitespace(void *ctx, const xmlChar *ch, int len)
      73             : {
      74      213174 : }
      75             : 
      76        6212 : static void soap_Comment(void *ctx, const xmlChar *value)
      77             : {
      78        6212 : }
      79             : 
      80         735 : xmlDocPtr soap_xmlParseFile(const char *filename)
      81             : {
      82         735 :         xmlParserCtxtPtr ctxt = NULL;
      83             :         xmlDocPtr ret;
      84             :         zend_bool old_allow_url_fopen;
      85             : 
      86             : /*
      87             :         xmlInitParser();
      88             : */
      89             : 
      90         735 :         old_allow_url_fopen = PG(allow_url_fopen);
      91         735 :         PG(allow_url_fopen) = 1;
      92         735 :         ctxt = xmlCreateFileParserCtxt(filename);
      93         735 :         PG(allow_url_fopen) = old_allow_url_fopen;
      94         735 :         if (ctxt) {
      95             :                 zend_bool old;
      96             : 
      97         734 :                 ctxt->keepBlanks = 0;
      98         734 :                 ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
      99         734 :                 ctxt->sax->comment = soap_Comment;
     100         734 :                 ctxt->sax->warning = NULL;
     101         734 :                 ctxt->sax->error = NULL;
     102             :                 /*ctxt->sax->fatalError = NULL;*/
     103             : #if LIBXML_VERSION >= 20703
     104         734 :                 ctxt->options |= XML_PARSE_HUGE;
     105             : #endif
     106         734 :                 old = php_libxml_disable_entity_loader(1);
     107         734 :                 xmlParseDocument(ctxt);
     108         734 :                 php_libxml_disable_entity_loader(old);
     109         734 :                 if (ctxt->wellFormed) {
     110         733 :                         ret = ctxt->myDoc;
     111         733 :                         if (ret->URL == NULL && ctxt->directory != NULL) {
     112           0 :                                 ret->URL = xmlCharStrdup(ctxt->directory);
     113             :                         }
     114             :                 } else {
     115           1 :                         ret = NULL;
     116           1 :                         xmlFreeDoc(ctxt->myDoc);
     117           1 :                         ctxt->myDoc = NULL;
     118             :                 }
     119         734 :                 xmlFreeParserCtxt(ctxt);
     120             :         } else {
     121           1 :                 ret = NULL;
     122             :         }
     123             : 
     124             : /*
     125             :         xmlCleanupParser();
     126             : */
     127             : 
     128         735 :         if (ret) {
     129         733 :                 cleanup_xml_node((xmlNodePtr)ret);
     130             :         }
     131         735 :         return ret;
     132             : }
     133             : 
     134         549 : xmlDocPtr soap_xmlParseMemory(const void *buf, size_t buf_size)
     135             : {
     136         549 :         xmlParserCtxtPtr ctxt = NULL;
     137             :         xmlDocPtr ret;
     138             : 
     139             : 
     140             : /*
     141             :         xmlInitParser();
     142             : */
     143         549 :         ctxt = xmlCreateMemoryParserCtxt(buf, buf_size);
     144         549 :         if (ctxt) {
     145             :                 zend_bool old;
     146             : 
     147         549 :                 ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
     148         549 :                 ctxt->sax->comment = soap_Comment;
     149         549 :                 ctxt->sax->warning = NULL;
     150         549 :                 ctxt->sax->error = NULL;
     151             :                 /*ctxt->sax->fatalError = NULL;*/
     152             : #if LIBXML_VERSION >= 20703
     153         549 :                 ctxt->options |= XML_PARSE_HUGE;
     154             : #endif
     155         549 :                 old = php_libxml_disable_entity_loader(1);
     156         549 :                 xmlParseDocument(ctxt);
     157         549 :                 php_libxml_disable_entity_loader(old);
     158         549 :                 if (ctxt->wellFormed) {
     159         548 :                         ret = ctxt->myDoc;
     160         548 :                         if (ret->URL == NULL && ctxt->directory != NULL) {
     161           0 :                                 ret->URL = xmlCharStrdup(ctxt->directory);
     162             :                         }
     163             :                 } else {
     164           1 :                         ret = NULL;
     165           1 :                         xmlFreeDoc(ctxt->myDoc);
     166           1 :                         ctxt->myDoc = NULL;
     167             :                 }
     168         549 :                 xmlFreeParserCtxt(ctxt);
     169             :         } else {
     170           0 :                 ret = NULL;
     171             :         }
     172             : 
     173             : /*
     174             :         xmlCleanupParser();
     175             : */
     176             : 
     177             : /*
     178             :         if (ret) {
     179             :                 cleanup_xml_node((xmlNodePtr)ret);
     180             :         }
     181             : */
     182         549 :         return ret;
     183             : }
     184             : 
     185        7423 : xmlNsPtr attr_find_ns(xmlAttrPtr node)
     186             : {
     187        7423 :         if (node->ns) {
     188        4584 :                 return node->ns;
     189        2839 :         } else if (node->parent->ns) {
     190        2839 :                 return node->parent->ns;
     191             :         } else {
     192           0 :                 return xmlSearchNs(node->doc, node->parent, NULL);
     193             :         }
     194             : }
     195             : 
     196      156320 : xmlNsPtr node_find_ns(xmlNodePtr node)
     197             : {
     198      156320 :         if (node->ns) {
     199      156320 :                 return node->ns;
     200             :         } else {
     201           0 :                 return xmlSearchNs(node->doc, node, NULL);
     202             :         }
     203             : }
     204             : 
     205      728440 : int attr_is_equal_ex(xmlAttrPtr node, char *name, char *ns)
     206             : {
     207      728440 :         if (name == NULL || strcmp((char*)node->name, name) == 0) {
     208      271579 :                 if (ns) {
     209        6379 :                         xmlNsPtr nsPtr = attr_find_ns(node);
     210        6379 :                         if (nsPtr) {
     211        6379 :                                 return (strcmp((char*)nsPtr->href, ns) == 0);
     212             :                         } else {
     213           0 :                                 return FALSE;
     214             :                         }
     215             :                 }
     216      265200 :                 return TRUE;
     217             :         }
     218      456861 :         return FALSE;
     219             : }
     220             : 
     221      566280 : int node_is_equal_ex(xmlNodePtr node, char *name, char *ns)
     222             : {
     223      566280 :         if (name == NULL || strcmp((char*)node->name, name) == 0) {
     224      286464 :                 if (ns) {
     225      156320 :                         xmlNsPtr nsPtr = node_find_ns(node);
     226      156320 :                         if (nsPtr) {
     227      156320 :                                 return (strcmp((char*)nsPtr->href, ns) == 0);
     228             :                         } else {
     229           0 :                                 return FALSE;
     230             :                         }
     231             :                 }
     232      130144 :                 return TRUE;
     233             :         }
     234      279816 :         return FALSE;
     235             : }
     236             : 
     237             : 
     238      479977 : xmlAttrPtr get_attribute_ex(xmlAttrPtr node, char *name, char *ns)
     239             : {
     240     1395331 :         while (node!=NULL) {
     241      703895 :                 if (attr_is_equal_ex(node, name, ns)) {
     242      268518 :                         return node;
     243             :                 }
     244      435377 :                 node = node->next;
     245             :         }
     246      211459 :         return NULL;
     247             : }
     248             : 
     249      114958 : xmlNodePtr get_node_ex(xmlNodePtr node, char *name, char *ns)
     250             : {
     251      267664 :         while (node!=NULL) {
     252      151073 :                 if (node_is_equal_ex(node, name, ns)) {
     253      113325 :                         return node;
     254             :                 }
     255       37748 :                 node = node->next;
     256             :         }
     257        1633 :         return NULL;
     258             : }
     259             : 
     260           0 : xmlNodePtr get_node_recurisve_ex(xmlNodePtr node, char *name, char *ns)
     261             : {
     262           0 :         while (node != NULL) {
     263           0 :                 if (node_is_equal_ex(node, name, ns)) {
     264           0 :                         return node;
     265           0 :                 } else if (node->children != NULL) {
     266           0 :                         xmlNodePtr tmp = get_node_recurisve_ex(node->children, name, ns);
     267           0 :                         if (tmp) {
     268           0 :                                 return tmp;
     269             :                         }
     270             :                 }
     271           0 :                 node = node->next;
     272             :         }
     273           0 :         return NULL;
     274             : }
     275             : 
     276       10433 : xmlNodePtr get_node_with_attribute_ex(xmlNodePtr node, char *name, char *name_ns, char *attribute, char *value, char *attr_ns)
     277             : {
     278             :         xmlAttrPtr attr;
     279             : 
     280       80987 :         while (node != NULL) {
     281       70554 :                 if (name != NULL) {
     282       70554 :                         node = get_node_ex(node, name, name_ns);
     283       70554 :                         if (node==NULL) {
     284          34 :                                 return NULL;
     285             :                         }
     286             :                 }
     287             : 
     288       70520 :                 attr = get_attribute_ex(node->properties, attribute, attr_ns);
     289       70520 :                 if (attr != NULL && strcmp((char*)attr->children->content, value) == 0) {
     290       10399 :                         return node;
     291             :                 }
     292       60121 :                 node = node->next;
     293             :         }
     294           0 :         return NULL;
     295             : }
     296             : 
     297       18961 : xmlNodePtr get_node_with_attribute_recursive_ex(xmlNodePtr node, char *name, char *name_ns, char *attribute, char *value, char *attr_ns)
     298             : {
     299       70238 :         while (node != NULL) {
     300       32990 :                 if (node_is_equal_ex(node, name, name_ns)) {
     301       32990 :                         xmlAttrPtr attr = get_attribute_ex(node->properties, attribute, attr_ns);
     302       32990 :                         if (attr != NULL && strcmp((char*)attr->children->content, value) == 0) {
     303         222 :                                 return node;
     304             :                         }
     305             :                 }
     306       32768 :                 if (node->children != NULL) {
     307       18738 :                         xmlNodePtr tmp = get_node_with_attribute_recursive_ex(node->children, name, name_ns, attribute, value, attr_ns);
     308       18738 :                         if (tmp) {
     309         452 :                                 return tmp;
     310             :                         }
     311             :                 }
     312       32316 :                 node = node->next;
     313             :         }
     314       18287 :         return NULL;
     315             : }
     316             : 
     317       36651 : int parse_namespace(const xmlChar *inval, char **value, char **namespace)
     318             : {
     319       36651 :         char *found = strrchr((char*)inval, ':');
     320             : 
     321       71834 :         if (found != NULL && found != (char*)inval) {
     322       35183 :                 (*namespace) = estrndup((char*)inval, found - (char*)inval);
     323       35183 :                 (*value) = estrdup(++found);
     324             :         } else {
     325        1468 :                 (*value) = estrdup((char*)inval);
     326        1468 :                 (*namespace) = NULL;
     327             :         }
     328             : 
     329       36651 :         return FALSE;
     330             : }

Generated by: LCOV version 1.10

Generated at Mon, 27 Jul 2015 02:32:26 +0000 (3 days ago)

Copyright © 2005-2015 The PHP Group
All rights reserved.