fxstest: Use DAHDI_SPECIFY when opening by integer channel number.
[dahdi/tools.git] / dahdi_maint.c
1 /*
2  * Performance and Maintenance utility
3  *
4  * Written by Russ Meyerriecks <rmeyerriecks@digium.com>
5  *
6  * Copyright (C) 2009-2010 Digium, Inc.
7  *
8  * All rights reserved.
9  *
10  */
11
12 /*
13  * See http://www.asterisk.org for more information about
14  * the Asterisk project. Please do not directly contact
15  * any of the maintainers of this project for assistance;
16  * the project provides a web site, mailing lists and IRC
17  * channels for your use.
18  *
19  * This program is free software, distributed under the terms of
20  * the GNU General Public License Version 2 as published by the
21  * Free Software Foundation. See the LICENSE file included with
22  * this program for more details.
23  */
24
25 #include <stdio.h>
26 #include <getopt.h>
27 #include <unistd.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <sys/ioctl.h>
31 #include <fcntl.h>
32 #include <stdlib.h>
33
34 #include <dahdi/user.h>
35 #include "dahdi_tools_version.h"
36
37 #define DAHDI_CTL "/dev/dahdi/ctl"
38
39 extern char *optarg;
40 extern int optind;
41
42 void display_help(char *argv0, int exitcode)
43 {
44         char *c;
45         c = strrchr(argv0, '/');
46         if (!c)
47                 c = argv0;
48         else
49                 c++;
50         fprintf(stderr, "%s\n\n", dahdi_tools_version);
51         fprintf(stderr, "Usage: %s -s <span num> <options>\n", c);
52         fprintf(stderr, "Options:\n");
53         fprintf(stderr, "        -h, --help             display help\n");
54         fprintf(stderr, "        -s, --span <span num>  specify the span\n");
55         fprintf(stderr, "        -l, --loopback <localhost|networkline|"\
56                                                 "networkpayload|loopup|"\
57                                                 "loopdown|off>\n"\
58                         "\t\tlocalhost - loop back towards host\n"\
59                         "\t\tnetworkline - network line loopback\n"\
60                         "\t\tnetworkpayload - network payload loopback\n"\
61                         "\t\tloopup - transmit loopup signal\n"\
62                         "\t\tloopdown - transmit loopdown signal\n"\
63                         "\t\toff - end loopback mode\n");
64         fprintf(stderr, "        -i, --insert <fas|multi|crc|cas|prbs|bipolar>"\
65                         "\n\t\tinsert an error of a specific type\n");
66         fprintf(stderr, "        -r, --reset            "\
67                         "reset the error counters\n\n");
68         fprintf(stderr, "Examples: \n");
69         fprintf(stderr, "Enable network line loopback\n");
70         fprintf(stderr, "       dahdi_maint -s 1 --loopback networkline\n");
71         fprintf(stderr, "Disable network line loopback\n");
72         fprintf(stderr, "       dahdi_maint -s 1 --loopback off\n\n");
73
74         exit(exitcode);
75 }
76
77 int main(int argc, char *argv[])
78 {
79         static int ctl = -1;
80         int res;
81
82         int doloopback = 0;
83         char *larg = NULL;
84         int span = 1;
85         int iflag = 0;
86         char *iarg = NULL;
87         int gflag = 0;
88         int c;
89         int rflag = 0;
90
91         struct dahdi_maintinfo m;
92         struct dahdi_spaninfo s;
93
94         static struct option long_options[] = {
95                 {"help",        no_argument,       0, 'h'},
96                 {"loopback",    required_argument, 0, 'l'},
97                 {"span",        required_argument, 0, 's'},
98                 {"insert",      required_argument, 0, 'i'},
99                 {"reset",       no_argument,       0, 'r'},
100                 {0, 0, 0, 0}
101         };
102         int option_index = 0;
103
104         if (argc < 2) { /* no options */
105                 display_help(argv[0], 1);
106         }
107
108         while ((c = getopt_long(argc, argv, "hj:l:p:s:i:g:r",
109                                 long_options, &option_index)) != -1) {
110                         switch (c) {
111                         case 'h':
112                                 display_help(argv[0], 0);
113                                 break;
114                         case 'l': /* loopback */
115                                 larg = optarg;
116                                 doloopback = 1;
117                                 break;
118                         case 's': /* specify a span */
119                                 span = atoi(optarg);
120                                 break;
121                         case 'i': /* insert an error */
122                                 iarg = optarg;
123                                 iflag = 1;
124                                 break;
125                         case 'g': /* generate psuedo random sequence */
126                                 gflag = 1;
127                                 break;
128                         case 'r': /* reset the error counters */
129                                 rflag = 1;
130                                 break;
131                         }
132         }
133
134         ctl = open(DAHDI_CTL, O_RDWR);
135         if (ctl < 0) {
136                 fprintf(stderr, "Unable to open %s\n", DAHDI_CTL);
137                 return -1;
138         }
139
140         if (!(doloopback || iflag || gflag || rflag)) {
141                 s.spanno = span;
142                 res = ioctl(ctl, DAHDI_SPANSTAT, &s);
143                 if (res || ((__u32)-1 == s.fecount))
144                         printf("Error counters not supported by the driver"\
145                                         " for this span\n");
146                 printf("Span %d:\n", span);
147                 printf(">Framing Errors : %d:\n", s.fecount);
148                 printf(">CRC Errors : %d:\n", s.crc4count);
149                 printf(">Code Violations : %d:\n", s.cvcount);
150                 printf(">E-bit Count : %d:\n", s.ebitcount);
151                 printf(">General Errored Seconds : %d:\n", s.errsec);
152
153                 return 0;
154         }
155
156         m.spanno = span;
157
158         if (doloopback) {
159                 if (!strcasecmp(larg, "localhost")) {
160                         printf("Span %d: local host loopback ON\n", span);
161                         m.command = DAHDI_MAINT_LOCALLOOP;
162                 } else if (!strcasecmp(larg, "networkline")) {
163                         printf("Span %d: network line loopback ON\n", span);
164                         m.command = DAHDI_MAINT_NETWORKLINELOOP;
165                 } else if (!strcasecmp(larg, "networkpayload")) {
166                         printf("Span %d: network payload loopback ON\n", span);
167                         m.command = DAHDI_MAINT_NETWORKPAYLOADLOOP;
168                 } else if (!strcasecmp(larg, "loopup")) {
169                         printf("Span %d: transmitting loopup signal\n", span);
170                         m.command = DAHDI_MAINT_LOOPUP;
171                 } else if (!strcasecmp(larg, "loopdown")) {
172                         printf("Span %d: transmitting loopdown signal\n", span);
173                         m.command = DAHDI_MAINT_LOOPDOWN;
174                 } else if (!strcasecmp(larg, "off")) {
175                         printf("Span %d: loopback OFF\n", span);
176                         m.command = DAHDI_MAINT_NONE;
177                 } else {
178                         display_help(argv[0], 1);
179                 }
180
181                 res = ioctl(ctl, DAHDI_MAINT, &m);
182                 if (res) {
183                         printf("This type of looping not supported by the"\
184                                         " driver for this span\n");
185                         return 1;
186                 }
187
188                 /* Leave the loopup/loopdown signal on the line for
189                  * five seconds according to AT&T TR 54016
190                  */
191                 if ((m.command == DAHDI_MAINT_LOOPUP) ||
192                    (m.command == DAHDI_MAINT_LOOPDOWN)) {
193                         sleep(5);
194                         m.command = DAHDI_MAINT_NONE;
195                         ioctl(ctl, DAHDI_MAINT, &m);
196                 }
197         }
198
199         if (iflag) {
200                 if (!strcasecmp(iarg, "fas")) {
201                         m.command = DAHDI_MAINT_FAS_DEFECT;
202                         printf("Inserting a single FAS defect\n");
203                 } else if (!strcasecmp(iarg, "multi")) {
204                         m.command = DAHDI_MAINT_MULTI_DEFECT;
205                         printf("Inserting a single multiframe defect\n");
206                 } else if (!strcasecmp(iarg, "crc")) {
207                         m.command = DAHDI_MAINT_CRC_DEFECT;
208                         printf("Inserting a single CRC defect\n");
209                 } else if (!strcasecmp(iarg, "cas")) {
210                         m.command = DAHDI_MAINT_CAS_DEFECT;
211                         printf("Inserting a single CAS defect\n");
212                 } else if (!strcasecmp(iarg, "prbs")) {
213                         m.command = DAHDI_MAINT_PRBS_DEFECT;
214                         printf("Inserting a single PRBS defect\n");
215                 } else if (!strcasecmp(iarg, "bipolar")) {
216                         m.command = DAHDI_MAINT_BIPOLAR_DEFECT;
217                         printf("Inserting a single bipolar defect\n");
218 #ifdef DAHDI_MAINT_ALARM_SIM
219                 } else if (!strcasecmp(iarg, "sim")) {
220                         m.command = DAHDI_MAINT_ALARM_SIM;
221                         printf("Incrementing alarm simulator\n");
222 #endif
223                 } else {
224                         display_help(argv[0], 1);
225                 }
226                 res = ioctl(ctl, DAHDI_MAINT, &m);
227                 if (res)
228                         printf("This type of error injection is not supported"\
229                                         " by the driver for this span\n");
230         }
231
232         if (gflag) {
233                 printf("Enabled the Pseudo-Random Binary Sequence Generation"\
234                         " and Monitor\n");
235                 m.command = DAHDI_MAINT_PRBS;
236                 res = ioctl(ctl, DAHDI_MAINT, &m);
237                 if (res) {
238                         printf("Pseudo-random binary sequence generation is"\
239                                 " not supported by the driver for this span\n");
240                 }
241         }
242
243         if (rflag) {
244                 printf("Resetting error counters for span %d\n", span);
245                 m.command = DAHDI_RESET_COUNTERS;
246                 res = ioctl(ctl, DAHDI_MAINT, &m);
247                 if (res) {
248                         printf("Resetting error counters is not supported by"\
249                                         " the driver for this span\n");
250                 }
251         }
252
253         return 0;
254 }