← Back to branch summary

~ubuntu-branches/debian/stretch/ion/stretch

« back to all changes in this revision

Viewing changes to bp/dtn2/dtn2admin.c

  • Committer: Package Import Robot
  • Author(s): Leo Iannacone
  • Date: 2012-02-01 09:46:31 UTC
  • Revision ID: package-import@ubuntu.com-20120201094631-qpfwehc1b7ftkjgx
Tags: upstream-2.5.3~dfsg1
Import upstream version 2.5.3~dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
bp/dtn2/dtn2admin.c
 
1
/*
 
2
        dtn2admin.c:    BP routing adminstration interface for
 
3
                        the DTN endpoint ID scheme.
 
4
                                                                        */
 
5
/*                                                                      */
 
6
/*      Copyright (c) 2006, California Institute of Technology.         */
 
7
/*      All rights reserved.                                            */
 
8
/*      Author: Scott Burleigh, Jet Propulsion Laboratory               */
 
9
/*                                                                      */
 
10
 
 
11
#include "dtn2fw.h"
 
12
 
 
13
static int      _echo(int *newValue)
 
14
{
 
15
        static int      state = 0;
 
16
 
 
17
        if (newValue)
 
18
        {
 
19
                if (*newValue == 1)
 
20
                {
 
21
                        state = 1;
 
22
                }
 
23
                else
 
24
                {
 
25
                        state = 0;
 
26
                }
 
27
        }
 
28
 
 
29
        return state;
 
30
}
 
31
 
 
32
static void     printText(char *text)
 
33
{
 
34
        if (_echo(NULL))
 
35
        {
 
36
                writeMemo(text);
 
37
        }
 
38
 
 
39
        PUTS(text);
 
40
}
 
41
 
 
42
static void     handleQuit()
 
43
{
 
44
        printText("Please enter command 'q' to stop the program.");
 
45
}
 
46
 
 
47
static void     printSyntaxError(int lineNbr)
 
48
{
 
49
        char    buffer[80];
 
50
 
 
51
        isprintf(buffer, sizeof buffer,
 
52
                        "Syntax error at line %d of dtn2admin.c", lineNbr);
 
53
        printText(buffer);
 
54
}
 
55
 
 
56
#define SYNTAX_ERROR    printSyntaxError(__LINE__)
 
57
 
 
58
static void     printUsage()
 
59
{
 
60
        PUTS("Syntax of 'directive' is:");
 
61
        PUTS("\t{ f <endpoint ID> | x <protocol name>/<outduct name>[,dest \
 
62
induct name] }");
 
63
        PUTS("Note that, by convention, each node name must start with '//'.");
 
64
        PUTS("Valid commands are:");
 
65
        PUTS("\tq\tQuit");
 
66
        PUTS("\th\tHelp");
 
67
        PUTS("\t?\tHelp");
 
68
        PUTS("\ta\tAdd");
 
69
        PUTS("\t   a plan <node name> <default directive>");
 
70
        PUTS("\t   a rule <node name> <demux name> <directive>");
 
71
        PUTS("\tc\tChange");
 
72
        PUTS("\t   c plan <node name> <default directive>");
 
73
        PUTS("\t   c rule <node name> <demux name> <directive>");
 
74
        PUTS("\td\tDelete");
 
75
        PUTS("\t   d plan <node name>");
 
76
        PUTS("\t   d rule <node name> <demux name>");
 
77
        PUTS("\ti\tInfo");
 
78
        PUTS("\t   i plan <node name>");
 
79
        PUTS("\t   i rule <node name> <demux name>");
 
80
        PUTS("\tl\tList");
 
81
        PUTS("\t   l plan");
 
82
        PUTS("\t   l rule <node name>");
 
83
        PUTS("\t#\tComment");
 
84
        PUTS("\t   # <comment text>");
 
85
}
 
86
 
 
87
static int      parseDirective(char *actionToken, char *parmToken,
 
88
                        FwdDirective *dir)
 
89
{
 
90
        Sdr             sdr = getIonsdr();
 
91
        char            *protocolName;
 
92
        char            *cursor = NULL;
 
93
        char            *outductName;
 
94
        char            *destDuctName;
 
95
        VOutduct        *vduct;
 
96
        PsmAddress      vductElt;
 
97
 
 
98
        switch (*actionToken)
 
99
        {
 
100
        case 'f':
 
101
                if (strlen(parmToken) >= SDRSTRING_BUFSZ)
 
102
                {
 
103
                        putErrmsg("Station EID is too long.", parmToken);
 
104
                        return -1;
 
105
                }
 
106
 
 
107
                dir->action = fwd;
 
108
                sdr_begin_xn(sdr);
 
109
                dir->eid = sdr_string_create(sdr, parmToken);
 
110
                if (sdr_end_xn(sdr))
 
111
                {
 
112
                        putErrmsg("Can't write station EID.", NULL);
 
113
                        return 0;
 
114
                }
 
115
 
 
116
                return 1;
 
117
 
 
118
        case 'x':
 
119
                dir->action = xmit;
 
120
                cursor = parmToken;
 
121
                protocolName = cursor;
 
122
                cursor = strchr(cursor, '/');
 
123
                if (cursor == NULL)
 
124
                {
 
125
                        putErrmsg("Malformed directive: <protocol>/<duct>",
 
126
                                        parmToken);
 
127
                        return 0;
 
128
                }
 
129
 
 
130
                *cursor = '\0';
 
131
                cursor++;
 
132
                outductName = cursor;
 
133
                cursor = strchr(cursor, ',');
 
134
                if (cursor == NULL)
 
135
                {
 
136
                        destDuctName = NULL;
 
137
                        dir->destDuctName = 0;
 
138
                }
 
139
                else
 
140
                {
 
141
                        *cursor = '\0';
 
142
                        cursor++;
 
143
                        destDuctName = cursor;
 
144
                        if (strlen(destDuctName) >= SDRSTRING_BUFSZ)
 
145
                        {
 
146
                                putErrmsg("Destination duct name is too long.",
 
147
                                                destDuctName);
 
148
                                return 0;
 
149
                        }
 
150
                }
 
151
 
 
152
                findOutduct(protocolName, outductName, &vduct, &vductElt);
 
153
                if (vductElt == 0)
 
154
                {
 
155
                        putErrmsg("Unknown outduct.", outductName);
 
156
                        return 0;
 
157
                }
 
158
 
 
159
                dir->outductElt = vduct->outductElt;
 
160
                if (destDuctName)
 
161
                {
 
162
                        sdr_begin_xn(sdr);
 
163
                        dir->destDuctName = sdr_string_create(sdr,
 
164
                                        destDuctName);
 
165
                        if (sdr_end_xn(sdr))
 
166
                        {
 
167
                                putErrmsg("Can't write duct name.", NULL);
 
168
                                return 0;
 
169
                        }
 
170
                }
 
171
 
 
172
                return 1;
 
173
 
 
174
        default:
 
175
                putErrmsg("Invalid action code in directive", cursor);
 
176
                return 0;
 
177
        }
 
178
}
 
179
 
 
180
static void     executeAdd(int tokenCount, char **tokens)
 
181
{
 
182
        FwdDirective    directive;
 
183
 
 
184
        if (tokenCount < 2)
 
185
        {
 
186
                printText("Add what?");
 
187
                return;
 
188
        }
 
189
 
 
190
        if (strcmp(tokens[1], "plan") == 0)
 
191
        {
 
192
                if (tokenCount != 5)
 
193
                {
 
194
                        SYNTAX_ERROR;
 
195
                        return;
 
196
                }
 
197
 
 
198
                if (parseDirective(tokens[3], tokens[4], &directive) < 1)
 
199
                {
 
200
                        return;
 
201
                }
 
202
 
 
203
                if (dtn2_addPlan(tokens[2], &directive) < 1)
 
204
                {
 
205
                        dtn2_destroyDirective(&directive);
 
206
                }
 
207
 
 
208
                return;
 
209
        }
 
210
 
 
211
        if (strcmp(tokens[1], "rule") == 0)
 
212
        {
 
213
                if (tokenCount != 6)
 
214
                {
 
215
                        SYNTAX_ERROR;
 
216
                        return;
 
217
                }
 
218
 
 
219
                if (parseDirective(tokens[4], tokens[5], &directive) < 1)
 
220
                {
 
221
                        return;
 
222
                }
 
223
 
 
224
                if (dtn2_addRule(tokens[2], tokens[3], &directive) < 1)
 
225
                {
 
226
                        dtn2_destroyDirective(&directive);
 
227
                }
 
228
 
 
229
                return;
 
230
        }
 
231
 
 
232
        SYNTAX_ERROR;
 
233
}
 
234
 
 
235
static void     executeChange(int tokenCount, char **tokens)
 
236
{
 
237
        FwdDirective    directive;
 
238
 
 
239
        if (tokenCount < 2)
 
240
        {
 
241
                printText("Change what?");
 
242
                return;
 
243
        }
 
244
 
 
245
        if (strcmp(tokens[1], "plan") == 0)
 
246
        {
 
247
                if (tokenCount != 5)
 
248
                {
 
249
                        SYNTAX_ERROR;
 
250
                        return;
 
251
                }
 
252
 
 
253
                if (parseDirective(tokens[3], tokens[4], &directive) < 1)
 
254
                {
 
255
                        return;
 
256
                }
 
257
 
 
258
                if (dtn2_updatePlan(tokens[2], &directive) < 1)
 
259
                {
 
260
                        dtn2_destroyDirective(&directive);
 
261
                }
 
262
 
 
263
                return;
 
264
        }
 
265
 
 
266
        if (strcmp(tokens[1], "rule") == 0)
 
267
        {
 
268
                if (tokenCount != 6)
 
269
                {
 
270
                        SYNTAX_ERROR;
 
271
                        return;
 
272
                }
 
273
 
 
274
                if (parseDirective(tokens[4], tokens[5], &directive) < 1)
 
275
                {
 
276
                        return;
 
277
                }
 
278
 
 
279
                if (dtn2_updateRule(tokens[2], tokens[3], &directive) < 1)
 
280
                {
 
281
                        dtn2_destroyDirective(&directive);
 
282
                }
 
283
 
 
284
                return;
 
285
        }
 
286
 
 
287
        SYNTAX_ERROR;
 
288
}
 
289
 
 
290
static void     executeDelete(int tokenCount, char **tokens)
 
291
{
 
292
        if (tokenCount < 2)
 
293
        {
 
294
                printText("Delete what?");
 
295
                return;
 
296
        }
 
297
 
 
298
        if (strcmp(tokens[1], "plan") == 0)
 
299
        {
 
300
                if (tokenCount != 3)
 
301
                {
 
302
                        SYNTAX_ERROR;
 
303
                        return;
 
304
                }
 
305
 
 
306
                dtn2_removePlan(tokens[2]);
 
307
                return;
 
308
        }
 
309
 
 
310
        if (strcmp(tokens[1], "rule") == 0)
 
311
        {
 
312
                if (tokenCount != 4)
 
313
                {
 
314
                        SYNTAX_ERROR;
 
315
                        return;
 
316
                }
 
317
 
 
318
                dtn2_removeRule(tokens[2], tokens[3]);
 
319
                return;
 
320
        }
 
321
 
 
322
        SYNTAX_ERROR;
 
323
}
 
324
 
 
325
static void     printDirective(char *context, FwdDirective *dir)
 
326
{
 
327
        Sdr     sdr = getIonsdr();
 
328
        char    eidString[SDRSTRING_BUFSZ + 1];
 
329
                OBJ_POINTER(Outduct, duct);
 
330
                OBJ_POINTER(ClProtocol, clp);
 
331
        char    destDuctName[SDRSTRING_BUFSZ + 1];
 
332
        char    buffer[1024];
 
333
 
 
334
        switch (dir->action)
 
335
        {
 
336
        case fwd:
 
337
                if (sdr_string_read(sdr, eidString, dir->eid) < 1)
 
338
                {
 
339
                        isprintf(buffer, sizeof buffer, "%.256s f ?", context);
 
340
                        printText(buffer);
 
341
                }
 
342
                else
 
343
                {
 
344
                        isprintf(buffer, sizeof buffer, "%.256s f %.256s\n",
 
345
                                        context, eidString);
 
346
                        printText(buffer);
 
347
                }
 
348
 
 
349
                return;
 
350
 
 
351
        case xmit:
 
352
                GET_OBJ_POINTER(sdr, Outduct, duct, sdr_list_data(sdr,
 
353
                                dir->outductElt));
 
354
                GET_OBJ_POINTER(sdr, ClProtocol, clp, duct->protocol);
 
355
                if (dir->destDuctName == 0)
 
356
                {
 
357
                        destDuctName[0] = '\0';
 
358
                }
 
359
                else
 
360
                {
 
361
                        destDuctName[0] = ':';
 
362
                        if (sdr_string_read(sdr, destDuctName + 1,
 
363
                                        dir->destDuctName) < 0)
 
364
                        {
 
365
                                istrcpy(destDuctName + 1, "?",
 
366
                                                sizeof destDuctName - 1);
 
367
                        }
 
368
                }
 
369
 
 
370
                isprintf(buffer, sizeof buffer, "%.256s x %.8s.%.128s%.128s\n",
 
371
                                context, clp->name, duct->name, destDuctName);
 
372
                printText(buffer);
 
373
                return;
 
374
 
 
375
        default:
 
376
                printText("?");
 
377
        }
 
378
}
 
379
 
 
380
static void     printPlan(Dtn2Plan *plan)
 
381
{
 
382
        char    nameBuf[SDRSTRING_BUFSZ];
 
383
        char    *nodeName;
 
384
 
 
385
        if (sdr_string_read(getIonsdr(), nameBuf, plan->nodeName) < 0)
 
386
        {
 
387
                nodeName = "?";
 
388
        }
 
389
        else
 
390
        {
 
391
                nodeName = nameBuf;
 
392
        }
 
393
 
 
394
        printDirective(nodeName, &plan->defaultDirective);
 
395
}
 
396
 
 
397
static void     infoPlan(int tokenCount, char **tokens)
 
398
{
 
399
        Object  planAddr;
 
400
                OBJ_POINTER(Dtn2Plan, plan);
 
401
        Object  elt;
 
402
 
 
403
        if (tokenCount != 3)
 
404
        {
 
405
                SYNTAX_ERROR;
 
406
                return;
 
407
        }
 
408
 
 
409
        dtn2_findPlan(tokens[2], &planAddr, &elt);
 
410
        if (elt == 0)
 
411
        {
 
412
                printText("Unknown plan.");
 
413
                return;
 
414
        }
 
415
 
 
416
        GET_OBJ_POINTER(getIonsdr(), Dtn2Plan, plan, planAddr);
 
417
        printPlan(plan);
 
418
}
 
419
 
 
420
static void     printRule(Dtn2Plan *plan, Dtn2Rule *rule)
 
421
{
 
422
        Sdr     sdr = getIonsdr();
 
423
        char    toNodeName[SDRSTRING_BUFSZ];
 
424
        char    demux[SDRSTRING_BUFSZ];
 
425
        char    context[128];
 
426
 
 
427
        if (sdr_string_read(sdr, toNodeName, plan->nodeName) < 0)
 
428
        {
 
429
                istrcpy(toNodeName, "?", sizeof toNodeName);
 
430
        }
 
431
 
 
432
        if (sdr_string_read(sdr, demux, rule->demux) < 0)
 
433
        {
 
434
                istrcpy(demux, "?", sizeof toNodeName);
 
435
        }
 
436
 
 
437
        isprintf(context, sizeof context, "%.64s, for %.32s =", toNodeName,
 
438
                        demux);
 
439
        printDirective(context, &rule->directive);
 
440
}
 
441
 
 
442
static void     infoRule(int tokenCount, char **tokens)
 
443
{
 
444
        Sdr     sdr = getIonsdr();
 
445
        Object  planAddr;
 
446
                OBJ_POINTER(Dtn2Plan, plan);
 
447
        Object  ruleAddr;
 
448
                OBJ_POINTER(Dtn2Rule, rule);
 
449
        Object  elt;
 
450
 
 
451
        if (tokenCount != 4)
 
452
        {
 
453
                SYNTAX_ERROR;
 
454
                return;
 
455
        }
 
456
 
 
457
        dtn2_findPlan(tokens[2], &planAddr, &elt);
 
458
        if (elt == 0)
 
459
        {
 
460
                printText("Unknown plan.");
 
461
                return;
 
462
        }
 
463
 
 
464
        GET_OBJ_POINTER(sdr, Dtn2Plan, plan, planAddr);
 
465
        dtn2_findRule(tokens[2], tokens[3], plan, &ruleAddr, &elt);
 
466
        if (elt == 0)
 
467
        {
 
468
                printText("Unknown rule.");
 
469
                return;
 
470
        }
 
471
 
 
472
        GET_OBJ_POINTER(sdr, Dtn2Rule, rule, ruleAddr);
 
473
        printRule(plan, rule);
 
474
}
 
475
 
 
476
static void     executeInfo(int tokenCount, char **tokens)
 
477
{
 
478
        if (tokenCount < 2)
 
479
        {
 
480
                printText("Information on what?");
 
481
                return;
 
482
        }
 
483
 
 
484
        if (strcmp(tokens[1], "plan") == 0)
 
485
        {
 
486
                infoPlan(tokenCount, tokens);
 
487
                return;
 
488
        }
 
489
 
 
490
        if (strcmp(tokens[1], "rule") == 0)
 
491
        {
 
492
                infoRule(tokenCount, tokens);
 
493
                return;
 
494
        }
 
495
 
 
496
        SYNTAX_ERROR;
 
497
}
 
498
 
 
499
static void     listPlans()
 
500
{
 
501
        Sdr     sdr = getIonsdr();
 
502
        Object  elt;
 
503
                OBJ_POINTER(Dtn2Plan, plan);
 
504
 
 
505
        for (elt = sdr_list_first(sdr, (getDtnConstants())->plans); elt;
 
506
                        elt = sdr_list_next(sdr, elt))
 
507
        {
 
508
                GET_OBJ_POINTER(sdr, Dtn2Plan, plan, sdr_list_data(sdr, elt));
 
509
                printPlan(plan);
 
510
        }
 
511
}
 
512
 
 
513
static void     listRules(Dtn2Plan *plan)
 
514
{
 
515
        Sdr     sdr = getIonsdr();
 
516
        Object  elt;
 
517
                OBJ_POINTER(Dtn2Rule, rule);
 
518
 
 
519
        for (elt = sdr_list_first(sdr, plan->rules); elt;
 
520
                        elt = sdr_list_next(sdr, elt))
 
521
        {
 
522
                GET_OBJ_POINTER(sdr, Dtn2Rule, rule, sdr_list_data(sdr, elt));
 
523
                printRule(plan, rule);
 
524
        }
 
525
}
 
526
 
 
527
static void     executeList(int tokenCount, char **tokens)
 
528
{
 
529
        Object  planAddr;
 
530
                OBJ_POINTER(Dtn2Plan, plan);
 
531
        Object  elt;
 
532
 
 
533
        if (tokenCount < 2)
 
534
        {
 
535
                printText("List what?");
 
536
                return;
 
537
        }
 
538
 
 
539
        if (strcmp(tokens[1], "plan") == 0)
 
540
        {
 
541
                listPlans();
 
542
                return;
 
543
        }
 
544
 
 
545
        if (strcmp(tokens[1], "rule") == 0)
 
546
        {
 
547
                if (tokenCount < 3)
 
548
                {
 
549
                        printText("Must specify node name for rules list.");
 
550
                        return;
 
551
                }
 
552
 
 
553
                dtn2_findPlan(tokens[2], &planAddr, &elt);
 
554
                if (elt == 0)
 
555
                {
 
556
                        printText("Unknown plan.");
 
557
                        return;
 
558
                }
 
559
 
 
560
                GET_OBJ_POINTER(getIonsdr(), Dtn2Plan, plan, planAddr);
 
561
                listRules(plan);
 
562
                return;
 
563
        }
 
564
 
 
565
        SYNTAX_ERROR;
 
566
}
 
567
 
 
568
static void     switchEcho(int tokenCount, char **tokens)
 
569
{
 
570
        int     state;
 
571
 
 
572
        if (tokenCount < 2)
 
573
        {
 
574
                printText("Echo on or off?");
 
575
                return;
 
576
        }
 
577
 
 
578
        switch (*(tokens[1]))
 
579
        {
 
580
        case '0':
 
581
                state = 0;
 
582
                oK(_echo(&state));
 
583
                break;
 
584
 
 
585
        case '1':
 
586
                state = 1;
 
587
                oK(_echo(&state));
 
588
                break;
 
589
 
 
590
        default:
 
591
                printText("Echo on or off?");
 
592
        }
 
593
}
 
594
 
 
595
static int      processLine(char *line, int lineLength)
 
596
{
 
597
        int     tokenCount;
 
598
        char    *cursor;
 
599
        int     i;
 
600
        char    *tokens[9];
 
601
 
 
602
        tokenCount = 0;
 
603
        for (cursor = line, i = 0; i < 9; i++)
 
604
        {
 
605
                if (*cursor == '\0')
 
606
                {
 
607
                        tokens[i] = NULL;
 
608
                }
 
609
                else
 
610
                {
 
611
                        findToken(&cursor, &(tokens[i]));
 
612
                        tokenCount++;
 
613
                }
 
614
        }
 
615
 
 
616
        if (tokenCount == 0)
 
617
        {
 
618
                return 0;
 
619
        }
 
620
 
 
621
        /*      Skip over any trailing whitespace.                      */
 
622
 
 
623
        while (isspace((int) *cursor))
 
624
        {
 
625
                cursor++;
 
626
        }
 
627
 
 
628
        /*      Make sure we've parsed everything.                      */
 
629
 
 
630
        if (*cursor != '\0')
 
631
        {
 
632
                printText("Too many tokens.");
 
633
                return 0;
 
634
        }
 
635
 
 
636
        /*      Have parsed the command.  Now execute it.               */
 
637
 
 
638
        switch (*(tokens[0]))           /*      Command code.           */
 
639
        {
 
640
                case 0:                 /*      Empty line.             */
 
641
                case '#':               /*      Comment.                */
 
642
                        return 0;
 
643
 
 
644
                case '?':
 
645
                case 'h':
 
646
                        printUsage();
 
647
                        return 0;
 
648
 
 
649
                case 'a':
 
650
                        executeAdd(tokenCount, tokens);
 
651
                        return 0;
 
652
 
 
653
                case 'c':
 
654
                        executeChange(tokenCount, tokens);
 
655
                        return 0;
 
656
 
 
657
                case 'd':
 
658
                        executeDelete(tokenCount, tokens);
 
659
                        return 0;
 
660
 
 
661
                case 'i':
 
662
                        executeInfo(tokenCount, tokens);
 
663
                        return 0;
 
664
 
 
665
                case 'l':
 
666
                        executeList(tokenCount, tokens);
 
667
                        return 0;
 
668
 
 
669
                case 'e':
 
670
                        switchEcho(tokenCount, tokens);
 
671
                        return 0;
 
672
 
 
673
                case 'q':
 
674
                        return -1;      /*      End program.            */
 
675
 
 
676
                default:
 
677
                        printText("Invalid command.  Enter '?' for help.");
 
678
                        return 0;
 
679
        }
 
680
}
 
681
 
 
682
static int      run_dtn2admin(char *cmdFileName)
 
683
{
 
684
        int     cmdFile;
 
685
        char    line[256];
 
686
        int     len;
 
687
 
 
688
        if (bpAttach() < 0)
 
689
        {
 
690
                putErrmsg("dtn2admin can't attach to BP.", NULL);
 
691
                return -1;
 
692
        }
 
693
 
 
694
        if (dtn2Init() < 0)
 
695
        {
 
696
                putErrmsg("dtn2admin can't initialize routing database", NULL);
 
697
                return -1;
 
698
        }
 
699
 
 
700
        if (cmdFileName == NULL)        /*      Interactive.            */
 
701
        {
 
702
#ifdef FSWLOGGER
 
703
                return 0;
 
704
#endif
 
705
                cmdFile = fileno(stdin);
 
706
                isignal(SIGINT, handleQuit);
 
707
                while (1)
 
708
                {
 
709
                        printf(": ");
 
710
                        fflush(stdout);
 
711
                        if (igets(cmdFile, line, sizeof line, &len) == NULL)
 
712
                        {
 
713
                                if (len == 0)
 
714
                                {
 
715
                                        break;
 
716
                                }
 
717
 
 
718
                                putErrmsg("igets failed.", NULL);
 
719
                                break;          /*      Out of loop.    */
 
720
                        }
 
721
 
 
722
                        if (len == 0)
 
723
                        {
 
724
                                continue;
 
725
                        }
 
726
 
 
727
                        if (processLine(line, len))
 
728
                        {
 
729
                                break;          /*      Out of loop.    */
 
730
                        }
 
731
                }
 
732
        }
 
733
        else                            /*      Scripted.               */
 
734
        {
 
735
                cmdFile = iopen(cmdFileName, O_RDONLY, 0777);
 
736
                if (cmdFile < 0)
 
737
                {
 
738
                        PERROR("Can't open command file");
 
739
                }
 
740
                else
 
741
                {
 
742
                        while (1)
 
743
                        {
 
744
                                if (igets(cmdFile, line, sizeof line, &len)
 
745
                                                == NULL)
 
746
                                {
 
747
                                        if (len == 0)
 
748
                                        {
 
749
                                                break;  /*      Loop.   */
 
750
                                        }
 
751
 
 
752
                                        putErrmsg("igets failed.", NULL);
 
753
                                        break;          /*      Loop.   */
 
754
                                }
 
755
 
 
756
                                if (len == 0
 
757
                                || line[0] == '#')      /*      Comment.*/
 
758
                                {
 
759
                                        continue;
 
760
                                }
 
761
 
 
762
                                if (processLine(line, len))
 
763
                                {
 
764
                                        break;  /*      Out of loop.    */
 
765
                                }
 
766
                        }
 
767
 
 
768
                        close(cmdFile);
 
769
                }
 
770
        }
 
771
 
 
772
        writeErrmsgMemos();
 
773
        printText("Stopping dtn2admin.");
 
774
        ionDetach();
 
775
        return 0;
 
776
}
 
777
 
 
778
#if defined (VXWORKS) || defined (RTEMS)
 
779
int     dtn2admin(int a1, int a2, int a3, int a4, int a5,
 
780
                int a6, int a7, int a8, int a9, int a10)
 
781
{
 
782
        char    *cmdFileName = (char *) a1;
 
783
#else
 
784
int     main(int argc, char **argv)
 
785
{
 
786
        char    *cmdFileName = argc > 1 ? argv[1] : NULL;
 
787
#endif
 
788
        return run_dtn2admin(cmdFileName);
 
789
}