← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/isdnutils/jaunty-proposed

« back to all changes in this revision

Viewing changes to capiinit/capiinit.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2004-09-04 08:20:20 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040904082020-g641px056lshw203
Tags: 1:3.3.0.20040728-2
http://bugs.debian.org/268767
http://bugs.debian.org/268716
http://bugs.debian.org/269666
* Put libcapi20 development files into new libcapi20-dev package,
  change libcapi20 soname to libcapi20-3, conflict with existing
  versions of packages depending on libcapi20-3 (closes: #268767).
* Update debconf translation strings (closes: #268716).
* Update french debconf translation (closes: #269666).

Show diffs side-by-side

added added

removed removed

Lines of Context:
capiinit/capiinit.c
1
1
/*
2
 
 * $Id: capiinit.c,v 1.8 2001/04/18 10:21:42 calle Exp $
 
2
 * $Id: capiinit.c,v 1.16 2004/01/19 09:15:57 calle Exp $
3
3
 *
4
4
 * $Log: capiinit.c,v $
 
5
 * Revision 1.16  2004/01/19 09:15:57  calle
 
6
 * Always use capifs, don't trust devfs.
 
7
 *
 
8
 * Revision 1.15  2004/01/16 15:27:12  calle
 
9
 * remove several warnings.
 
10
 *
 
11
 * Revision 1.14  2004/01/16 12:33:16  calle
 
12
 * Modifications to let ist run with patched 2.6 kernel.
 
13
 * Pure 2.6.0/2.6.1 is not working.
 
14
 *
 
15
 * Revision 1.13  2003/03/31 09:50:52  calle
 
16
 * Bugfix: fixed problems with activate and deactivate subcommands, when
 
17
 *         AVM B1 PCI V4 is used.
 
18
 *
 
19
 * Revision 1.12  2003/03/11 13:39:07  paul
 
20
 * Also search for firmware in /usr/share/isdn, which is more in line with LSB
 
21
 *
 
22
 * Revision 1.11  2003/01/14 13:47:15  calle
 
23
 * New Commands to only load modules, only initialize cards,
 
24
 * only reset cards, inititialize a single card or reset a single card.
 
25
 *
 
26
 * Revision 1.10  2002/10/25 13:50:44  calle
 
27
 * The protocol value was not tranfered to the patchinfo. Because of
 
28
 * this for example NI1 did not work ...
 
29
 *
 
30
 * Revision 1.9  2002/05/23 12:52:36  calle
 
31
 * - Uaah. Bugfix for c2 patchvalues.
 
32
 *
5
33
 * Revision 1.8  2001/04/18 10:21:42  calle
6
34
 * support for "AVM ISDN Controller C2" added.
7
35
 *
35
63
 *
36
64
 */
37
65
 
 
66
#include <sys/types.h>
 
67
#include <sys/signal.h>
38
68
#include <stdio.h>
39
69
#include <stddef.h>
40
70
#include <stdlib.h>
48
78
#include <sys/mman.h>
49
79
#include <sys/stat.h>
50
80
#include <sys/ioctl.h>
51
 
#include <signal.h>
52
 
#include <linux/isdn.h>
 
81
#define _LINUX_LIST_H
53
82
#include <linux/b1lli.h>
54
83
#include <linux/capi.h>
55
84
#include <linux/kernelcapi.h>
61
90
static char *capidevname = capidevnameold;
62
91
 
63
92
static char *firmwarepath[] = {
64
 
        DATADIR,
65
 
        "/etc/isdn",
 
93
        "/usr/share/isdn",
66
94
        "/usr/lib/isdn",
67
95
        "/lib/isdn",
68
96
        0
73
101
static int capifd = -1;
74
102
 
75
103
static int patchdebug = 0;      /* -d || -debug */
76
 
char *configfilename = "/etc/isdn/capi.conf";
 
104
static int silent = 0;          /* -s || -silent */
 
105
char *configfilename = "/etc/capi.conf";
77
106
 
78
107
/* ---------------- utils -------------------------------------------- */
79
108
 
104
133
 
105
134
/* ---------------- load module -------------------------------------- */
106
135
 
 
136
static int is_module_loaded(char *module)
 
137
{
 
138
        static char *fn = "/proc/modules";
 
139
        char buf[4096];
 
140
        FILE *fp;
 
141
        char *s;
 
142
 
 
143
        if ((fp = fopen_with_errmsg(fn, "r")) == NULL)
 
144
                return 0;
 
145
        while (fgets(buf,sizeof(buf),fp)) {
 
146
                s = skip_nonwhitespace(buf);
 
147
                if (s) {
 
148
                   *s = 0;
 
149
                   if (strcmp(module,buf) == 0) {
 
150
                      fclose(fp);
 
151
                      return 1;
 
152
                   }
 
153
                }
 
154
        }
 
155
        fclose(fp);
 
156
        return 0;
 
157
}
 
158
 
107
159
static int load_module(char *module)
108
160
{
109
161
        char buf[1024];
114
166
static int unload_module(char *module)
115
167
{
116
168
        char buf[1024];
117
 
        snprintf(buf, sizeof(buf), "%s -r %s", MODPROBE, module);
118
 
        return system(buf);
 
169
        if (is_module_loaded(module)) {
 
170
                snprintf(buf, sizeof(buf), "%s -r %s", MODPROBE, module);
 
171
                return system(buf);
 
172
        }
 
173
        return 0;
119
174
}
120
175
 
121
176
/* ---------------- /proc/capi/controller ---------------------------- */
258
313
        return p;
259
314
}
260
315
 
261
 
static void show_contrprocinfo(struct contrprocinfo *cpinfo)
 
316
static void show_contrprocinfo(struct contrprocinfo *cpinfo, char *cardname)
262
317
{
263
318
        struct contrprocinfo *p;
264
319
        for (p = cpinfo; p; p = p->next) {
 
320
                if (cardname && strcmp(cardname, p->name) != 0)
 
321
                        continue;
265
322
                printf("%d %-10s %-8s %-16s %s\n", 
266
323
                        p->contr, p->driver, cardstate2str(p->state),
267
324
                        p->name, p->driverinfo);
587
644
                p->protoname = strdup(t);
588
645
                if (!p->protoname) goto nomem;
589
646
                p->proto = dchan_protocol(t);
 
647
                p->patchinfo.protocol = p->proto;
590
648
                s = skip_whitespace(s);
591
649
 
592
650
                /* ioaddr */
958
1016
                                cp = cp->next;
959
1017
                }
960
1018
                next = cp->next;
 
1019
        } else if (strcmp(card->driver, "c2") == 0) {
 
1020
                struct capicard *cp;
 
1021
                int i;
 
1022
                for (i=0,cp=card; i < 2; i++) {
 
1023
                        addpatchbyte("CtlrNr", i);
 
1024
                        addpatchvalues(&cp->patchinfo);
 
1025
                        if (cp->next && strcmp(cp->next->driver, "c2") == 0)
 
1026
                                cp = cp->next;
 
1027
                }
 
1028
                next = cp->next;
961
1029
        } else {
962
1030
                addpatchvalues(&card->patchinfo);
963
1031
        }
1079
1147
 
1080
1148
static int check_for_kernelcapi(void)
1081
1149
{
1082
 
        if (access("/proc/capi/users", 0) == 0)
 
1150
        if (access("/proc/capi/applications", 0) == 0)
1083
1151
                return 0;
1084
1152
        load_module("kernelcapi");
1085
 
        if (access("/proc/capi/users", 0) == 0)
 
1153
        if (access("/proc/capi/applications", 0) == 0)
1086
1154
                return 0;
1087
1155
        fprintf(stderr, "ERROR: cannot load module kernelcapi\n");
1088
1156
        return -1;
1123
1191
        load_filesystem("capifs");
1124
1192
        if (filesystem_available("capifs")) 
1125
1193
                return 0;
 
1194
#ifdef WITH_DEVFS
1126
1195
        if (filesystem_available("devfs"))
1127
1196
                return 0;
 
1197
#endif
1128
1198
        load_filesystem("capifs");
1129
1199
        if (filesystem_available("capifs")) 
1130
1200
                return 0;
1145
1215
static int check_for_capifs_mounted(void)
1146
1216
{
1147
1217
        char *mp;
 
1218
#ifdef WITH_DEVFS
1148
1219
        if (filesystem_available("devfs")) {
1149
1220
                if ((mp = mounted("devfs")) != 0 && strcmp(mp, "/dev") == 0)
1150
1221
                        return 0;
1151
1222
        }
 
1223
#endif
1152
1224
        if (filesystem_available("capifs")) {
1153
1225
                if ((mp = mounted("capifs")) != 0 && strcmp(mp, "/dev/capi") == 0)
1154
1226
                        return 0;
1192
1264
 
1193
1265
/* ------------------------------------------------------------------- */
1194
1266
 
 
1267
static int is_card_of_driver(char *cardname, struct contrprocinfo *p)
 
1268
{
 
1269
        if (strcmp(cardname, p->driver) == 0)
 
1270
                return 1;
 
1271
        if (   strcmp(cardname, "b1pci") == 0
 
1272
            && strcmp(p->driver, "b1pciv4") == 0)
 
1273
                return 1;
 
1274
        if (strcmp(cardname, p->name) == 0)
 
1275
           return 1;
 
1276
        return 0;
 
1277
}
 
1278
 
1195
1279
static int card_exists(const char * driver, int ioaddr)
1196
1280
{
1197
1281
        static char buf[64];
1208
1292
}
1209
1293
 
1210
1294
 
1211
 
int main_start(void)
 
1295
int main_start(int activate, char *cardname, int number)
1212
1296
{
1213
1297
        struct capicard *cards, *card;
1214
1298
        struct contrprocinfo *cpinfo, *p;
1215
1299
        int contr, lastcontr;
1216
1300
        int ret = 0;
 
1301
        char cname[32];
1217
1302
 
1218
1303
        if (prestartcheck() < 0)
1219
1304
                return -1;
1220
1305
 
 
1306
        cname[0] = 0;
 
1307
 
1221
1308
        /* could not fail, tested by check_for_capi() */
1222
1309
        capifd = open(capidevname, O_RDWR);
1223
1310
 
1235
1322
        }
1236
1323
 
1237
1324
        mark_unfound(cards); 
1238
 
        cpinfo = load_contrprocinfo(&lastcontr);
1239
 
        for (contr = 1; contr <= lastcontr; contr++) {
1240
 
                struct capicard *thiscard;
1241
 
                cpinfo = load_contrprocinfo(0);
1242
 
                p = find_contrprocinfo(cpinfo, contr);
1243
 
                thiscard = find_config(cards, p->driver);
1244
 
                if (p->state == CARD_LOADING)
1245
 
                        reset_controller(contr);
1246
 
                if (p->state == CARD_DETECTED) {
1247
 
                        if (thiscard) {
1248
 
                                card = load_firmware(contr, thiscard);
1249
 
                        } else {
1250
 
                                fprintf(stderr,"ERROR: missing config entry for controller %d driver %s name %s\n",
1251
 
                                        p->contr, p->driver, p->name);
1252
 
                        }
1253
 
                }
1254
 
                free_contrprocinfo(&cpinfo);
1255
 
        }
1256
 
        mark_unfound(cards); 
1257
 
        cpinfo = load_contrprocinfo(&lastcontr);
1258
 
        for (contr = 1; contr <= lastcontr; contr++) {
1259
 
                struct capicard *thiscard;
1260
 
                cpinfo = load_contrprocinfo(0);
1261
 
                p = find_contrprocinfo(cpinfo, contr);
1262
 
                thiscard = find_config(cards, p->driver);
1263
 
                if (p->state == CARD_DETECTED && thiscard) {
1264
 
                        fprintf(stderr,"ERROR: failed to load firmware for controller %d driver %s name %s\n",
1265
 
                                        p->contr, p->driver, p->name);
1266
 
                        ret = 3;
1267
 
                }
1268
 
                free_contrprocinfo(&cpinfo);
1269
 
        }
1270
 
 
1271
 
        cpinfo = load_contrprocinfo(0);
1272
 
        show_contrprocinfo(cpinfo);
1273
 
 
1274
 
        free_contrprocinfo(&cpinfo);
 
1325
        if (activate) {
 
1326
                int act;
 
1327
                act = 0;
 
1328
                cpinfo = load_contrprocinfo(&lastcontr);
 
1329
                for (contr = 1; contr <= lastcontr; contr++) {
 
1330
                        struct capicard *thiscard;
 
1331
                        cpinfo = load_contrprocinfo(0);
 
1332
                        p = find_contrprocinfo(cpinfo, contr);
 
1333
                        thiscard = find_config(cards, p->driver);
 
1334
                        if (cardname) {
 
1335
                                if (number == 0) {
 
1336
                                        if (strcmp(cardname, p->name) != 0) {
 
1337
                                                free_contrprocinfo(&cpinfo);
 
1338
                                                continue;
 
1339
                                        }
 
1340
                                } else if (is_card_of_driver(cardname, p)) {
 
1341
                                        if (++act != number) {
 
1342
                                                free_contrprocinfo(&cpinfo);
 
1343
                                                continue;
 
1344
                                        }
 
1345
                                } else {
 
1346
                                        free_contrprocinfo(&cpinfo);
 
1347
                                        continue;
 
1348
                                }
 
1349
                                strncpy(cname, p->name, sizeof(cname));
 
1350
                        }
 
1351
                        if (p->state == CARD_LOADING)
 
1352
                                reset_controller(contr);
 
1353
                        if (p->state == CARD_DETECTED) {
 
1354
                                if (thiscard) {
 
1355
                                        card = load_firmware(contr, thiscard);
 
1356
                                } else {
 
1357
                                        fprintf(stderr,"ERROR: missing config entry for controller %d driver %s name %s\n",
 
1358
                                                p->contr, p->driver, p->name);
 
1359
                                }
 
1360
                        }
 
1361
                        free_contrprocinfo(&cpinfo);
 
1362
                }
 
1363
                mark_unfound(cards); 
 
1364
                act = 0;
 
1365
                cpinfo = load_contrprocinfo(&lastcontr);
 
1366
                for (contr = 1; contr <= lastcontr; contr++) {
 
1367
                        struct capicard *thiscard;
 
1368
                        cpinfo = load_contrprocinfo(0);
 
1369
                        p = find_contrprocinfo(cpinfo, contr);
 
1370
                        thiscard = find_config(cards, p->driver);
 
1371
                        if (cardname && cname[0]) {
 
1372
                                if (strcmp(cname, p->name) != 0) {
 
1373
                                        free_contrprocinfo(&cpinfo);
 
1374
                                        continue;
 
1375
                                }
 
1376
                        }
 
1377
                        if (p->state == CARD_DETECTED && thiscard) {
 
1378
                                fprintf(stderr,"ERROR: failed to load firmware for controller %d driver %s name %s\n",
 
1379
                                                p->contr, p->driver, p->name);
 
1380
                                ret = 3;
 
1381
                        }
 
1382
                        free_contrprocinfo(&cpinfo);
 
1383
                }
 
1384
        }
 
1385
 
 
1386
        if (cardname && cname[0] == 0) {
 
1387
                fprintf(stderr,"ERROR: card \"%s\"  not found\n", cardname);
 
1388
                ret = 4;
 
1389
        }
 
1390
 
 
1391
        if (!silent) {
 
1392
                cpinfo = load_contrprocinfo(0);
 
1393
                show_contrprocinfo(cpinfo, cardname ? cname: "");
 
1394
                free_contrprocinfo(&cpinfo);
 
1395
        }
 
1396
 
1275
1397
        free_config(&cards);
1276
1398
        close(capifd);
1277
1399
 
1280
1402
 
1281
1403
/* ------------------------------------------------------------------- */
1282
1404
 
1283
 
int main_stop(void)
 
1405
int main_stop(int unload, char *cardname, int number)
1284
1406
{
1285
1407
        struct capicard *cards, *card;
1286
1408
        struct contrprocinfo *cpinfo, *p;
1287
1409
        int contr, lastcontr;
1288
1410
        char *mp;
 
1411
        int act;
 
1412
        char cname[32];
1289
1413
 
1290
1414
        if (prestopcheck() < 0)
1291
1415
                return -1;
1292
1416
 
 
1417
        cname[0] = 0;
 
1418
 
1293
1419
        /* could not fail, tested by check_for_capi() */
1294
1420
        capifd = open(capidevname, O_RDWR);
1295
1421
 
1296
 
        cpinfo = load_contrprocinfo(&lastcontr);
1297
 
        for (contr = lastcontr; contr > 0; contr--) {
1298
 
                cpinfo = load_contrprocinfo(0);
1299
 
                p = find_contrprocinfo(cpinfo, contr);
1300
 
                if (p && p->state == CARD_RUNNING)
1301
 
                        reset_controller(contr);
1302
 
                free_contrprocinfo(&cpinfo);
1303
 
        }
1304
 
        cpinfo = load_contrprocinfo(&lastcontr);
1305
 
        for (contr = lastcontr; contr > 0; contr--) {
1306
 
                cpinfo = load_contrprocinfo(0);
1307
 
                p = find_contrprocinfo(cpinfo, contr);
1308
 
                if (p)
1309
 
                        remove_controller(contr);
1310
 
                free_contrprocinfo(&cpinfo);
1311
 
        }
1312
 
 
1313
 
        cpinfo = load_contrprocinfo(0);
1314
 
        show_contrprocinfo(cpinfo);
1315
 
        free_contrprocinfo(&cpinfo);
 
1422
        act = 0;
 
1423
        cpinfo = load_contrprocinfo(&lastcontr);
 
1424
        if (cardname) {
 
1425
                for (contr = 1; contr <= lastcontr; contr++) {
 
1426
                        cpinfo = load_contrprocinfo(0);
 
1427
                        p = find_contrprocinfo(cpinfo, contr);
 
1428
                        if (number == 0) {
 
1429
                                if (strcmp(cardname, p->name) != 0) {
 
1430
                                        free_contrprocinfo(&cpinfo);
 
1431
                                        continue;
 
1432
                                }
 
1433
                        } else if (is_card_of_driver(cardname, p)) {
 
1434
                                if (++act != number) {
 
1435
                                        free_contrprocinfo(&cpinfo);
 
1436
                                        continue;
 
1437
                                }
 
1438
                        } else {
 
1439
                                free_contrprocinfo(&cpinfo);
 
1440
                                continue;
 
1441
                        }
 
1442
                        strncpy(cname, p->name, sizeof(cname));
 
1443
                        if (p && p->state != CARD_DETECTED)
 
1444
                                reset_controller(contr);
 
1445
                        free_contrprocinfo(&cpinfo);
 
1446
                }
 
1447
        } else {
 
1448
                for (contr = lastcontr; contr > 0; contr--) {
 
1449
                        cpinfo = load_contrprocinfo(0);
 
1450
                        p = find_contrprocinfo(cpinfo, contr);
 
1451
                        if (p && p->state != CARD_DETECTED)
 
1452
                                reset_controller(contr);
 
1453
                        free_contrprocinfo(&cpinfo);
 
1454
                }
 
1455
        }
 
1456
        if (unload) {
 
1457
                cpinfo = load_contrprocinfo(&lastcontr);
 
1458
                for (contr = lastcontr; contr > 0; contr--) {
 
1459
                        cpinfo = load_contrprocinfo(0);
 
1460
                        p = find_contrprocinfo(cpinfo, contr);
 
1461
                        if (p)
 
1462
                                remove_controller(contr);
 
1463
                        free_contrprocinfo(&cpinfo);
 
1464
                }
 
1465
        }
 
1466
 
 
1467
        if (unload && !cardname) {
 
1468
                cards = load_config(configfilename);
 
1469
                for (card = cards; card; card = card->next) {
 
1470
                        if (driver_loaded(card->driver))
 
1471
                                unload_driver(card->driver);
 
1472
                }
 
1473
                for (card = cards; card; card = card->next) {
 
1474
                        if (driver_loaded(card->driver))
 
1475
                                unload_driver(card->driver);
 
1476
                }
 
1477
        }
 
1478
 
 
1479
        if (!silent) {
 
1480
                cpinfo = load_contrprocinfo(0);
 
1481
                show_contrprocinfo(cpinfo, cardname ? cname: 0);
 
1482
                free_contrprocinfo(&cpinfo);
 
1483
        }
1316
1484
        close(capifd);
1317
1485
 
1318
 
        cards = load_config(configfilename);
1319
 
        for (card = cards; card; card = card->next) {
1320
 
                if (driver_loaded(card->driver))
1321
 
                        unload_driver(card->driver);
1322
 
        }
1323
 
        for (card = cards; card; card = card->next) {
1324
 
                if (driver_loaded(card->driver))
1325
 
                        unload_driver(card->driver);
1326
 
        }
1327
 
 
1328
 
        unload_module("capi");
1329
 
        unload_module("capidrv");
1330
 
        unload_module("kernelcapi");
1331
 
        unload_module("capiutil");
1332
 
        if ((mp = mounted("capifs")) != 0 && strcmp(mp, "/dev/capi") == 0)
1333
 
                system("umount /dev/capi");
1334
 
        if (filesystem_available("capifs"))
1335
 
                unload_filesystem("capifs");
 
1486
        if (unload && !cardname) {
 
1487
                unload_module("capi");
 
1488
                unload_module("capidrv");
 
1489
                unload_module("kernelcapi");
 
1490
                unload_module("capiutil");
 
1491
                if ((mp = mounted("capifs")) != 0 && strcmp(mp, "/dev/capi") == 0)
 
1492
                        system("umount /dev/capi");
 
1493
                if (filesystem_available("capifs"))
 
1494
                        unload_filesystem("capifs");
 
1495
        }
 
1496
        if (cardname && cname[0] == 0) {
 
1497
                fprintf(stderr,"ERROR: card \"%s\"  not found\n", cardname);
 
1498
                return 4;
 
1499
        }
1336
1500
        return 0;
1337
1501
}
1338
1502
 
1351
1515
 
1352
1516
/* ------------------------------------------------------------------- */
1353
1517
 
 
1518
int main_status(void)
 
1519
{
 
1520
        struct contrprocinfo *cpinfo;
 
1521
 
 
1522
        cpinfo = load_contrprocinfo(0);
 
1523
        show_contrprocinfo(cpinfo, 0);
 
1524
        free_contrprocinfo(&cpinfo);
 
1525
        return 0;
 
1526
}
 
1527
 
 
1528
/* ------------------------------------------------------------------- */
 
1529
 
1354
1530
static void usage(void)
1355
1531
{
1356
1532
    fprintf(stderr, "Usage: capiinit [OPTION]\n");
1357
1533
    fprintf(stderr, "   or: capiinit [OPTION] start\n");
 
1534
    fprintf(stderr, "       - load all modules and inititialize all cards\n");
1358
1535
    fprintf(stderr, "   or: capiinit [OPTION] stop\n");
 
1536
    fprintf(stderr, "       - reset all cards and unload modules\n");
1359
1537
    fprintf(stderr, "   or: capiinit [OPTION] show\n");
 
1538
    fprintf(stderr, "       - show current config\n");
 
1539
    fprintf(stderr, "   or: capiinit [OPTION] status\n");
 
1540
    fprintf(stderr, "       - show current status\n");
 
1541
    fprintf(stderr, "   or: capiinit [OPTION] prepare\n");
 
1542
    fprintf(stderr, "       - load all modules\n");
 
1543
    fprintf(stderr, "   or: capiinit [OPTION] activate\n");
 
1544
    fprintf(stderr, "       - inititialize all cards \n");
 
1545
    fprintf(stderr, "   or: capiinit [OPTION] activate cardname\n");
 
1546
    fprintf(stderr, "       - inititialize one cards (i.e.: c4-ec00) \n");
 
1547
    fprintf(stderr, "   or: capiinit [OPTION] activate driver [cardnumber]\n");
 
1548
    fprintf(stderr, "       - inititialize one card \n");
 
1549
    fprintf(stderr, "   or: capiinit [OPTION] deactivate\n");
 
1550
    fprintf(stderr, "       - reset all cards \n");
 
1551
    fprintf(stderr, "   or: capiinit [OPTION] deactivate cardname\n");
 
1552
    fprintf(stderr, "       - reset one card (i.e.: c4-ec00) \n");
 
1553
    fprintf(stderr, "   or: capiinit [OPTION] deactivate driver [cardnumber]\n");
 
1554
    fprintf(stderr, "       - reset one cards \n");
 
1555
    fprintf(stderr, "   or: capiinit [OPTION] reload\n");
 
1556
    fprintf(stderr, "       - reset all cards and initialize them again\n");
1360
1557
    fprintf(stderr, "Setup or unsetup CAPI2.0 Controllers\n");
1361
1558
    fprintf(stderr, "   -c, --config filename  (default %s)\n", configfilename);
1362
1559
    fprintf(stderr, "   -d, --debug            save patchvalues for debugging\n");
 
1560
    fprintf(stderr, "   -s, --silent           don't show status\n");
1363
1561
}
1364
1562
 
1365
1563
int main(int ac, char *av[])
1371
1569
                static struct option long_options[] = {
1372
1570
                        {"config", 1, 0, 'c'},
1373
1571
                        {"debug", 1, 0, 'd'},
 
1572
                        {"silent", 1, 0, 's'},
1374
1573
                        {0, 0, 0, 0}
1375
1574
                };
1376
1575
 
1377
 
                c = getopt_long (ac, av, "c:d",
 
1576
                c = getopt_long (ac, av, "c:ds",
1378
1577
                                long_options, &option_index);
1379
1578
                if (c == -1)
1380
1579
                        break;
1394
1593
                        case 'd':
1395
1594
                                patchdebug = 1;
1396
1595
                                break;
 
1596
                        case 's':
 
1597
                                silent = 1;
 
1598
                                break;
1397
1599
                        case '?':
1398
1600
                                usage();
1399
1601
                                return 1;
1401
1603
        }
1402
1604
 
1403
1605
        if (optind == ac) {
1404
 
                return main_start();
 
1606
                return main_start(1, 0, 0);
1405
1607
        } else if (optind+1 == ac) {
1406
 
                if (strcmp(av[optind], "start") == 0)
1407
 
                        return main_start();
1408
 
                else if (strcmp(av[optind], "stop") == 0)
1409
 
                        return main_stop();
1410
 
                else if (strcmp(av[optind], "show") == 0)
 
1608
                if (strcmp(av[optind], "start") == 0) {
 
1609
                        return main_start(1, 0, 0);
 
1610
                } else if (strcmp(av[optind], "activate") == 0) {
 
1611
                        return main_start(1, 0, 0);
 
1612
                } else if (strcmp(av[optind], "prepare") == 0) {
 
1613
                        return main_start(0, 0, 0);
 
1614
                } else if (strcmp(av[optind], "stop") == 0) {
 
1615
                        return main_stop(1, 0, 0);
 
1616
                } else if (strcmp(av[optind], "deactivate") == 0) {
 
1617
                        return main_stop(0, 0, 0);
 
1618
                } else if (strcmp(av[optind], "show") == 0) {
1411
1619
                        return main_show();
 
1620
                } else if (strcmp(av[optind], "status") == 0) {
 
1621
                        return main_status();
 
1622
                } else if (strcmp(av[optind], "reload") == 0) {
 
1623
                        if (main_stop(0, 0, 0) == 0)
 
1624
                           return main_start(1, 0, 0);
 
1625
                }
 
1626
        } else if (optind+2 == ac) {
 
1627
                int number = strchr(av[optind+1], '-') == 0 ? 1 : 0;
 
1628
                if (strcmp(av[optind], "activate") == 0)
 
1629
                        return main_start(1, av[optind+1], number);
 
1630
                else if (strcmp(av[optind], "deactivate") == 0)
 
1631
                        return main_stop(0, av[optind+1], number);
 
1632
        } else if (optind+3 == ac) {
 
1633
                if (strcmp(av[optind], "activate") == 0)
 
1634
                        return main_start(1, av[optind+1], atoi(av[optind+2]));
 
1635
                else if (strcmp(av[optind], "deactivate") == 0)
 
1636
                        return main_stop(0, av[optind+1], atoi(av[optind+2]));
1412
1637
        }
1413
1638
        usage();
1414
1639
        return 1;