src/auth_mac.c

   1 /*
   2  *      auth.c from Access Point SNMP Utils for Linux
   3  *
   4  * Copyright (c) 2002 Roman Festchook <roma at polesye dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License Version 2 from
   8  * June 1991 as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18  *
  19  */
  20
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <string.h>
  24 #include "ap-utils.h"
  25 #include "ap-curses.h"
  26
  27 #define MAX_LINES LINES-6
  28 #define PACKET_ERROR _("AuthorizedMacTableString packet error")
  29
  30 #define MAC_AUTH _("[A] MAC authorization: ")
  31 #define MAC_ADD  _("Enter MAC: ")
  32 #define MAC_DEL  _("Delete Num: ")
  33 #define MAC_TITLE _("Authorized MAC addresses")
  34 #define MAC_HEADER _("NUM     MAC address")
  35 #define MAC_HELP _("A - auth; N - new; D - del; arrows - scroll; W - write conf; Q - quit")
  36
  37 extern WINDOW *main_sub;
  38 extern int LINES;
  39 extern short ap_type;
  40
  41 void atmel_auth_mac()
  42 {
  43     struct AuthorizedMacTableString {
  44         unsigned int short Action;
  45         unsigned int short NumOfAllTableAddresses;
  46         unsigned int short NumOfCurrentAddress;
  47         unsigned char MacAddress[6];
  48     } *AuthMac = NULL, get;
  49
  50     struct MacListStat *pmac, *first = NULL, *curr = NULL;
  51     uint32_t auth_mac_hw;
  52
  53     char EnableAuthMAC[] =
  54         { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01,
  55         0x02, 0x06, 0x01, 0x00
  56     };
  57     char AutorizedMac[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01,
  58         0x02, 0x06, 0x02, 0x00
  59     };
  60
  61     char message[1024], m_authmac = 0;
  62     int i, total_mac, auth_mac = 0, mac_num = 0, begin, end;
  63     varbind varbinds[1];
  64
  65     if (ap_type == ATMEL12350) {
  66         EnableAuthMAC[5] = 0xE0;
  67         EnableAuthMAC[6] = 0x3E;
  68         AutorizedMac[5] = 0xE0;
  69         AutorizedMac[6] = 0x3E;
  70     }
  71
  72     varbinds[0].oid = EnableAuthMAC;
  73     varbinds[0].len_oid = sizeof(EnableAuthMAC);
  74     varbinds[0].type = NULL_VALUE;
  75     varbinds[0].len_val = 0;
  76     print_help(WAIT_RET);
  77     if (snmp(varbinds, 1, GET) <= 0) {
  78         print_helperr(ERR_RET);
  79         goto exit;
  80     }
  81     print_title(MAC_TITLE);
  82
  83     auth_mac = *(varbinds[0].value);
  84     sprintf(message, "%s%s", MAC_AUTH, (auth_mac == 1) ? ON : OFF);
  85     mvwaddstr(main_sub, 0, 0, message);
  86     mvwaddstr(main_sub, 2, 1, MAC_HEADER);
  87     wrefresh(main_sub);
  88
  89     total_mac = 0;
  90     mac_num = 0;
  91
  92     while (mac_num <= total_mac) {
  93         get.Action = 0x02; rshort(get.Action);
  94         get.NumOfAllTableAddresses = total_mac; rshort(get.NumOfAllTableAddresses);
  95         get.NumOfCurrentAddress = mac_num; rshort(get.NumOfCurrentAddress);
  96
  97         varbinds[0].oid = AutorizedMac;
  98         varbinds[0].len_oid = sizeof(AutorizedMac);
  99         varbinds[0].value = (char *) &get;
 100         varbinds[0].len_val = 12;
 101         varbinds[0].type = STRING_VALUE;
 102
 103         if (snmp(varbinds, 1, SET) <= 0) {
 104             print_helperr(ERR_RET);
 105             goto exit;
 106         }
 107
 108         if (varbinds[0].len_val == 12) {
 109             if (AuthMac)
 110                 free(AuthMac);
 111             AuthMac =
 112                 (struct AuthorizedMacTableString *) malloc(varbinds[0].
 113                                                            len_val);
 114             memcpy(AuthMac, varbinds[0].value, varbinds[0].len_val);
 115 /*          AuthMac =
 116                 (struct AuthorizedMacTableString *) varbinds[0].value;*/
 117         } else {
 118             print_helperr(PACKET_ERROR);
 119             goto exit;
 120         }
 121
 122         rshort(AuthMac->NumOfAllTableAddresses);
 123         total_mac =
 124             (AuthMac->NumOfAllTableAddresses ==
 125              65535) ? 0 : AuthMac->NumOfAllTableAddresses;
 126
 127         if (mac_num) {
 128             if (first == NULL) {
 129                 first = (struct MacListStat *)
 130                     malloc(sizeof(struct MacListStat));
 131                 curr = first;
 132             } else {
 133                 curr->next = (struct MacListStat *)
 134                     malloc(sizeof(struct MacListStat));
 135                 curr = curr->next;
 136             }
 137             memcpy(curr->addr, AuthMac->MacAddress, 6);
 138             curr->next = NULL;
 139         }
 140         mac_num++;
 141     }
 142
 143     begin = 1;
 144     end = (MAX_LINES < mac_num) ? MAX_LINES : mac_num;
 145     scroll_rows(first, begin, end, 3, 0);
 146
 147     noecho();
 148
 149     print_help(MAC_HELP);
 150     while (1) {
 151         switch (getch()) {
 152         case 'q':
 153         case 'Q':
 154             goto quit;
 155         case 'a':
 156         case 'A':
 157             auth_mac = on_off(0, strlen(MAC_AUTH));
 158             clear_main_new(0, 1);
 159             print_menusel(0, 0, MAC_AUTH, (auth_mac == 1) ? ON : OFF);
 160             m_authmac = 1;
 161             continue;
 162         case 'd':
 163         case 'D':
 164             mvwaddstr(main_sub, 1, 0, MAC_DEL);
 165             get_value(message, 1, strlen(MAC_DEL), 5, INT_STRING,
 166                 1, mac_num - 1, NULL);
 167             i = atoi(message);
 168             if (i == 1) {
 169                 pmac = first;
 170                 first = first->next;
 171                 free(pmac);
 172             } else {
 173                 curr = first;
 174                 while (--i > 1)
 175                     curr = curr->next;
 176                 pmac = curr->next;
 177                 curr->next = pmac->next;
 178                 free(pmac);
 179             }
 180             mac_num--;
 181             begin = 1;
 182             end = (MAX_LINES < mac_num) ? MAX_LINES : mac_num;
 183             scroll_rows(first, begin, end, 3, 0);
 184             clear_main_new(1, 2);
 185             continue;
 186         case 'n':
 187         case 'N':
 188             mvwaddstr(main_sub, 1, 0, MAC_ADD);
 189             curr = first;
 190             while (curr && curr->next)
 191                 curr = curr->next;
 192             if (first == NULL) {
 193                 first = (struct MacListStat *)
 194                     malloc(sizeof(struct MacListStat));
 195                 curr = first;
 196             } else {
 197                 curr->next = (struct MacListStat *)
 198                     malloc(sizeof(struct MacListStat));
 199                 curr = curr->next;
 200             }
 201             curr->next = NULL;
 202             mac_num++;
 203 /*          get_value(message, 1, strlen(MAC_ADD), 13, ANY_STRING, 0, 0,
 204                 NULL);
 205
 206             for (i = 0; i < 6; i++) {
 207                 mess[0] = message[2 * i];
 208                 mess[1] = message[2 * i + 1];
 209                 mess[2] = '\0';
 210                 curr->addr[i] = strtol(mess, NULL, 16);
 211             }
 212             clear_main_new(1, 2);
 213 */
 214             get_mac(curr->addr, 1, strlen(MAC_ADD));
 215             begin = 1;
 216             end = (MAX_LINES < mac_num) ? MAX_LINES : mac_num;
 217             scroll_rows(first, begin, end, 3, 0);
 218             clear_main_new(1, 2);
 219             continue;
 220         case 'w':
 221         case 'W':
 222             if (m_authmac) {
 223                 auth_mac_hw = swap4(auth_mac);
 224                 varbinds[0].oid = EnableAuthMAC;
 225                 varbinds[0].len_oid = sizeof(EnableAuthMAC);
 226                 varbinds[0].type = INT_VALUE;
 227                 varbinds[0].value = (char *) &auth_mac_hw;
 228                 varbinds[0].len_val = 1;
 229                 print_help(WAIT_SET);
 230                 if (snmp(varbinds, 1, SET) <= 0) {
 231                     print_helperr(ERR_RET);
 232                     goto exit;
 233                 }
 234             }
 235             curr = first;
 236             i = 1;
 237             while (curr != NULL) {
 238                 get.Action = 0x01; rshort(get.Action);
 239                 get.NumOfAllTableAddresses = mac_num - 1; rshort(get.NumOfAllTableAddresses);
 240                 get.NumOfCurrentAddress = i; rshort(get.NumOfCurrentAddress);
 241                 memcpy(get.MacAddress, curr->addr, 6);
 242                 varbinds[0].oid = AutorizedMac;
 243                 varbinds[0].len_oid = sizeof(AutorizedMac);
 244                 varbinds[0].value = (char *) &get;
 245                 varbinds[0].len_val = 12;
 246                 varbinds[0].type = STRING_VALUE;
 247                 print_help(WAIT_SET);
 248                 if (snmp(varbinds, 1, SET) <= 0) {
 249                     print_helperr(ERR_RET);
 250                     goto exit;
 251                 }
 252                 if (varbinds[0].len_val != 12) {
 253                     print_helperr(PACKET_ERROR);
 254                     goto exit;
 255                 }
 256                 curr = curr->next;
 257                 i++;
 258             }
 259             print_help(DONE_SET);
 260             goto exit;
 261         case KEY_DOWN:
 262         case KEY_RIGHT:
 263             if (end < mac_num) {
 264                 begin++;
 265                 end++;
 266                 scroll_rows(first, begin, end, 3, 0);
 267             }
 268             continue;
 269         case KEY_UP:
 270         case KEY_LEFT:
 271             if (begin > 1) {
 272                 begin--;
 273                 end--;
 274                 scroll_rows(first, begin, end, 3, 0);
 275             }
 276             continue;
 277         }
 278         continue;
 279     }
 280
 281     print_help(ANY_KEY);
 282   exit:
 283     getch();
 284   quit:
 285     while ((curr = first)) {
 286         first = curr->next;
 287         free(curr);
 288     }
 289     if (AuthMac)
 290         free(AuthMac);
 291     print_title("");
 292     clear_main(0);
 293 }
 294
 295 void nwn_auth_mac()
 296 {
 297     struct MacListStat *pmac, *first = NULL, *curr = NULL;
 298     char Mac[] =
 299         { 0x2b, 0x06, 0x01, 0x04, 0x01, 0x87, 0x29, 0x03, 0x01, 0x03, 0x02,
 300         0x02, 0x01, 0x02, 0x00
 301     };
 302     char MacAllow[] =
 303         { 0x2b, 0x06, 0x01, 0x04, 0x01, 0x87, 0x29, 0x03, 0x01, 0x03, 0x02,
 304         0x02, 0x01, 0x03, 0x00
 305     };
 306     char MacRowStatus[] =
 307         { 0x2b, 0x06, 0x01, 0x04, 0x01, 0x87, 0x29, 0x03, 0x01, 0x03, 0x02,
 308         0x02, 0x01, 0x04, 0x00
 309     };
 310     char message[1024], auth_enable[] =
 311         { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 312     char destroy = 6, create = 4, allow = 1;
 313     int i, auth_mac = 0, mac_num = 0, begin, end;
 314     varbind varbinds[3];
 315     print_title(MAC_TITLE);
 316
 317     mvwaddstr(main_sub, 2, 5, MAC_HEADER);
 318     wrefresh(main_sub);
 319     print_help(WAIT_RET);
 320
 321     mac_num = 1;
 322     varbinds[0].oid = Mac;
 323     varbinds[0].len_oid = sizeof(Mac);
 324     varbinds[0].value = Mac;
 325     varbinds[0].len_val = 0;
 326     varbinds[0].type = NULL_VALUE;
 327     if (snmp(varbinds, 1, GET_NEXT) <= 0) {
 328         print_helperr(ERR_RET);
 329         goto exit;
 330     }
 331
 332     while (memcmp(varbinds[0].oid, Mac, sizeof(Mac) - 1) == 0) {
 333
 334         Mac[sizeof(Mac) - 1] = varbinds[0].oid[sizeof(Mac) - 1];
 335         MacAllow[sizeof(MacAllow) - 1] = varbinds[0].oid[sizeof(Mac) - 1];
 336         MacRowStatus[sizeof(MacRowStatus) - 1] =
 337             varbinds[0].oid[sizeof(Mac) - 1];
 338
 339         varbinds[0].oid = Mac;
 340         varbinds[0].len_oid = sizeof(Mac);
 341         varbinds[0].value = Mac;
 342         varbinds[0].len_val = 0;
 343         varbinds[0].type = NULL_VALUE;
 344         varbinds[1].oid = MacAllow;
 345         varbinds[1].len_oid = sizeof(MacAllow);
 346         varbinds[1].value = Mac;
 347         varbinds[1].len_val = 0;
 348         varbinds[1].type = NULL_VALUE;
 349         varbinds[2].oid = MacRowStatus;
 350         varbinds[2].len_oid = sizeof(MacRowStatus);
 351         varbinds[2].value = Mac;
 352         varbinds[2].len_val = 0;
 353         varbinds[2].type = NULL_VALUE;
 354         if (snmp(varbinds, 3, GET) <= 0) {
 355             print_helperr(ERR_RET);
 356             goto exit;
 357         }
 358         if (memcmp(auth_enable, varbinds[0].value, 6)) {
 359             if (first == NULL) {
 360                 first = (struct MacListStat *)
 361                     malloc(sizeof(struct MacListStat));
 362                 curr = first;
 363             } else {
 364                 curr->next = (struct MacListStat *)
 365                     malloc(sizeof(struct MacListStat));
 366                 curr = curr->next;
 367             }
 368             memcpy(curr->addr, varbinds[0].value, 6);
 369             curr->next = NULL;
 370             mac_num++;
 371         } else
 372             auth_mac = 1;
 373
 374
 375         varbinds[0].oid = Mac;
 376         varbinds[0].len_oid = sizeof(Mac);
 377         varbinds[0].value = Mac;
 378         varbinds[0].len_val = 0;
 379         varbinds[0].type = NULL_VALUE;
 380         if (snmp(varbinds, 1, GET_NEXT) <= 0) {
 381             print_helperr(ERR_RET);
 382             goto exit;
 383         }
 384     }
 385
 386     begin = 1;
 387     end = (MAX_LINES < mac_num) ? MAX_LINES : mac_num;
 388
 389     sprintf(message, "%s%s", MAC_AUTH, (auth_mac) ? OFF : ON);
 390     mvwaddstr(main_sub, 0, 0, message);
 391
 392     scroll_rows(first, begin, end, 3, 0);
 393
 394     noecho();
 395
 396     print_help(MAC_HELP);
 397     while (1) {
 398         switch (getch()) {
 399         case 'Q':
 400         case 'q':
 401             goto quit;
 402         case 'a':
 403             auth_mac = on_off(0, strlen(MAC_AUTH)) - 1;
 404             clear_main_new(0, 1);
 405             print_menusel(0, 0, MAC_AUTH, (auth_mac) ? OFF : ON);
 406             continue;
 407         case 'd':
 408             mvwaddstr(main_sub, 1, 0, MAC_DEL);
 409             get_value(message, 1, strlen(MAC_DEL), 5, INT_STRING,
 410                 1, mac_num - 1, NULL);
 411             i = atoi(message);
 412             if (i == 1) {
 413                 pmac = first;
 414                 first = first->next;
 415                 free(pmac);
 416             } else {
 417                 curr = first;
 418                 while (--i > 1)
 419                     curr = curr->next;
 420                 pmac = curr->next;
 421                 curr->next = pmac->next;
 422                 free(pmac);
 423             }
 424             mac_num--;
 425             begin = 1;
 426             end = (MAX_LINES < mac_num) ? MAX_LINES : mac_num;
 427             scroll_rows(first, begin, end, 3, 0);
 428             clear_main_new(1, 2);
 429             continue;
 430         case 'n':
 431         case 'N':
 432             mvwaddstr(main_sub, 1, 0, MAC_ADD);
 433             curr = first;
 434             while (curr && curr->next)
 435                 curr = curr->next;
 436             if (first == NULL) {
 437                 first = (struct MacListStat *)
 438                     malloc(sizeof(struct MacListStat));
 439                 curr = first;
 440             } else {
 441                 curr->next = (struct MacListStat *)
 442                     malloc(sizeof(struct MacListStat));
 443                 curr = curr->next;
 444             }
 445             curr->next = NULL;
 446             mac_num++;
 447             get_mac(curr->addr, 1, strlen(MAC_ADD));
 448 /*
 449             for (i = 0; i < 6; i++) {
 450                 get_value(message, 1, 20 + i * 3, 3, ANY_STRING, 0, 0, NULL);
 451                 curr->addr[i] = strtol(message, NULL, 16);
 452             }
 453             clear_main_new(1, 2);
 454 */
 455             begin = 1;
 456             end = (MAX_LINES < mac_num) ? MAX_LINES : mac_num;
 457             scroll_rows(first, begin, end, 3, 0);
 458             continue;
 459         case 'w':
 460         case 'W':
 461             print_help(WAIT_SET);
 462
 463             Mac[sizeof(Mac) - 1] = 0;
 464
 465             varbinds[0].oid = Mac;
 466             varbinds[0].len_oid = sizeof(Mac);
 467             varbinds[0].value = Mac;
 468             varbinds[0].len_val = 0;
 469             varbinds[0].type = NULL_VALUE;
 470             if (snmp(varbinds, 1, GET_NEXT) <= 0) {
 471                 print_helperr(ERR_RET);
 472                 goto exit;
 473             }
 474             while (memcmp(varbinds[0].oid, Mac, sizeof(Mac) - 1) == 0) {
 475
 476                 MacRowStatus[sizeof(MacRowStatus) - 1] =
 477                     varbinds[0].oid[sizeof(Mac) - 1];
 478                 varbinds[0].oid = MacRowStatus;
 479                 varbinds[0].len_oid = sizeof(MacRowStatus);
 480                 varbinds[0].value = &destroy;
 481                 varbinds[0].len_val = 1;
 482                 varbinds[0].type = INT_VALUE;
 483                 if (snmp(varbinds, 1, SET) <= 0) {
 484                     print_helperr(ERR_RET);
 485                     goto exit;
 486                 }
 487                 varbinds[0].oid = Mac;
 488                 varbinds[0].len_oid = sizeof(Mac);
 489                 varbinds[0].value = Mac;
 490                 varbinds[0].len_val = 0;
 491                 varbinds[0].type = NULL_VALUE;
 492                 if (snmp(varbinds, 1, GET_NEXT) <= 0) {
 493                     print_helperr(ERR_RET);
 494                     goto exit;
 495                 }
 496             }
 497
 498
 499             curr = first;
 500             i = 1;
 501
 502             if (auth_mac) {
 503                 Mac[sizeof(Mac) - 1] = i;
 504                 MacAllow[sizeof(MacAllow) - 1] = i;
 505                 MacRowStatus[sizeof(MacRowStatus) - 1] = i;
 506
 507                 varbinds[0].oid = MacRowStatus;
 508                 varbinds[0].len_oid = sizeof(MacRowStatus);
 509                 varbinds[0].value = &create;
 510                 varbinds[0].len_val = 1;
 511                 varbinds[0].type = INT_VALUE;
 512                 varbinds[1].oid = Mac;
 513                 varbinds[1].len_oid = sizeof(Mac);
 514                 varbinds[1].value = auth_enable;
 515                 varbinds[1].len_val = 6;
 516                 varbinds[1].type = STRING_VALUE;
 517                 varbinds[2].oid = MacAllow;
 518                 varbinds[2].len_oid = sizeof(MacAllow);
 519                 varbinds[2].value = &allow;
 520                 varbinds[2].len_val = 1;
 521                 varbinds[2].type = INT_VALUE;
 522                 print_help(WAIT_SET);
 523                 if (snmp(varbinds, 3, SET) <= 0) {
 524                     print_helperr(ERR_RET);
 525                     goto exit;
 526                 }
 527                 i++;
 528             }
 529
 530
 531
 532
 533             while (curr != NULL) {
 534                 Mac[sizeof(Mac) - 1] = i;
 535                 MacAllow[sizeof(MacAllow) - 1] = i;
 536                 MacRowStatus[sizeof(MacRowStatus) - 1] = i;
 537
 538                 varbinds[0].oid = MacRowStatus;
 539                 varbinds[0].len_oid = sizeof(MacRowStatus);
 540                 varbinds[0].value = &create;
 541                 varbinds[0].len_val = 1;
 542                 varbinds[0].type = INT_VALUE;
 543                 varbinds[1].oid = Mac;
 544                 varbinds[1].len_oid = sizeof(Mac);
 545                 varbinds[1].value = curr->addr;
 546                 varbinds[1].len_val = 6;
 547                 varbinds[1].type = STRING_VALUE;
 548                 varbinds[2].oid = MacAllow;
 549                 varbinds[2].len_oid = sizeof(MacAllow);
 550                 varbinds[2].value = &allow;
 551                 varbinds[2].len_val = 1;
 552                 varbinds[2].type = INT_VALUE;
 553                 print_help(WAIT_SET);
 554                 if (snmp(varbinds, 3, SET) <= 0) {
 555                     print_helperr(ERR_RET);
 556                     goto exit;
 557                 }
 558                 curr = curr->next;
 559                 i++;
 560             }
 561             print_help(DONE_SET);
 562             goto exit;
 563         case KEY_DOWN:
 564         case KEY_RIGHT:
 565             if (end < mac_num) {
 566                 begin++;
 567                 end++;
 568                 scroll_rows(first, begin, end, 3, 0);
 569             }
 570
 571             continue;
 572         case KEY_UP:
 573         case KEY_LEFT:
 574             if (begin > 1) {
 575                 begin--;
 576                 end--;
 577                 scroll_rows(first, begin, end, 3, 0);
 578             }
 579             continue;
 580         }
 581         continue;
 582     }
 583
 584     print_help(ANY_KEY);
 585   exit:
 586     getch();
 587   quit:
 588     while ((curr = first)) {
 589         first = curr->next;
 590         free(curr);
 591     }
 592     print_title("");
 593     clear_main(0);
 594 }