← Back to branch summary

~ubuntu-branches/debian/squeeze/ntp/squeeze-201010051545

« back to all changes in this revision

Viewing changes to ntpd/cmd_args.c

  • Committer: Bazaar Package Importer
  • Author(s): Kurt Roeckx
  • Date: 2009-01-05 21:10:03 UTC
  • mfrom: (1.2.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20090105211003-mh6zc3um4k1uhsj7
Tags: 1:4.2.4p4+dfsg-8
It did not properly check the return value of EVP_VerifyFinal
which results in an malformed DSA signature being treated as
a good signature rather than as an error.  (CVE-2009-0021)

Show diffs side-by-side

added added

removed removed

Lines of Context:
ntpd/cmd_args.c
10
10
#include "ntp_cmdargs.h"
11
11
 
12
12
#ifdef SIM
13
 
#include "ntpsim.h"
 
13
# include "ntpsim.h"
 
14
# include "ntpdsim-opts.h"
 
15
# define OPTSTRUCT      ntpdsimOptions
 
16
#else
 
17
# include "ntpd-opts.h"
 
18
# define OPTSTRUCT      ntpdOptions
14
19
#endif /* SIM */
15
20
 
16
21
/*
17
22
 * Definitions of things either imported from or exported to outside
18
23
 */
19
24
extern char const *progname;
20
 
int     listen_to_virtual_ips = 1;
21
 
 
22
 
#ifdef SYS_WINNT
23
 
extern BOOL NoWinService;
24
 
#endif
25
 
 
26
 
static const char *ntp_options = "aAbB:c:C:dD:f:gi:k:l:LmnNO:p:P:qr:s:S:t:T:W:u:v:V:xY:Z:-:";
 
25
extern const char *specific_interface;
 
26
extern short default_ai_family;
27
27
 
28
28
#ifdef HAVE_NETINFO
29
29
extern int      check_netinfo;
31
31
 
32
32
 
33
33
/*
34
 
 * getstartup - search through the options looking for a debugging flag
35
 
 */
36
 
void
37
 
getstartup(
38
 
        int argc,
39
 
        char *argv[]
40
 
        )
41
 
{
42
 
        int errflg;
43
 
        extern int priority_done;
44
 
        int c;
45
 
 
46
 
#ifdef DEBUG
47
 
        debug = 0;              /* no debugging by default */
48
 
#endif
49
 
 
50
 
        /*
51
 
         * This is a big hack.  We don't really want to read command line
52
 
         * configuration until everything else is initialized, since
53
 
         * the ability to configure the system may depend on storage
54
 
         * and the like having been initialized.  Except that we also
55
 
         * don't want to initialize anything until after detaching from
56
 
         * the terminal, but we won't know to do that until we've
57
 
         * parsed the command line.  Do that now, crudely, and do it
58
 
         * again later.  Our ntp_getopt() is explicitly reusable, by the
59
 
         * way.  Your own mileage may vary.
60
 
         *
61
 
         * This hack is even called twice (to allow complete logging to file)
62
 
         */
63
 
        errflg = 0;
64
 
        progname = argv[0];
65
 
 
66
 
        /*
67
 
         * Decode argument list
68
 
         */
69
 
        while ((c = ntp_getopt(argc, argv, ntp_options)) != EOF)
70
 
            switch (c) {
71
 
#ifdef DEBUG
72
 
                case 'd':
73
 
                    ++debug;
74
 
                    break;
75
 
                case 'D':
76
 
                    debug = (int)atol(ntp_optarg);
77
 
                    printf("Debug1: %s -> %x = %d\n", ntp_optarg, debug, debug);
78
 
                    break;
79
 
#else
80
 
                case 'd':
81
 
                case 'D':
82
 
                    msyslog(LOG_ERR, "ntpd not compiled with -DDEBUG option - no DEBUG support");
83
 
                    fprintf(stderr, "ntpd not compiled with -DDEBUG option - no DEBUG support\n");
84
 
                    ++errflg;
85
 
                    break;
86
 
#endif
87
 
                case 'L':
88
 
                    listen_to_virtual_ips = 0;
89
 
                    break;
90
 
                case 'l':
91
 
                        {
92
 
                                FILE *new_file;
93
 
 
94
 
                                if(strcmp(ntp_optarg, "stderr") == 0)
95
 
                                        new_file = stderr;
96
 
                                else if(strcmp(ntp_optarg, "stdout") == 0)
97
 
                                        new_file = stdout;
98
 
                                else
99
 
                                        new_file = fopen(ntp_optarg, "a");
100
 
                                if (new_file != NULL) {
101
 
                                        NLOG(NLOG_SYSINFO)
102
 
                                                msyslog(LOG_NOTICE, "logging to file %s", ntp_optarg);
103
 
                                        if (syslog_file != NULL &&
104
 
                                                fileno(syslog_file) != fileno(new_file))
105
 
                                                (void)fclose(syslog_file);
106
 
 
107
 
                                        syslog_file = new_file;
108
 
                                        syslogit = 0;
109
 
                                }
110
 
                                else
111
 
                                        msyslog(LOG_ERR,
112
 
                                                "Cannot open log file %s",
113
 
                                                ntp_optarg);
114
 
                        }
115
 
                        break;
116
 
 
117
 
                case 'n':
118
 
                case 'q':
119
 
                    ++nofork;
120
 
#ifdef SYS_WINNT
121
 
                    NoWinService = TRUE;         
122
 
#endif
123
 
                    break;
124
 
 
125
 
                case 'N':
126
 
                    priority_done = 0;
127
 
                    break;
128
 
                        
129
 
                case '?':
130
 
                    ++errflg;
131
 
                    break;
132
 
 
133
 
            case '-':
134
 
              if ( ! strcmp(ntp_optarg, "version") ) {
135
 
                printf("%.80s: %.80s\n", progname, Version);
136
 
                exit(0);
137
 
              } else if ( ! strcmp(ntp_optarg, "help") ) {
138
 
                /* usage(); */
139
 
                /* exit(0); */
140
 
                ++errflg;
141
 
              } else if ( ! strcmp(ntp_optarg, "copyright") ) {
142
 
                printf("unknown\n");
143
 
                exit(0);
144
 
              } else {
145
 
                fprintf(stderr, "%.80s: Error unknown argument '--%.80s'\n",
146
 
                        progname,
147
 
                        ntp_optarg);
148
 
                exit(12);
149
 
              }
150
 
              break;
151
 
 
152
 
                default:
153
 
                        break;
154
 
                }
155
 
 
156
 
        if (errflg || ntp_optind != argc) {
157
 
                (void) fprintf(stderr, "usage: %s [ -abdgmnqx ] [ -c config_file ] [ -e e_delay ]\n", progname);
158
 
                (void) fprintf(stderr, "\t\t[ -f freq_file ] [ -k key_file ] [ -l log_file ]\n");
159
 
                (void) fprintf(stderr, "\t\t[ -p pid_file ] [ -r broad_delay ] [ -s statdir ]\n");
160
 
                (void) fprintf(stderr, "\t\t[ -t trust_key ] [ -v sys_var ] [ -V default_sysvar ]\n");
161
 
#if defined(HAVE_SCHED_SETSCHEDULER)
162
 
                (void) fprintf(stderr, "\t\t[ -P fixed_process_priority ]\n");
163
 
#endif
164
 
#ifdef HAVE_DROPROOT
165
 
                (void) fprintf(stderr, "\t\t[ -u user[:group] ] [ -i chrootdir ]\n");
166
 
#endif
167
 
                exit(2);
168
 
        }
169
 
        ntp_optind = 0; /* reset ntp_optind to restart ntp_getopt */
170
 
 
171
 
#ifdef DEBUG
172
 
        if (debug) {
173
 
#ifdef HAVE_SETVBUF
174
 
                static char buf[BUFSIZ];
175
 
                setvbuf(stdout, buf, _IOLBF, BUFSIZ);
176
 
#else
177
 
                setlinebuf(stdout);
178
 
#endif
179
 
        }
180
 
#endif
181
 
}
182
 
 
183
 
/*
184
34
 * getCmdOpts - get command line options
185
35
 */
186
36
void
189
39
        char *argv[]
190
40
        )
191
41
{
192
 
        extern char *config_file;
193
 
        struct sockaddr_in inaddrntp;
 
42
        extern const char *config_file;
194
43
        int errflg;
195
 
        int c;
 
44
        tOptions *myOptions = &OPTSTRUCT;
196
45
 
197
46
        /*
198
47
         * Initialize, initialize
199
48
         */
200
49
        errflg = 0;
201
 
#ifdef DEBUG
202
 
        debug = 0;
203
 
#endif  /* DEBUG */
204
 
 
205
 
        progname = argv[0];
206
 
 
207
 
        /*
208
 
         * Decode argument list
209
 
         */
210
 
        while ((c = ntp_getopt(argc, argv, ntp_options)) != EOF) {
211
 
                switch (c) {
212
 
                    case 'a':
213
 
                        proto_config(PROTO_AUTHENTICATE, 1, 0., NULL);
214
 
                        break;
215
 
 
216
 
                    case 'A':
217
 
                        proto_config(PROTO_AUTHENTICATE, 0, 0., NULL);
218
 
                        break;
219
 
 
220
 
                    case 'b':
221
 
                        proto_config(PROTO_BROADCLIENT, 1, 0., NULL);
222
 
                        break;
223
 
 
224
 
                    case 'c':
225
 
                        config_file = ntp_optarg;
 
50
 
 
51
        switch (WHICH_IDX_IPV4) {
 
52
            case INDEX_OPT_IPV4:
 
53
                default_ai_family = AF_INET;
 
54
                break;
 
55
            case INDEX_OPT_IPV6:
 
56
                default_ai_family = AF_INET6;
 
57
                break;
 
58
            default:
 
59
                /* ai_fam_templ = ai_fam_default;       */
 
60
                break;
 
61
        }
 
62
 
 
63
        if (HAVE_OPT( AUTHREQ ))
 
64
                proto_config(PROTO_AUTHENTICATE, 1, 0., NULL);
 
65
 
 
66
        if (HAVE_OPT( AUTHNOREQ ))
 
67
                proto_config(PROTO_AUTHENTICATE, 0, 0., NULL);
 
68
 
 
69
        if (HAVE_OPT( BCASTSYNC ))
 
70
                proto_config(PROTO_BROADCLIENT, 1, 0., NULL);
 
71
 
 
72
        if (HAVE_OPT( CONFIGFILE )) {
 
73
                config_file = OPT_ARG( CONFIGFILE );
226
74
#ifdef HAVE_NETINFO
227
 
                        check_netinfo = 0;
228
 
#endif
229
 
                        break;
230
 
 
231
 
                    case 'd':
232
 
#ifdef DEBUG
233
 
                        debug++;
234
 
#else
235
 
                        errflg++;
236
 
#endif  /* DEBUG */
237
 
                        break;
238
 
 
239
 
                    case 'D':
240
 
#ifdef DEBUG
241
 
                        debug = (int)atol(ntp_optarg);
242
 
                        printf("Debug2: %s -> %x = %d\n", ntp_optarg, debug, debug);
243
 
#else
244
 
                        errflg++;
245
 
#endif  /* DEBUG */
246
 
                        break;
247
 
 
248
 
                    case 'f':
249
 
                        stats_config(STATS_FREQ_FILE, ntp_optarg);
250
 
                        break;
251
 
 
252
 
                    case 'g':
253
 
                        allow_panic = TRUE;
254
 
                        break;
255
 
 
256
 
                    case 'i':
257
 
#ifdef HAVE_DROPROOT
258
 
                        droproot = 1;
259
 
                        if (!ntp_optarg)
260
 
                                errflg++;
261
 
                        else
262
 
                                chrootdir = ntp_optarg;
263
 
                        break;
264
 
#else
265
 
                        errflg++;
266
 
#endif
267
 
                    case 'k':
268
 
                        getauthkeys(ntp_optarg);
269
 
                        break;
270
 
 
271
 
                    case 'L':   /* already done at pre-scan */
272
 
                    case 'l':   /* already done at pre-scan */
273
 
                        break;
274
 
 
275
 
                    case 'm':
276
 
                        inaddrntp.sin_family = AF_INET;
277
 
                        inaddrntp.sin_port = htons(NTP_PORT);
278
 
                        inaddrntp.sin_addr.s_addr = htonl(INADDR_NTP);
279
 
                        proto_config(PROTO_MULTICAST_ADD, 0, 0., (struct sockaddr_storage*)&inaddrntp);
280
 
                        sys_bclient = 1;
281
 
                        break;
282
 
 
283
 
                    case 'n':   /* already done at pre-scan */
284
 
                        break;
285
 
 
286
 
                    case 'N':   /* already done at pre-scan */
287
 
                        break;
288
 
 
289
 
                    case 'p':
290
 
                        stats_config(STATS_PID_FILE, ntp_optarg);
291
 
                        break;
292
 
 
293
 
                    case 'P':
294
 
#if defined(HAVE_SCHED_SETSCHEDULER)
295
 
                        config_priority = (int)atol(ntp_optarg);
296
 
                        config_priority_override = 1;
297
 
#else
298
 
                        errflg++;
299
 
#endif
300
 
                        break;
301
 
 
302
 
                    case 'q':
303
 
                        mode_ntpdate = TRUE;
304
 
                        break;
305
 
 
306
 
                    case 'r':
307
 
                        do {
308
 
                                double tmp;
309
 
 
310
 
                                if (sscanf(ntp_optarg, "%lf", &tmp) != 1) {
311
 
                                        msyslog(LOG_ERR,
312
 
                                                "command line broadcast delay value %s undecodable",
313
 
                                                ntp_optarg);
314
 
                                } else {
315
 
                                        proto_config(PROTO_BROADDELAY, 0, tmp, NULL);
316
 
                                }
317
 
                        } while (0);
318
 
                        break;
319
 
                        
320
 
                    case 'u':
321
 
#ifdef HAVE_DROPROOT
322
 
                        droproot = 1;
323
 
                        if( ! ntp_optarg ) {
324
 
                                errflg++;
325
 
                        } else {
326
 
                                user = malloc(strlen(ntp_optarg) + 1);
327
 
                                if (user == NULL) {
328
 
                                        errflg++;
329
 
                                } else {
330
 
                                        (void)strncpy(user, ntp_optarg, strlen(ntp_optarg) + 1);
331
 
                                        group = rindex(user, ':');
332
 
                                        if (group)
333
 
                                                *group++ = '\0'; /* get rid of the ':' */
334
 
                                }
335
 
                        }
336
 
#else
337
 
                        errflg++;
338
 
#endif
339
 
                        break;
340
 
                    case 's':
341
 
                        stats_config(STATS_STATSDIR, ntp_optarg);
342
 
                        break;
343
 
                        
344
 
                    case 't':
345
 
                        do {
346
 
                                u_long tkey;
347
 
                                
348
 
                                tkey = (int)atol(ntp_optarg);
349
 
                                if (tkey <= 0 || tkey > NTP_MAXKEY) {
350
 
                                        msyslog(LOG_ERR,
351
 
                                            "command line trusted key %s is invalid",
352
 
                                            ntp_optarg);
353
 
                                } else {
354
 
                                        authtrust(tkey, 1);
355
 
                                }
356
 
                        } while (0);
357
 
                        break;
358
 
 
359
 
                    case 'v':
360
 
                    case 'V':
361
 
                        set_sys_var(ntp_optarg, strlen(ntp_optarg)+1,
362
 
                            (u_short) (RW | ((c == 'V') ? DEF : 0)));
363
 
                        break;
364
 
 
365
 
                    case 'x':
366
 
                        clock_max = 600;
367
 
                        break;
 
75
                check_netinfo = 0;
 
76
#endif
 
77
        }
 
78
 
 
79
        if (HAVE_OPT( DRIFTFILE ))
 
80
                stats_config(STATS_FREQ_FILE, OPT_ARG( DRIFTFILE ));
 
81
 
 
82
        if (HAVE_OPT( PANICGATE ))
 
83
                allow_panic = TRUE;
 
84
 
 
85
        if (HAVE_OPT( JAILDIR )) {
 
86
#ifdef HAVE_DROPROOT
 
87
                        droproot = 1;
 
88
                        chrootdir = OPT_ARG( JAILDIR );
 
89
#else
 
90
                        errflg++;
 
91
#endif
 
92
        }
 
93
 
 
94
        if (HAVE_OPT( KEYFILE ))
 
95
                getauthkeys(OPT_ARG( KEYFILE ));
 
96
 
 
97
        if (HAVE_OPT( PIDFILE ))
 
98
                stats_config(STATS_PID_FILE, OPT_ARG( PIDFILE ));
 
99
 
 
100
        if (HAVE_OPT( QUIT ))
 
101
                mode_ntpdate = TRUE;
 
102
 
 
103
        if (HAVE_OPT( PROPAGATIONDELAY ))
 
104
                do {
 
105
                        double tmp;
 
106
                        const char *my_ntp_optarg = OPT_ARG( PROPAGATIONDELAY );
 
107
 
 
108
                        if (sscanf(my_ntp_optarg, "%lf", &tmp) != 1) {
 
109
                                msyslog(LOG_ERR,
 
110
                                        "command line broadcast delay value %s undecodable",
 
111
                                        my_ntp_optarg);
 
112
                        } else {
 
113
                                proto_config(PROTO_BROADDELAY, 0, tmp, NULL);
 
114
                        }
 
115
                } while (0);
 
116
 
 
117
        if (HAVE_OPT( STATSDIR ))
 
118
                stats_config(STATS_STATSDIR, OPT_ARG( STATSDIR ));
 
119
 
 
120
        if (HAVE_OPT( TRUSTEDKEY )) {
 
121
                int           ct = STACKCT_OPT(  TRUSTEDKEY );
 
122
                const char**  pp = STACKLST_OPT( TRUSTEDKEY );
 
123
 
 
124
                do  {
 
125
                        u_long tkey;
 
126
                        const char* p = *pp++;
 
127
 
 
128
                        tkey = (int)atol(p);
 
129
                        if (tkey == 0 || tkey > NTP_MAXKEY) {
 
130
                                msyslog(LOG_ERR,
 
131
                                    "command line trusted key %s is invalid",
 
132
                                    p);
 
133
                        } else {
 
134
                                authtrust(tkey, 1);
 
135
                        }
 
136
                } while (--ct > 0);
 
137
        }
 
138
 
 
139
        if (HAVE_OPT( USER )) {
 
140
#ifdef HAVE_DROPROOT
 
141
                char *ntp_optarg = OPT_ARG( USER );
 
142
 
 
143
                droproot = 1;
 
144
                user = malloc(strlen(ntp_optarg) + 1);
 
145
                if (user == NULL) {
 
146
                        errflg++;
 
147
                } else {
 
148
                        (void)strncpy(user, ntp_optarg, strlen(ntp_optarg) + 1);
 
149
                        group = rindex(user, ':');
 
150
                        if (group)
 
151
                                *group++ = '\0'; /* get rid of the ':' */
 
152
                }
 
153
#else
 
154
                errflg++;
 
155
#endif
 
156
        }
 
157
 
 
158
        if (HAVE_OPT( VAR )) {
 
159
                int           ct = STACKCT_OPT(  VAR );
 
160
                const char**  pp = STACKLST_OPT( VAR );
 
161
 
 
162
                do  {
 
163
                        const char* my_ntp_optarg = *pp++;
 
164
 
 
165
                        set_sys_var(my_ntp_optarg, strlen(my_ntp_optarg)+1,
 
166
                            (u_short) (RW));
 
167
                } while (--ct > 0);
 
168
        }
 
169
 
 
170
        if (HAVE_OPT( DVAR )) {
 
171
                int           ct = STACKCT_OPT(  DVAR );
 
172
                const char**  pp = STACKLST_OPT( DVAR );
 
173
 
 
174
                do  {
 
175
                        const char* my_ntp_optarg = *pp++;
 
176
 
 
177
                        set_sys_var(my_ntp_optarg, strlen(my_ntp_optarg)+1,
 
178
                            (u_short) (RW | DEF));
 
179
                } while (--ct > 0);
 
180
        }
 
181
 
 
182
        if (HAVE_OPT( SLEW ))
 
183
                clock_max = 600;
 
184
 
 
185
        if (HAVE_OPT( UPDATEINTERVAL )) {
 
186
                long val = OPT_VALUE_UPDATEINTERVAL;
 
187
                          
 
188
                if ((val >= 60) || (val == 0))
 
189
                        interface_interval = val;
 
190
                else {
 
191
                        msyslog(LOG_ERR,
 
192
                                "command line interface update interval %ld must be 0 or longer than 60 seconds",
 
193
                                      val);
 
194
                        errflg++;
 
195
                }
 
196
        }
368
197
#ifdef SIM
369
 
                case 'B':
370
 
                        sscanf(ntp_optarg, "%lf", &ntp_node.bdly);
371
 
                        break;
372
 
 
373
 
                case 'C':
374
 
                        sscanf(ntp_optarg, "%lf", &ntp_node.snse);
375
 
                        break;
376
 
 
377
 
                case 'H':
378
 
                        sscanf(ntp_optarg, "%lf", &ntp_node.slew);
379
 
                        break;
380
 
 
381
 
                case 'O':
382
 
                        sscanf(ntp_optarg, "%lf", &ntp_node.clk_time);
383
 
                        break;
384
 
 
385
 
                case 'S':
386
 
                        sscanf(ntp_optarg, "%lf", &ntp_node.sim_time);
387
 
                        break;
388
 
 
389
 
                case 'T':
390
 
                        sscanf(ntp_optarg, "%lf", &ntp_node.ferr);
391
 
                        break;
392
 
 
393
 
                case 'W':
394
 
                        sscanf(ntp_optarg, "%lf", &ntp_node.fnse);
395
 
                        break;
396
 
 
397
 
                case 'Y':
398
 
                        sscanf(ntp_optarg, "%lf", &ntp_node.ndly);
399
 
                        break;
400
 
 
401
 
                case 'Z': 
402
 
                        sscanf(ntp_optarg, "%lf", &ntp_node.pdly);
403
 
                        break;
 
198
        if (HAVE_OPT( SIMBROADCASTDELAY ))
 
199
                sscanf(OPT_ARG( SIMBROADCASTDELAY ), "%lf", &ntp_node.bdly);
 
200
 
 
201
        if (HAVE_OPT( PHASENOISE ))
 
202
                sscanf(OPT_ARG( PHASENOISE ), "%lf", &ntp_node.snse);
 
203
 
 
204
        if (HAVE_OPT( SIMSLEW ))
 
205
                sscanf(OPT_ARG( SIMSLEW ), "%lf", &ntp_node.slew);
 
206
 
 
207
        if (HAVE_OPT( SERVERTIME ))
 
208
                sscanf(OPT_ARG( SERVERTIME ), "%lf", &ntp_node.clk_time);
 
209
 
 
210
        if (HAVE_OPT( ENDSIMTIME ))
 
211
                sscanf(OPT_ARG( ENDSIMTIME ), "%lf", &ntp_node.sim_time);
 
212
 
 
213
        if (HAVE_OPT( FREQERR ))
 
214
                sscanf(OPT_ARG( FREQERR ), "%lf", &ntp_node.ferr);
 
215
 
 
216
        if (HAVE_OPT( WALKNOISE ))
 
217
                sscanf(OPT_ARG( WALKNOISE ), "%lf", &ntp_node.fnse);
 
218
 
 
219
        if (HAVE_OPT( NDELAY ))
 
220
                sscanf(OPT_ARG( NDELAY ), "%lf", &ntp_node.ndly);
 
221
 
 
222
        if (HAVE_OPT( PDELAY ))
 
223
                sscanf(OPT_ARG( PDELAY ), "%lf", &ntp_node.pdly);
404
224
 
405
225
#endif /* SIM */
406
 
                    default:
407
 
                        errflg++;
408
 
                        break;
409
 
                }
410
 
        }
411
226
 
412
 
        if (errflg || ntp_optind != argc) {
413
 
                (void) fprintf(stderr, "usage: %s [ -abdgmnx ] [ -c config_file ] [ -e e_delay ]\n", progname);
414
 
                (void) fprintf(stderr, "\t\t[ -f freq_file ] [ -k key_file ] [ -l log_file ]\n");
415
 
                (void) fprintf(stderr, "\t\t[ -p pid_file ] [ -r broad_delay ] [ -s statdir ]\n");
416
 
                (void) fprintf(stderr, "\t\t[ -t trust_key ] [ -v sys_var ] [ -V default_sysvar ]\n");
417
 
#if defined(HAVE_SCHED_SETSCHEDULER)
418
 
                (void) fprintf(stderr, "\t\t[ -P fixed_process_priority ]\n");
419
 
#endif
420
 
#ifdef HAVE_DROPROOT
421
 
                (void) fprintf(stderr, "\t\t[ -u user[:group] ] [ -i chrootdir ]\n");
422
 
#endif
423
 
                exit(2);
 
227
        if (errflg || argc) {
 
228
                printf("argc is <%d>\n", argc);
 
229
                optionUsage(myOptions, 2);
424
230
        }
425
231
        return;
426
232
}