← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libxml-libxml-perl/trusty-security

« back to all changes in this revision

Viewing changes to perl-libxml-mm.c

  • Committer: Package Import Robot
  • Author(s): Alessandro Ghedini
  • Date: 2012-10-16 14:10:26 UTC
  • mfrom: (1.2.26)
  • Revision ID: package-import@ubuntu.com-20121016141026-3x0th9su7cue9hl0
Tags: 2.0006+dfsg-1
* New upstream release
* Refresh patches
* Bump Standards-Version to 3.9.4 (no changes needed)

Show diffs side-by-side

added added

removed removed

Lines of Context:
perl-libxml-mm.c
43
43
#endif
44
44
 
45
45
/**
46
 
 * this is a wrapper function that does the type evaluation for the 
 
46
 * this is a wrapper function that does the type evaluation for the
47
47
 * node. this makes the code a little more readable in the .XS
48
 
 * 
49
 
 * the code is not really portable, but i think we'll avoid some 
 
48
 *
 
49
 * the code is not really portable, but i think we'll avoid some
50
50
 * memory leak problems that way.
51
51
 **/
52
52
const char*
56
56
    if ( elem != NULL ) {
57
57
        switch ( elem->type ) {
58
58
        case XML_ELEMENT_NODE:
59
 
            name = "XML::LibXML::Element";   
 
59
            name = "XML::LibXML::Element";
60
60
            break;
61
61
        case XML_TEXT_NODE:
62
62
            name = "XML::LibXML::Text";
68
68
            name = "XML::LibXML::CDATASection";
69
69
            break;
70
70
        case XML_ATTRIBUTE_NODE:
71
 
            name = "XML::LibXML::Attr"; 
 
71
            name = "XML::LibXML::Attr";
72
72
            break;
73
73
        case XML_DOCUMENT_NODE:
74
74
        case XML_HTML_DOCUMENT_NODE:
357
357
}
358
358
 
359
359
ProxyNodePtr
360
 
PmmNewFragment(xmlDocPtr doc) 
 
360
PmmNewFragment(xmlDocPtr doc)
361
361
{
362
362
    ProxyNodePtr retval = NULL;
363
363
    xmlNodePtr frag = NULL;
386
386
 */
387
387
void
388
388
PmmFreeNode( xmlNodePtr node )
389
 
{  
 
389
{
390
390
    switch( node->type ) {
391
391
    case XML_DOCUMENT_NODE:
392
392
    case XML_HTML_DOCUMENT_NODE:
403
403
        break;
404
404
    case XML_DTD_NODE:
405
405
        if ( node->doc != NULL ) {
406
 
            if ( node->doc->extSubset != (xmlDtdPtr)node 
 
406
            if ( node->doc->extSubset != (xmlDtdPtr)node
407
407
                 && node->doc->intSubset != (xmlDtdPtr)node ) {
408
408
                xs_warn( "PmmFreeNode: XML_DTD_NODE\n");
409
409
                node->doc = NULL;
429
429
   the subtree if it is not required any more.
430
430
 */
431
431
int
432
 
PmmREFCNT_dec( ProxyNodePtr node ) 
433
 
{ 
 
432
PmmREFCNT_dec( ProxyNodePtr node )
 
433
{
434
434
    xmlNodePtr libnode = NULL;
435
 
    ProxyNodePtr owner = NULL;  
 
435
    ProxyNodePtr owner = NULL;
436
436
    int retval = 0;
437
437
 
438
438
    if ( node != NULL ) {
471
471
            }
472
472
            else if ( libnode != NULL ) {
473
473
                xs_warn( "PmmREFCNT_dec:   STANDALONE REAL DELETE\n" );
474
 
                
 
474
 
475
475
                PmmFreeNode( libnode );
476
476
            }
477
477
                        else {
500
500
 * nodes.
501
501
 */
502
502
SV*
503
 
PmmNodeToSv( xmlNodePtr node, ProxyNodePtr owner ) 
 
503
PmmNodeToSv( xmlNodePtr node, ProxyNodePtr owner )
504
504
{
505
505
    ProxyNodePtr dfProxy= NULL;
506
506
    SV * retval = &PL_sv_undef;
516
516
        xs_warn("PmmNodeToSv: return new perl node of class:\n");
517
517
        xs_warn( CLASS );
518
518
 
519
 
        if ( node->_private != NULL ) { 
 
519
        if ( node->_private != NULL ) {
520
520
            dfProxy = PmmNewNode(node);
521
521
            /* fprintf(stderr, " at 0x%08.8X\n", dfProxy); */
522
522
        }
544
544
        if( PmmUSEREGISTRY )
545
545
            PmmRegistryREFCNT_inc(dfProxy);
546
546
#endif
547
 
        PmmREFCNT_inc(dfProxy); 
 
547
        PmmREFCNT_inc(dfProxy);
548
548
        /* fprintf(stderr, "REFCNT incremented on node: 0x%08.8X\n", dfProxy); */
549
549
 
550
550
        switch ( node->type ) {
575
575
PmmCloneNode( xmlNodePtr node, int recursive )
576
576
{
577
577
    xmlNodePtr retval = NULL;
578
 
    
 
578
 
579
579
    if ( node != NULL ) {
580
580
        switch ( node->type ) {
581
581
        case XML_ELEMENT_NODE:
585
585
        case XML_PI_NODE:
586
586
        case XML_COMMENT_NODE:
587
587
        case XML_DOCUMENT_FRAG_NODE:
588
 
        case XML_ENTITY_DECL: 
 
588
        case XML_ENTITY_DECL:
589
589
          retval = xmlCopyNode( node, recursive ? 1 : 2 );
590
590
          break;
591
591
        case XML_ATTRIBUTE_NODE:
614
614
 */
615
615
 
616
616
xmlNodePtr
617
 
PmmSvNodeExt( SV* perlnode, int copy ) 
 
617
PmmSvNodeExt( SV* perlnode, int copy )
618
618
{
619
619
    xmlNodePtr retval = NULL;
620
620
    ProxyNodePtr proxy = NULL;
643
643
        else if ( sv_derived_from( perlnode, "XML::GDOME::Node" ) ) {
644
644
            GdomeNode* gnode = (GdomeNode*)SvIV((SV*)SvRV( perlnode ));
645
645
            if ( gnode == NULL ) {
646
 
                warn( "no XML::GDOME data found (datastructure empty)" );    
 
646
                warn( "no XML::GDOME data found (datastructure empty)" );
647
647
            }
648
648
            else {
649
649
                retval = gdome_xml_n_get_xmlNode( gnode );
664
664
/* extracts the libxml2 owner node from a perl reference
665
665
 */
666
666
xmlNodePtr
667
 
PmmSvOwner( SV* perlnode ) 
 
667
PmmSvOwner( SV* perlnode )
668
668
{
669
669
    xmlNodePtr retval = NULL;
670
670
    if ( perlnode != NULL
678
678
/* reverse to PmmSvOwner(). sets the owner of the current node. this
679
679
 * will increase the proxy count of the owner.
680
680
 */
681
 
SV* 
 
681
SV*
682
682
PmmSetSvOwner( SV* perlnode, SV* extra )
683
683
{
684
 
    if ( perlnode != NULL && perlnode != &PL_sv_undef ) {        
 
684
    if ( perlnode != NULL && perlnode != &PL_sv_undef ) {
685
685
        PmmOWNER( SvPROXYNODE(perlnode)) = PmmNODE( SvPROXYNODE(extra) );
686
686
        PmmREFCNT_inc( SvPROXYNODE(extra) );
687
687
        /* fprintf(stderr, "REFCNT incremented on new owner: 0x%08.8X\n", SvPROXYNODE(extra)); */
695
695
 * this functions fixes the reference counts for an entire subtree.
696
696
 * it is very important to fix an entire subtree after node operations
697
697
 * where the documents or the owner node may get changed. this method is
698
 
 * aware about nodes that already belong to a certain owner node. 
 
698
 * aware about nodes that already belong to a certain owner node.
699
699
 *
700
700
 * the method uses the internal methods PmmFixNode and PmmChildNodes to
701
701
 * do the real updates.
702
 
 * 
 
702
 *
703
703
 * in the worst case this traverses the subtree twice during a node
704
704
 * operation. this case is only given when the node has to be
705
 
 * adopted by the document. Since the ownerdocument and the effective 
 
705
 * adopted by the document. Since the ownerdocument and the effective
706
706
 * owner may differ this double traversing makes sense.
707
 
 */ 
 
707
 */
708
708
int
709
 
PmmFixOwner( ProxyNodePtr nodetofix, ProxyNodePtr parent ) 
 
709
PmmFixOwner( ProxyNodePtr nodetofix, ProxyNodePtr parent )
710
710
{
711
711
    ProxyNodePtr oldParent = NULL;
712
712
 
726
726
        if ( PmmOWNER(nodetofix) != NULL ) {
727
727
            oldParent = PmmOWNERPO(nodetofix);
728
728
        }
729
 
        
 
729
 
730
730
        /* The owner data is only fixed if the node is neither a
731
731
         * fragment nor a document. Also no update will happen if
732
732
         * the node is already his owner or the owner has not
743
743
            else {
744
744
                PmmOWNER(nodetofix) = NULL;
745
745
            }
746
 
            
 
746
 
747
747
            if ( oldParent != NULL && oldParent != nodetofix )
748
748
                PmmREFCNT_dec(oldParent);
749
 
            
 
749
 
750
750
            if ( PmmNODE(nodetofix)->type != XML_ATTRIBUTE_NODE
751
751
                 && PmmNODE(nodetofix)->properties != NULL ) {
752
752
                PmmFixOwnerList( (xmlNodePtr)PmmNODE(nodetofix)->properties,
813
813
        else {
814
814
            xs_warn( "PmmFixOwnerNode: calling PmmFixOwnerList\n" );
815
815
            PmmFixOwnerList(node->children, parent );
816
 
        } 
 
816
        }
817
817
    }
818
 
} 
 
818
}
819
819
 
820
820
ProxyNodePtr
821
821
PmmNewContext(xmlParserCtxtPtr node)
833
833
    }
834
834
    return proxy;
835
835
}
836
 
 
 
836
 
837
837
int
838
 
PmmContextREFCNT_dec( ProxyNodePtr node ) 
839
 
{ 
 
838
PmmContextREFCNT_dec( ProxyNodePtr node )
 
839
{
840
840
    xmlParserCtxtPtr libnode = NULL;
841
841
    int retval = 0;
842
842
    if ( node != NULL ) {
876
876
 
877
877
        retval = NEWSV(0,0);
878
878
        sv_setref_pv( retval, CLASS, (void*)dfProxy );
879
 
        PmmREFCNT_inc(dfProxy); 
 
879
        PmmREFCNT_inc(dfProxy);
880
880
        /* fprintf(stderr, "REFCNT incremented on new context: 0x%08.8X\n", dfProxy); */
881
 
    }         
 
881
    }
882
882
    else {
883
883
        xs_warn( "PmmContextSv: no node found!\n" );
884
884
    }
887
887
}
888
888
 
889
889
xmlParserCtxtPtr
890
 
PmmSvContext( SV * scalar ) 
 
890
PmmSvContext( SV * scalar )
891
891
{
892
892
    xmlParserCtxtPtr retval = NULL;
893
893
 
919
919
PmmFastEncodeString( int charset,
920
920
                     const xmlChar *string,
921
921
                     const xmlChar *encoding,
922
 
                     STRLEN len ) 
 
922
                     STRLEN len )
923
923
{
924
924
    xmlCharEncodingHandlerPtr coder = NULL;
925
925
    xmlChar *retval = NULL;
988
988
        else {
989
989
            /* warn( "b0rked encoiding!\n"); */
990
990
        }
991
 
        
 
991
 
992
992
        xmlBufferFree( in );
993
993
        xmlBufferFree( out );
994
994
        xmlCharEncCloseFunc( coder );
1000
1000
PmmFastDecodeString( int charset,
1001
1001
                     const xmlChar *string,
1002
1002
                     const xmlChar *encoding,
1003
 
                     STRLEN* len ) 
 
1003
                     STRLEN* len )
1004
1004
{
1005
1005
    xmlCharEncodingHandlerPtr coder = NULL;
1006
1006
    xmlChar *retval = NULL;
1040
1040
        else {
1041
1041
            /* xs_warn("PmmFastEncodeString: decoding error\n"); */
1042
1042
        }
1043
 
        
 
1043
 
1044
1044
        xmlBufferFree( in );
1045
1045
        xmlBufferFree( out );
1046
1046
        xmlCharEncCloseFunc( coder );
1048
1048
    return retval;
1049
1049
}
1050
1050
 
1051
 
/** 
 
1051
/**
1052
1052
 * encodeString returns an UTF-8 encoded String
1053
1053
 * while the encodig has the name of the encoding of string
1054
 
 **/ 
 
1054
 **/
1055
1055
xmlChar*
1056
1056
PmmEncodeString( const char *encoding, const xmlChar *string, STRLEN len ){
1057
1057
    xmlCharEncoding enc;
1058
1058
    xmlChar *ret = NULL;
1059
 
    
 
1059
 
1060
1060
    if ( string != NULL ) {
1061
1061
        if( encoding != NULL ) {
1062
1062
            xs_warn("PmmEncodeString: encoding to UTF-8 from:\n");
1091
1091
        }
1092
1092
 
1093
1093
        retval = newSVpvn( (const char *)string, (STRLEN) xmlStrlen(string) );
1094
 
   
 
1094
 
1095
1095
        if ( enc == XML_CHAR_ENCODING_UTF8 ) {
1096
 
            /* create an UTF8 string. */       
 
1096
            /* create an UTF8 string. */
1097
1097
#ifdef HAVE_UTF8
1098
1098
            xs_warn("C2Sv: set UTF8-SV-flag\n");
1099
1099
            SvUTF8_on(retval);
1100
 
#endif            
 
1100
#endif
1101
1101
        }
1102
1102
    }
1103
1103
 
1121
1121
            xs_warn( "SV2C:   use UTF8\n" );
1122
1122
            if( !DO_UTF8(scalar) && encoding != NULL ) {
1123
1123
#else
1124
 
            if ( encoding != NULL ) {        
 
1124
            if ( encoding != NULL ) {
1125
1125
#endif
1126
1126
                xs_warn( "SV2C:   domEncodeString!\n" );
1127
1127
                ts= PmmEncodeString( (const char *)encoding, string, len );
1132
1132
                string=ts;
1133
1133
            }
1134
1134
        }
1135
 
             
 
1135
 
1136
1136
        retval = xmlStrdup(string);
1137
1137
        if (string != NULL ) {
1138
1138
            xmlFree(string);
1164
1164
 
1165
1165
            decoded = PmmFastDecodeString( PmmNodeEncoding(real_doc),
1166
1166
                                           (const xmlChar *)string,
1167
 
                                           (const xmlChar *)real_doc->encoding, 
 
1167
                                           (const xmlChar *)real_doc->encoding,
1168
1168
                                           &len );
1169
1169
 
1170
1170
            xs_warn( "push decoded string into SV" );
1175
1175
#ifdef HAVE_UTF8
1176
1176
                xs_warn("nodeC2Sv: set UTF8-SV-flag\n");
1177
1177
                SvUTF8_on(retval);
1178
 
#endif            
 
1178
#endif
1179
1179
            }
1180
 
           
 
1180
 
1181
1181
            return retval;
1182
1182
        }
1183
1183
    }
1227
1227
                        xs_warn( "nodeSv2C:   no encoding set, use UTF8!\n" );
1228
1228
                    }
1229
1229
#endif
1230
 
                } 
 
1230
                }
1231
1231
                if (string==NULL) {
1232
1232
                    return xmlStrndup((xmlChar*)t_pv,len);
1233
1233
                } else {
1246
1246
    }
1247
1247
    xs_warn("nodeSv2C: no encoding !!\n");
1248
1248
 
1249
 
    return  Sv2C( scalar, NULL ); 
 
1249
    return  Sv2C( scalar, NULL );
1250
1250
}
1251
1251
 
1252
 
SV * 
1253
 
PmmNodeToGdomeSv( xmlNodePtr node ) 
 
1252
SV *
 
1253
PmmNodeToGdomeSv( xmlNodePtr node )
1254
1254
{
1255
1255
    SV * retval = &PL_sv_undef;
1256
1256
 
1270
1270
                CLASS = "XML::GDOME::Attr";
1271
1271
                break;
1272
1272
            case GDOME_TEXT_NODE:
1273
 
                CLASS = "XML::GDOME::Text"; 
 
1273
                CLASS = "XML::GDOME::Text";
1274
1274
                break;
1275
1275
            case GDOME_CDATA_SECTION_NODE:
1276
 
                CLASS = "XML::GDOME::CDATASection"; 
 
1276
                CLASS = "XML::GDOME::CDATASection";
1277
1277
                break;
1278
1278
            case GDOME_ENTITY_REFERENCE_NODE:
1279
 
                CLASS = "XML::GDOME::EntityReference"; 
 
1279
                CLASS = "XML::GDOME::EntityReference";
1280
1280
                break;
1281
1281
            case GDOME_ENTITY_NODE:
1282
 
                CLASS = "XML::GDOME::Entity"; 
 
1282
                CLASS = "XML::GDOME::Entity";
1283
1283
                break;
1284
1284
            case GDOME_PROCESSING_INSTRUCTION_NODE:
1285
 
                CLASS = "XML::GDOME::ProcessingInstruction"; 
 
1285
                CLASS = "XML::GDOME::ProcessingInstruction";
1286
1286
                break;
1287
1287
            case GDOME_COMMENT_NODE:
1288
 
                CLASS = "XML::GDOME::Comment"; 
 
1288
                CLASS = "XML::GDOME::Comment";
1289
1289
                break;
1290
1290
            case GDOME_DOCUMENT_TYPE_NODE:
1291
 
                CLASS = "XML::GDOME::DocumentType"; 
 
1291
                CLASS = "XML::GDOME::DocumentType";
1292
1292
                break;
1293
1293
            case GDOME_DOCUMENT_FRAGMENT_NODE:
1294
 
                CLASS = "XML::GDOME::DocumentFragment"; 
 
1294
                CLASS = "XML::GDOME::DocumentFragment";
1295
1295
                break;
1296
1296
            case GDOME_NOTATION_NODE:
1297
 
                CLASS = "XML::GDOME::Notation"; 
 
1297
                CLASS = "XML::GDOME::Notation";
1298
1298
                break;
1299
1299
            case GDOME_DOCUMENT_NODE:
1300
 
                CLASS = "XML::GDOME::Document"; 
 
1300
                CLASS = "XML::GDOME::Document";
1301
1301
                break;
1302
1302
            default:
1303
1303
                break;