← Back to branch summary

~ubuntu-branches/ubuntu/raring/reprepro/raring

« back to all changes in this revision

Viewing changes to sources.c

  • Committer: Bazaar Package Importer
  • Author(s): Bernhard R. Link
  • Date: 2011-05-05 16:34:23 UTC
  • mfrom: (21.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110505163423-x49kbdijyoubai4x
Tags: 4.6.0-1
* new release
- general cleanup
- new FilterSrcList
* increase Standards-Version, no changes needed

Show diffs side-by-side

added added

removed removed

Lines of Context:
sources.c
41
41
        const char *p, *fn, *fnend;
42
42
        char *filen;
43
43
 
44
 
        assert( fileline != NULL );
45
 
        if( *fileline == '\0' )
 
44
        assert (fileline != NULL);
 
45
        if (*fileline == '\0')
46
46
                return RET_NOTHING;
47
47
 
48
48
        /* the md5sums begins after the (perhaps) heading spaces ...  */
49
49
        p = fileline;
50
 
        while( *p != '\0' && (*p == ' ' || *p == '\t') )
 
50
        while (*p != '\0' && (*p == ' ' || *p == '\t'))
51
51
                p++;
52
 
        if( *p == '\0' )
 
52
        if (*p == '\0')
53
53
                return RET_NOTHING;
54
54
        /* ... and ends with the following spaces. */
55
 
        while( *p != '\0' && !(*p == ' ' || *p == '\t') )
 
55
        while (*p != '\0' && !(*p == ' ' || *p == '\t'))
56
56
                p++;
57
 
        if( *p == '\0' ) {
 
57
        if (*p == '\0') {
58
58
                fprintf(stderr, "Expecting more data after md5sum!\n");
59
59
                return RET_ERROR;
60
60
        }
61
61
        /* Then the size of the file is expected: */
62
 
        while( (*p == ' ' || *p == '\t') )
63
 
                p++;
64
 
        while( *p !='\0' && !(*p == ' ' || *p == '\t') )
65
 
                p++;
66
 
        if( *p == '\0' ) {
 
62
        while ((*p == ' ' || *p == '\t'))
 
63
                p++;
 
64
        while (*p !='\0' && !(*p == ' ' || *p == '\t'))
 
65
                p++;
 
66
        if (*p == '\0') {
67
67
                fprintf(stderr, "Expecting more data after size!\n");
68
68
                return RET_ERROR;
69
69
        }
70
70
        /* Then the filename */
71
71
        fn = p;
72
 
        while( (*fn == ' ' || *fn == '\t') )
 
72
        while ((*fn == ' ' || *fn == '\t'))
73
73
                fn++;
74
74
        fnend = fn;
75
 
        while( *fnend != '\0' && !(*fnend == ' ' || *fnend == '\t') )
 
75
        while (*fnend != '\0' && !(*fnend == ' ' || *fnend == '\t'))
76
76
                fnend++;
77
77
 
78
78
        filen = strndup(fn, fnend-fn);
79
 
        if( FAILEDTOALLOC(filen) )
 
79
        if (FAILEDTOALLOC(filen))
80
80
                return RET_ERROR_OOM;
81
81
        *filename = filen;
82
82
        return RET_OK;
83
83
}
84
84
 
85
 
static retvalue getBasenames(const struct strlist *filelines,/*@out@*/struct strlist *basenames) {
 
85
static retvalue getBasenames(const struct strlist *filelines, /*@out@*/struct strlist *basenames) {
86
86
        int i;
87
87
        retvalue r;
88
88
 
89
 
        assert( filelines != NULL && basenames != NULL );
 
89
        assert (filelines != NULL && basenames != NULL);
90
90
 
91
 
        r = strlist_init_n(filelines->count,basenames);
92
 
        if( RET_WAS_ERROR(r) )
 
91
        r = strlist_init_n(filelines->count, basenames);
 
92
        if (RET_WAS_ERROR(r))
93
93
                return r;
94
94
        r = RET_NOTHING;
95
 
        for( i = 0 ; i < filelines->count ; i++ ) {
 
95
        for (i = 0 ; i < filelines->count ; i++) {
96
96
                char *basefilename IFSTUPIDCC(=NULL);
97
97
                const char *fileline = filelines->values[i];
98
98
 
99
99
                r = calc_parsefileline(fileline, &basefilename);
100
 
                if( r == RET_NOTHING ) {
 
100
                if (r == RET_NOTHING) {
101
101
                        fprintf(stderr, "Malformed Files: line '%s'!\n",
102
102
                                        fileline);
103
103
                        r = RET_ERROR;
104
104
                }
105
 
                if( RET_WAS_ERROR(r) )
 
105
                if (RET_WAS_ERROR(r))
106
106
                        break;
107
107
 
108
108
                r = strlist_add(basenames, basefilename);
109
 
                if( RET_WAS_ERROR(r) ) {
 
109
                if (RET_WAS_ERROR(r)) {
110
110
                        break;
111
111
                }
112
112
                r = RET_OK;
113
113
        }
114
 
        if( RET_WAS_ERROR(r) ) {
 
114
        if (RET_WAS_ERROR(r)) {
115
115
                strlist_done(basenames);
116
116
        } else {
117
 
                assert( filelines->count == basenames->count );
 
117
                assert (filelines->count == basenames->count);
118
118
        }
119
119
        return r;
120
120
}
122
122
retvalue sources_getversion(const char *control, char **version) {
123
123
        retvalue r;
124
124
 
125
 
        r = chunk_getvalue(control,"Version",version);
126
 
        if( RET_WAS_ERROR(r) )
 
125
        r = chunk_getvalue(control, "Version", version);
 
126
        if (RET_WAS_ERROR(r))
127
127
                return r;
128
 
        if( r == RET_NOTHING ) {
129
 
                fprintf(stderr, "Missing 'Version' field in chunk:'%s'\n", control);
 
128
        if (r == RET_NOTHING) {
 
129
                fprintf(stderr, "Missing 'Version' field in chunk:'%s'\n",
 
130
                                control);
130
131
                return RET_ERROR;
131
132
        }
132
133
        return r;
145
146
        struct checksumsarray files;
146
147
        enum checksumtype cs;
147
148
 
148
 
        assert( architecture == architecture_source );
 
149
        assert (architecture == architecture_source);
149
150
 
150
 
        for( cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++ ) {
151
 
                assert( source_checksum_names[cs] != NULL );
 
151
        for (cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++) {
 
152
                assert (source_checksum_names[cs] != NULL);
152
153
                r = chunk_getextralinelist(chunk, source_checksum_names[cs],
153
154
                                &filelines[cs]);
154
 
                if( r == RET_NOTHING ) {
155
 
                        if( cs == cs_md5sum ) {
 
155
                if (r == RET_NOTHING) {
 
156
                        if (cs == cs_md5sum) {
156
157
                                fprintf(stderr,
157
 
"Missing 'Files' entry in '%s'!\n",             chunk);
 
158
"Missing 'Files' entry in '%s'!\n",
 
159
                                                chunk);
158
160
                                r = RET_ERROR;
159
161
                        } else
160
162
                                strlist_init(&filelines[cs]);
161
163
                }
162
 
                if( RET_WAS_ERROR(r) ) {
163
 
                        while( cs-- > cs_md5sum ) {
 
164
                if (RET_WAS_ERROR(r)) {
 
165
                        while (cs-- > cs_md5sum) {
164
166
                                strlist_done(&filelines[cs]);
165
167
                        }
166
168
                        return r;
167
169
                }
168
170
        }
169
171
        r = checksumsarray_parse(&files, filelines, packagename);
170
 
        for( cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++ ) {
 
172
        for (cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++) {
171
173
                strlist_done(&filelines[cs]);
172
174
        }
173
 
        if( RET_WAS_ERROR(r) )
 
175
        if (RET_WAS_ERROR(r))
174
176
                return r;
175
177
 
176
178
        r = chunk_getvalue(chunk, "Directory", &origdirectory);
177
 
        if( r == RET_NOTHING ) {
 
179
        if (r == RET_NOTHING) {
178
180
/* Flat repositories can come without this, TODO: add warnings in other cases
179
 
                fprintf(stderr,"Missing 'Directory' entry in '%s'!\n",chunk);
 
181
                fprintf(stderr, "Missing 'Directory' entry in '%s'!\n", chunk);
180
182
                r = RET_ERROR;
181
183
*/
182
184
                origdirectory = strdup(".");
183
 
                if( FAILEDTOALLOC(origdirectory) )
 
185
                if (FAILEDTOALLOC(origdirectory))
184
186
                        r = RET_ERROR_OOM;
185
187
        }
186
 
        if( RET_WAS_ERROR(r) ) {
 
188
        if (RET_WAS_ERROR(r)) {
187
189
                checksumsarray_done(&files);
188
190
                return r;
189
191
        }
190
192
 
191
193
        r = propersourcename(packagename);
192
 
        assert( r != RET_NOTHING );
193
 
        if( RET_IS_OK(r) )
 
194
        assert (r != RET_NOTHING);
 
195
        if (RET_IS_OK(r))
194
196
                r = properfilenames(&files.names);
195
 
        if( RET_WAS_ERROR(r) ) {
196
 
                fprintf(stderr,"Forbidden characters in source package '%s'!\n", packagename);
 
197
        if (RET_WAS_ERROR(r)) {
 
198
                fprintf(stderr,
 
199
"Forbidden characters in source package '%s'!\n", packagename);
197
200
                free(origdirectory);
198
201
                checksumsarray_done(&files);
199
202
                return r;
200
203
        }
201
204
 
202
 
        directory = calc_sourcedir(t->component_atom, packagename);
203
 
        if( directory == NULL )
 
205
        directory = calc_sourcedir(t->component, packagename);
 
206
        if (FAILEDTOALLOC(directory))
204
207
                r = RET_ERROR_OOM;
205
208
        else
206
209
                r = calc_dirconcats(directory, &files.names, &myfilekeys);
207
 
        if( RET_WAS_ERROR(r) ) {
 
210
        if (RET_WAS_ERROR(r)) {
208
211
                free(directory);
209
212
                free(origdirectory);
210
213
                checksumsarray_done(&files);
212
215
        }
213
216
        r = calc_inplacedirconcats(origdirectory, &files.names);
214
217
        free(origdirectory);
215
 
        if( !RET_WAS_ERROR(r) ) {
 
218
        if (!RET_WAS_ERROR(r)) {
216
219
                mychunk = chunk_replacefield(chunk,
217
220
                                "Directory", directory, true);
218
 
                if( mychunk == NULL )
 
221
                if (FAILEDTOALLOC(mychunk))
219
222
                        r = RET_ERROR_OOM;
220
223
        }
221
224
        free(directory);
222
 
        if( RET_WAS_ERROR(r) ) {
 
225
        if (RET_WAS_ERROR(r)) {
223
226
                strlist_done(&myfilekeys);
224
227
                checksumsarray_done(&files);
225
228
                return r;
239
242
 
240
243
        /* Read the directory given there */
241
244
        r = chunk_getvalue(chunk, "Directory", &origdirectory);
242
 
        if( r == RET_NOTHING ) {
 
245
        if (r == RET_NOTHING) {
243
246
                //TODO: check if it is even text and do not print
244
247
                //of looking binary??
245
 
                fprintf(stderr, "Does not look like source control: '%s'\n", chunk);
 
248
                fprintf(stderr, "Does not look like source control: '%s'\n",
 
249
                                chunk);
246
250
                return RET_ERROR;
247
251
        }
248
 
        if( RET_WAS_ERROR(r) )
 
252
        if (RET_WAS_ERROR(r))
249
253
                return r;
250
254
 
251
255
        r = chunk_getextralinelist(chunk, "Files", &filelines);
252
 
        if( r == RET_NOTHING ) {
 
256
        if (r == RET_NOTHING) {
253
257
                //TODO: check if it is even text and do not print
254
258
                //of looking binary??
255
 
                fprintf(stderr, "Does not look like source control: '%s'\n", chunk);
 
259
                fprintf(stderr, "Does not look like source control: '%s'\n",
 
260
                                chunk);
256
261
                r = RET_ERROR;
257
262
        }
258
 
        if( RET_WAS_ERROR(r) ) {
 
263
        if (RET_WAS_ERROR(r)) {
259
264
                free(origdirectory);
260
265
                return r;
261
266
        }
262
267
        r = getBasenames(&filelines, &basenames);
263
268
        strlist_done(&filelines);
264
 
        if( RET_WAS_ERROR(r) ) {
 
269
        if (RET_WAS_ERROR(r)) {
265
270
                free(origdirectory);
266
271
                return r;
267
272
        }
281
286
 
282
287
        /* Read the directory given there */
283
288
        r = chunk_getvalue(chunk, "Directory", &origdirectory);
284
 
        if( !RET_IS_OK(r) )
 
289
        if (!RET_IS_OK(r))
285
290
                return r;
286
291
 
287
 
        for( cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++ ) {
288
 
                assert( source_checksum_names[cs] != NULL );
 
292
        for (cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++) {
 
293
                assert (source_checksum_names[cs] != NULL);
289
294
                r = chunk_getextralinelist(chunk, source_checksum_names[cs],
290
295
                                &filelines[cs]);
291
 
                if( r == RET_NOTHING ) {
292
 
                        if( cs == cs_md5sum ) {
 
296
                if (r == RET_NOTHING) {
 
297
                        if (cs == cs_md5sum) {
293
298
                                fprintf(stderr,
294
 
"Missing 'Files' entry in '%s'!\n",             chunk);
 
299
"Missing 'Files' entry in '%s'!\n",
 
300
                                                chunk);
295
301
                                r = RET_ERROR;
296
302
                        } else
297
303
                                strlist_init(&filelines[cs]);
298
304
                }
299
 
                if( RET_WAS_ERROR(r) ) {
300
 
                        while( cs-- > cs_md5sum ) {
 
305
                if (RET_WAS_ERROR(r)) {
 
306
                        while (cs-- > cs_md5sum) {
301
307
                                strlist_done(&filelines[cs]);
302
308
                        }
303
309
                        free(origdirectory);
305
311
                }
306
312
        }
307
313
        r = checksumsarray_parse(&a, filelines, "source chunk");
308
 
        for( cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++ ) {
 
314
        for (cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++) {
309
315
                strlist_done(&filelines[cs]);
310
316
        }
311
 
        if( RET_WAS_ERROR(r) ) {
 
317
        if (RET_WAS_ERROR(r)) {
312
318
                free(origdirectory);
313
319
                return r;
314
320
        }
315
321
 
316
322
        r = calc_inplacedirconcats(origdirectory, &a.names);
317
323
        free(origdirectory);
318
 
        if( RET_WAS_ERROR(r) ) {
 
324
        if (RET_WAS_ERROR(r)) {
319
325
                checksumsarray_done(&a);
320
326
                return r;
321
327
        }
329
335
        char *newchunk;
330
336
        retvalue r;
331
337
 
332
 
        if( interrupted() )
 
338
        if (interrupted())
333
339
                return RET_ERROR_INTERRUPTED;
334
340
 
335
341
        o = override_search(target->distribution->overrides.dsc, packagename);
336
 
        if( o == NULL )
 
342
        if (o == NULL)
337
343
                return RET_NOTHING;
338
344
 
339
345
        r = override_allreplacefields(o, &fields);
340
 
        if( !RET_IS_OK(r) )
 
346
        if (!RET_IS_OK(r))
341
347
                return r;
342
348
        newchunk = chunk_replacefields(controlchunk, fields,
343
349
                        "Directory", true);
344
350
        addfield_free(fields);
345
 
        if( newchunk == NULL )
 
351
        if (FAILEDTOALLOC(newchunk))
346
352
                return RET_ERROR_OOM;
347
353
        *newcontrolchunk = newchunk;
348
354
        return RET_OK;
349
355
}
350
356
 
351
 
retvalue sources_retrack(const char *sourcename, const char *chunk, trackingdb tracks, struct database *database) {
 
357
retvalue sources_retrack(const char *sourcename, const char *chunk, trackingdb tracks) {
352
358
        retvalue r;
353
359
        char *sourceversion;
354
360
        struct trackedpackage *pkg;
358
364
        //TODO: elliminate duplicate code!
359
365
        assert(sourcename!=NULL);
360
366
 
361
 
        if( interrupted() )
 
367
        if (interrupted())
362
368
                return RET_ERROR_INTERRUPTED;
363
369
 
364
 
        r = chunk_getvalue(chunk,"Version",&sourceversion);
365
 
        if( r == RET_NOTHING ) {
366
 
                fprintf(stderr, "Missing 'Version' field in chunk:'%s'\n", chunk);
 
370
        r = chunk_getvalue(chunk, "Version", &sourceversion);
 
371
        if (r == RET_NOTHING) {
 
372
                fprintf(stderr, "Missing 'Version' field in chunk:'%s'\n",
 
373
                                chunk);
367
374
                r = RET_ERROR;
368
375
        }
369
 
        if( RET_WAS_ERROR(r) ) {
 
376
        if (RET_WAS_ERROR(r)) {
370
377
                return r;
371
378
        }
372
379
 
373
380
        r = sources_getfilekeys(chunk, &filekeys);
374
 
        if( r == RET_NOTHING ) {
 
381
        if (r == RET_NOTHING) {
375
382
                fprintf(stderr, "Malformed source control:'%s'\n", chunk);
376
383
                r = RET_ERROR;
377
384
        }
378
 
        if( RET_WAS_ERROR(r) ) {
 
385
        if (RET_WAS_ERROR(r)) {
379
386
                free(sourceversion);
380
387
                return r;
381
388
        }
382
389
 
383
 
        r = tracking_getornew(tracks,sourcename,sourceversion,&pkg);
 
390
        r = tracking_getornew(tracks, sourcename, sourceversion, &pkg);
384
391
        free(sourceversion);
385
 
        if( RET_WAS_ERROR(r) ) {
 
392
        if (RET_WAS_ERROR(r)) {
386
393
                strlist_done(&filekeys);
387
394
                return r;
388
395
        }
390
397
        // TODO: error handling is suboptimal here.
391
398
        //  is there a way to again remove old additions (esp. references)
392
399
        //  where something fails?
393
 
        for( i = 0 ; i < filekeys.count ; i++ ) {
 
400
        for (i = 0 ; i < filekeys.count ; i++) {
394
401
                r = trackedpackage_addfilekey(tracks, pkg,
395
 
                                ft_SOURCE, filekeys.values[i],
396
 
                                true, database);
 
402
                                ft_SOURCE, filekeys.values[i], true);
397
403
                filekeys.values[i] = NULL;
398
 
                if( RET_WAS_ERROR(r) ) {
 
404
                if (RET_WAS_ERROR(r)) {
399
405
                        strlist_done(&filekeys);
400
406
                        trackedpackage_free(pkg);
401
407
                        return r;
413
419
        //TODO: elliminate duplicate code!
414
420
        assert(packagename!=NULL);
415
421
 
416
 
        r = chunk_getvalue(chunk,"Version",&sourceversion);
417
 
        if( r == RET_NOTHING ) {
418
 
                fprintf(stderr, "Missing 'Version' field in chunk:'%s'\n", chunk);
 
422
        r = chunk_getvalue(chunk, "Version", &sourceversion);
 
423
        if (r == RET_NOTHING) {
 
424
                fprintf(stderr, "Missing 'Version' field in chunk:'%s'\n",
 
425
                                chunk);
419
426
                r = RET_ERROR;
420
427
        }
421
 
        if( RET_WAS_ERROR(r) ) {
 
428
        if (RET_WAS_ERROR(r)) {
422
429
                return r;
423
430
        }
424
431
        sourcename = strdup(packagename);
425
 
        if( sourcename == NULL ) {
 
432
        if (FAILEDTOALLOC(sourcename)) {
426
433
                free(sourceversion);
427
434
                return RET_ERROR_OOM;
428
435
        }
433
440
 
434
441
/****************************************************************/
435
442
 
436
 
static inline retvalue getvalue(const char *filename,const char *chunk,const char *field,char **value) {
437
 
        retvalue r;
438
 
 
439
 
        r = chunk_getvalue(chunk,field,value);
440
 
        if( r == RET_NOTHING ) {
441
 
                fprintf(stderr,"Missing '%s' field in %s!\n",field,filename);
442
 
                r = RET_ERROR;
443
 
        }
444
 
        return r;
445
 
}
446
 
 
447
 
static inline retvalue checkvalue(const char *filename,const char *chunk,const char *field) {
448
 
        retvalue r;
449
 
 
450
 
        r = chunk_checkfield(chunk,field);
451
 
        if( r == RET_NOTHING ) {
452
 
                fprintf(stderr,"Cannot find '%s' field in %s!\n",field,filename);
453
 
                r = RET_ERROR;
454
 
        }
455
 
        return r;
456
 
}
457
 
 
458
 
static inline retvalue getvalue_n(const char *chunk,const char *field,char **value) {
459
 
        retvalue r;
460
 
 
461
 
        r = chunk_getvalue(chunk,field,value);
462
 
        if( r == RET_NOTHING ) {
 
443
static inline retvalue getvalue(const char *filename, const char *chunk, const char *field, char **value) {
 
444
        retvalue r;
 
445
 
 
446
        r = chunk_getvalue(chunk, field, value);
 
447
        if (r == RET_NOTHING) {
 
448
                fprintf(stderr, "Missing '%s' field in %s!\n",
 
449
                                field, filename);
 
450
                r = RET_ERROR;
 
451
        }
 
452
        return r;
 
453
}
 
454
 
 
455
static inline retvalue checkvalue(const char *filename, const char *chunk, const char *field) {
 
456
        retvalue r;
 
457
 
 
458
        r = chunk_checkfield(chunk, field);
 
459
        if (r == RET_NOTHING) {
 
460
                fprintf(stderr, "Cannot find '%s' field in %s!\n",
 
461
                                field, filename);
 
462
                r = RET_ERROR;
 
463
        }
 
464
        return r;
 
465
}
 
466
 
 
467
static inline retvalue getvalue_n(const char *chunk, const char *field, char **value) {
 
468
        retvalue r;
 
469
 
 
470
        r = chunk_getvalue(chunk, field, value);
 
471
        if (r == RET_NOTHING) {
463
472
                *value = NULL;
464
473
        }
465
474
        return r;
472
481
 
473
482
        r = signature_readsignedchunk(filename, filenametoshow,
474
483
                        &dsc->control, NULL, broken);
475
 
        if( RET_WAS_ERROR(r) ) {
 
484
        if (RET_WAS_ERROR(r)) {
476
485
                return r;
477
486
        }
478
 
        if( verbose > 100 ) {
 
487
        if (verbose > 100) {
479
488
                fprintf(stderr, "Extracted control chunk from '%s': '%s'\n",
480
489
                                filenametoshow, dsc->control);
481
490
        }
483
492
        /* first look for fields that should be there */
484
493
 
485
494
        r = chunk_getname(dsc->control, "Source", &dsc->name, false);
486
 
        if( r == RET_NOTHING ) {
487
 
                fprintf(stderr, "Missing 'Source' field in %s!\n", filenametoshow);
 
495
        if (r == RET_NOTHING) {
 
496
                fprintf(stderr, "Missing 'Source' field in %s!\n",
 
497
                                filenametoshow);
488
498
                return RET_ERROR;
489
499
        }
490
 
        if( RET_WAS_ERROR(r) )
 
500
        if (RET_WAS_ERROR(r))
491
501
                return r;
492
502
 
493
 
        /* This is needed and cannot be ignored unless 
 
503
        /* This is needed and cannot be ignored unless
494
504
         * sources_complete is changed to not need it */
495
505
        r = checkvalue(filenametoshow, dsc->control, "Format");
496
 
        if( RET_WAS_ERROR(r) )
 
506
        if (RET_WAS_ERROR(r))
497
507
                return r;
498
508
 
499
509
        r = checkvalue(filenametoshow, dsc->control, "Maintainer");
500
 
        if( RET_WAS_ERROR(r) )
 
510
        if (RET_WAS_ERROR(r))
501
511
                return r;
502
512
 
503
513
        r = getvalue(filenametoshow, dsc->control, "Version", &dsc->version);
504
 
        if( RET_WAS_ERROR(r) )
 
514
        if (RET_WAS_ERROR(r))
505
515
                return r;
506
516
 
507
517
        r = getvalue_n(dsc->control, SECTION_FIELDNAME, &dsc->section);
508
 
        if( RET_WAS_ERROR(r) )
 
518
        if (RET_WAS_ERROR(r))
509
519
                return r;
510
520
        r = getvalue_n(dsc->control, PRIORITY_FIELDNAME, &dsc->priority);
511
 
        if( RET_WAS_ERROR(r) )
 
521
        if (RET_WAS_ERROR(r))
512
522
                return r;
513
523
 
514
 
        for( cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++ ) {
515
 
                assert( source_checksum_names[cs] != NULL );
 
524
        for (cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++) {
 
525
                assert (source_checksum_names[cs] != NULL);
516
526
                r = chunk_getextralinelist(dsc->control,
517
527
                                source_checksum_names[cs], &filelines[cs]);
518
 
                if( r == RET_NOTHING ) {
519
 
                        if( cs == cs_md5sum ) {
 
528
                if (r == RET_NOTHING) {
 
529
                        if (cs == cs_md5sum) {
520
530
                                fprintf(stderr,
521
 
"Missing 'Files' field in '%s'!\n",             filenametoshow);
 
531
"Missing 'Files' field in '%s'!\n",
 
532
                                        filenametoshow);
522
533
                                r = RET_ERROR;
523
534
                        } else
524
535
                                strlist_init(&filelines[cs]);
525
536
                }
526
 
                if( RET_WAS_ERROR(r) ) {
527
 
                        while( cs-- > cs_md5sum ) {
 
537
                if (RET_WAS_ERROR(r)) {
 
538
                        while (cs-- > cs_md5sum) {
528
539
                                strlist_done(&filelines[cs]);
529
540
                        }
530
541
                        return r;
531
542
                }
532
543
        }
533
544
        r = checksumsarray_parse(&dsc->files, filelines, filenametoshow);
534
 
        for( cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++ ) {
 
545
        for (cs = cs_md5sum ; cs < cs_hashCOUNT ; cs++) {
535
546
                strlist_done(&filelines[cs]);
536
547
        }
537
548
        return r;
550
561
        retvalue r;
551
562
        struct fieldtoadd *name;
552
563
        struct fieldtoadd *replace;
553
 
        char *newchunk,*newchunk2;
 
564
        char *newchunk, *newchunk2;
554
565
        char *newfilelines, *newsha1lines, *newsha256lines;
555
566
 
556
567
        assert(section != NULL && priority != NULL);
557
568
 
558
569
        /* first replace the "Source" with a "Package": */
559
 
        name = addfield_new("Package",dsc->name,NULL);
560
 
        if( name == NULL )
 
570
        name = addfield_new("Package", dsc->name, NULL);
 
571
        if (FAILEDTOALLOC(name))
561
572
                return RET_ERROR_OOM;
562
 
        name = deletefield_new("Source",name);
563
 
        if( name == NULL )
 
573
        name = deletefield_new("Source", name);
 
574
        if (FAILEDTOALLOC(name))
564
575
                return RET_ERROR_OOM;
565
576
        newchunk2  = chunk_replacefields(dsc->control, name, "Format", true);
566
577
        addfield_free(name);
567
 
        if( newchunk2 == NULL )
 
578
        if (FAILEDTOALLOC(newchunk2))
568
579
                return RET_ERROR_OOM;
569
580
 
570
581
        r = checksumsarray_genfilelist(&dsc->files,
571
582
                        &newfilelines, &newsha1lines, &newsha256lines);
572
 
        if( RET_WAS_ERROR(r) ) {
 
583
        if (RET_WAS_ERROR(r)) {
573
584
                free(newchunk2);
574
 
                return RET_ERROR_OOM;
 
585
                return r;
575
586
        }
576
 
        assert( newfilelines != NULL );
 
587
        assert (newfilelines != NULL);
577
588
        replace = aodfield_new("Checksums-Sha256", newsha256lines, NULL);
578
 
        if( replace != NULL )
 
589
        if (!FAILEDTOALLOC(replace))
579
590
                replace = aodfield_new("Checksums-Sha1", newsha1lines, replace);
580
 
        if( replace != NULL )
 
591
        if (!FAILEDTOALLOC(replace))
581
592
                replace = addfield_new("Files", newfilelines, replace);
582
 
        if( replace != NULL )
583
 
                replace = addfield_new("Directory",directory,replace);
584
 
        if( replace != NULL )
585
 
                replace = deletefield_new("Status",replace);
586
 
        if( replace != NULL )
587
 
                replace = addfield_new(SECTION_FIELDNAME,section,replace);
588
 
        if( replace != NULL )
589
 
                replace = addfield_new(PRIORITY_FIELDNAME,priority,replace);
590
 
        if( replace != NULL )
591
 
                replace = override_addreplacefields(override,replace);
592
 
        if( replace == NULL ) {
 
593
        if (!FAILEDTOALLOC(replace))
 
594
                replace = addfield_new("Directory", directory, replace);
 
595
        if (!FAILEDTOALLOC(replace))
 
596
                replace = deletefield_new("Status", replace);
 
597
        if (!FAILEDTOALLOC(replace))
 
598
                replace = addfield_new(SECTION_FIELDNAME, section, replace);
 
599
        if (!FAILEDTOALLOC(replace))
 
600
                replace = addfield_new(PRIORITY_FIELDNAME, priority, replace);
 
601
        if (!FAILEDTOALLOC(replace))
 
602
                replace = override_addreplacefields(override, replace);
 
603
        if (FAILEDTOALLOC(replace)) {
593
604
                free(newsha256lines);
594
605
                free(newsha1lines);
595
606
                free(newfilelines);
603
614
        free(newfilelines);
604
615
        free(newchunk2);
605
616
        addfield_free(replace);
606
 
        if( newchunk == NULL ) {
 
617
        if (FAILEDTOALLOC(newchunk)) {
607
618
                return RET_ERROR_OOM;
608
619
        }
609
620
 
624
635
        /* fake a checksumarray... */
625
636
        checksums.checksums = c;
626
637
        checksums.names.count = filekeys->count;
627
 
        checksums.names.values = calloc(filekeys->count, sizeof(char*));
628
 
        if (checksums.names.values == NULL)
 
638
        checksums.names.values = nzNEW(filekeys->count, char *);
 
639
        if (FAILEDTOALLOC(checksums.names.values))
629
640
                return RET_ERROR_OOM;
630
 
        for( i = 0 ; i < filekeys->count ; i++ ) {
 
641
        for (i = 0 ; i < filekeys->count ; i++) {
631
642
                checksums.names.values[i] = (char*)
632
643
                        dirs_basename(filekeys->values[i]);
633
644
        }
635
646
        r = checksumsarray_genfilelist(&checksums,
636
647
                        &newfilelines, &newsha1lines, &newsha256lines);
637
648
        free(checksums.names.values);
638
 
        if( RET_WAS_ERROR(r) ) {
639
 
                return RET_ERROR_OOM;
640
 
        }
641
 
        assert( newfilelines != NULL );
 
649
        if (RET_WAS_ERROR(r))
 
650
                return r;
 
651
        assert (newfilelines != NULL);
642
652
        replace = aodfield_new("Checksums-Sha256", newsha256lines, NULL);
643
 
        if( replace != NULL )
 
653
        if (!FAILEDTOALLOC(replace))
644
654
                replace = aodfield_new("Checksums-Sha1", newsha1lines, replace);
645
 
        if( replace != NULL )
 
655
        if (!FAILEDTOALLOC(replace))
646
656
                replace = addfield_new("Files", newfilelines, replace);
647
 
        if( replace == NULL ) {
 
657
        if (FAILEDTOALLOC(replace)) {
648
658
                free(newsha256lines);
649
659
                free(newsha1lines);
650
660
                free(newfilelines);
655
665
        free(newsha1lines);
656
666
        free(newfilelines);
657
667
        addfield_free(replace);
658
 
        if( newchunk == NULL )
 
668
        if (FAILEDTOALLOC(newchunk))
659
669
                return RET_ERROR_OOM;
660
670
 
661
671
        *out = newchunk;
664
674
 
665
675
char *calc_source_basename(const char *name, const char *version) {
666
676
        const char *v = strchr(version, ':');
667
 
        if( v != NULL )
 
677
        if (v != NULL)
668
678
                v++;
669
679
        else
670
680
                v = version;
673
683
 
674
684
char *calc_sourcedir(component_t component, const char *sourcename) {
675
685
 
676
 
        assert( *sourcename != '\0' );
 
686
        assert (*sourcename != '\0');
677
687
 
678
 
        if( sourcename[0] == 'l' && sourcename[1] == 'i' &&
679
 
                        sourcename[2] == 'b' && sourcename[3] != '\0' )
 
688
        if (sourcename[0] == 'l' && sourcename[1] == 'i' &&
 
689
                        sourcename[2] == 'b' && sourcename[3] != '\0')
680
690
                return mprintf("pool/%s/lib%c/%s",
681
691
                                atoms_components[component],
682
692
                                sourcename[3], sourcename);
683
 
        else if( *sourcename != '\0' )
 
693
        else if (*sourcename != '\0')
684
694
                return mprintf("pool/%s/%c/%s",
685
695
                                atoms_components[component],
686
696
                                sourcename[0], sourcename);
689
699
}
690
700
 
691
701
char *calc_filekey(component_t component, const char *sourcename, const char *filename) {
692
 
        if( sourcename[0] == 'l' && sourcename[1] == 'i' &&
693
 
                        sourcename[2] == 'b' && sourcename[3] != '\0' )
 
702
        if (sourcename[0] == 'l' && sourcename[1] == 'i' &&
 
703
                        sourcename[2] == 'b' && sourcename[3] != '\0')
694
704
                return mprintf("pool/%s/lib%c/%s/%s",
695
705
                                atoms_components[component],
696
706
                                sourcename[3], sourcename, filename);
697
 
        else if( *sourcename != '\0' )
 
707
        else if (*sourcename != '\0')
698
708
                return mprintf("pool/%s/%c/%s/%s",
699
709
                                atoms_components[component],
700
710
                                sourcename[0], sourcename, filename);
703
713
}
704
714
 
705
715
char *calc_byhanddir(component_t component, const char *sourcename, const char *version) {
706
 
        if( sourcename[0] == 'l' && sourcename[1] == 'i' &&
707
 
                        sourcename[2] == 'b' && sourcename[3] != '\0' )
 
716
        if (sourcename[0] == 'l' && sourcename[1] == 'i' &&
 
717
                        sourcename[2] == 'b' && sourcename[3] != '\0')
708
718
                return mprintf("pool/%s/lib%c/%s/%s_%s_byhand",
709
719
                                atoms_components[component],
710
720
                                sourcename[3], sourcename,
711
721
                                sourcename, version);
712
 
        else if( *sourcename != '\0' )
 
722
        else if (*sourcename != '\0')
713
723
                return mprintf("pool/%s/%c/%s/%s_%s_byhand",
714
724
                                atoms_components[component],
715
725
                                sourcename[0], sourcename,