wireless_tools/iwpriv.c

   1 /*
   2  *      Wireless Tools
   3  *
   4  *              Jean II - HPLB 97->99 - HPL 99->00
   5  *
   6  * Main code for "iwconfig". This is the generic tool for most
   7  * manipulations...
   8  * You need to link this code against "iwcommon.c" and "-lm".
   9  *
  10  * This file is released under the GPL license.
  11  */
  12
  13 #include "iwcommon.h"           /* Header */
  14
  15 /************************* MISC SUBROUTINES **************************/
  16
  17 /*------------------------------------------------------------------*/
  18 /*
  19  * Print usage string
  20  */
  21 static void
  22 iw_usage(void)
  23 {
  24   fprintf(stderr, "Usage: iwpriv interface [private-command [private-arguments]]\n");
  25   fprintf(stderr, "              interface [roam {on|off}]\n");
  26   fprintf(stderr, "              interface [port {ad-hoc|managed|N}]\n");
  27   exit(1);
  28 }
  29
  30 /************************ GENERIC FUNCTIONS *************************/
  31
  32 /*------------------------------------------------------------------*/
  33 /*
  34  * Print on the screen in a neat fashion all the info we have collected
  35  * on a device.
  36  */
  37 static void
  38 print_priv_info(int             skfd,
  39                 char *          ifname)
  40 {
  41   int           k;
  42   iwprivargs    priv[16];
  43   int           n;
  44   char *        argtype[] = { "    ", "byte", "char", "", "int", "float" };
  45
  46   /* Read the private ioctls */
  47   n = get_priv_info(skfd, ifname, priv);
  48
  49   /* Is there any ? */
  50   if(n <= 0)
  51     {
  52       /* Could skip this message ? */
  53       fprintf(stderr, "%-8.8s  no private ioctls.\n\n",
  54               ifname);
  55     }
  56   else
  57     {
  58       printf("%-8.8s  Available private ioctl :\n", ifname);
  59       /* Print the all */
  60       for(k = 0; k < n; k++)
  61         printf("          %s (%X) : set %3d %s & get %3d %s\n",
  62                priv[k].name, priv[k].cmd,
  63                priv[k].set_args & IW_PRIV_SIZE_MASK,
  64                argtype[(priv[k].set_args & IW_PRIV_TYPE_MASK) >> 12],
  65                priv[k].get_args & IW_PRIV_SIZE_MASK,
  66                argtype[(priv[k].get_args & IW_PRIV_TYPE_MASK) >> 12]);
  67       printf("\n");
  68     }
  69 }
  70
  71 /*------------------------------------------------------------------*/
  72 /*
  73  * Get info on all devices and print it on the screen
  74  */
  75 static void
  76 print_priv_devices(int          skfd)
  77 {
  78   char          buff[1024];
  79   struct ifconf ifc;
  80   struct ifreq *ifr;
  81   int i;
  82
  83   /* Get list of active devices */
  84   ifc.ifc_len = sizeof(buff);
  85   ifc.ifc_buf = buff;
  86   if(ioctl(skfd, SIOCGIFCONF, &ifc) < 0)
  87     {
  88       fprintf(stderr, "SIOCGIFCONF: %s\n", strerror(errno));
  89       return;
  90     }
  91   ifr = ifc.ifc_req;
  92
  93   /* Print them */
  94   for(i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; ifr++)
  95     print_priv_info(skfd, ifr->ifr_name);
  96 }
  97
  98 /************************* SETTING ROUTINES **************************/
  99
 100 /*------------------------------------------------------------------*/
 101 /*
 102  * Execute a private command on the interface
 103  */
 104 static int
 105 set_private(int         skfd,           /* Socket */
 106             char *      args[],         /* Command line args */
 107             int         count,          /* Args count */
 108             char *      ifname)         /* Dev name */
 109 {
 110   u_char        buffer[1024];
 111   struct iwreq          wrq;
 112   int           i = 0;          /* Start with first arg */
 113   int           k;
 114   iwprivargs    priv[16];
 115   int           number;
 116
 117   /* Read the private ioctls */
 118   number = get_priv_info(skfd, ifname, priv);
 119
 120   /* Is there any ? */
 121   if(number <= 0)
 122     {
 123       /* Could skip this message ? */
 124       fprintf(stderr, "%-8.8s  no private ioctls.\n\n",
 125               ifname);
 126       return(-1);
 127     }
 128
 129   /* Search the correct ioctl */
 130   k = -1;
 131   while((++k < number) && strcmp(priv[k].name, args[i]));
 132
 133   /* If not found... */
 134   if(k == number)
 135     {
 136       fprintf(stderr, "Invalid command : %s\n", args[i]);
 137       return(-1);
 138     }
 139
 140   /* Next arg */
 141   i++;
 142
 143   /* If we have to set some data */
 144   if((priv[k].set_args & IW_PRIV_TYPE_MASK) &&
 145      (priv[k].set_args & IW_PRIV_SIZE_MASK))
 146     {
 147       switch(priv[k].set_args & IW_PRIV_TYPE_MASK)
 148         {
 149         case IW_PRIV_TYPE_BYTE:
 150           /* Number of args to fetch */
 151           wrq.u.data.length = count - 1;
 152           if(wrq.u.data.length > (priv[k].set_args & IW_PRIV_SIZE_MASK))
 153             wrq.u.data.length = priv[k].set_args & IW_PRIV_SIZE_MASK;
 154
 155           /* Fetch args */
 156           for(; i < wrq.u.data.length + 1; i++)
 157             sscanf(args[i], "%d", (int *)(buffer + i - 1));
 158           break;
 159
 160         case IW_PRIV_TYPE_INT:
 161           /* Number of args to fetch */
 162           wrq.u.data.length = count - 1;
 163           if(wrq.u.data.length > (priv[k].set_args & IW_PRIV_SIZE_MASK))
 164             wrq.u.data.length = priv[k].set_args & IW_PRIV_SIZE_MASK;
 165
 166           /* Fetch args */
 167           for(; i < wrq.u.data.length + 1; i++)
 168             sscanf(args[i], "%d", ((u_int *) buffer) + i - 1);
 169           break;
 170
 171         case IW_PRIV_TYPE_CHAR:
 172           if(i < count)
 173             {
 174               /* Size of the string to fetch */
 175               wrq.u.data.length = strlen(args[i]) + 1;
 176               if(wrq.u.data.length > (priv[k].set_args & IW_PRIV_SIZE_MASK))
 177                 wrq.u.data.length = priv[k].set_args & IW_PRIV_SIZE_MASK;
 178
 179               /* Fetch string */
 180               memcpy(buffer, args[i], wrq.u.data.length);
 181               buffer[sizeof(buffer) - 1] = '\0';
 182               i++;
 183             }
 184           else
 185             {
 186               wrq.u.data.length = 1;
 187               buffer[0] = '\0';
 188             }
 189           break;
 190
 191         default:
 192           fprintf(stderr, "Not yet implemented...\n");
 193           return(-1);
 194         }
 195
 196       if((priv[k].set_args & IW_PRIV_SIZE_FIXED) &&
 197          (wrq.u.data.length != (priv[k].set_args & IW_PRIV_SIZE_MASK)))
 198         {
 199           printf("The command %s need exactly %d argument...\n",
 200                  priv[k].name, priv[k].set_args & IW_PRIV_SIZE_MASK);
 201           return(-1);
 202         }
 203     }   /* if args to set */
 204   else
 205     {
 206       wrq.u.data.length = 0L;
 207     }
 208
 209   strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
 210
 211   if((priv[k].set_args & IW_PRIV_SIZE_FIXED) &&
 212      (byte_size(priv[k].set_args) < IFNAMSIZ))
 213     memcpy(wrq.u.name, buffer, IFNAMSIZ);
 214   else
 215     {
 216       wrq.u.data.pointer = (caddr_t) buffer;
 217       wrq.u.data.flags = 0;
 218     }
 219
 220   /* Perform the private ioctl */
 221   if(ioctl(skfd, priv[k].cmd, &wrq) < 0)
 222     {
 223       fprintf(stderr, "Interface doesn't accept private ioctl...\n");
 224       fprintf(stderr, "%X: %s\n", priv[k].cmd, strerror(errno));
 225       return(-1);
 226     }
 227
 228   /* If we have to get some data */
 229   if((priv[k].get_args & IW_PRIV_TYPE_MASK) &&
 230      (priv[k].get_args & IW_PRIV_SIZE_MASK))
 231     {
 232       int       j;
 233       int       n = 0;          /* number of args */
 234
 235       printf("%-8.8s  %s:", ifname, priv[k].name);
 236
 237       if((priv[k].get_args & IW_PRIV_SIZE_FIXED) &&
 238          (byte_size(priv[k].get_args) < IFNAMSIZ))
 239         {
 240           memcpy(buffer, wrq.u.name, IFNAMSIZ);
 241           n = priv[k].get_args & IW_PRIV_SIZE_MASK;
 242         }
 243       else
 244         n = wrq.u.data.length;
 245
 246       switch(priv[k].get_args & IW_PRIV_TYPE_MASK)
 247         {
 248         case IW_PRIV_TYPE_BYTE:
 249           /* Display args */
 250           for(j = 0; j < n; j++)
 251             printf("%d  ", buffer[j]);
 252           printf("\n");
 253           break;
 254
 255         case IW_PRIV_TYPE_INT:
 256           /* Display args */
 257           for(j = 0; j < n; j++)
 258             printf("%d  ", ((u_int *) buffer)[j]);
 259           printf("\n");
 260           break;
 261
 262         case IW_PRIV_TYPE_CHAR:
 263           /* Display args */
 264           buffer[wrq.u.data.length - 1] = '\0';
 265           printf("%s\n", buffer);
 266           break;
 267
 268         default:
 269           fprintf(stderr, "Not yet implemented...\n");
 270           return(-1);
 271         }
 272     }   /* if args to set */
 273
 274   return(0);
 275 }
 276
 277 /********************** PRIVATE IOCTLS MANIPS ***********************/
 278 /*
 279  * Convenient access to some private ioctls of some devices
 280  */
 281
 282 /*------------------------------------------------------------------*/
 283 /*
 284  * Set roaming mode on and off
 285  * Found in wavelan_cs driver
 286  */
 287 static int
 288 set_roaming(int         skfd,           /* Socket */
 289             char *      args[],         /* Command line args */
 290             int         count,          /* Args count */
 291             char *      ifname)         /* Dev name */
 292 {
 293   u_char        buffer[1024];
 294   struct iwreq          wrq;
 295   int           i = 0;          /* Start with first arg */
 296   int           k;
 297   iwprivargs    priv[16];
 298   int           number;
 299   char          RoamState;              /* buffer to hold new roam state */
 300   char          ChangeRoamState=0;      /* whether or not we are going to
 301                                            change roam states */
 302
 303   /* Read the private ioctls */
 304   number = get_priv_info(skfd, ifname, priv);
 305
 306   /* Is there any ? */
 307   if(number <= 0)
 308     {
 309       /* Could skip this message ? */
 310       fprintf(stderr, "%-8.8s  no private ioctls.\n\n",
 311               ifname);
 312       return(-1);
 313     }
 314
 315   if(count != 1)
 316     iw_usage();
 317
 318   if(!strcasecmp(args[i], "on"))
 319     {
 320       printf("%-8.8s  enable roaming\n", ifname);
 321       if(!number)
 322         {
 323           fprintf(stderr, "This device doesn't support roaming\n");
 324           return(-1);
 325         }
 326       ChangeRoamState=1;
 327       RoamState=1;
 328     }
 329   else
 330     if(!strcasecmp(args[i], "off"))
 331       {
 332         i++;
 333         printf("%-8.8s  disable roaming\n",  ifname);
 334         if(!number)
 335           {
 336             fprintf(stderr, "This device doesn't support roaming\n");
 337             return(-1);
 338           }
 339         ChangeRoamState=1;
 340         RoamState=0;
 341       }
 342     else
 343       {
 344         iw_usage();
 345         return(-1);
 346       }
 347
 348   if(ChangeRoamState)
 349     {
 350       k = -1;
 351       while((++k < number) && strcmp(priv[k].name, "setroam"));
 352       if(k == number)
 353         {
 354           fprintf(stderr, "This device doesn't support roaming\n");
 355           return(-1);
 356         }
 357       strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
 358
 359       buffer[0]=RoamState;
 360
 361       memcpy(wrq.u.name, &buffer, IFNAMSIZ);
 362
 363       if(ioctl(skfd, priv[k].cmd, &wrq) < 0)
 364         {
 365           fprintf(stderr, "Roaming support is broken.\n");
 366           exit(0);
 367         }
 368     }
 369   i++;
 370
 371   return(i);
 372 }
 373
 374 /*------------------------------------------------------------------*/
 375 /*
 376  * Get and set the port type
 377  * Found in wavelan2_cs and wvlan_cs drivers
 378  */
 379 static int
 380 port_type(int           skfd,           /* Socket */
 381           char *        args[],         /* Command line args */
 382           int           count,          /* Args count */
 383           char *        ifname)         /* Dev name */
 384 {
 385   struct iwreq  wrq;
 386   int           i = 0;          /* Start with first arg */
 387   int           k;
 388   iwprivargs    priv[16];
 389   int           number;
 390   char          ptype = 0;
 391   char *        modes[] = { "invalid", "managed (BSS)", "reserved", "ad-hoc" };
 392
 393   /* Read the private ioctls */
 394   number = get_priv_info(skfd, ifname, priv);
 395
 396   /* Is there any ? */
 397   if(number <= 0)
 398     {
 399       /* Could skip this message ? */
 400       fprintf(stderr, "%-8.8s  no private ioctls.\n\n", ifname);
 401       return(-1);
 402     }
 403
 404   /* Arguments ? */
 405   if(count == 0)
 406     {
 407       /* So, we just want to see the current value... */
 408       k = -1;
 409       while((++k < number) && strcmp(priv[k].name, "gport_type") &&
 410              strcmp(priv[k].name, "get_port"));
 411       if(k == number)
 412         {
 413           fprintf(stderr, "This device doesn't support getting port type\n");
 414           return(-1);
 415         }
 416       strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
 417
 418       /* Get it */
 419       if(ioctl(skfd, priv[k].cmd, &wrq) < 0)
 420         {
 421           fprintf(stderr, "Port type support is broken.\n");
 422           exit(0);
 423         }
 424       ptype = *wrq.u.name;
 425
 426       /* Display it */
 427       printf("%-8.8s  Current port mode is %s <port type is %d>.\n\n",
 428              ifname, modes[(int) ptype], ptype);
 429
 430       return(0);
 431     }
 432
 433   if(count != 1)
 434     iw_usage();
 435
 436   /* Read it */
 437   /* As a string... */
 438   k = 0;
 439   while((k < 4) && strncasecmp(args[i], modes[k], 2))
 440     k++;
 441   if(k < 4)
 442     ptype = k;
 443   else
 444     /* ...or as an integer */
 445     if(sscanf(args[i], "%d", (int *) &ptype) != 1)
 446       iw_usage();
 447
 448   k = -1;
 449   while((++k < number) && strcmp(priv[k].name, "sport_type") &&
 450         strcmp(priv[k].name, "set_port"));
 451   if(k == number)
 452     {
 453       fprintf(stderr, "This device doesn't support setting port type\n");
 454       return(-1);
 455     }
 456   strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
 457
 458   *(wrq.u.name) = ptype;
 459
 460   if(ioctl(skfd, priv[k].cmd, &wrq) < 0)
 461     {
 462       fprintf(stderr, "Invalid port type (or setting not allowed)\n");
 463       exit(0);
 464     }
 465
 466   i++;
 467   return(i);
 468 }
 469
 470 /******************************* MAIN ********************************/
 471
 472 /*------------------------------------------------------------------*/
 473 /*
 474  * The main !
 475  */
 476 int
 477 main(int        argc,
 478      char **    argv)
 479 {
 480   int skfd = -1;                /* generic raw socket desc.     */
 481   int goterr = 0;
 482
 483   /* Create a channel to the NET kernel. */
 484   if((skfd = sockets_open()) < 0)
 485     {
 486       perror("socket");
 487       exit(-1);
 488     }
 489
 490   /* No argument : show the list of all device + info */
 491   if(argc == 1)
 492     {
 493       print_priv_devices(skfd);
 494       close(skfd);
 495       exit(0);
 496     }
 497
 498   /* Special cases take one... */
 499   /* Help */
 500   if((!strncmp(argv[1], "-h", 9)) ||
 501      (!strcmp(argv[1], "--help")))
 502     {
 503       iw_usage();
 504       close(skfd);
 505       exit(0);
 506     }
 507
 508   /* The device name must be the first argument */
 509   /* Name only : show for that device only */
 510   if(argc == 2)
 511     {
 512       print_priv_info(skfd, argv[1]);
 513       close(skfd);
 514       exit(0);
 515     }
 516
 517   /* Special cases take two... */
 518   /* Roaming */
 519   if(!strncmp(argv[2], "roam", 4))
 520     {
 521       goterr = set_roaming(skfd, argv + 3, argc - 3, argv[1]);
 522       close(skfd);
 523       exit(0);
 524     }
 525
 526   /* Port type */
 527   if(!strncmp(argv[2], "port", 4))
 528     {
 529       goterr = port_type(skfd, argv + 3, argc - 3, argv[1]);
 530       close(skfd);
 531       exit(0);
 532     }
 533
 534   /* Otherwise, it's a private ioctl */
 535   goterr = set_private(skfd, argv + 2, argc - 2, argv[1]);
 536
 537   /* Close the socket. */
 538   close(skfd);
 539
 540   return(1);
 541 }