← Back to branch summary

~ubuntu-branches/ubuntu/edgy/ap-utils/edgy

« back to all changes in this revision

Viewing changes to lib/common.c

  • Committer: Bazaar Package Importer
  • Author(s): Celso González
  • Date: 2004-12-05 19:40:10 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20041205194010-4sbpbou1f4nn5xh9
Tags: 1.4.1+1.5pre1-1
http://bugs.debian.org/243208
* The "Freedom Of Ukraine" release
* New upstream release (closes: #243208 fix little incorrection in man page)
  - added two new programs ap-auth and ap-gl
  - added support for VERNET AP extension
  - lots of ui improvement
  - Some lintian fixes about utf8 encoding
  

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/common.c
27
27
#include <sys/ioctl.h>
28
28
#include "ap-utils.h"
29
29
 
30
 
#define AUTODETECT _("Autodetect AP type? ")
31
30
#define APIP _("Access Point IP-address: ")
32
31
#define APPASS _("Password (community): ")
33
 
#define APTYPE _("AP type: ")
 
32
#define AUTODETECT _("Autodetect AP MIB properties? ")
 
33
#define APTYPE _("AP MIB type: ")
 
34
#define APVENDOREXT _("AP MIB vendor extensions: ")
 
35
#define WANT_SYS_APLABEL _("Do you want to use AP's name as its label? ")
 
36
#define APLABEL _("Access Point label: ")
34
37
#define SAVESETTINGS _("Save connect-settings: ")
35
38
 
 
39
char *ap_types[] = {
 
40
    "ATMEL410",
 
41
    "NWN",
 
42
    "ATMEL12350"
 
43
};
 
44
 
 
45
char *ap_vendorexts[][3] = {
 
46
    { "NONE", "SBRIDGES" },             /* ATMEL410 exts */
 
47
    { "NONE" },                         /* NWN exts */
 
48
    { "NONE", "TELLUS", "VERNET" }      /* ATMEL12350 exts */
 
49
};
 
50
 
 
51
rdprops regdom_types[] = {
 
52
    { 0x10, "FCC (USA)", 1, 11 },
 
53
    { 0x20, "DOC (Canada)", 1, 11 },
 
54
    { 0x30, "ETSI (Europe)", 1, 13 },
 
55
    { 0x31, "Spain", 10, 2 },
 
56
    { 0x32, "France", 10, 4 },
 
57
    { 0x40, "MKK (Japan)", 14, 1 },
 
58
    { 0x41, "MKK1 (Japan)", 1, 14 },
 
59
    { 0x42, "Israel", 3, 7 },
 
60
    { 0x00, "unknown", 1, 14 }  /* hopefully 0x00 is not taken by any? */
 
61
};
 
62
 
 
63
char *channels[] = {
 
64
    "01", "02", "03", "04", "05", "06", "07",
 
65
    "08", "09", "10", "11", "12", "13", "14"
 
66
};
 
67
 
36
68
extern WINDOW *main_sub;
37
69
extern char *community, *prog_title;
38
 
extern short ap_type;
 
70
short ap_type, ap_vendorext;
39
71
extern int sockfd;
40
72
extern struct in_addr ap_ip;
41
 
extern char *ap_types[];
42
73
 
43
74
void about()
44
75
{
45
 
    int nrow = 12, ncol = 47, brow = (LINES - 4 - nrow) / 2, bcol =
 
76
    int nrow = 14, ncol = 47, brow = (LINES - 5 - nrow) / 2, bcol =
46
77
        (COLS - MCOLS - 2 - ncol) / 2, i;
47
78
    char message[100];
48
79
 
49
80
    noecho();
50
81
    curs_set(0);
51
82
 
52
 
    print_title(_("About"));
 
83
    print_top(NULL, _("About"));
53
84
 
54
85
    /* drawing the box */
55
86
    mvwaddch(main_sub, brow, bcol, ACS_ULCORNER);
73
104
    mvwaddstr(main_sub, brow + 5, bcol + 2,
74
105
              _("Written by Roman Festchook roma@polesye.net"));
75
106
    mvwaddstr(main_sub, brow + 6, bcol + 2,
76
 
              _("Copyright (c) Roman Festchook 2001-2004"));
77
 
    mvwaddstr(main_sub, brow + 7, bcol + 2, "http://ap-utils.polesye.net/");
78
 
    mvwaddstr(main_sub, brow + 9, bcol + 2,
 
107
              _("Portions by Jan Rafaj aputils@cedric.unob.cz"));
 
108
    mvwaddstr(main_sub, brow + 7, bcol + 2,
 
109
              _("Copyright (c) 2001-2004"));
 
110
    mvwaddstr(main_sub, brow + 8, bcol + 2,
 
111
              _("Roman Festchook and Jan Rafaj"));
 
112
    mvwaddstr(main_sub, brow + 9, bcol + 2, "http://ap-utils.polesye.net/");
 
113
    mvwaddstr(main_sub, brow + 11, bcol + 2,
79
114
              _("This program is distributed under the terms"));
80
 
    mvwaddstr(main_sub, brow +10, bcol + 2,
 
115
    mvwaddstr(main_sub, brow +12, bcol + 2,
81
116
              _("of the GNU General Public License version 2."));
82
 
    mvwaddstr(main_sub, brow + 11, bcol + 2,
 
117
    mvwaddstr(main_sub, brow + 13, bcol + 2,
83
118
              _("See the included COPYING file for details."));
84
119
 
85
120
 
88
123
    print_help(ANY_KEY);
89
124
    getch();
90
125
    print_help("");
91
 
    print_title("");
 
126
    print_top(NULL, NULL);
92
127
    clear_main(0);
93
128
    return;
94
129
}
95
130
 
96
131
void connect_options(unsigned long int ip, int type)
97
132
{
98
 
    int i;
 
133
    /*
 
134
     * operAccessPointName OIDs used to retrieve AP NAME [in order of
 
135
     * corresponding AP MIB types: ATMEL410, NWN, ATMEL12350]
 
136
     */
 
137
    char operAccessPointName[3][12] = {
 
138
      {0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01, 0x02, 0x01, 0x0A, 0x00},
 
139
      {0x2B, 0x06, 0x01, 0x02, 0x01, 0x01, 0x05, 0x00},
 
140
      {0x2B, 0x06, 0x01, 0x04, 0x01, 0xE0, 0x3E, 0x01, 0x02, 0x01, 0x0A, 0x00}
 
141
    };
 
142
 
99
143
    struct sockaddr_in client;
100
 
    unsigned char message[16];
101
 
    int fd;
 
144
    extern int atmel410_filter; /* to check is this function called from ap-gl utility */
 
145
    unsigned char message[256];
 
146
    unsigned char label[17];
 
147
    int fd, i;
102
148
    char *home_dir;
103
149
    char save_settings=1;
104
 
    char sysDescr_NWN[] = { 0x2B, 0x06, 0x01, 0x02, 0x01, 0x01, 0x01, 0x00 };
105
 
    char sysDescr_ATMEL410[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A,
106
 
        0x01, 0x01, 0x01, 0x01, 0x00 };
107
 
    char sysDescr_ATMEL12350[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0xE0, 0x3E,
108
 
        0x01, 0x01, 0x01, 0x01, 0x00 };
109
150
    varbind varbinds[1];
110
151
 
111
 
 
112
152
    memset(&client, 0, sizeof client);
113
153
    client.sin_family = AF_INET;
114
154
    client.sin_port = INADDR_ANY;
132
172
    noecho();
133
173
    curs_set(0);
134
174
 
135
 
    print_title(_("Connect options"));
 
175
    print_top(NULL, _("Connect options"));
136
176
 
137
177
get_all_again:
138
178
    mvwaddstr(main_sub, 1, 1, APIP);
145
185
    }
146
186
 
147
187
    mvwaddstr(main_sub, 2, 1, APPASS);
148
 
    print_help(_("Entered characters will not be displayed "
149
 
        "for security reason."));
150
 
    get_pass(message, 2, 1 + strlen(APPASS), 16);
151
 
    if (community)
152
 
        free(community);
153
 
    i = strlen(message) + 1;
154
 
    community = (char *) malloc(i);
155
 
    strncpy(community, message, i);
156
188
 
 
189
    i = 0;
157
190
    print_help("");
158
 
    if (type) {
 
191
 
 
192
        print_help(_("Entered characters will not be displayed "
 
193
                     "for security reason."));
 
194
        get_pass(message, 2, 1 + strlen(APPASS), 16);
 
195
        if (community)
 
196
            free(community);
 
197
        i = strlen(message) + 1;
 
198
        community = (char *) malloc(i);
 
199
        strncpy(community, message, i);
 
200
 
 
201
 
 
202
    if (type && ! atmel410_filter) {
 
203
        /* entered from ap_search() */
 
204
 
 
205
        /* community already exists */
 
206
/*      wattrset(main_sub, A_BOLD);
 
207
        for(i = 0; community[i++]; waddch(main_sub, '*'));
 
208
        wattrset(main_sub, A_NORMAL);
 
209
*/
159
210
        ap_type = --type;
160
 
        mvwaddstr(main_sub, 3, 1, APTYPE);
 
211
 
 
212
        print_menusel(3, 1, APTYPE, ap_types[ap_type]);
 
213
 
 
214
        /* well, we already know the MIB type, but lets find out MIB ext */
 
215
        get_mib_details();
 
216
 
 
217
        /* marks that we want offer AP name -> AP label later */
 
218
        i = 1;
 
219
 
 
220
        mvwaddstr(main_sub, 4, 1, APVENDOREXT);
161
221
    } else {
162
 
        mvwaddstr(main_sub, 3, 1, AUTODETECT);
163
 
        wrefresh(main_sub);
164
 
        i = yes_no(3, 1 + strlen(AUTODETECT));
165
 
        clear_main_new(3, 4);
166
 
        mvwaddstr(main_sub, 3, 1, APTYPE);
167
 
        if (i == 2) { /* NO */
168
 
            wrefresh(main_sub);
169
 
            ap_type = menu_choose(3, 1 + strlen(APTYPE), ap_types, 3);
170
 
        } else { /* YES */
171
 
            print_help(_("Determining AP type. Please wait..."));
172
 
            varbinds[0].oid = sysDescr_NWN;
173
 
            varbinds[0].len_oid = sizeof(sysDescr_NWN);
174
 
            varbinds[0].value = NULL;
175
 
            varbinds[0].len_val = 0;
176
 
            varbinds[0].type = NULL_VALUE;
177
 
            if (snmp(varbinds, 1, GET) > 0) {
178
 
                ap_type = NWN;
179
 
            } else {
180
 
                varbinds[0].oid = sysDescr_ATMEL410;
181
 
                varbinds[0].len_oid = sizeof(sysDescr_ATMEL410);
182
 
                varbinds[0].value = NULL;
183
 
                varbinds[0].len_val = 0;
184
 
                varbinds[0].type = NULL_VALUE;
185
 
                if (snmp(varbinds, 1, GET) > 0) {
186
 
                    ap_type = ATMEL410;
187
 
                } else {
188
 
                    varbinds[0].oid = sysDescr_ATMEL12350;
189
 
                    varbinds[0].len_oid = sizeof(sysDescr_ATMEL12350);
190
 
                    varbinds[0].value = NULL;
191
 
                    varbinds[0].len_val = 0;
192
 
                    varbinds[0].type = NULL_VALUE;
193
 
                    if (snmp(varbinds, 1, GET) > 0) {
194
 
                        ap_type = ATMEL12350;
195
 
                    } else {
196
 
                        print_helperr(_("Unable to determine AP type "
197
 
                            "(no response). Press any key."));
198
 
                        getch();
 
222
 
 
223
        if (atmel410_filter) {
 
224
                ap_type = --type;
 
225
                print_menusel(3, 1, APTYPE, ap_types[ap_type]);
 
226
                ap_vendorext = NONE; /* no need to choose here, really */
 
227
                /* marks that we want offer AP name -> AP label later */
 
228
                i = 1;
 
229
                mvwaddstr(main_sub, 4, 1, APVENDOREXT);
 
230
        } else {
 
231
                mvwaddstr(main_sub, 3, 1, AUTODETECT);
 
232
                wrefresh(main_sub);
 
233
                i = yes_no(3, 1 + strlen(AUTODETECT));
 
234
                clear_main_new(3, 4);
 
235
                mvwaddstr(main_sub, 3, 1, APTYPE);
 
236
                if (i == 2) { /* NO */
 
237
                    char **p;
 
238
    
 
239
                    wrefresh(main_sub);
 
240
 
 
241
                    ap_type = menu_choose(3, 1 + strlen(APTYPE), ap_types, 3);
 
242
                    print_bold(main_sub, ap_types[ap_type]);
 
243
 
 
244
                    mvwaddstr(main_sub, 4, 1, APVENDOREXT);
 
245
                    wrefresh(main_sub);
 
246
                    for (i = 0, p = ap_vendorexts[ap_type]; *p++; i++);
 
247
                    if (i == 1)
 
248
                        ap_vendorext = NONE; /* no need to choose here, really */
 
249
                    else
 
250
                        ap_vendorext = menu_choose(4, 1 + strlen(APVENDOREXT),
 
251
                    ap_vendorexts[ap_type], i);
 
252
                } else { /* YES */
 
253
                    if (get_mib_details() == -1) {
199
254
                        clear_main_new(1, 4);
200
255
                        goto get_all_again;
201
256
                    }
 
257
                print_bold(main_sub, ap_types[ap_type]);
 
258
 
 
259
            mvwaddstr(main_sub, 4, 1, APVENDOREXT);
 
260
        }
 
261
    }
 
262
    }
 
263
    print_bold(main_sub, ap_vendorexts[ap_type][ap_vendorext]);
 
264
 
 
265
    print_help(
 
266
        _("This label will be stored on HDD (independently on AP name!)."));
 
267
    if (i == 1) {
 
268
        /*
 
269
         * (being called from ap_search()) or (YES for AP type autodetection)
 
270
         * => offer possibility to use AP's name as the label
 
271
         */
 
272
        mvwaddstr(main_sub, 5, 1, WANT_SYS_APLABEL);
 
273
        wrefresh(main_sub);
 
274
        if (yes_no(5, 1 + strlen(WANT_SYS_APLABEL)) == 1) { /* YES */
 
275
            varbinds[0].oid = operAccessPointName[ap_type];
 
276
            varbinds[0].len_oid = (ap_type == NWN ?
 
277
                8 : sizeof(operAccessPointName[ap_type]));
 
278
            varbinds[0].type = NULL_VALUE;
 
279
            varbinds[0].len_val = 0;
 
280
 
 
281
            print_help(WAIT_RET);
 
282
            if (snmp(varbinds, i, GET) <= 0) {
 
283
                print_helperr(ERR_RET);
 
284
                getch();
 
285
            } else {
 
286
                clear_main_new(5, 6);
 
287
                mvwaddstr(main_sub, 5, 1, APLABEL);
 
288
                wattrset(main_sub, A_BOLD);
 
289
                for (i = 0; i < varbinds[0].len_val && i < 16 &&
 
290
                     *(varbinds[0].value + i); i++) {
 
291
                    label[i] = *(varbinds[0].value + i);
 
292
                    waddch(main_sub, label[i]);
 
293
                }
 
294
                label[++i] = '\0';
 
295
                wattrset(main_sub, A_NORMAL);
 
296
                if (strlen(varbinds[0].value) > 16) {
 
297
                    print_helperr("Warning! AP LABEL truncated to first 16 characters of AP NAME. Press any key.");
 
298
                    getch();
202
299
                }
203
300
            }
204
 
        }                           
205
 
        wattrset(main_sub, A_BOLD);
206
 
    }
207
 
    waddstr(main_sub, ap_types[ap_type]);
208
 
    wattrset(main_sub, A_NORMAL);
209
 
 
210
 
    mvwaddstr(main_sub, 4, 1, SAVESETTINGS);
 
301
            print_help("");
 
302
            i = -1;
 
303
        }
 
304
    }
 
305
 
 
306
    if (i != -1) { /* we have NOT been asked with WANT_SYS_APLABEL */
 
307
        clear_main_new(5, 6);
 
308
        mvwaddstr(main_sub, 5, 1, APLABEL);
 
309
        get_value(message, 5, 1 + strlen(APLABEL), -sizeof(label), ANY_STRING,
 
310
            0, 0, NULL);
 
311
        strncpy(label, message, strlen(message) + 1);
 
312
    }
 
313
 
 
314
    mvwaddstr(main_sub, 6, 1, SAVESETTINGS);
211
315
    wrefresh(main_sub);
212
 
    save_settings = on_off(4, 1 + strlen(SAVESETTINGS));
 
316
    save_settings = on_off(6, 1 + strlen(SAVESETTINGS));
213
317
 
214
318
    print_bottom(inet_ntoa(ap_ip));
215
319
 
216
320
    if(save_settings == 1) {
217
321
        if ((home_dir = getenv("HOME"))) {
218
322
            sprintf(message, "%s/.ap-config", home_dir);
219
 
            if ((fd = open(message, O_CREAT | O_WRONLY | O_APPEND, 0600)) != -1) {
220
 
                sprintf(message, "%s:%s:%d\n", inet_ntoa(ap_ip),
221
 
                    community, ap_type);
 
323
            if ((fd = open(message, O_CREAT|O_WRONLY|O_APPEND, 0600)) != -1) {
 
324
                sprintf(message, "%s:%s:%s:%d:%d\n", inet_ntoa(ap_ip),
 
325
                    community, label, ap_type, ap_vendorext);
222
326
                write(fd, message, strlen(message));
223
327
                close(fd);
224
328
            }
226
330
    }
227
331
  exit:
228
332
    print_help("");
229
 
    print_title("");
 
333
    print_top(NULL, NULL);
230
334
    clear_main(0);
231
335
    return;
232
336
}
233
337
 
 
338
/*
 
339
 * Determines AP MIB type (fills ap_type), and AP MIB vendor extensions
 
340
 * (changes values of ap_vendorext global). Returns with -1 on error or 0
 
341
 * if everything is OK.
 
342
 */
 
343
int get_mib_details()
 
344
{
 
345
    char sysDescr_NWN[] = {
 
346
        0x2B, 0x06, 0x01, 0x02, 0x01, 0x01, 0x01, 0x00
 
347
    };
 
348
    char sysDescr_ATMEL[] = {
 
349
        0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01, 0x01, 0x01, 0x01, 0x00
 
350
    };
 
351
    char operEthernetAddress_ATMEL[] = {
 
352
        0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01, 0x01, 0x02, 0x03, 0x00
 
353
    };
 
354
    char Wireless_ATMEL[] = {
 
355
        0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01, 0x02, 0x03, 0x01, 0x00
 
356
    };
 
357
    varbind varbinds[2];
 
358
    char oui_sbridges[3] = { 0x00, 0x30, 0x1A };
 
359
    char oui_tellus[3] = { 0x00, 0x04, 0xDB };
 
360
 
 
361
    print_help(_("Trying to probe AP for MIB properties. Please wait..."));
 
362
 
 
363
    /* first, determine the private MIB types according to enterprises ID */
 
364
    varbinds[0].oid = sysDescr_NWN;
 
365
    varbinds[0].len_oid = sizeof(sysDescr_NWN);
 
366
    varbinds[0].value = NULL;
 
367
    varbinds[0].len_val = 0;
 
368
    varbinds[0].type = NULL_VALUE;
 
369
    if (snmp(varbinds, 1, GET) > 0) {
 
370
        ap_type = NWN;
 
371
    } else {
 
372
        varbinds[0].oid = sysDescr_ATMEL;
 
373
        varbinds[0].len_oid = sizeof(sysDescr_ATMEL);
 
374
        varbinds[0].value = NULL;
 
375
        varbinds[0].len_val = 0;
 
376
        varbinds[0].type = NULL_VALUE;
 
377
        if (snmp(varbinds, 1, GET) > 0) {
 
378
            ap_type = ATMEL410;
 
379
        } else {
 
380
            sysDescr_ATMEL[5] = 0xE0;
 
381
            sysDescr_ATMEL[6] = 0x3E;
 
382
            varbinds[0].oid = sysDescr_ATMEL;
 
383
            varbinds[0].len_oid = sizeof(sysDescr_ATMEL);
 
384
            varbinds[0].value = NULL;
 
385
            varbinds[0].len_val = 0;
 
386
            varbinds[0].type = NULL_VALUE;
 
387
            if (snmp(varbinds, 1, GET) > 0) {
 
388
                ap_type = ATMEL12350;
 
389
            } else {
 
390
                print_helperr(_("Unable to determine AP MIB properties "
 
391
                    "(no response from AP). Press any key."));
 
392
                getch();
 
393
                return -1;
 
394
            }
 
395
        }
 
396
    }
 
397
 
 
398
    /*
 
399
     * It is best to do the following HERE and FOR ONCE ONLY: find out more
 
400
     * about specific MIB modifications - we'll use them on different places
 
401
     * later.
 
402
     */
 
403
    varbinds[0].type = NULL_VALUE;
 
404
    varbinds[0].oid = operEthernetAddress_ATMEL;
 
405
    varbinds[0].len_oid = sizeof(operEthernetAddress_ATMEL);
 
406
    varbinds[0].len_val = 0;
 
407
    varbinds[1].type = NULL_VALUE;
 
408
    varbinds[1].oid = Wireless_ATMEL;
 
409
    varbinds[1].len_oid = sizeof(Wireless_ATMEL);
 
410
    varbinds[1].len_val = 0;
 
411
    if (ap_type == ATMEL12350) {
 
412
        operEthernetAddress_ATMEL[5] = 0xE0;
 
413
        operEthernetAddress_ATMEL[6] = 0x3E;
 
414
        Wireless_ATMEL[5] = 0xE0;
 
415
        Wireless_ATMEL[6] = 0x3E;
 
416
    }
 
417
    if (snmp(varbinds, 2, GET) <= 0) {
 
418
        print_helperr(ERR_RET);
 
419
        getch();
 
420
        return -1;
 
421
    }
 
422
 
 
423
    /*
 
424
     * Detection of different vendor-modified ATMEL private MIBs.
 
425
     * Note that results here are considered mutually exclusive, although
 
426
     * MIBs *may* share a lot of properties - for example, the condition
 
427
     * for TELLUS is matched also with VERNET firmware, but we want
 
428
     * unambiguous results => exactly one type is to be returned each pass
 
429
     * => the order of these conditions is important.
 
430
     */
 
431
    ap_vendorext = NONE;
 
432
 
 
433
    if (ap_type == ATMEL410 && (memcmp(oui_sbridges, varbinds[0].value, 3) ==0))
 
434
        ap_vendorext = SBRIDGES;
 
435
 
 
436
    if (ap_type == ATMEL12350 && (memcmp(oui_tellus, varbinds[0].value, 3) ==0))
 
437
        ap_vendorext = TELLUS;
 
438
 
 
439
    if (ap_type == ATMEL12350 && varbinds[1].len_val == 104)
 
440
        ap_vendorext = VERNET;
 
441
 
 
442
    return 0;
 
443
}
 
444
 
234
445
void exit_program()
235
446
{
236
447
    endwin();
246
457
    refresh();
247
458
}
248
459
 
249
 
/* 
250
 
 * Fill channels list string array using regulation domain
251
 
 * restrictions and return number of the channels
 
460
/*
 
461
 * Expects regulatory domain code on input and returns index of a corresponding
 
462
 * regdom_types[] member, that describes the given regulatory domain properties.
252
463
 */
253
 
int ch_list(int regulation_domain, char **list)
 
464
int regdom_idx(char regdom)
254
465
{
255
 
    int FIRST_CHANNEL, LAST_CHANNEL, i;
256
 
 
257
 
#ifndef NO_REG_DOMAIN
258
 
    switch (regulation_domain) {
259
 
    case 0x10:
260
 
    case 0x20:
261
 
        FIRST_CHANNEL = 1;
262
 
        LAST_CHANNEL = 11;
263
 
        break;
264
 
    case 0x30:
265
 
        FIRST_CHANNEL = 1;
266
 
        LAST_CHANNEL = 13;
267
 
        break;
268
 
    case 0x31:
269
 
        FIRST_CHANNEL = 10;
270
 
        LAST_CHANNEL = 11;
271
 
        break;
272
 
    case 0x32:
273
 
        FIRST_CHANNEL = 10;
274
 
        LAST_CHANNEL = 13;
275
 
        break;
276
 
    default: /* also case 0x40 */
277
 
#endif    
278
 
        FIRST_CHANNEL = 1;
279
 
        LAST_CHANNEL = 14;
280
 
#ifndef NO_REG_DOMAIN
281
 
    }
282
 
#endif    
283
 
 
284
 
    for (i = 0; i < LAST_CHANNEL - FIRST_CHANNEL + 1; i++) {
285
 
        list[i] = (char *) malloc(3);
286
 
        sprintf(list[i], "%02u", FIRST_CHANNEL + i);
287
 
    }
 
466
    int i;
 
467
 
 
468
    for (i = 0; &regdom_types[i]; i++)
 
469
        if (regdom_types[i].code == regdom)
 
470
            return i;
 
471
 
288
472
    return i;
289
473
}
290
474