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: 143 161 88.8 %
Date: 2014-09-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      213002 : static void soap_ignorableWhitespace(void *ctx, const xmlChar *ch, int len)
      73             : {
      74      213002 : }
      75             : 
      76        6210 : static void soap_Comment(void *ctx, const xmlChar *value)
      77             : {
      78        6210 : }
      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         728 :                 old = php_libxml_disable_entity_loader(1 TSRMLS_CC);
     104         728 :                 xmlParseDocument(ctxt);
     105         728 :                 php_libxml_disable_entity_loader(old TSRMLS_CC);
     106         728 :                 if (ctxt->wellFormed) {
     107         727 :                         ret = ctxt->myDoc;
     108         727 :                         if (ret->URL == NULL && ctxt->directory != NULL) {
     109           0 :                                 ret->URL = xmlCharStrdup(ctxt->directory);
     110             :                         }
     111             :                 } else {
     112           1 :                         ret = NULL;
     113           1 :                         xmlFreeDoc(ctxt->myDoc);
     114           1 :                         ctxt->myDoc = NULL;
     115             :                 }
     116         728 :                 xmlFreeParserCtxt(ctxt);
     117             :         } else {
     118           1 :                 ret = NULL;
     119             :         }
     120             : 
     121             : /*
     122             :         xmlCleanupParser();
     123             : */
     124             : 
     125         729 :         if (ret) {
     126         727 :                 cleanup_xml_node((xmlNodePtr)ret);
     127             :         }
     128         729 :         return ret;
     129             : }
     130             : 
     131         549 : xmlDocPtr soap_xmlParseMemory(const void *buf, size_t buf_size)
     132             : {
     133         549 :         xmlParserCtxtPtr ctxt = NULL;
     134             :         xmlDocPtr ret;
     135             : 
     136             :         TSRMLS_FETCH();
     137             : 
     138             : /*
     139             :         xmlInitParser();
     140             : */
     141         549 :         ctxt = xmlCreateMemoryParserCtxt(buf, buf_size);
     142         549 :         if (ctxt) {
     143             :                 zend_bool old;
     144             : 
     145         549 :                 ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
     146         549 :                 ctxt->sax->comment = soap_Comment;
     147         549 :                 ctxt->sax->warning = NULL;
     148         549 :                 ctxt->sax->error = NULL;
     149             :                 /*ctxt->sax->fatalError = NULL;*/
     150             : #if LIBXML_VERSION >= 20703
     151         549 :                 ctxt->options |= XML_PARSE_HUGE;
     152             : #endif
     153         549 :                 old = php_libxml_disable_entity_loader(1 TSRMLS_CC);
     154         549 :                 xmlParseDocument(ctxt);
     155         549 :                 php_libxml_disable_entity_loader(old TSRMLS_CC);
     156         549 :                 if (ctxt->wellFormed) {
     157         548 :                         ret = ctxt->myDoc;
     158         548 :                         if (ret->URL == NULL && ctxt->directory != NULL) {
     159           0 :                                 ret->URL = xmlCharStrdup(ctxt->directory);
     160             :                         }
     161             :                 } else {
     162           1 :                         ret = NULL;
     163           1 :                         xmlFreeDoc(ctxt->myDoc);
     164           1 :                         ctxt->myDoc = NULL;
     165             :                 }
     166         549 :                 xmlFreeParserCtxt(ctxt);
     167             :         } else {
     168           0 :                 ret = NULL;
     169             :         }
     170             : 
     171             : /*
     172             :         xmlCleanupParser();
     173             : */
     174             : 
     175             : /*
     176             :         if (ret) {
     177             :                 cleanup_xml_node((xmlNodePtr)ret);
     178             :         }
     179             : */
     180         549 :         return ret;
     181             : }
     182             : 
     183        7421 : xmlNsPtr attr_find_ns(xmlAttrPtr node)
     184             : {
     185        7421 :         if (node->ns) {
     186        4584 :                 return node->ns;
     187        2837 :         } else if (node->parent->ns) {
     188        2837 :                 return node->parent->ns;
     189             :         } else {
     190           0 :                 return xmlSearchNs(node->doc, node->parent, NULL);
     191             :         }
     192             : }
     193             : 
     194      156246 : xmlNsPtr node_find_ns(xmlNodePtr node)
     195             : {
     196      156246 :         if (node->ns) {
     197      156246 :                 return node->ns;
     198             :         } else {
     199           0 :                 return xmlSearchNs(node->doc, node, NULL);
     200             :         }
     201             : }
     202             : 
     203      743359 : int attr_is_equal_ex(xmlAttrPtr node, char *name, char *ns)
     204             : {
     205      743359 :         if (name == NULL || strcmp((char*)node->name, name) == 0) {
     206      271867 :                 if (ns) {
     207        6378 :                         xmlNsPtr nsPtr = attr_find_ns(node);
     208        6378 :                         if (nsPtr) {
     209        6378 :                                 return (strcmp((char*)nsPtr->href, ns) == 0);
     210             :                         } else {
     211           0 :                                 return FALSE;
     212             :                         }
     213             :                 }
     214      265489 :                 return TRUE;
     215             :         }
     216      471492 :         return FALSE;
     217             : }
     218             : 
     219      565917 : int node_is_equal_ex(xmlNodePtr node, char *name, char *ns)
     220             : {
     221      565917 :         if (name == NULL || strcmp((char*)node->name, name) == 0) {
     222      286312 :                 if (ns) {
     223      156246 :                         xmlNsPtr nsPtr = node_find_ns(node);
     224      156246 :                         if (nsPtr) {
     225      156246 :                                 return (strcmp((char*)nsPtr->href, ns) == 0);
     226             :                         } else {
     227           0 :                                 return FALSE;
     228             :                         }
     229             :                 }
     230      130066 :                 return TRUE;
     231             :         }
     232      279605 :         return FALSE;
     233             : }
     234             : 
     235             : 
     236      494625 : xmlAttrPtr get_attribute_ex(xmlAttrPtr node, char *name, char *ns)
     237             : {
     238     1439271 :         while (node!=NULL) {
     239      718828 :                 if (attr_is_equal_ex(node, name, ns)) {
     240      268807 :                         return node;
     241             :                 }
     242      450021 :                 node = node->next;
     243             :         }
     244      225818 :         return NULL;
     245             : }
     246             : 
     247      114921 : xmlNodePtr get_node_ex(xmlNodePtr node, char *name, char *ns)
     248             : {
     249      267572 :         while (node!=NULL) {
     250      151020 :                 if (node_is_equal_ex(node, name, ns)) {
     251      113290 :                         return node;
     252             :                 }
     253       37730 :                 node = node->next;
     254             :         }
     255        1631 :         return NULL;
     256             : }
     257             : 
     258           0 : xmlNodePtr get_node_recurisve_ex(xmlNodePtr node, char *name, char *ns)
     259             : {
     260           0 :         while (node != NULL) {
     261           0 :                 if (node_is_equal_ex(node, name, ns)) {
     262           0 :                         return node;
     263           0 :                 } else if (node->children != NULL) {
     264           0 :                         xmlNodePtr tmp = get_node_recurisve_ex(node->children, name, ns);
     265           0 :                         if (tmp) {
     266           0 :                                 return tmp;
     267             :                         }
     268             :                 }
     269           0 :                 node = node->next;
     270             :         }
     271           0 :         return NULL;
     272             : }
     273             : 
     274       10429 : xmlNodePtr get_node_with_attribute_ex(xmlNodePtr node, char *name, char *name_ns, char *attribute, char *value, char *attr_ns)
     275             : {
     276             :         xmlAttrPtr attr;
     277             : 
     278       80978 :         while (node != NULL) {
     279       70549 :                 if (name != NULL) {
     280       70549 :                         node = get_node_ex(node, name, name_ns);
     281       70549 :                         if (node==NULL) {
     282          34 :                                 return NULL;
     283             :                         }
     284             :                 }
     285             : 
     286       70515 :                 attr = get_attribute_ex(node->properties, attribute, attr_ns);
     287       70515 :                 if (attr != NULL && strcmp((char*)attr->children->content, value) == 0) {
     288       10395 :                         return node;
     289             :                 }
     290       60120 :                 node = node->next;
     291             :         }
     292           0 :         return NULL;
     293             : }
     294             : 
     295       18961 : xmlNodePtr get_node_with_attribute_recursive_ex(xmlNodePtr node, char *name, char *name_ns, char *attribute, char *value, char *attr_ns)
     296             : {
     297       70238 :         while (node != NULL) {
     298       32990 :                 if (node_is_equal_ex(node, name, name_ns)) {
     299       32990 :                         xmlAttrPtr attr = get_attribute_ex(node->properties, attribute, attr_ns);
     300       32990 :                         if (attr != NULL && strcmp((char*)attr->children->content, value) == 0) {
     301         222 :                                 return node;
     302             :                         }
     303             :                 }
     304       32768 :                 if (node->children != NULL) {
     305       18738 :                         xmlNodePtr tmp = get_node_with_attribute_recursive_ex(node->children, name, name_ns, attribute, value, attr_ns);
     306       18738 :                         if (tmp) {
     307         452 :                                 return tmp;
     308             :                         }
     309             :                 }
     310       32316 :                 node = node->next;
     311             :         }
     312       18287 :         return NULL;
     313             : }
     314             : 
     315       36625 : int parse_namespace(const xmlChar *inval, char **value, char **namespace)
     316             : {
     317       36625 :         char *found = strrchr((char*)inval, ':');
     318             : 
     319       71782 :         if (found != NULL && found != (char*)inval) {
     320       35157 :                 (*namespace) = estrndup((char*)inval, found - (char*)inval);
     321       35157 :                 (*value) = estrdup(++found);
     322             :         } else {
     323        1468 :                 (*value) = estrdup((char*)inval);
     324        1468 :                 (*namespace) = NULL;
     325             :         }
     326             : 
     327       36625 :         return FALSE;
     328             : }

Generated by: LCOV version 1.10

Generated at Mon, 29 Sep 2014 14:26:29 +0000 (3 days ago)

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