ap-gl/auth.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
  26 #define MAX_LINES LINES-6
  27 #define PACKET_ERROR _("AuthorizedMacTableString packet error")
  28
  29 #define AUTH_TITLE _("APClient authorization credentials")
  30
  31 #define MAC_AUTH _("[A] MAC authorization: ")
  32 #define MAC_ADD  _("Enter MAC: ")
  33 #define MAC_DEL  _("Delete Num: ")
  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 #define MAC_RADIUS_HELP _("A - auth; IPSTF - set; W - write conf; Q - quit")
  37 #define MAC_NONE_HELP _("A - auth; W - write conf; Q - quit")
  38
  39 #define RADIUS_IP _("[I] RADIUS SERVER IP: ")
  40 #define RADIUS_DEST_PORT _("[P] RADIUS SERVER PORT: ")
  41 #define RADIUS_SECRET _("[S] RADIUS SERVER SECRET: ")
  42 #define RADIUS_TIME _("[T] REAUTHORIZATION TIME: ")
  43 #define RADIUS_PORT _("[F] RADIUS SOURCE PORT: ")
  44
  45 extern WINDOW *main_sub;
  46 extern int LINES;
  47 extern short ap_type;
  48
  49 void atmel_auth()
  50 {
  51     struct AuthorizedMacTableString {
  52         unsigned int short Action;
  53         unsigned int short NumOfAllTableAddresses;
  54         unsigned int short NumOfCurrentAddress;
  55         unsigned char MacAddress[6];
  56     } *AuthMac = NULL, get;
  57
  58     struct MacListStat *pmac, *first = NULL, *curr = NULL;
  59     uint32_t auth_mac_hw;
  60
  61     char EnableAuthMAC[] =
  62         { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01,
  63         0x02, 0x06, 0x01, 0x00
  64     };
  65     char AutorizedMac[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01,
  66         0x02, 0x06, 0x02, 0x00
  67     };
  68
  69     char AuthRadiusIP[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01,
  70         0x02, 0x06, 0x03, 0x00
  71     };
  72     char AuthRadiusSecret[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01,
  73         0x02, 0x06, 0x04, 0x00
  74     };
  75     char AuthRadiusSecretLength[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01,
  76         0x02, 0x06, 0x05, 0x00
  77     };
  78     char AuthRadiusPort[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01,
  79         0x02, 0x06, 0x06, 0x00
  80     };
  81     char AuthRadiusReauthorizationTime[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01,
  82         0x02, 0x06, 0x07, 0x00
  83     };
  84     char AuthRadiusDestinPort[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x83, 0x1A, 0x01,
  85         0x02, 0x06, 0x08, 0x00
  86     };
  87
  88     char *auth_types[] = { _("Internal"), OFF, "RADIUS" };
  89
  90     struct in_addr radius_ip;
  91     char message[1024], m_authmac = 0, radius_secret[32], m_radius_secret=0, m_radius_ip=0;
  92     int radius_port, radius_time, radius_dest_port, m_radius_port=0, m_radius_time=0, m_radius_dest_port=0;
  93     int i, total_mac, auth_mac = 0, mac_num = 0, begin=0, end=0, c=0;
  94     varbind varbinds[7];
  95
  96     memcpy(radius_secret, _("<hidden>"), 32);
  97
  98     varbinds[0].oid = EnableAuthMAC;
  99     varbinds[0].len_oid = sizeof(EnableAuthMAC);
 100     varbinds[0].type = NULL_VALUE;
 101     varbinds[0].len_val = 0;
 102
 103     varbinds[1].oid = AuthRadiusIP;
 104     varbinds[1].len_oid = sizeof(AuthRadiusIP);
 105     varbinds[1].type = NULL_VALUE;
 106     varbinds[1].len_val = 0;
 107
 108     varbinds[3].oid = AuthRadiusPort;
 109     varbinds[3].len_oid = sizeof(AuthRadiusPort);
 110     varbinds[3].type = NULL_VALUE;
 111     varbinds[3].len_val = 0;
 112
 113     varbinds[4].oid = AuthRadiusReauthorizationTime;
 114     varbinds[4].len_oid = sizeof(AuthRadiusReauthorizationTime);
 115     varbinds[4].type = NULL_VALUE;
 116     varbinds[4].len_val = 0;
 117
 118     varbinds[2].oid = AuthRadiusDestinPort;
 119     varbinds[2].len_oid = sizeof(AuthRadiusDestinPort);
 120     varbinds[2].type = NULL_VALUE;
 121     varbinds[2].len_val = 0;
 122
 123     print_help(WAIT_RET);
 124     if (snmp(varbinds, 5, GET) < 5) {
 125         print_helperr(ERR_RET);
 126         goto exit;
 127     }
 128     print_top(NULL, AUTH_TITLE);
 129
 130     auth_mac = *(varbinds[0].value);
 131     memcpy(&radius_ip.s_addr, varbinds[1].value, 4);
 132     memcpy(&radius_dest_port, varbinds[2].value, 2);
 133     radius_dest_port = ntohs(radius_dest_port);
 134     memcpy(&radius_port, varbinds[3].value, 2);
 135     radius_port = ntohs(radius_port);
 136     memcpy(&radius_time, varbinds[4].value, 2);
 137     radius_time = ntohs(radius_time);
 138
 139     sprintf(message, "%s%s", MAC_AUTH, auth_types[auth_mac-1]);
 140     mvwaddstr(main_sub, 0, 0, message);
 141     wrefresh(main_sub);
 142
 143     total_mac = 0;
 144     mac_num = 0;
 145
 146     while (mac_num <= total_mac) {
 147         get.Action = 0x02; rshort(get.Action);
 148         get.NumOfAllTableAddresses = total_mac; rshort(get.NumOfAllTableAddresses);
 149         get.NumOfCurrentAddress = mac_num; rshort(get.NumOfCurrentAddress);
 150
 151         varbinds[0].oid = AutorizedMac;
 152         varbinds[0].len_oid = sizeof(AutorizedMac);
 153         varbinds[0].value = (char *) &get;
 154         varbinds[0].len_val = 12;
 155         varbinds[0].type = STRING_VALUE;
 156
 157         i = snmp(varbinds, 1, SET);
 158         if (i == 0) {
 159             print_helperr(ERR_SET);
 160             goto exit;
 161         }
 162         if (i < 0)
 163             break;
 164
 165         if (varbinds[0].len_val == 12) {
 166             if (AuthMac)
 167                 free(AuthMac);
 168             AuthMac =
 169                 (struct AuthorizedMacTableString *) malloc(varbinds[0].
 170                                                            len_val);
 171             memcpy(AuthMac, varbinds[0].value, varbinds[0].len_val);
 172 /*          AuthMac =
 173                 (struct AuthorizedMacTableString *) varbinds[0].value;*/
 174         } else {
 175             print_helperr(PACKET_ERROR);
 176             goto exit;
 177         }
 178
 179         rshort(AuthMac->NumOfAllTableAddresses);
 180         total_mac =
 181             (AuthMac->NumOfAllTableAddresses ==
 182              65535) ? 0 : AuthMac->NumOfAllTableAddresses;
 183
 184         if (mac_num) {
 185             if (first == NULL) {
 186                 first = (struct MacListStat *)
 187                     malloc(sizeof(struct MacListStat));
 188                 curr = first;
 189             } else {
 190                 curr->next = (struct MacListStat *)
 191                     malloc(sizeof(struct MacListStat));
 192                 curr = curr->next;
 193             }
 194             memcpy(curr->addr, AuthMac->MacAddress, 6);
 195             curr->next = NULL;
 196         }
 197         mac_num++;
 198     }
 199
 200 choose_view:
 201     clear_main(2);
 202     if (auth_mac == 1) {
 203         mvwaddstr(main_sub, 2, 1, MAC_HEADER);
 204         begin = 1;
 205         end = (MAX_LINES < mac_num) ? MAX_LINES : mac_num;
 206         scroll_rows(first, begin, end, 3, 0);
 207         print_help(MAC_HELP);
 208     } else if(auth_mac == 3) {
 209         sprintf(message, "%s%s", RADIUS_IP, inet_ntoa(radius_ip));
 210         mvwaddstr(main_sub, 2, 0, message);
 211         sprintf(message, "%s%d", RADIUS_DEST_PORT, radius_dest_port);
 212         mvwaddstr(main_sub, 3, 0, message);
 213         sprintf(message, "%s%s", RADIUS_SECRET, radius_secret);
 214         mvwaddstr(main_sub, 4, 0, message);
 215         sprintf(message, "%s%d", RADIUS_TIME, radius_time);
 216         mvwaddstr(main_sub, 5, 0, message);
 217         sprintf(message, "%s%d", RADIUS_PORT, radius_port);
 218         mvwaddstr(main_sub, 6, 0, message);
 219
 220         wrefresh(main_sub);
 221         print_help(MAC_RADIUS_HELP);
 222     } else {
 223         print_help(MAC_NONE_HELP);
 224     }
 225
 226     if (i < 0) {
 227         mvwaddstr(main_sub, 3, 1, _("(insufficient community used)"));
 228         wrefresh(main_sub);
 229     }
 230
 231     noecho();
 232
 233     while (1) {
 234         switch (getch()) {
 235         case 'q':
 236         case 'Q':
 237             goto quit;
 238         case 'a':
 239         case 'A':
 240             auth_mac = menu_choose(0, strlen(MAC_AUTH), auth_types, 3)+1;
 241             clear_main_new(0, 1);
 242             print_menusel(0, 0, MAC_AUTH, auth_types[auth_mac-1]);
 243             m_authmac = 1;
 244             goto choose_view;
 245         case 'S':
 246         case 's':
 247             if (auth_mac != 3) {
 248                         continue;
 249             }
 250             get_value(radius_secret, 4, strlen(RADIUS_SECRET), 32, ANY_STRING, 0, 0, NULL);
 251             m_radius_secret = 1;
 252             continue;
 253         case 'P':
 254         case 'p':
 255             if (auth_mac != 3) {
 256                continue;
 257             }
 258             get_value(message, 3, strlen(RADIUS_DEST_PORT), 6, INT_STRING, 0, 65535, MAC_RADIUS_HELP);
 259             radius_dest_port = atoi(message);
 260             m_radius_dest_port = 1;
 261             continue;
 262         case 'T':
 263         case 't':
 264             if (auth_mac != 3) {
 265                     continue;
 266             }
 267             get_value(message, 5, strlen(RADIUS_TIME), 6, INT_STRING, 0, 65535, MAC_RADIUS_HELP);
 268             radius_time = atoi(message);
 269             m_radius_time = 1;
 270             continue;
 271         case 'F':
 272         case 'f':
 273             if (auth_mac != 3) {
 274                continue;
 275             }
 276             get_value(message, 6, strlen(RADIUS_PORT), 6, INT_STRING, 0, 65535, MAC_RADIUS_HELP);
 277             radius_port = atoi(message);
 278             m_radius_port = 1;
 279             continue;
 280         case 'I':
 281         case 'i':
 282             if (auth_mac != 3) {
 283                 continue;
 284             }
 285             get_ip(&radius_ip, 2, strlen(RADIUS_IP), MAC_RADIUS_HELP);
 286             m_radius_ip = 1;
 287             continue;
 288         case 'd':
 289         case 'D':
 290             if (auth_mac != 1) {
 291                 continue;
 292             }
 293             mvwaddstr(main_sub, 1, 0, MAC_DEL);
 294             get_value(message, 1, strlen(MAC_DEL), 5, INT_STRING,
 295                 1, mac_num - 1, NULL);
 296             i = atoi(message);
 297             if (i == 1) {
 298                 pmac = first;
 299                 first = first->next;
 300                 free(pmac);
 301             } else {
 302                 curr = first;
 303                 while (--i > 1)
 304                     curr = curr->next;
 305                 pmac = curr->next;
 306                 curr->next = pmac->next;
 307                 free(pmac);
 308             }
 309             mac_num--;
 310             begin = 1;
 311             end = (MAX_LINES < mac_num) ? MAX_LINES : mac_num;
 312             scroll_rows(first, begin, end, 3, 0);
 313             clear_main_new(1, 2);
 314             continue;
 315         case 'n':
 316         case 'N':
 317             if (auth_mac != 1) {
 318                 continue;
 319             }
 320             mvwaddstr(main_sub, 1, 0, MAC_ADD);
 321             curr = first;
 322             while (curr && curr->next)
 323                 curr = curr->next;
 324             if (first == NULL) {
 325                 first = (struct MacListStat *)
 326                     malloc(sizeof(struct MacListStat));
 327                 curr = first;
 328             } else {
 329                 curr->next = (struct MacListStat *)
 330                     malloc(sizeof(struct MacListStat));
 331                 curr = curr->next;
 332             }
 333             curr->next = NULL;
 334             mac_num++;
 335             get_mac(curr->addr, 1, strlen(MAC_ADD));
 336             begin = 1;
 337             end = (MAX_LINES < mac_num) ? MAX_LINES : mac_num;
 338             scroll_rows(first, begin, end, 3, 0);
 339             clear_main_new(1, 2);
 340             continue;
 341         case 'w':
 342         case 'W':
 343             i=0;
 344             if (m_authmac) {
 345                 auth_mac_hw = swap4(auth_mac);
 346                 varbinds[i].oid = EnableAuthMAC;
 347                 varbinds[i].len_oid = sizeof(EnableAuthMAC);
 348                 varbinds[i].type = INT_VALUE;
 349                 varbinds[i].value = (char *) &auth_mac_hw;
 350                 varbinds[i].len_val = 1;
 351                 i++;
 352             }
 353
 354             if (m_radius_ip) {
 355                 radius_ip.s_addr = htonl(radius_ip.s_addr);
 356                 radius_ip.s_addr = swap4(radius_ip.s_addr);
 357                 varbinds[i].oid = AuthRadiusIP;
 358                 varbinds[i].len_oid = sizeof(AuthRadiusIP);
 359                 varbinds[i].value = (char *) &radius_ip.s_addr;
 360                 varbinds[i].len_val = 4;
 361                 varbinds[i].type = INT_VALUE;
 362                 i++;
 363             }
 364
 365             if (m_radius_dest_port) {
 366                 varbinds[i].oid = AuthRadiusDestinPort;
 367                 varbinds[i].len_oid = sizeof(AuthRadiusDestinPort);
 368                 radius_dest_port = htons(radius_dest_port);
 369                 varbinds[i].value = (char *) &radius_dest_port;
 370                 varbinds[i].len_val = 2;
 371                 varbinds[i].type = 0x02;
 372                 i++;
 373             }
 374
 375             if (m_radius_time) {
 376                 varbinds[i].oid = AuthRadiusReauthorizationTime;
 377                 varbinds[i].len_oid = sizeof(AuthRadiusReauthorizationTime);
 378                 radius_time = htons(radius_time);
 379                 varbinds[i].value = (char *) &radius_time;
 380                 varbinds[i].len_val = 2;
 381                 varbinds[i].type = 0x02;
 382                 i++;
 383             }
 384
 385            if (m_radius_port) {
 386                 varbinds[i].oid = AuthRadiusPort;
 387                 varbinds[i].len_oid = sizeof(AuthRadiusPort);
 388                 radius_port = htons(radius_port);
 389                 varbinds[i].value = (char *) &radius_port;
 390                 varbinds[i].len_val = 2;
 391                 varbinds[i].type = 0x02;
 392                 i++;
 393             }
 394            if (m_radius_secret) {
 395                 c = strlen(radius_secret);
 396                 varbinds[i].oid = AuthRadiusSecretLength;
 397                 varbinds[i].len_oid = sizeof(AuthRadiusSecretLength);
 398                 varbinds[i].value = (char *)&c;
 399                 varbinds[i].len_val = 1;
 400                 varbinds[i].type = INT_VALUE;
 401                 i++;
 402                 varbinds[i].oid = AuthRadiusSecret;
 403                 varbinds[i].len_oid = sizeof(AuthRadiusSecret);
 404                 varbinds[i].value = radius_secret;
 405                 varbinds[i].len_val = c;
 406                 varbinds[i].type = STRING_VALUE;
 407                 i++;
 408            }
 409
 410             print_help(WAIT_SET);
 411             if (snmp(varbinds, i, SET) <= 0) {
 412                 print_helperr(ERR_RET);
 413                 goto exit;
 414             }
 415
 416             curr = first;
 417             i = 1;
 418             while (curr != NULL) {
 419                 get.Action = 0x01; rshort(get.Action);
 420                 get.NumOfAllTableAddresses = mac_num - 1; rshort(get.NumOfAllTableAddresses);
 421                 get.NumOfCurrentAddress = i; rshort(get.NumOfCurrentAddress);
 422                 memcpy(get.MacAddress, curr->addr, 6);
 423                 varbinds[0].oid = AutorizedMac;
 424                 varbinds[0].len_oid = sizeof(AutorizedMac);
 425                 varbinds[0].value = (char *) &get;
 426                 varbinds[0].len_val = 12;
 427                 varbinds[0].type = STRING_VALUE;
 428                 print_help(WAIT_SET);
 429                 if (snmp(varbinds, 1, SET) <= 0) {
 430                     print_helperr(ERR_RET);
 431                     goto exit;
 432                 }
 433                 if (varbinds[0].len_val != 12) {
 434                     print_helperr(PACKET_ERROR);
 435                     goto exit;
 436                 }
 437                 curr = curr->next;
 438                 i++;
 439             }
 440             wbkgd(main_sub, A_NORMAL);
 441             wrefresh(main_sub);
 442             print_help(DONE_SET);
 443             goto exit;
 444         case KEY_DOWN:
 445         case KEY_RIGHT:
 446             if (auth_mac != 1) {
 447                 continue;
 448             }
 449             if (end < mac_num) {
 450                 begin++;
 451                 end++;
 452                 scroll_rows(first, begin, end, 3, 0);
 453             }
 454             continue;
 455         case KEY_UP:
 456         case KEY_LEFT:
 457             if (auth_mac != 1) {
 458                 continue;
 459             }
 460             if (begin > 1) {
 461                 begin--;
 462                 end--;
 463                 scroll_rows(first, begin, end, 3, 0);
 464             }
 465             continue;
 466         }
 467         continue;
 468     }
 469
 470     print_help(ANY_KEY);
 471   exit:
 472     getch();
 473   quit:
 474     while ((curr = first)) {
 475         first = curr->next;
 476         free(curr);
 477     }
 478     if (AuthMac)
 479         free(AuthMac);
 480     print_top(NULL, NULL);
 481     clear_main(0);
 482 }