← Back to branch summary

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

« back to all changes in this revision

Viewing changes to archallflood.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:
archallflood.c
80
80
};
81
81
 
82
82
static void aa_package_data_free(/*@only@*/struct aa_package_data *data){
83
 
        if( data == NULL )
 
83
        if (data == NULL)
84
84
                return;
85
85
        free(data->name);
86
86
        free(data->old_version);
95
95
        struct aa_source_package *s;
96
96
        struct aa_package_data *l;
97
97
 
98
 
        if( list == NULL )
 
98
        if (list == NULL)
99
99
                return;
100
100
 
101
101
        l = list->list;
102
 
        while( l != NULL ) {
 
102
        while (l != NULL) {
103
103
                struct aa_package_data *n = l->next;
104
104
                aa_package_data_free(l);
105
105
                l = n;
106
106
        }
107
107
        s = list->sources;
108
 
        while( s != NULL ) {
 
108
        while (s != NULL) {
109
109
                struct aa_source_package *n;
110
110
 
111
 
                while( s->left_child != NULL || s->right_child != NULL ) {
112
 
                        if( s->left_child != NULL ) {
 
111
                while (s->left_child != NULL || s->right_child != NULL) {
 
112
                        if (s->left_child != NULL) {
113
113
                                n = s->left_child;
114
114
                                s->left_child = NULL;
115
115
                                s = n;
120
120
                        }
121
121
                }
122
122
 
123
 
                while( s->nextversion != NULL ) {
 
123
                while (s->nextversion != NULL) {
124
124
                        n = s->nextversion->nextversion;
125
125
                        /* do not free name, it is not malloced */
126
126
                        free(s->nextversion->version);
147
147
        /* if this gets too slow, make it a balanced tree,
148
148
         * but it seems fast enough even as simple tree */
149
149
 
150
 
        while( *p != NULL ) {
 
150
        while (*p != NULL) {
151
151
                c = strcmp(source, (*p)->name);
152
 
                if( c == 0 )
 
152
                if (c == 0)
153
153
                        break;
154
154
                parent = *p;
155
 
                if( c > 0 )
 
155
                if (c > 0)
156
156
                        p = &parent->right_child;
157
157
                else
158
158
                        p = &parent->left_child;
159
159
        }
160
 
        if( *p == NULL ) {
 
160
        if (*p == NULL) {
161
161
                /* there is not even something with this name */
162
 
                n = calloc(1, sizeof(struct aa_source_package));
163
 
                if( FAILEDTOALLOC(n) ) {
 
162
                n = zNEW(struct aa_source_package);
 
163
                if (FAILEDTOALLOC(n)) {
164
164
                        free(source); free(sourceversion);
165
165
                        return RET_ERROR_OOM;
166
166
                }
175
175
        source = (*p)->name;
176
176
        /* source name found, now look for version: */
177
177
        c = strcmp(sourceversion, (*p)->version);
178
 
        if( c == 0 ) {
 
178
        if (c == 0) {
179
179
                free(sourceversion);
180
180
                *src_p = *p;
181
181
                return RET_OK;
182
182
        }
183
 
        if( c < 0 ) {
 
183
        if (c < 0) {
184
184
                /* before first item, do some swapping as this is
185
185
                 * part of the name linked list */
186
 
                n = calloc(1, sizeof(struct aa_source_package));
187
 
                if( FAILEDTOALLOC(n) ) {
 
186
                n = zNEW(struct aa_source_package);
 
187
                if (FAILEDTOALLOC(n)) {
188
188
                        free(sourceversion);
189
189
                        return RET_ERROR_OOM;
190
190
                }
204
204
        }
205
205
        do {
206
206
                p = &(*p)->nextversion;
207
 
                if( *p == NULL )
 
207
                if (*p == NULL)
208
208
                        break;
209
209
                c = strcmp(sourceversion, (*p)->version);
210
 
        } while( c > 0 );
 
210
        } while (c > 0);
211
211
 
212
 
        if( c == 0 ) {
213
 
                assert( *p != NULL );
 
212
        if (c == 0) {
 
213
                assert (*p != NULL);
214
214
                free(sourceversion);
215
215
                *src_p = *p;
216
216
                return RET_OK;
217
217
        }
218
 
        n = calloc(1, sizeof(struct aa_source_package));
219
 
        if( FAILEDTOALLOC(n) ) {
 
218
        n = zNEW(struct aa_source_package);
 
219
        if (FAILEDTOALLOC(n)) {
220
220
                free(sourceversion);
221
221
                return RET_ERROR_OOM;
222
222
        }
234
234
 
235
235
        p = list->sources;
236
236
 
237
 
        while( p != NULL ) {
 
237
        while (p != NULL) {
238
238
                c = strcmp(source, p->name);
239
 
                if( c == 0 )
 
239
                if (c == 0)
240
240
                        break;
241
 
                if( c > 0 )
 
241
                if (c > 0)
242
242
                        p = p->right_child;
243
243
                else
244
244
                        p = p->left_child;
245
245
        }
246
 
        if( p == NULL )
 
246
        if (p == NULL)
247
247
                return NULL;
248
 
        while( p != NULL && (c = strcmp(sourceversion, p->version)) > 0 )
 
248
        while (p != NULL && (c = strcmp(sourceversion, p->version)) > 0)
249
249
                p = p->nextversion;
250
 
        if( c < 0 )
 
250
        if (c < 0)
251
251
                return NULL;
252
252
        else
253
253
                return p;
264
264
        struct aa_package_data *package;
265
265
 
266
266
        r = list->target->getarchitecture(chunk, &architecture);
267
 
        if( RET_WAS_ERROR(r) )
 
267
        if (RET_WAS_ERROR(r))
268
268
                return r;
269
269
 
270
270
        r = list->target->getsourceandversion(chunk, packagename,
271
271
                        &source, &sourceversion);
272
 
        if( RET_WAS_ERROR(r) )
 
272
        if (RET_WAS_ERROR(r))
273
273
                return r;
274
274
 
275
275
        r = find_or_add_source(list, source, sourceversion, &src);
276
276
        source = NULL; sourceversion = NULL; // just to be sure
277
 
        if( RET_WAS_ERROR(r) )
 
277
        if (RET_WAS_ERROR(r))
278
278
                return r;
279
279
 
280
280
        r = list->target->getversion(chunk, &version);
281
 
        if( RET_WAS_ERROR(r) )
 
281
        if (RET_WAS_ERROR(r))
282
282
                return r;
283
283
 
284
284
 
285
 
        if( architecture != architecture_all ) {
 
285
        if (architecture != architecture_all) {
286
286
                free(version);
287
287
                src->has_sibling = true;
288
288
                return RET_NOTHING;
289
289
        }
290
290
 
291
 
        package = calloc(1,sizeof(struct aa_package_data));
292
 
        if( package == NULL ) {
 
291
        package = zNEW(struct aa_package_data);
 
292
        if (FAILEDTOALLOC(package)) {
293
293
                free(version);
294
294
                return RET_ERROR_OOM;
295
295
        }
296
296
 
297
297
        package->name = strdup(packagename);
298
 
        if( package->name == NULL ) {
 
298
        if (FAILEDTOALLOC(package->name)) {
299
299
                free(package);
300
300
                free(version);
301
301
                return RET_ERROR_OOM;
304
304
        version = NULL; // just to be sure...
305
305
        package->old_source = src;
306
306
 
307
 
        if( list->list == NULL ) {
 
307
        if (list->list == NULL) {
308
308
                /* first chunk to add: */
309
309
                list->list = package;
310
310
                list->last = package;
311
311
        } else {
312
 
                if( strcmp(packagename, list->last->name) > 0 ) {
 
312
                if (strcmp(packagename, list->last->name) > 0) {
313
313
                        list->last->next = package;
314
314
                        list->last = package;
315
315
                } else {
316
316
                        /* this should only happen if the underlying
317
317
                         * database-method get changed, so just throwing
318
318
                         * out here */
319
 
                        fprintf(stderr, "INTERNAL ERROR: Package database is not sorted!!!\n");
 
319
                        fprintf(stderr,
 
320
"INTERNAL ERROR: Package database is not sorted!!!\n");
320
321
                        assert(false);
321
322
                        exit(EXIT_FAILURE);
322
323
                }
324
325
        return RET_OK;
325
326
}
326
327
 
327
 
static retvalue floodlist_initialize(struct floodlist **fl, struct target *t, struct database *database) {
 
328
static retvalue floodlist_initialize(struct floodlist **fl, struct target *t) {
328
329
        struct floodlist *list;
329
 
        retvalue r,r2;
 
330
        retvalue r, r2;
330
331
        const char *packagename, *controlchunk;
331
332
        struct target_cursor iterator;
332
333
 
333
 
        list = calloc(1,sizeof(struct floodlist));
334
 
        if( list == NULL )
 
334
        list = zNEW(struct floodlist);
 
335
        if (FAILEDTOALLOC(list))
335
336
                return RET_ERROR_OOM;
336
337
 
337
338
        list->target = t;
338
339
 
339
340
        /* Begin with the packages currently in the archive */
340
341
 
341
 
        r = target_openiterator(t, database, READONLY, &iterator);
342
 
        if( RET_WAS_ERROR(r) ) {
 
342
        r = target_openiterator(t, READONLY, &iterator);
 
343
        if (RET_WAS_ERROR(r)) {
343
344
                floodlist_free(list);
344
345
                return r;
345
346
        }
346
 
        while( target_nextpackage(&iterator, &packagename, &controlchunk) ) {
 
347
        while (target_nextpackage(&iterator, &packagename, &controlchunk)) {
347
348
                r2 = save_package_version(list, packagename, controlchunk);
348
349
                RET_UPDATE(r, r2);
349
 
                if( RET_WAS_ERROR(r2) )
 
350
                if (RET_WAS_ERROR(r2))
350
351
                        break;
351
352
        }
352
353
        r2 = target_closeiterator(&iterator);
353
354
        RET_UPDATE(r, r2);
354
355
 
355
 
        if( RET_WAS_ERROR(r) ) {
 
356
        if (RET_WAS_ERROR(r)) {
356
357
                floodlist_free(list);
357
358
                return r;
358
359
        }
368
369
        /* insertafter = NULL will mean insert before list */
369
370
        insertafter = list->last;
370
371
        /* the next one to test, current = NULL will mean not found */
371
 
        if( insertafter != NULL )
 
372
        if (insertafter != NULL)
372
373
                current = insertafter->next;
373
374
        else
374
375
                current = list->list;
376
377
        /* the algorithm assumes almost all packages are feed in
377
378
         * alphabetically. */
378
379
 
379
 
        while( true ) {
 
380
        while (true) {
380
381
                int cmp;
381
382
 
382
 
                assert( insertafter == NULL || insertafter->next == current );
383
 
                assert( insertafter != NULL || current == list->list );
 
383
                assert (insertafter == NULL || insertafter->next == current);
 
384
                assert (insertafter != NULL || current == list->list);
384
385
 
385
 
                if( current == NULL )
 
386
                if (current == NULL)
386
387
                        cmp = -1; /* every package is before the end of list */
387
388
                else
388
389
                        cmp = strcmp(packagename_const, current->name);
389
390
 
390
 
                if( cmp == 0 )
 
391
                if (cmp == 0)
391
392
                        break;
392
393
 
393
 
                if( cmp < 0 ) {
 
394
                if (cmp < 0) {
394
395
                        int precmp;
395
396
 
396
 
                        if( insertafter == NULL ) {
 
397
                        if (insertafter == NULL) {
397
398
                                /* if we are before the first
398
399
                                 * package, add us there...*/
399
400
                                current = NULL;
400
401
                                break;
401
402
                        }
402
403
                        precmp = strcmp(packagename_const, insertafter->name);
403
 
                        if( precmp == 0 ) {
 
404
                        if (precmp == 0) {
404
405
                                current = insertafter;
405
406
                                break;
406
 
                        } else if( precmp < 0 ) {
 
407
                        } else if (precmp < 0) {
407
408
                                /* restart at the beginning: */
408
409
                                current = list->list;
409
410
                                insertafter = NULL;
413
414
                                current = NULL;
414
415
                                break;
415
416
                        }
416
 
                        assert( "This is not reached" == NULL );
 
417
                        assert ("This is not reached" == NULL);
417
418
                }
418
419
                /* cmp > 0 : may come later... */
419
 
                assert( current != NULL );
 
420
                assert (current != NULL);
420
421
                insertafter = current;
421
422
                current = current->next;
422
 
                if( current == NULL ) {
 
423
                if (current == NULL) {
423
424
                        /* add behind insertafter at end of list */
424
425
                        break;
425
426
                }
426
427
                /* otherwise repeat until place found */
427
428
        }
428
 
        if( current == NULL ) {
 
429
        if (current == NULL) {
429
430
                /* adding a package not yet known */
430
431
                struct aa_package_data *new;
431
432
                char *source, *sourceversion;
433
434
 
434
435
                r = list->target->getsourceandversion(chunk,
435
436
                                packagename_const, &source, &sourceversion);
436
 
                if( ! RET_IS_OK(r) ) {
 
437
                if (! RET_IS_OK(r)) {
437
438
                        free(version);
438
439
                        return r;
439
440
                }
440
441
                src = find_source(list, source, sourceversion);
441
442
                free(source); free(sourceversion);
442
 
                new = calloc(1,sizeof(struct aa_package_data));
443
 
                if( new == NULL ) {
 
443
                new = zNEW(struct aa_package_data);
 
444
                if (FAILEDTOALLOC(new)) {
444
445
                        free(version);
445
446
                        return RET_ERROR_OOM;
446
447
                }
448
449
                new->new_version = version;
449
450
                version = NULL;
450
451
                new->name = strdup(packagename_const);
451
 
                if( FAILEDTOALLOC(new->name) ) {
 
452
                if (FAILEDTOALLOC(new->name)) {
452
453
                        aa_package_data_free(new);
453
454
                        return RET_ERROR_OOM;
454
455
                }
457
458
                                architecture_all, chunk,
458
459
                                &new->new_control, &new->new_filekeys,
459
460
                                &new->new_origfiles);
460
 
                if( RET_WAS_ERROR(r) ) {
 
461
                if (RET_WAS_ERROR(r)) {
461
462
                        aa_package_data_free(new);
462
463
                        return r;
463
464
                }
464
 
                if( insertafter != NULL ) {
 
465
                if (insertafter != NULL) {
465
466
                        new->next = insertafter->next;
466
467
                        insertafter->next = new;
467
468
                } else {
480
481
 
481
482
                list->last = current;
482
483
 
483
 
                if( current->new_has_sibling ) {
 
484
                if (current->new_has_sibling) {
484
485
                        /* it has a new and that has a binary sibling,
485
486
                         * which means this becomes the new version
486
487
                         * exactly when it is newer than the old newest */
487
488
                        r = dpkgversions_cmp(version, current->new_version,
488
489
                                        &versioncmp);
489
 
                        if( RET_WAS_ERROR(r) ) {
 
490
                        if (RET_WAS_ERROR(r)) {
490
491
                                free(version);
491
492
                                return r;
492
493
                        }
493
 
                        if( versioncmp <= 0 ) {
 
494
                        if (versioncmp <= 0) {
494
495
                                free(version);
495
496
                                return RET_NOTHING;
496
497
                        }
497
 
                } else if( current->old_version != NULL ) {
 
498
                } else if (current->old_version != NULL) {
498
499
                        /* if it is older than the old one, we will
499
500
                         * always discard it */
500
501
                        r = dpkgversions_cmp(version, current->old_version,
501
502
                                        &versioncmp);
502
 
                        if( RET_WAS_ERROR(r) ) {
 
503
                        if (RET_WAS_ERROR(r)) {
503
504
                                free(version);
504
505
                                return r;
505
506
                        }
506
 
                        if( versioncmp <= 0 ) {
 
507
                        if (versioncmp <= 0) {
507
508
                                free(version);
508
509
                                return RET_NOTHING;
509
510
                        }
512
513
 
513
514
                r = list->target->getsourceandversion(chunk,
514
515
                                packagename_const, &source, &sourceversion);
515
 
                if( ! RET_IS_OK(r) ) {
 
516
                if (! RET_IS_OK(r)) {
516
517
                        free(version);
517
518
                        return r;
518
519
                }
519
520
                src = find_source(list, source, sourceversion);
520
521
                free(source); free(sourceversion);
521
 
                if( src == NULL || !src->has_sibling ) {
 
522
                if (src == NULL || !src->has_sibling) {
522
523
                        /* the new one has no sibling, only allowed
523
524
                         * to override those that have: */
524
 
                        if( current->new_version == NULL ) {
525
 
                                if( current->old_source->has_sibling ) {
 
525
                        if (current->new_version == NULL) {
 
526
                                if (current->old_source->has_sibling) {
526
527
                                        free(version);
527
528
                                        return RET_NOTHING;
528
529
                                }
529
 
                        } else if( current->new_has_sibling ) {
 
530
                        } else if (current->new_has_sibling) {
530
531
                                free(version);
531
532
                                return RET_NOTHING;
532
533
                        } else {
533
534
                                /* the new one has no sibling and the old one
534
535
                                 * has not too, take the newer one: */
535
 
                                r = dpkgversions_cmp(version, current->new_version,
 
536
                                r = dpkgversions_cmp(version,
 
537
                                                current->new_version,
536
538
                                                &versioncmp);
537
 
                                if( RET_WAS_ERROR(r) ) {
 
539
                                if (RET_WAS_ERROR(r)) {
538
540
                                        free(version);
539
541
                                        return r;
540
542
                                }
541
 
                                if( versioncmp <= 0 ) {
 
543
                                if (versioncmp <= 0) {
542
544
                                        free(version);
543
545
                                        return RET_NOTHING;
544
546
                                }
549
551
                                packagename_const, version,
550
552
                                architecture_all, chunk,
551
553
                                &control, &files, &origfiles);
552
 
                if( RET_WAS_ERROR(r) ) {
 
554
                if (RET_WAS_ERROR(r)) {
553
555
                        free(version);
554
556
                        return r;
555
557
                }
567
569
        return RET_OK;
568
570
}
569
571
 
570
 
static retvalue floodlist_pull(struct floodlist *list, struct target *source, struct database *database) {
 
572
static retvalue floodlist_pull(struct floodlist *list, struct target *source) {
571
573
        retvalue result, r;
572
574
        const char *package, *control;
573
575
        struct target_cursor iterator;
574
576
 
575
577
        list->last = NULL;
576
 
        r = target_openiterator(source, database, READONLY, &iterator);
577
 
        if( RET_WAS_ERROR(r) )
 
578
        r = target_openiterator(source, READONLY, &iterator);
 
579
        if (RET_WAS_ERROR(r))
578
580
                return r;
579
581
        result = RET_NOTHING;
580
 
        while( target_nextpackage(&iterator, &package, &control) ) {
 
582
        while (target_nextpackage(&iterator, &package, &control)) {
581
583
                char *version;
582
584
                architecture_t package_architecture;
583
585
 
584
 
                r = list->target->getarchitecture(control, &package_architecture);
585
 
                if( r == RET_NOTHING )
 
586
                r = list->target->getarchitecture(control,
 
587
                                &package_architecture);
 
588
                if (r == RET_NOTHING)
586
589
                        continue;
587
 
                if( !RET_IS_OK(r) ) {
 
590
                if (!RET_IS_OK(r)) {
588
591
                        RET_UPDATE(result, r);
589
592
                        break;
590
593
                }
591
 
                if( package_architecture != architecture_all )
 
594
                if (package_architecture != architecture_all)
592
595
                        continue;
593
596
 
594
597
                r = list->target->getversion(control, &version);
595
 
                if( r == RET_NOTHING )
 
598
                if (r == RET_NOTHING)
596
599
                        continue;
597
 
                if( !RET_IS_OK(r) ) {
 
600
                if (!RET_IS_OK(r)) {
598
601
                        RET_UPDATE(result, r);
599
602
                        break;
600
603
                }
601
604
                r = floodlist_trypackage(list, package, version, control);
602
605
                RET_UPDATE(result, r);
603
 
                if( RET_WAS_ERROR(r) )
 
606
                if (RET_WAS_ERROR(r))
604
607
                        break;
605
 
                if( interrupted() ) {
 
608
                if (interrupted()) {
606
609
                        result = RET_ERROR_INTERRUPTED;
607
610
                        break;
608
611
                }
609
612
        }
610
613
        r = target_closeiterator(&iterator);
611
 
        RET_ENDUPDATE(result,r);
 
614
        RET_ENDUPDATE(result, r);
612
615
        return result;
613
616
}
614
617
 
615
 
static retvalue floodlist_install(struct floodlist *list, struct logger *logger, struct database *database, /*@NULL@*/struct trackingdata *td) {
 
618
static retvalue floodlist_install(struct floodlist *list, struct logger *logger, /*@NULL@*/struct trackingdata *td) {
616
619
        struct aa_package_data *pkg;
617
 
        retvalue result,r;
 
620
        retvalue result, r;
618
621
 
619
 
        if( list->list == NULL )
 
622
        if (list->list == NULL)
620
623
                return RET_NOTHING;
621
624
 
622
 
        result = target_initpackagesdb(list->target, database, READWRITE);
623
 
        if( RET_WAS_ERROR(result) )
 
625
        result = target_initpackagesdb(list->target, READWRITE);
 
626
        if (RET_WAS_ERROR(result))
624
627
                return result;
625
628
        result = RET_NOTHING;
626
 
        for( pkg = list->list ; pkg != NULL ; pkg = pkg->next ) {
627
 
                if( pkg->new_version != NULL ) {
628
 
                        r = files_expectfiles(database,
629
 
                                        &pkg->new_filekeys,
 
629
        for (pkg = list->list ; pkg != NULL ; pkg = pkg->next) {
 
630
                if (pkg->new_version != NULL) {
 
631
                        r = files_expectfiles(&pkg->new_filekeys,
630
632
                                        pkg->new_origfiles.checksums);
631
633
                        RET_UPDATE(result, r);
632
 
                        if( RET_WAS_ERROR(r) )
 
634
                        if (RET_WAS_ERROR(r))
633
635
                                continue;
634
 
                        if( interrupted() ) {
 
636
                        if (interrupted()) {
635
637
                                r = RET_ERROR_INTERRUPTED;
636
638
                                break;
637
639
                        }
638
 
                        if( td != NULL ) {
639
 
                                if( pkg->new_source != NULL ) {
 
640
                        if (td != NULL) {
 
641
                                if (pkg->new_source != NULL) {
640
642
                                        r = trackingdata_switch(td,
641
643
                                                pkg->new_source->name,
642
644
                                                pkg->new_source->version);
648
650
                                                        pkg->name,
649
651
                                                        &source,
650
652
                                                        &sourceversion);
651
 
                                        assert( r != RET_NOTHING );
652
 
                                        if( RET_WAS_ERROR(r) ) {
 
653
                                        assert (r != RET_NOTHING);
 
654
                                        if (RET_WAS_ERROR(r)) {
653
655
                                                RET_UPDATE(result, r);
654
656
                                                break;
655
657
                                        }
658
660
                                        free(source);
659
661
                                        free(sourceversion);
660
662
                                }
661
 
                                if( RET_WAS_ERROR(r) ) {
 
663
                                if (RET_WAS_ERROR(r)) {
662
664
                                        RET_UPDATE(result, r);
663
665
                                        break;
664
666
                                }
665
667
                        }
666
668
                        r = target_addpackage(list->target,
667
 
                                        logger, database,
668
 
                                        pkg->name, pkg->new_version,
 
669
                                        logger, pkg->name, pkg->new_version,
669
670
                                        pkg->new_control, &pkg->new_filekeys,
670
 
                                        false, td, architecture_all,
 
671
                                        false, td, architecture_all,
671
672
                                        NULL, NULL);
672
673
                        RET_UPDATE(result, r);
673
 
                        if( RET_WAS_ERROR(r) )
 
674
                        if (RET_WAS_ERROR(r))
674
675
                                break;
675
676
                }
676
677
        }
679
680
        return result;
680
681
}
681
682
 
682
 
retvalue flood(struct distribution *d, const struct atomlist *components, const struct atomlist *architectures, const struct atomlist *packagetypes, architecture_t architecture, struct database *database, trackingdb tracks) {
 
683
retvalue flood(struct distribution *d, const struct atomlist *components, const struct atomlist *architectures, const struct atomlist *packagetypes, architecture_t architecture, trackingdb tracks) {
683
684
        struct target *t, *s;
684
685
        retvalue result = RET_NOTHING, r;
685
686
        struct trackingdata trackingdata;
686
687
 
687
 
        if( tracks != NULL ) {
 
688
        if (tracks != NULL) {
688
689
                r = trackingdata_new(tracks, &trackingdata);
689
 
                if( RET_WAS_ERROR(r) )
 
690
                if (RET_WAS_ERROR(r))
690
691
                        return r;
691
692
        }
692
693
 
693
 
        for( t = d->targets ; t != NULL ; t = t->next ) {
 
694
        for (t = d->targets ; t != NULL ; t = t->next) {
694
695
                struct floodlist *fl = NULL;
695
696
 
696
 
                if( atom_defined(architecture) ) {
697
 
                        if( architecture != t->architecture_atom )
698
 
                                continue;
699
 
                } else if( limitations_missed(architectures,
700
 
                                                t->architecture_atom) )
701
 
                                continue;
702
 
                if( limitations_missed(components, t->component_atom) )
703
 
                        continue;
704
 
                if( limitations_missed(packagetypes, t->packagetype_atom) )
705
 
                        continue;
706
 
                if( t->packagetype_atom != pt_deb
707
 
                                && t->packagetype_atom != pt_udeb )
 
697
                if (atom_defined(architecture)) {
 
698
                        if (architecture != t->architecture)
 
699
                                continue;
 
700
                } else if (limitations_missed(architectures,
 
701
                                        t->architecture))
 
702
                                continue;
 
703
                if (limitations_missed(components, t->component))
 
704
                        continue;
 
705
                if (limitations_missed(packagetypes, t->packagetype))
 
706
                        continue;
 
707
                if (t->packagetype != pt_deb && t->packagetype != pt_udeb)
708
708
                        continue;
709
709
 
710
 
                r = floodlist_initialize(&fl, t, database);
711
 
                if( RET_WAS_ERROR(r) ) {
712
 
                        if( tracks != NULL )
 
710
                r = floodlist_initialize(&fl, t);
 
711
                if (RET_WAS_ERROR(r)) {
 
712
                        if (tracks != NULL)
713
713
                                trackingdata_done(&trackingdata);
714
714
                        return r;
715
715
                }
716
716
 
717
 
                for( s = d->targets ; s != NULL ; s = s->next ) {
718
 
                        if( s->component_atom != t->component_atom )
 
717
                for (s = d->targets ; s != NULL ; s = s->next) {
 
718
                        if (s->component != t->component)
719
719
                                continue;
720
 
                        if( s->packagetype_atom != t->packagetype_atom )
 
720
                        if (s->packagetype != t->packagetype)
721
721
                                continue;
722
722
                        /* no need to copy things from myself: */
723
 
                        if( s->architecture_atom == t->architecture_atom )
724
 
                                continue;
725
 
                        if( limitations_missed(architectures,
726
 
                                                s->architecture_atom) )
727
 
                                continue;
728
 
                        r = floodlist_pull(fl, s, database);
 
723
                        if (s->architecture == t->architecture)
 
724
                                continue;
 
725
                        if (limitations_missed(architectures,
 
726
                                                s->architecture))
 
727
                                continue;
 
728
                        r = floodlist_pull(fl, s);
729
729
                        RET_UPDATE(d->status, r);
730
 
                        if( RET_WAS_ERROR(r) ) {
731
 
                                if( tracks != NULL )
 
730
                        if (RET_WAS_ERROR(r)) {
 
731
                                if (tracks != NULL)
732
732
                                        trackingdata_done(&trackingdata);
733
733
                                floodlist_free(fl);
734
734
                                return r;
735
735
                        }
736
736
                }
737
 
                r = floodlist_install(fl, d->logger, database,
 
737
                r = floodlist_install(fl, d->logger,
738
738
                                (tracks != NULL)?&trackingdata:NULL);
739
739
                RET_UPDATE(result, r);
740
740
                floodlist_free(fl);
741
 
                if( RET_WAS_ERROR(r) ) {
742
 
                        if( tracks != NULL )
 
741
                if (RET_WAS_ERROR(r)) {
 
742
                        if (tracks != NULL)
743
743
                                trackingdata_done(&trackingdata);
744
744
                        return r;
745
745
                }
746
746
        }
747
 
        if( tracks != NULL ) {
748
 
                r = trackingdata_finish(tracks, &trackingdata, database);
 
747
        if (tracks != NULL) {
 
748
                r = trackingdata_finish(tracks, &trackingdata);
749
749
                RET_ENDUPDATE(result, r);
750
750
        }
751
751
        return result;