← Back to branch summary

~ubuntu-branches/debian/lenny/xar/lenny

« back to all changes in this revision

Viewing changes to lib/archive.c

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Berg
  • Date: 2008-01-02 22:20:14 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080102222014-xb7xn21dd7z5h0ez
Tags: 1.5.2-1
New upstream version, now also builds static libraries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/archive.c
354
354
 
355
355
                t = time(NULL);
356
356
                gmtime_r(&t, &tmptm);
357
 
                memset(timestr, sizeof(timestr), 0);
 
357
                memset(timestr, 0, sizeof(timestr));
358
358
                strftime(timestr, sizeof(timestr), "%FT%T", &tmptm);
359
359
                xar_prop_set(XAR_FILE(x), "creation-time", timestr);
360
360
 
1309
1309
        xmlTextReaderPtr reader;
1310
1310
        xar_file_t f = NULL;
1311
1311
        const xmlChar *name, *prefix, *uri;
1312
 
        int type, noattr;
 
1312
        int type, noattr, ret;
1313
1313
 
1314
1314
        reader = xmlReaderForIO(toc_read_callback, close_callback, XAR(x), NULL, NULL, 0);
1315
1315
        if( !reader ) return -1;
1316
1316
 
1317
 
        while( xmlTextReaderRead(reader) == 1 ) {
 
1317
        while( (ret = xmlTextReaderRead(reader)) == 1 ) {
1318
1318
                type = xmlTextReaderNodeType(reader);
1319
1319
                noattr = xmlTextReaderAttributeCount(reader);
1320
1320
                name = xmlTextReaderConstLocalName(reader);
1321
 
                if( type == XML_READER_TYPE_ELEMENT ) {
1322
 
                        if(strcmp((const char*)name, "xar") == 0) {
1323
 
                                while( xmlTextReaderRead(reader) == 1 ) {
1324
 
                                        type = xmlTextReaderNodeType(reader);
1325
 
                                        noattr = xmlTextReaderAttributeCount(reader);
1326
 
                                        name = xmlTextReaderConstLocalName(reader);
1327
 
                                        if( type == XML_READER_TYPE_ELEMENT ) {
1328
 
                                                if(strcmp((const char*)name, "toc") == 0) {
1329
 
                                                        while( xmlTextReaderRead(reader) == 1 ) {
1330
 
                                                                type = xmlTextReaderNodeType(reader);
1331
 
                                                                noattr = xmlTextReaderAttributeCount(reader);
1332
 
                                                                name = xmlTextReaderConstLocalName(reader);
1333
 
                                                                if( type == XML_READER_TYPE_ELEMENT ) {
1334
 
                                                                        if(strcmp((const char*)name, "file") == 0) {
1335
 
                                                                                f = xar_file_unserialize(x, NULL, reader);
1336
 
                                                                                XAR_FILE(f)->next = XAR(x)->files;
1337
 
                                                                                XAR(x)->files = f;
1338
 
                                                                        } else if( strcmp((const char*)name, "signature") == 0 ){
1339
 
                                                                                xar_signature_t sig = NULL;                     
1340
 
                                                                                sig = xar_signature_unserialize(x, reader );
1341
 
                                                                                
1342
 
                                                                                if( !sig )
1343
 
                                                                                        return -1;
1344
 
                                                                                
1345
 
                                                                                if( XAR(x)->signatures )
1346
 
                                                                                        XAR_SIGNATURE(XAR(x)->signatures)->next = XAR_SIGNATURE(sig);
1347
 
                                                                                else
1348
 
                                                                                        XAR(x)->signatures = sig;
1349
 
                                                                                        
1350
 
                                                                        } else {
1351
 
                                                                                xar_prop_unserialize(XAR_FILE(x), NULL, reader);
1352
 
                                                                        }
 
1321
                if( type != XML_READER_TYPE_ELEMENT )
 
1322
                        continue;
 
1323
                if(strcmp((const char*)name, "xar") != 0)
 
1324
                        continue;
 
1325
                while( (ret = xmlTextReaderRead(reader)) == 1 ) {
 
1326
                        type = xmlTextReaderNodeType(reader);
 
1327
                        noattr = xmlTextReaderAttributeCount(reader);
 
1328
                        name = xmlTextReaderConstLocalName(reader);
 
1329
                        if( type == XML_READER_TYPE_ELEMENT ) {
 
1330
                                if(strcmp((const char*)name, "toc") == 0) {
 
1331
                                        while( (ret = xmlTextReaderRead(reader)) == 1 ) {
 
1332
                                                type = xmlTextReaderNodeType(reader);
 
1333
                                                noattr = xmlTextReaderAttributeCount(reader);
 
1334
                                                name = xmlTextReaderConstLocalName(reader);
 
1335
                                                if( type == XML_READER_TYPE_ELEMENT ) {
 
1336
                                                        if(strcmp((const char*)name, "file") == 0) {
 
1337
                                                                f = xar_file_unserialize(x, NULL, reader);
 
1338
                                                                XAR_FILE(f)->next = XAR(x)->files;
 
1339
                                                                XAR(x)->files = f;
 
1340
                                                        } else if( strcmp((const char*)name, "signature") == 0 ){
 
1341
                                                                xar_signature_t sig = NULL;                     
 
1342
                                                                sig = xar_signature_unserialize(x, reader );
 
1343
                                                                
 
1344
                                                                if( !sig ) {
 
1345
                                                                        xmlFreeTextReader(reader);
 
1346
                                                                        xmlDictCleanup();
 
1347
                                                                        xmlCleanupCharEncodingHandlers();
 
1348
                                                                        return -1;
1353
1349
                                                                }
1354
 
                                                        }
1355
 
                                                } else {
1356
 
                                                        xar_subdoc_t s;
1357
 
                                                        int i;
1358
 
 
1359
 
                                                        prefix = xmlTextReaderPrefix(reader);
1360
 
                                                        uri = xmlTextReaderNamespaceUri(reader);
1361
 
 
1362
 
                                                        i = xmlTextReaderAttributeCount(reader);
1363
 
                                                        if( i > 0 ) {
1364
 
                                                                for(i = xmlTextReaderMoveToFirstAttribute(reader); i == 1; i = xmlTextReaderMoveToNextAttribute(reader)) {
1365
 
                                                                        xar_attr_t a;
1366
 
                                                                        const char *aname = (const char *)xmlTextReaderConstLocalName(reader);
1367
 
                                                                        const char *avalue = (const char *)xmlTextReaderConstValue(reader);
 
1350
                                                                
 
1351
                                                                if( XAR(x)->signatures )
 
1352
                                                                        XAR_SIGNATURE(XAR(x)->signatures)->next = XAR_SIGNATURE(sig);
 
1353
                                                                else
 
1354
                                                                        XAR(x)->signatures = sig;
1368
1355
                                                                        
1369
 
                                                                        if( aname && (strcmp("subdoc_name", aname) == 0) ) {
1370
 
                                                                                name = (const unsigned char *)avalue;
1371
 
                                                                        } else {
1372
 
                                                                                a = xar_attr_new();
1373
 
                                                                                XAR_ATTR(a)->key = strdup(aname);
1374
 
                                                                                XAR_ATTR(a)->value = strdup(avalue);
1375
 
                                                                                XAR_ATTR(a)->next = XAR_SUBDOC(s)->attrs;
1376
 
                                                                                XAR_SUBDOC(s)->attrs = XAR_ATTR(a);
1377
 
                                                                        }
1378
 
                                                                }
1379
 
                                                        }
1380
 
 
1381
 
                                                        s = xar_subdoc_new(x, (const char *)name);
1382
 
                                                        xar_subdoc_unserialize(s, reader);
1383
 
                                                }
1384
 
                                        }
1385
 
                                        if( (type == XML_READER_TYPE_END_ELEMENT) && (strcmp((const char *)name, "toc")==0) ) {
1386
 
                                                break;
1387
 
                                        }
1388
 
 
 
1356
                                                        } else {
 
1357
                                                                xar_prop_unserialize(XAR_FILE(x), NULL, reader);
 
1358
                                                        }
 
1359
                                                }
 
1360
                                        }
 
1361
                                        if( ret == -1 ) {
 
1362
                                                xmlFreeTextReader(reader);
 
1363
                                                xmlDictCleanup();
 
1364
                                                xmlCleanupCharEncodingHandlers();
 
1365
                                                return -1;
 
1366
                                        }
 
1367
                                } else {
 
1368
                                        xar_subdoc_t s;
 
1369
                                        int i;
 
1370
 
 
1371
                                        prefix = xmlTextReaderPrefix(reader);
 
1372
                                        uri = xmlTextReaderNamespaceUri(reader);
 
1373
 
 
1374
                                        i = xmlTextReaderAttributeCount(reader);
 
1375
                                        if( i > 0 ) {
 
1376
                                                for(i = xmlTextReaderMoveToFirstAttribute(reader); i == 1; i = xmlTextReaderMoveToNextAttribute(reader)) {
 
1377
                                                        xar_attr_t a;
 
1378
                                                        const char *aname = (const char *)xmlTextReaderConstLocalName(reader);
 
1379
                                                        const char *avalue = (const char *)xmlTextReaderConstValue(reader);
 
1380
                                                        
 
1381
                                                        if( aname && (strcmp("subdoc_name", aname) == 0) ) {
 
1382
                                                                name = (const unsigned char *)avalue;
 
1383
                                                        } else {
 
1384
                                                                a = xar_attr_new();
 
1385
                                                                XAR_ATTR(a)->key = strdup(aname);
 
1386
                                                                XAR_ATTR(a)->value = strdup(avalue);
 
1387
                                                                XAR_ATTR(a)->next = XAR_SUBDOC(s)->attrs;
 
1388
                                                                XAR_SUBDOC(s)->attrs = XAR_ATTR(a);
 
1389
                                                        }
 
1390
                                                }
 
1391
                                        }
 
1392
 
 
1393
                                        s = xar_subdoc_new(x, (const char *)name);
 
1394
                                        xar_subdoc_unserialize(s, reader);
1389
1395
                                }
1390
1396
                        }
1391
 
                }
 
1397
                        if( (type == XML_READER_TYPE_END_ELEMENT) && (strcmp((const char *)name, "toc")==0) ) {
 
1398
                                break;
 
1399
                        }
 
1400
                }
 
1401
                if( ret == -1 ) {
 
1402
                        xmlFreeTextReader(reader);
 
1403
                        xmlDictCleanup();
 
1404
                        xmlCleanupCharEncodingHandlers();
 
1405
                        return -1;
 
1406
                }
 
1407
        }
 
1408
 
 
1409
        if( ret == -1 ) {
 
1410
                xmlFreeTextReader(reader);
 
1411
                xmlDictCleanup();
 
1412
                xmlCleanupCharEncodingHandlers();
 
1413
                return -1;
1392
1414
        }
1393
1415
                
1394
1416
        xmlFreeTextReader(reader);
 
1417
        xmlDictCleanup();
 
1418
        xmlCleanupCharEncodingHandlers();
1395
1419
        return 0;
1396
1420
}