← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/avscan/gutsy-backports

« back to all changes in this revision

Viewing changes to avscan/main.c

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Berg
  • Date: 2007-02-28 19:26:49 UTC
  • mfrom: (1.4.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070228192649-ur655x0ttlqucokc
Tags: 1.3.1-openssl-4
http://bugs.debian.org/411760
http://bugs.debian.org/412838
* Add MIME entry for application/x-msdos-program (Closes: #411760).
* Update clamav 0.90 patch, s/CL_SCAN_STDOPT/CL_DB_STDOPT/
  (Closes: #412838).

Show diffs side-by-side

added added

removed removed

Lines of Context:
avscan/main.c
16
16
#include <unistd.h>
17
17
 
18
18
#include "guiutils.h"
 
19
#include "fprompt.h"
19
20
#include "cdialog.h"
20
21
#include "pdialog.h"
21
 
#include "fprompt.h"
22
22
#include "fb.h"
23
23
 
24
 
#include "avscanop.h"
25
24
#include "cfg.h"
26
25
#include "cfg_fio.h"
 
26
#include "scanner_opts.h"
 
27
#include "avscanop.h"
27
28
#include "obj.h"
28
29
#include "objfio.h"
29
30
#include "win.h"
48
49
win_struct *MainNewAVScan(core_struct *core, gint argc, gchar **argv);
49
50
 
50
51
 
51
 
static gint     *avscan_scan_stop_count;
 
52
static gint             *avscan_scan_stop_count;
 
53
static gboolean         *avscan_reload;
52
54
 
53
55
 
54
56
#define ATOI(s)         (((s) != NULL) ? atoi(s) : 0)
70
72
{
71
73
        switch(s)
72
74
        {
 
75
#ifdef SIGHUP
 
76
          case SIGHUP:
 
77
            if(avscan_reload != NULL)
 
78
                *avscan_reload = TRUE;
 
79
            break;
 
80
#endif
 
81
 
 
82
#ifdef SIGINT
73
83
          case SIGINT:
74
84
            /* Is this process running as a scan process? */
75
85
            if(avscan_scan_stop_count != NULL)
93
103
                exit(4);        /* User aborted */
94
104
            }
95
105
            break;
 
106
#endif
96
107
 
 
108
#ifdef SIGTERM
97
109
          case SIGTERM:
98
 
            exit(4);    /* User aborted */
 
110
            exit(4);            /* User aborted */
99
111
            break;
 
112
#endif
100
113
 
 
114
#ifdef SIGSEGV
101
115
          case SIGSEGV:
102
 
            exit(8);    /* Segmentation fault */
103
 
            break;
104
 
 
105
 
          case SIGSTOP:
106
 
            break;
107
 
 
108
 
          case SIGCONT:
109
 
            break;
 
116
            exit(8);            /* Segmentation fault */
 
117
            break;
 
118
#endif
 
119
 
 
120
#ifdef SIGPIPE
 
121
          case SIGPIPE:
 
122
            break;
 
123
#endif
110
124
        }
111
125
}
112
126
 
150
164
        if((total_windows == 0) || core->close_all_windows)
151
165
        {
152
166
            gtk_main_quit();
 
167
            core->main_toid = 0;
153
168
            return(FALSE);
154
169
        }
155
170
 
192
207
            cfg_list, CFG_PARM_DB_LAST_UPDATE,
193
208
            0l, FALSE
194
209
        );
 
210
 
 
211
        CFGItemListSetValueI(
 
212
            cfg_list, CFG_PARM_SCAN_CPU_PRIORITY,
 
213
            1, FALSE
 
214
        );
 
215
        CFGItemListSetValueI(
 
216
            cfg_list, CFG_PARM_SCAN_REPORT_ALL_OBJECTS,
 
217
            FALSE, FALSE
 
218
        );
 
219
        CFGItemListSetValueL(
 
220
            cfg_list, CFG_PARM_SCAN_MAX_FILES,
 
221
            1000l, FALSE
 
222
        );
 
223
        CFGItemListSetValueL(
 
224
            cfg_list, CFG_PARM_SCAN_MAX_FILE_SIZE,
 
225
            10l * 1048576l, FALSE
 
226
        );
 
227
        CFGItemListSetValueL(
 
228
            cfg_list, CFG_PARM_SCAN_MAX_RECURSIONS,
 
229
            5l, FALSE
 
230
        );
 
231
        CFGItemListSetValueL(
 
232
            cfg_list, CFG_PARM_SCAN_MAX_MAIL_RECURSIONS,
 
233
            64l, FALSE
 
234
        );
 
235
        CFGItemListSetValueL(
 
236
            cfg_list, CFG_PARM_SCAN_MAX_COMPRESSION_RATIO,
 
237
            200l, FALSE
 
238
        );
195
239
 
196
240
        CFGItemListSetValueI(
197
241
            cfg_list, CFG_PARM_WIN_X,
286
330
        core_struct *core;
287
331
 
288
332
        /* Initialize the globals */
 
333
        avscan_reload = NULL;
289
334
        avscan_scan_stop_count = NULL;
290
335
 
291
336
        /* Set up the signal callbacks */
 
337
#ifdef SIGINT
292
338
        signal(SIGINT, MainSignalCB);
 
339
#endif
 
340
#ifdef SIGTERM
293
341
        signal(SIGTERM, MainSignalCB);
 
342
#endif
 
343
#ifdef SIGSEGV
294
344
        signal(SIGSEGV, MainSignalCB);
295
 
        signal(SIGSTOP, MainSignalCB);
296
 
        signal(SIGCONT, MainSignalCB);
 
345
#endif
 
346
#ifdef SIGPIPE
297
347
        signal(SIGPIPE, MainSignalCB);
 
348
#endif
298
349
 
299
350
        /* Get the current working directory */
300
351
        cwd = g_get_current_dir();
341
392
            else if(!g_strcasecmp(arg, "--scan"))
342
393
            {
343
394
                /* Do scan procedure and return */
 
395
                gboolean reload = FALSE;
344
396
                gint status, stop_count = 0;
345
397
                gchar *db_path = NULL;
346
398
                GList *path_list = NULL;
347
399
                gboolean        recursive = FALSE,
348
400
                                executables_only = FALSE,
349
401
                                ignore_links = FALSE;
 
402
                scanner_opts_struct scanner_opts;
 
403
 
 
404
#define DELETE_LOCALS   {                               \
 
405
 if(path_list != NULL) {                                \
 
406
  g_list_foreach(path_list, (GFunc)g_free, NULL);       \
 
407
  g_list_free(path_list);                               \
 
408
 }                                                      \
 
409
 g_free(db_path);                                       \
 
410
}
 
411
 
350
412
 
351
413
                /* Set the stop count pointer for the signal callback */
 
414
                avscan_reload = &reload;
352
415
                avscan_scan_stop_count = &stop_count;
353
416
 
 
417
                scanner_opts.flags = 0;
 
418
                scanner_opts.max_files = 1000l;
 
419
                scanner_opts.max_file_size_bytes = 10l * 1048576l;
 
420
                scanner_opts.max_recursions = 5l;
 
421
                scanner_opts.max_mail_recursions = 64l;
 
422
                scanner_opts.max_compression_ratio = 200l;
 
423
                scanner_opts.cpu_priority = SCANNER_CPU_PRIORITY_HIGH;
 
424
 
 
425
 
354
426
                /* Collect subsequent arguments */
355
427
                for(i++; i < argc; i++)
356
428
                {
366
438
                        i++;
367
439
                        arg = (i < argc) ? argv[i] : NULL;
368
440
                        if(arg != NULL)
 
441
                        {
369
442
                            db_path = STRDUP(arg);
 
443
                        }
370
444
                        else
 
445
                        {
371
446
                            g_printerr(
372
447
                                "%s: Requires argument.\n",
373
448
                                argv[i - 1]
374
449
                            );
 
450
                            DELETE_LOCALS
 
451
                            return(2);
 
452
                        }
375
453
                    }
376
454
                    /* Recursive */
377
455
                    else if(!g_strcasecmp(arg, "--recursive") ||
396
474
                    {
397
475
                        ignore_links = TRUE;
398
476
                    }
 
477
                    /* Report All Objects */
 
478
                    else if(!g_strcasecmp(arg, "--report-all-objects") ||
 
479
                            !g_strcasecmp(arg, "--report_all_objects")
 
480
                    )
 
481
                    {
 
482
                        scanner_opts.flags |= SCANNER_FLAG_REPORT_ALL_OBJECTS;
 
483
                    }
 
484
                    /* Max Files */
 
485
                    else if(!g_strcasecmp(arg, "--max-files") ||
 
486
                            !g_strcasecmp(arg, "--max_files")
 
487
                    )
 
488
                    {
 
489
                        i++;
 
490
                        arg = (i < argc) ? argv[i] : NULL;
 
491
                        if(arg != NULL)
 
492
                        {
 
493
                            scanner_opts.max_files = ATOL(arg);
 
494
                        }
 
495
                        else
 
496
                        {
 
497
                            g_printerr(
 
498
                                "%s: Requires argument.\n",
 
499
                                argv[i - 1]
 
500
                            );
 
501
                            DELETE_LOCALS
 
502
                            return(2);
 
503
                        }
 
504
                    }
 
505
                    /* Max File Size */
 
506
                    else if(!g_strcasecmp(arg, "--max-file-size") ||
 
507
                            !g_strcasecmp(arg, "--max_file_size")
 
508
                    )
 
509
                    {
 
510
                        i++;
 
511
                        arg = (i < argc) ? argv[i] : NULL;
 
512
                        if(arg != NULL)
 
513
                        {
 
514
                            scanner_opts.max_file_size_bytes = ATOL(arg);
 
515
                        }
 
516
                        else
 
517
                        {
 
518
                            g_printerr(
 
519
                                "%s: Requires argument.\n",
 
520
                                argv[i - 1]
 
521
                            );
 
522
                            DELETE_LOCALS
 
523
                            return(2);
 
524
                        }
 
525
                    }
 
526
                    /* Max Recursions */
 
527
                    else if(!g_strcasecmp(arg, "--max-recursions") ||
 
528
                            !g_strcasecmp(arg, "--max_recursions")
 
529
                    )
 
530
                    {
 
531
                        i++;
 
532
                        arg = (i < argc) ? argv[i] : NULL;
 
533
                        if(arg != NULL)
 
534
                        {
 
535
                            scanner_opts.max_recursions = ATOL(arg);
 
536
                        }
 
537
                        else
 
538
                        {
 
539
                            g_printerr(
 
540
                                "%s: Requires argument.\n",
 
541
                                argv[i - 1]
 
542
                            );
 
543
                            DELETE_LOCALS
 
544
                            return(2);
 
545
                        }
 
546
                    }
 
547
                    /* Max Mail Recursions */
 
548
                    else if(!g_strcasecmp(arg, "--max-mail-recursions") ||
 
549
                            !g_strcasecmp(arg, "--max_mail_recursions")
 
550
                    )
 
551
                    {
 
552
                        i++;
 
553
                        arg = (i < argc) ? argv[i] : NULL;
 
554
                        if(arg != NULL)
 
555
                        {
 
556
                            scanner_opts.max_mail_recursions = ATOL(arg);
 
557
                        }
 
558
                        else
 
559
                        {
 
560
                            g_printerr(
 
561
                                "%s: Requires argument.\n",
 
562
                                argv[i - 1]
 
563
                            );
 
564
                            DELETE_LOCALS
 
565
                            return(2);
 
566
                        }
 
567
                    }
 
568
                    /* Max Compression Ratio */
 
569
                    else if(!g_strcasecmp(arg, "--max-compression-ratio") ||
 
570
                            !g_strcasecmp(arg, "--max_compression_ratio")
 
571
                    )
 
572
                    {
 
573
                        i++;
 
574
                        arg = (i < argc) ? argv[i] : NULL;
 
575
                        if(arg != NULL)
 
576
                        {
 
577
                            scanner_opts.max_compression_ratio = ATOL(arg);
 
578
                        }
 
579
                        else
 
580
                        {
 
581
                            g_printerr(
 
582
                                "%s: Requires argument.\n",
 
583
                                argv[i - 1]
 
584
                            );
 
585
                            DELETE_LOCALS
 
586
                            return(2);
 
587
                        }
 
588
                    }
 
589
                    /* CPU Priority */
 
590
                    else if(!g_strcasecmp(arg, "--cpu-priority") ||
 
591
                            !g_strcasecmp(arg, "--cpu_priority")
 
592
                    )
 
593
                    {
 
594
                        i++;
 
595
                        arg = (i < argc) ? argv[i] : NULL;
 
596
                        if(arg != NULL)
 
597
                        {
 
598
                            scanner_cpu_priority p = SCANNER_CPU_PRIORITY_LOWEST;
 
599
                            if(!g_strcasecmp(arg, "highest"))
 
600
                                p = SCANNER_CPU_PRIORITY_HIGHEST;
 
601
                            else if(!g_strcasecmp(arg, "high"))
 
602
                                p = SCANNER_CPU_PRIORITY_HIGH;
 
603
                            else if(!g_strcasecmp(arg, "medium"))
 
604
                                p = SCANNER_CPU_PRIORITY_MEDIUM;
 
605
                            else if(!g_strcasecmp(arg, "low"))
 
606
                                p = SCANNER_CPU_PRIORITY_LOW;
 
607
                            else if(!g_strcasecmp(arg, "lowest"))
 
608
                                p = SCANNER_CPU_PRIORITY_LOWEST;
 
609
                            else
 
610
                            {
 
611
                                g_printerr(
 
612
"%s: Invalid value, valid values are; highest, high, medium, low, lowest.\n",
 
613
                                    argv[i - 1]
 
614
                                );
 
615
                                DELETE_LOCALS
 
616
                                return(2);
 
617
                            }
 
618
                            scanner_opts.cpu_priority = p;
 
619
                        }
 
620
                        else
 
621
                        {
 
622
                            g_printerr(
 
623
                                "%s: Requires argument.\n",
 
624
                                argv[i - 1]
 
625
                            );
 
626
                            DELETE_LOCALS
 
627
                            return(2);
 
628
                        }
 
629
                    }
399
630
                    /* All else assume path */
400
631
                    else if((*arg != '-') && (*arg != '+'))
401
632
                    {
404
635
                            g_strconcat(cwd, G_DIR_SEPARATOR_S, arg, NULL);
405
636
                        path_list = g_list_append(path_list, path);
406
637
                    }
 
638
                    /* Unsupported argument? */
 
639
                    else if((*arg == '-') || (*arg == '+'))
 
640
                    {
 
641
                        g_printerr(
 
642
                            "%s: Unsupported argument.\n",
 
643
                            arg
 
644
                        );
 
645
                        DELETE_LOCALS
 
646
                        return(2);
 
647
                    }
407
648
                }
408
649
 
409
 
                /* Do scan procedure */
 
650
                /* Do the scan procedure */
410
651
                status = AVScanOP(
411
652
                    db_path,            /* Database Path */
412
653
                    path_list,          /* Paths to objects to scan */
413
 
                    recursive,          /* Recursive */
414
 
                    executables_only,   /* Executables Only */
415
 
                    ignore_links,       /* Ignore Links */
416
 
                    &stop_count
 
654
                    recursive,
 
655
                    executables_only,
 
656
                    ignore_links,
 
657
                    avscan_reload, avscan_scan_stop_count,
 
658
                    &scanner_opts
417
659
                );
418
660
 
419
661
                /* Unset the stop count pointer */
 
662
                avscan_reload = NULL;
420
663
                avscan_scan_stop_count = NULL;
421
664
 
422
 
                g_list_foreach(path_list, (GFunc)g_free, NULL);
423
 
                g_list_free(path_list);
424
 
 
425
 
                g_free(db_path);
 
665
                DELETE_LOCALS
426
666
 
427
667
                return(status);
 
668
#undef DELETE_LOCALS
428
669
            }
429
670
        }
430
671
 
 
672
#ifdef HAVE_EDV2
 
673
#define DELETE_CORE_LIBS        {                       \
 
674
 if(core != NULL) {                                     \
 
675
  /* Endeavour Mark II context */                       \
 
676
  if(core->edv_ctx != NULL) {                           \
 
677
   EDVContextDelete(core->edv_ctx);                     \
 
678
   core->edv_ctx = NULL;                                \
 
679
  }                                                     \
 
680
 }                                                      \
 
681
}
 
682
#else
 
683
#define DELETE_CORE_LIBS        { }
 
684
#endif
 
685
 
 
686
#define DELETE_CORE_SHUTDOWN    {                       \
 
687
                                                        \
 
688
 if(core != NULL) {                                     \
 
689
  /* Windows */                                         \
 
690
  if(core->win != NULL) {                               \
 
691
   g_list_foreach(core->win, (GFunc)WinDelete, NULL);   \
 
692
   g_list_free(core->win);                              \
 
693
   core->win = NULL;                                    \
 
694
  }                                                     \
 
695
                                                        \
 
696
  /* Cursors */                                         \
 
697
  GDK_CURSOR_DESTROY(core->busy_cur);                   \
 
698
  GDK_CURSOR_DESTROY(core->passive_busy_cur);           \
 
699
                                                        \
 
700
  /* Pixmaps */                                         \
 
701
  GDK_PIXMAP_UNREF(core->scan_item_pixmap);             \
 
702
  GDK_BITMAP_UNREF(core->scan_item_mask);               \
 
703
  GDK_PIXMAP_UNREF(core->file_infected_pixmap);         \
 
704
  GDK_BITMAP_UNREF(core->file_infected_mask);           \
 
705
  GDK_PIXMAP_UNREF(core->folder_closed_pixmap);         \
 
706
  GDK_BITMAP_UNREF(core->folder_closed_mask);           \
 
707
  GDK_PIXMAP_UNREF(core->folder_opened_pixmap);         \
 
708
  GDK_BITMAP_UNREF(core->folder_opened_mask);           \
 
709
  GDK_PIXMAP_UNREF(core->db_item_pixmap);               \
 
710
  GDK_BITMAP_UNREF(core->db_item_mask);                 \
 
711
                                                        \
 
712
  /* Configuration List */                              \
 
713
  CFGItemListDeleteList(core->cfg_list);                \
 
714
                                                        \
 
715
  DELETE_CORE_LIBS                                      \
 
716
                                                        \
 
717
  g_free(core->prog_name);                              \
 
718
  g_free(core->prog_path);                              \
 
719
  g_free(core->prog_data_dir);                          \
 
720
                                                        \
 
721
  g_free(core->title);                                  \
 
722
  g_free(core->geometry);                               \
 
723
                                                        \
 
724
  g_free(core);                                         \
 
725
  core = NULL;                                          \
 
726
 }                                                      \
 
727
                                                        \
 
728
 /* Shutdown dialogs */                                 \
 
729
 PDialogShutdown();                                     \
 
730
 FileBrowserShutdown();                                 \
 
731
 FPromptShutdown();                                     \
 
732
 CDialogShutdown();                                     \
 
733
}
431
734
 
432
735
        /* Initialize GTK as needed */
433
736
        if(!initialized_gtk)
450
753
 
451
754
        /* Initialize dialogs */
452
755
        CDialogInit();
453
 
        PDialogInit();
454
756
        FPromptInit();
455
757
        FileBrowserInit();
 
758
        PDialogInit();
456
759
 
457
760
 
458
761
        /* Begin creating the core */
459
 
        core = CORE(
460
 
            g_malloc0(sizeof(core_struct))
461
 
        );
 
762
        core = CORE(g_malloc0(sizeof(core_struct)));
 
763
        if(core == NULL)
 
764
        {
 
765
            DELETE_CORE_SHUTDOWN
 
766
            return(3);
 
767
        }
462
768
 
463
769
        /* Configuration List */
464
770
        core->cfg_list = cfg_list = MainCfgListNew();
465
771
 
 
772
 
466
773
#ifdef HAVE_EDV2
467
774
        /* Endeavour Mark II context */
468
775
        core->edv_ctx = ctx = EDVContextNew();
469
776
#endif
470
777
 
 
778
        core->target_scan_item_atom = gdk_atom_intern(
 
779
            DND_TARGET_SCAN_ITEM,
 
780
            FALSE
 
781
        );
 
782
 
471
783
        /* Pixmaps */
472
784
        core->scan_item_pixmap = GDK_PIXMAP_NEW_FROM_XPM_DATA(
473
785
            &core->scan_item_mask,
577
889
        core->prog_data_dir = NULL;
578
890
 
579
891
#ifdef HAVE_EDV2
580
 
        /* Load Endeavour configuration from file */
 
892
        /* Load the Endeavour configuration from file */
581
893
        EDVContextLoadConfigurationFile(ctx, NULL);
582
894
#endif
583
895
 
618
930
        {
619
931
            GList *paths_list = NULL;
620
932
 
 
933
#define DELETE_LOCALS   {                               \
 
934
 if(paths_list != NULL) {                               \
 
935
  g_list_foreach(paths_list, (GFunc)g_free, NULL);      \
 
936
  g_list_free(paths_list);                              \
 
937
 }                                                      \
 
938
}
 
939
 
621
940
            /* Parse the arguments */
622
941
            for(i = 1; i < argc; i++)
623
942
            {
633
952
                    i++;
634
953
                    arg = (i < argc) ? argv[i] : NULL;
635
954
                    if(arg != NULL)
 
955
                    {
636
956
                        CFGItemListSetValueS(
637
957
                            cfg_list, CFG_PARM_DB_LOCATION,
638
958
                            arg, FALSE
639
959
                        );
 
960
                    }
640
961
                    else
 
962
                    {
641
963
                        g_printerr(
642
964
                            "%s: Requires argument.\n",
643
965
                            argv[i - 1]
644
966
                        );
 
967
                        DELETE_LOCALS
 
968
                        DELETE_CORE_SHUTDOWN
 
969
                        return(2);
 
970
                    }
645
971
                }
646
972
                /* Recursive */
647
973
                else if(!g_strcasecmp(arg, "--recursive") ||
675
1001
                        TRUE
676
1002
                    );
677
1003
                }
678
 
                /* Skip GUI arguments that have a an argument */
 
1004
                /* Report All Objects */
 
1005
                else if(!g_strcasecmp(arg, "--report-all-objects") ||
 
1006
                        !g_strcasecmp(arg, "--report_all_objects")
 
1007
                )
 
1008
                {
 
1009
                    CFGItemListSetValueL(
 
1010
                        cfg_list, CFG_PARM_SCAN_REPORT_ALL_OBJECTS,
 
1011
                        TRUE, FALSE
 
1012
                    );
 
1013
                }
 
1014
                /* Do Not Report All Objects */
 
1015
                else if(!g_strcasecmp(arg, "--no-report-all-objects") ||
 
1016
                        !g_strcasecmp(arg, "--no-report_all_objects")
 
1017
                )
 
1018
                {
 
1019
                    CFGItemListSetValueL(
 
1020
                        cfg_list, CFG_PARM_SCAN_REPORT_ALL_OBJECTS,
 
1021
                        FALSE, FALSE
 
1022
                    );
 
1023
                }
 
1024
                /* Max Files */
 
1025
                else if(!g_strcasecmp(arg, "--max-files") ||
 
1026
                        !g_strcasecmp(arg, "--max_files")
 
1027
                )
 
1028
                {
 
1029
                    i++;
 
1030
                    arg = (i < argc) ? argv[i] : NULL;
 
1031
                    if(arg != NULL)
 
1032
                    {
 
1033
                        CFGItemListSetValueL(
 
1034
                            cfg_list, CFG_PARM_SCAN_MAX_FILES,
 
1035
                            ATOL(arg), FALSE
 
1036
                        );
 
1037
                    }
 
1038
                    else
 
1039
                    {
 
1040
                        g_printerr(
 
1041
                            "%s: Requires argument.\n",
 
1042
                            argv[i - 1]
 
1043
                        );
 
1044
                        DELETE_LOCALS
 
1045
                        DELETE_CORE_SHUTDOWN
 
1046
                        return(2);
 
1047
                    }
 
1048
                }
 
1049
                /* Max File Size */
 
1050
                else if(!g_strcasecmp(arg, "--max-file-size") ||
 
1051
                        !g_strcasecmp(arg, "--max_file_size")
 
1052
                )
 
1053
                {
 
1054
                    i++;
 
1055
                    arg = (i < argc) ? argv[i] : NULL;
 
1056
                    if(arg != NULL)
 
1057
                    {
 
1058
                        CFGItemListSetValueL(
 
1059
                            cfg_list, CFG_PARM_SCAN_MAX_FILE_SIZE,
 
1060
                            ATOL(arg), FALSE
 
1061
                        );
 
1062
                    }
 
1063
                    else
 
1064
                    {
 
1065
                        g_printerr(
 
1066
                            "%s: Requires argument.\n",
 
1067
                            argv[i - 1]
 
1068
                        );
 
1069
                        DELETE_LOCALS
 
1070
                        DELETE_CORE_SHUTDOWN
 
1071
                        return(2);
 
1072
                    }
 
1073
                }
 
1074
                /* Max Recursions */
 
1075
                else if(!g_strcasecmp(arg, "--max-recursions") ||
 
1076
                        !g_strcasecmp(arg, "--max_recursions")
 
1077
                )
 
1078
                {
 
1079
                    i++;
 
1080
                    arg = (i < argc) ? argv[i] : NULL;
 
1081
                    if(arg != NULL)
 
1082
                    {
 
1083
                        CFGItemListSetValueL(
 
1084
                            cfg_list, CFG_PARM_SCAN_MAX_RECURSIONS,
 
1085
                            ATOL(arg), FALSE
 
1086
                        );
 
1087
                    }
 
1088
                    else
 
1089
                    {
 
1090
                        g_printerr(
 
1091
                            "%s: Requires argument.\n",
 
1092
                            argv[i - 1]
 
1093
                        );
 
1094
                        DELETE_LOCALS
 
1095
                        DELETE_CORE_SHUTDOWN
 
1096
                        return(2);
 
1097
                    }
 
1098
                }
 
1099
                /* Max Mail Recursions */
 
1100
                else if(!g_strcasecmp(arg, "--max-mail-recursions") ||
 
1101
                        !g_strcasecmp(arg, "--max_mail_recursions")
 
1102
                )
 
1103
                {
 
1104
                    i++;
 
1105
                    arg = (i < argc) ? argv[i] : NULL;
 
1106
                    if(arg != NULL)
 
1107
                    {
 
1108
                        CFGItemListSetValueL(
 
1109
                            cfg_list, CFG_PARM_SCAN_MAX_MAIL_RECURSIONS,
 
1110
                            ATOL(arg), FALSE
 
1111
                        );
 
1112
                    }
 
1113
                    else
 
1114
                    {
 
1115
                        g_printerr(
 
1116
                            "%s: Requires argument.\n",
 
1117
                            argv[i - 1]
 
1118
                        );
 
1119
                        DELETE_LOCALS
 
1120
                        DELETE_CORE_SHUTDOWN
 
1121
                        return(2);
 
1122
                    }
 
1123
                }
 
1124
                /* Max Compression Ratio */
 
1125
                else if(!g_strcasecmp(arg, "--max-compression-ratio") ||
 
1126
                        !g_strcasecmp(arg, "--max_compression_ratio")
 
1127
                )
 
1128
                {
 
1129
                    i++;
 
1130
                    arg = (i < argc) ? argv[i] : NULL;
 
1131
                    if(arg != NULL)
 
1132
                    {
 
1133
                        CFGItemListSetValueL(
 
1134
                            cfg_list, CFG_PARM_SCAN_MAX_COMPRESSION_RATIO,
 
1135
                            ATOL(arg), FALSE
 
1136
                        );
 
1137
                    }
 
1138
                    else
 
1139
                    {
 
1140
                        g_printerr(
 
1141
                            "%s: Requires argument.\n",
 
1142
                            argv[i - 1]
 
1143
                        );
 
1144
                        DELETE_LOCALS
 
1145
                        DELETE_CORE_SHUTDOWN
 
1146
                        return(2);
 
1147
                    }
 
1148
                }
 
1149
                /* CPU Priority */
 
1150
                else if(!g_strcasecmp(arg, "--cpu-priority") ||
 
1151
                        !g_strcasecmp(arg, "--cpu_priority")
 
1152
                )
 
1153
                {
 
1154
                    i++;
 
1155
                    arg = (i < argc) ? argv[i] : NULL;
 
1156
                    if(arg != NULL)
 
1157
                    {
 
1158
                        scanner_cpu_priority p = SCANNER_CPU_PRIORITY_LOWEST;
 
1159
                        if(!g_strcasecmp(arg, "highest"))
 
1160
                            p = SCANNER_CPU_PRIORITY_HIGHEST;
 
1161
                        else if(!g_strcasecmp(arg, "high"))
 
1162
                            p = SCANNER_CPU_PRIORITY_HIGH;
 
1163
                        else if(!g_strcasecmp(arg, "medium"))
 
1164
                            p = SCANNER_CPU_PRIORITY_MEDIUM;
 
1165
                        else if(!g_strcasecmp(arg, "low"))
 
1166
                            p = SCANNER_CPU_PRIORITY_LOW;
 
1167
                        else if(!g_strcasecmp(arg, "lowest"))
 
1168
                            p = SCANNER_CPU_PRIORITY_LOWEST;
 
1169
                        else
 
1170
                        {
 
1171
                            g_printerr(
 
1172
"%s: Invalid value, valid values are; highest, high, medium, low, lowest.\n",
 
1173
                                argv[i - 1]
 
1174
                            );
 
1175
                            DELETE_LOCALS
 
1176
                            DELETE_CORE_SHUTDOWN
 
1177
                            return(2);
 
1178
                        }
 
1179
                        CFGItemListSetValueI(
 
1180
                            cfg_list, CFG_PARM_SCAN_CPU_PRIORITY,
 
1181
                            (gint)p, FALSE
 
1182
                        );
 
1183
                    }
 
1184
                    else
 
1185
                    {
 
1186
                        g_printerr(
 
1187
                            "%s: Requires argument.\n",
 
1188
                            argv[i - 1]
 
1189
                        );
 
1190
                        DELETE_LOCALS
 
1191
                        DELETE_CORE_SHUTDOWN
 
1192
                        return(2);
 
1193
                    }
 
1194
                }
 
1195
                /* Skip GUI arguments that have an argument */
679
1196
                else if(!g_strcasecmp(arg, "--geometry") ||
680
1197
                        !g_strcasecmp(arg, "-geometry") ||
681
1198
                        !g_strcasecmp(arg, "--fn") ||
739
1256
                g_free(location);
740
1257
 
741
1258
                WinStartCB(win->start_btn, win);
742
 
 
743
 
                g_list_foreach(paths_list, (GFunc)g_free, NULL);
744
 
                g_list_free(paths_list);
745
1259
            }
 
1260
 
 
1261
            DELETE_LOCALS
 
1262
 
 
1263
#undef DELETE_LOCALS
746
1264
        }
747
1265
 
748
 
        /* Set main timeout callback */
749
 
        gtk_timeout_add(1000l, MainTOCB, core);
 
1266
        /* Set the main timeout callback */
 
1267
        core->main_toid = gtk_timeout_add(
 
1268
            1000l,
 
1269
            MainTOCB, core
 
1270
        );
 
1271
 
 
1272
        /* Push the main GTK+ loop */
750
1273
        gtk_main();
751
1274
 
752
1275
 
760
1283
        CFGFileSave(path, cfg_list);
761
1284
        g_free(path);
762
1285
 
763
 
 
764
 
        /* Begin deleting core */
765
 
        g_list_foreach(core->win, (GFunc)WinDelete, NULL);
766
 
        g_list_free(core->win);
767
 
        core->win = NULL;
768
 
 
769
 
        /* Cursors */
770
 
        GDK_CURSOR_DESTROY(core->busy_cur);
771
 
        GDK_CURSOR_DESTROY(core->passive_busy_cur);
772
 
 
773
 
        /* Pixmaps */
774
 
        GDK_PIXMAP_UNREF(core->scan_item_pixmap);
775
 
        GDK_BITMAP_UNREF(core->scan_item_mask);
776
 
        GDK_PIXMAP_UNREF(core->file_infected_pixmap);
777
 
        GDK_BITMAP_UNREF(core->file_infected_mask);
778
 
        GDK_PIXMAP_UNREF(core->folder_closed_pixmap);
779
 
        GDK_BITMAP_UNREF(core->folder_closed_mask);
780
 
        GDK_PIXMAP_UNREF(core->folder_opened_pixmap);
781
 
        GDK_BITMAP_UNREF(core->folder_opened_mask);
782
 
        GDK_PIXMAP_UNREF(core->db_item_pixmap);
783
 
        GDK_BITMAP_UNREF(core->db_item_mask);
784
 
 
785
 
        /* Configuration List */
786
 
        CFGItemListDeleteList(core->cfg_list);
787
 
 
788
 
#ifdef HAVE_EDV2
789
 
        /* Endeavour Mark II context */
790
 
        EDVContextDelete(core->edv_ctx);
791
 
#endif
792
 
 
793
 
        g_free(core->prog_name);
794
 
        g_free(core->prog_path);
795
 
        g_free(core->prog_data_dir);
796
 
 
797
 
        g_free(core->title);
798
 
        g_free(core->geometry);
799
 
 
800
 
        g_free(core);
801
 
        core = NULL;
802
 
 
803
 
 
804
 
        /* Shutdown dialogs */
805
 
        FileBrowserShutdown();
806
 
        FPromptShutdown();
807
 
        PDialogShutdown();
808
 
        CDialogShutdown();
 
1286
        DELETE_CORE_SHUTDOWN
809
1287
 
810
1288
        return(0);
 
1289
 
 
1290
#undef DELETE_CORE_SHUTDOWN
 
1291
#undef DELETE_CORE_LIBS
811
1292
}