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-07-27 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-2013 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         548 : xmlDocPtr soap_xmlParseMemory(const void *buf, size_t buf_size)
     132             : {
     133         548 :         xmlParserCtxtPtr ctxt = NULL;
     134             :         xmlDocPtr ret;
     135             : 
     136             :         TSRMLS_FETCH();
     137             : 
     138             : /*
     139             :         xmlInitParser();
     140             : */
     141         548 :         ctxt = xmlCreateMemoryParserCtxt(buf, buf_size);
     142         548 :         if (ctxt) {
     143             :                 zend_bool old;
     144             : 
     145         548 :                 ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
     146         548 :                 ctxt->sax->comment = soap_Comment;
     147         548 :                 ctxt->sax->warning = NULL;
     148         548 :                 ctxt->sax->error = NULL;
     149             :                 /*ctxt->sax->fatalError = NULL;*/
     150             : #if LIBXML_VERSION >= 20703
     151         548 :                 ctxt->options |= XML_PARSE_HUGE;
     152             : #endif
     153         548 :                 old = php_libxml_disable_entity_loader(1 TSRMLS_CC);
     154         548 :                 xmlParseDocument(ctxt);
     155         548 :                 php_libxml_disable_entity_loader(old TSRMLS_CC);
     156         548 :                 if (ctxt->wellFormed) {
     157         547 :                         ret = ctxt->myDoc;
     158         547 :                         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         548 :                 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         548 :         return ret;
     181             : }
     182             : 
     183             : #ifndef ZEND_ENGINE_2
     184             : int php_stream_xmlIO_match_wrapper(const char *filename)
     185             : {
     186             :         TSRMLS_FETCH();
     187             :         return php_stream_locate_url_wrapper(filename, NULL, STREAM_LOCATE_WRAPPERS_ONLY TSRMLS_CC) ? 1 : 0;
     188             : }
     189             : 
     190             : void *php_stream_xmlIO_open_wrapper(const char *filename)
     191             : {
     192             :         TSRMLS_FETCH();
     193             :         return php_stream_open_wrapper((char*)filename, "rb", ENFORCE_SAFE_MODE|REPORT_ERRORS, NULL);
     194             : }
     195             : 
     196             : int php_stream_xmlIO_read(void *context, char *buffer, int len)
     197             : {
     198             :         TSRMLS_FETCH();
     199             :         return php_stream_read((php_stream*)context, buffer, len);
     200             : }
     201             : 
     202             : int php_stream_xmlIO_close(void *context)
     203             : {
     204             :         TSRMLS_FETCH();
     205             :         return php_stream_close((php_stream*)context);
     206             : }
     207             : #endif
     208             : 
     209        7420 : xmlNsPtr attr_find_ns(xmlAttrPtr node)
     210             : {
     211        7420 :         if (node->ns) {
     212        4584 :                 return node->ns;
     213        2836 :         } else if (node->parent->ns) {
     214        2836 :                 return node->parent->ns;
     215             :         } else {
     216           0 :                 return xmlSearchNs(node->doc, node->parent, NULL);
     217             :         }
     218             : }
     219             : 
     220      156243 : xmlNsPtr node_find_ns(xmlNodePtr node)
     221             : {
     222      156243 :         if (node->ns) {
     223      156243 :                 return node->ns;
     224             :         } else {
     225           0 :                 return xmlSearchNs(node->doc, node, NULL);
     226             :         }
     227             : }
     228             : 
     229      743338 : int attr_is_equal_ex(xmlAttrPtr node, char *name, char *ns)
     230             : {
     231      743338 :         if (name == NULL || strcmp((char*)node->name, name) == 0) {
     232      271866 :                 if (ns) {
     233        6377 :                         xmlNsPtr nsPtr = attr_find_ns(node);
     234        6377 :                         if (nsPtr) {
     235        6377 :                                 return (strcmp((char*)nsPtr->href, ns) == 0);
     236             :                         } else {
     237           0 :                                 return FALSE;
     238             :                         }
     239             :                 }
     240      265489 :                 return TRUE;
     241             :         }
     242      471472 :         return FALSE;
     243             : }
     244             : 
     245      565914 : int node_is_equal_ex(xmlNodePtr node, char *name, char *ns)
     246             : {
     247      565914 :         if (name == NULL || strcmp((char*)node->name, name) == 0) {
     248      286309 :                 if (ns) {
     249      156243 :                         xmlNsPtr nsPtr = node_find_ns(node);
     250      156243 :                         if (nsPtr) {
     251      156243 :                                 return (strcmp((char*)nsPtr->href, ns) == 0);
     252             :                         } else {
     253           0 :                                 return FALSE;
     254             :                         }
     255             :                 }
     256      130066 :                 return TRUE;
     257             :         }
     258      279605 :         return FALSE;
     259             : }
     260             : 
     261             : 
     262      494608 : xmlAttrPtr get_attribute_ex(xmlAttrPtr node, char *name, char *ns)
     263             : {
     264     1439216 :         while (node!=NULL) {
     265      718807 :                 if (attr_is_equal_ex(node, name, ns)) {
     266      268807 :                         return node;
     267             :                 }
     268      450000 :                 node = node->next;
     269             :         }
     270      225801 :         return NULL;
     271             : }
     272             : 
     273      114921 : xmlNodePtr get_node_ex(xmlNodePtr node, char *name, char *ns)
     274             : {
     275      267572 :         while (node!=NULL) {
     276      151020 :                 if (node_is_equal_ex(node, name, ns)) {
     277      113290 :                         return node;
     278             :                 }
     279       37730 :                 node = node->next;
     280             :         }
     281        1631 :         return NULL;
     282             : }
     283             : 
     284           0 : xmlNodePtr get_node_recurisve_ex(xmlNodePtr node, char *name, char *ns)
     285             : {
     286           0 :         while (node != NULL) {
     287           0 :                 if (node_is_equal_ex(node, name, ns)) {
     288           0 :                         return node;
     289           0 :                 } else if (node->children != NULL) {
     290           0 :                         xmlNodePtr tmp = get_node_recurisve_ex(node->children, name, ns);
     291           0 :                         if (tmp) {
     292           0 :                                 return tmp;
     293             :                         }
     294             :                 }
     295           0 :                 node = node->next;
     296             :         }
     297           0 :         return NULL;
     298             : }
     299             : 
     300       10429 : xmlNodePtr get_node_with_attribute_ex(xmlNodePtr node, char *name, char *name_ns, char *attribute, char *value, char *attr_ns)
     301             : {
     302             :         xmlAttrPtr attr;
     303             : 
     304       80978 :         while (node != NULL) {
     305       70549 :                 if (name != NULL) {
     306       70549 :                         node = get_node_ex(node, name, name_ns);
     307       70549 :                         if (node==NULL) {
     308          34 :                                 return NULL;
     309             :                         }
     310             :                 }
     311             : 
     312       70515 :                 attr = get_attribute_ex(node->properties, attribute, attr_ns);
     313       70515 :                 if (attr != NULL && strcmp((char*)attr->children->content, value) == 0) {
     314       10395 :                         return node;
     315             :                 }
     316       60120 :                 node = node->next;
     317             :         }
     318           0 :         return NULL;
     319             : }
     320             : 
     321       18961 : xmlNodePtr get_node_with_attribute_recursive_ex(xmlNodePtr node, char *name, char *name_ns, char *attribute, char *value, char *attr_ns)
     322             : {
     323       70238 :         while (node != NULL) {
     324       32990 :                 if (node_is_equal_ex(node, name, name_ns)) {
     325       32990 :                         xmlAttrPtr attr = get_attribute_ex(node->properties, attribute, attr_ns);
     326       32990 :                         if (attr != NULL && strcmp((char*)attr->children->content, value) == 0) {
     327         222 :                                 return node;
     328             :                         }
     329             :                 }
     330       32768 :                 if (node->children != NULL) {
     331       18738 :                         xmlNodePtr tmp = get_node_with_attribute_recursive_ex(node->children, name, name_ns, attribute, value, attr_ns);
     332       18738 :                         if (tmp) {
     333         452 :                                 return tmp;
     334             :                         }
     335             :                 }
     336       32316 :                 node = node->next;
     337             :         }
     338       18287 :         return NULL;
     339             : }
     340             : 
     341       36625 : int parse_namespace(const xmlChar *inval, char **value, char **namespace)
     342             : {
     343       36625 :         char *found = strrchr((char*)inval, ':');
     344             : 
     345       71782 :         if (found != NULL && found != (char*)inval) {
     346       35157 :                 (*namespace) = estrndup((char*)inval, found - (char*)inval);
     347       35157 :                 (*value) = estrdup(++found);
     348             :         } else {
     349        1468 :                 (*value) = estrdup((char*)inval);
     350        1468 :                 (*namespace) = NULL;
     351             :         }
     352             : 
     353       36625 :         return FALSE;
     354             : }

Generated by: LCOV version 1.10

Generated at Sun, 27 Jul 2014 12:58:35 +0000 (2 days ago)

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