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-06-29 Functions: 15 16 93.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :   +----------------------------------------------------------------------+
       3             :   | PHP Version 5                                                        |
       4             :   +----------------------------------------------------------------------+
       5             :   | Copyright (c) 1997-2014 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       69484 : static void cleanup_xml_node(xmlNodePtr node)
      43             : {
      44             :         xmlNodePtr trav;
      45       69484 :         xmlNodePtr del = NULL;
      46             : 
      47       69484 :         trav = node->children;
      48      277672 :         while (trav != NULL) {
      49      138704 :                 if (del != NULL) {
      50           2 :                         xmlUnlinkNode(del);
      51           2 :                         xmlFreeNode(del);
      52           2 :                         del = NULL;
      53             :                 }
      54      138704 :                 if (trav->type == XML_TEXT_NODE) {
      55         507 :                         if (is_blank(trav->content)) {
      56         217 :                                 del = trav;
      57             :                         }
      58      138201 :                 } else if ((trav->type != XML_ELEMENT_NODE) &&
      59           2 :                            (trav->type != XML_CDATA_SECTION_NODE)) {
      60           2 :                         del = trav;
      61      138195 :                 } else if (trav->children != NULL) {
      62       68757 :                         cleanup_xml_node(trav);
      63             :                 }
      64      138704 :                 trav = trav->next;
      65             :         }
      66       69484 :         if (del != NULL) {
      67         217 :                 xmlUnlinkNode(del);
      68         217 :                 xmlFreeNode(del);
      69             :         }
      70       69484 : }
      71             : 
      72      213004 : static void soap_ignorableWhitespace(void *ctx, const xmlChar *ch, int len)
      73             : {
      74      213004 : }
      75             : 
      76        6212 : static void soap_Comment(void *ctx, const xmlChar *value)
      77             : {
      78        6212 : }
      79             : 
      80         729 : xmlDocPtr soap_xmlParseFile(const char *filename TSRMLS_DC)
      81             : {
      82         729 :         xmlParserCtxtPtr ctxt = NULL;
      83             :         xmlDocPtr ret;
      84             :         zend_bool old_allow_url_fopen;
      85             : 
      86             : /*
      87             :         xmlInitParser();
      88             : */
      89             : 
      90         729 :         old_allow_url_fopen = PG(allow_url_fopen);
      91         729 :         PG(allow_url_fopen) = 1;
      92         729 :         ctxt = xmlCreateFileParserCtxt(filename);
      93         729 :         PG(allow_url_fopen) = old_allow_url_fopen;
      94         729 :         if (ctxt) {
      95             :                 zend_bool old;
      96             : 
      97         728 :                 ctxt->keepBlanks = 0;
      98         728 :                 ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
      99         728 :                 ctxt->sax->comment = soap_Comment;
     100         728 :                 ctxt->sax->warning = NULL;
     101         728 :                 ctxt->sax->error = NULL;
     102             :                 /*ctxt->sax->fatalError = NULL;*/
     103             : #if LIBXML_VERSION >= 20703
     104         728 :                 ctxt->options |= XML_PARSE_HUGE;
     105             : #endif
     106         728 :                 old = php_libxml_disable_entity_loader(1 TSRMLS_CC);
     107         728 :                 xmlParseDocument(ctxt);
     108         728 :                 php_libxml_disable_entity_loader(old TSRMLS_CC);
     109         728 :                 if (ctxt->wellFormed) {
     110         727 :                         ret = ctxt->myDoc;
     111         727 :                         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         728 :                 xmlFreeParserCtxt(ctxt);
     120             :         } else {
     121           1 :                 ret = NULL;
     122             :         }
     123             : 
     124             : /*
     125             :         xmlCleanupParser();
     126             : */
     127             : 
     128         729 :         if (ret) {
     129         727 :                 cleanup_xml_node((xmlNodePtr)ret);
     130             :         }
     131         729 :         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             :         TSRMLS_FETCH();
     140             : 
     141             : /*
     142             :         xmlInitParser();
     143             : */
     144         549 :         ctxt = xmlCreateMemoryParserCtxt(buf, buf_size);
     145         549 :         if (ctxt) {
     146             :                 zend_bool old;
     147             : 
     148         549 :                 ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
     149         549 :                 ctxt->sax->comment = soap_Comment;
     150         549 :                 ctxt->sax->warning = NULL;
     151         549 :                 ctxt->sax->error = NULL;
     152             :                 /*ctxt->sax->fatalError = NULL;*/
     153             : #if LIBXML_VERSION >= 20703
     154         549 :                 ctxt->options |= XML_PARSE_HUGE;
     155             : #endif
     156         549 :                 old = php_libxml_disable_entity_loader(1 TSRMLS_CC);
     157         549 :                 xmlParseDocument(ctxt);
     158         549 :                 php_libxml_disable_entity_loader(old TSRMLS_CC);
     159         549 :                 if (ctxt->wellFormed) {
     160         548 :                         ret = ctxt->myDoc;
     161         548 :                         if (ret->URL == NULL && ctxt->directory != NULL) {
     162           0 :                                 ret->URL = xmlCharStrdup(ctxt->directory);
     163             :                         }
     164             :                 } else {
     165           1 :                         ret = NULL;
     166           1 :                         xmlFreeDoc(ctxt->myDoc);
     167           1 :                         ctxt->myDoc = NULL;
     168             :                 }
     169         549 :                 xmlFreeParserCtxt(ctxt);
     170             :         } else {
     171           0 :                 ret = NULL;
     172             :         }
     173             : 
     174             : /*
     175             :         xmlCleanupParser();
     176             : */
     177             : 
     178             : /*
     179             :         if (ret) {
     180             :                 cleanup_xml_node((xmlNodePtr)ret);
     181             :         }
     182             : */
     183         549 :         return ret;
     184             : }
     185             : 
     186        7421 : xmlNsPtr attr_find_ns(xmlAttrPtr node)
     187             : {
     188        7421 :         if (node->ns) {
     189        4584 :                 return node->ns;
     190        2837 :         } else if (node->parent->ns) {
     191        2837 :                 return node->parent->ns;
     192             :         } else {
     193           0 :                 return xmlSearchNs(node->doc, node->parent, NULL);
     194             :         }
     195             : }
     196             : 
     197      156246 : xmlNsPtr node_find_ns(xmlNodePtr node)
     198             : {
     199      156246 :         if (node->ns) {
     200      156246 :                 return node->ns;
     201             :         } else {
     202           0 :                 return xmlSearchNs(node->doc, node, NULL);
     203             :         }
     204             : }
     205             : 
     206      743359 : int attr_is_equal_ex(xmlAttrPtr node, char *name, char *ns)
     207             : {
     208      743359 :         if (name == NULL || strcmp((char*)node->name, name) == 0) {
     209      271867 :                 if (ns) {
     210        6378 :                         xmlNsPtr nsPtr = attr_find_ns(node);
     211        6378 :                         if (nsPtr) {
     212        6378 :                                 return (strcmp((char*)nsPtr->href, ns) == 0);
     213             :                         } else {
     214           0 :                                 return FALSE;
     215             :                         }
     216             :                 }
     217      265489 :                 return TRUE;
     218             :         }
     219      471492 :         return FALSE;
     220             : }
     221             : 
     222      565917 : int node_is_equal_ex(xmlNodePtr node, char *name, char *ns)
     223             : {
     224      565917 :         if (name == NULL || strcmp((char*)node->name, name) == 0) {
     225      286312 :                 if (ns) {
     226      156246 :                         xmlNsPtr nsPtr = node_find_ns(node);
     227      156246 :                         if (nsPtr) {
     228      156246 :                                 return (strcmp((char*)nsPtr->href, ns) == 0);
     229             :                         } else {
     230           0 :                                 return FALSE;
     231             :                         }
     232             :                 }
     233      130066 :                 return TRUE;
     234             :         }
     235      279605 :         return FALSE;
     236             : }
     237             : 
     238             : 
     239      494625 : xmlAttrPtr get_attribute_ex(xmlAttrPtr node, char *name, char *ns)
     240             : {
     241     1439271 :         while (node!=NULL) {
     242      718828 :                 if (attr_is_equal_ex(node, name, ns)) {
     243      268807 :                         return node;
     244             :                 }
     245      450021 :                 node = node->next;
     246             :         }
     247      225818 :         return NULL;
     248             : }
     249             : 
     250      114921 : xmlNodePtr get_node_ex(xmlNodePtr node, char *name, char *ns)
     251             : {
     252      267572 :         while (node!=NULL) {
     253      151020 :                 if (node_is_equal_ex(node, name, ns)) {
     254      113290 :                         return node;
     255             :                 }
     256       37730 :                 node = node->next;
     257             :         }
     258        1631 :         return NULL;
     259             : }
     260             : 
     261           0 : xmlNodePtr get_node_recurisve_ex(xmlNodePtr node, char *name, char *ns)
     262             : {
     263           0 :         while (node != NULL) {
     264           0 :                 if (node_is_equal_ex(node, name, ns)) {
     265           0 :                         return node;
     266           0 :                 } else if (node->children != NULL) {
     267           0 :                         xmlNodePtr tmp = get_node_recurisve_ex(node->children, name, ns);
     268           0 :                         if (tmp) {
     269           0 :                                 return tmp;
     270             :                         }
     271             :                 }
     272           0 :                 node = node->next;
     273             :         }
     274           0 :         return NULL;
     275             : }
     276             : 
     277       10429 : xmlNodePtr get_node_with_attribute_ex(xmlNodePtr node, char *name, char *name_ns, char *attribute, char *value, char *attr_ns)
     278             : {
     279             :         xmlAttrPtr attr;
     280             : 
     281       80978 :         while (node != NULL) {
     282       70549 :                 if (name != NULL) {
     283       70549 :                         node = get_node_ex(node, name, name_ns);
     284       70549 :                         if (node==NULL) {
     285          34 :                                 return NULL;
     286             :                         }
     287             :                 }
     288             : 
     289       70515 :                 attr = get_attribute_ex(node->properties, attribute, attr_ns);
     290       70515 :                 if (attr != NULL && strcmp((char*)attr->children->content, value) == 0) {
     291       10395 :                         return node;
     292             :                 }
     293       60120 :                 node = node->next;
     294             :         }
     295           0 :         return NULL;
     296             : }
     297             : 
     298       18961 : xmlNodePtr get_node_with_attribute_recursive_ex(xmlNodePtr node, char *name, char *name_ns, char *attribute, char *value, char *attr_ns)
     299             : {
     300       70238 :         while (node != NULL) {
     301       32990 :                 if (node_is_equal_ex(node, name, name_ns)) {
     302       32990 :                         xmlAttrPtr attr = get_attribute_ex(node->properties, attribute, attr_ns);
     303       32990 :                         if (attr != NULL && strcmp((char*)attr->children->content, value) == 0) {
     304         222 :                                 return node;
     305             :                         }
     306             :                 }
     307       32768 :                 if (node->children != NULL) {
     308       18738 :                         xmlNodePtr tmp = get_node_with_attribute_recursive_ex(node->children, name, name_ns, attribute, value, attr_ns);
     309       18738 :                         if (tmp) {
     310         452 :                                 return tmp;
     311             :                         }
     312             :                 }
     313       32316 :                 node = node->next;
     314             :         }
     315       18287 :         return NULL;
     316             : }
     317             : 
     318       36625 : int parse_namespace(const xmlChar *inval, char **value, char **namespace)
     319             : {
     320       36625 :         char *found = strrchr((char*)inval, ':');
     321             : 
     322       71782 :         if (found != NULL && found != (char*)inval) {
     323       35157 :                 (*namespace) = estrndup((char*)inval, found - (char*)inval);
     324       35157 :                 (*value) = estrdup(++found);
     325             :         } else {
     326        1468 :                 (*value) = estrdup((char*)inval);
     327        1468 :                 (*namespace) = NULL;
     328             :         }
     329             : 
     330       36625 :         return FALSE;
     331             : }

Generated by: LCOV version 1.10

Generated at Mon, 29 Jun 2015 08:36:57 +0000 (2 days ago)

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