workbench/devs/networks/prism2/SetPrism2Defaults.c

   1 /*
   2
   3 Author: Neil Cafferkey
   4 Copyright (C) 2004,2005 Neil Cafferkey
   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 as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19 MA 02111-1307, USA.
  20
  21 */
  22
  23
  24 #include <exec/memory.h>
  25 #include <dos/dos.h>
  26 #include <utility/utility.h>
  27
  28 #include <proto/exec.h>
  29 #include <proto/dos.h>
  30 #include <proto/utility.h>
  31
  32 #include "wireless.h"
  33
  34
  35 #ifndef UPINT
  36 #ifdef __AROS__
  37 typedef IPTR UPINT;
  38 typedef SIPTR PINT;
  39 #else
  40 typedef ULONG UPINT;
  41 typedef LONG PINT;
  42 #endif
  43 #endif
  44
  45 #define UTILITY_VERSION 39
  46 #define DOS_VERSION 36
  47
  48 #ifndef __AROS__
  49 IMPORT struct ExecBase *AbsExecBase;
  50 #endif
  51
  52 struct ExecBase *SysBase;
  53 struct DosLibrary *DOSBase;
  54 struct UtilityBase *UtilityBase;
  55
  56 static UPINT ParseHexString(TEXT *str, UBYTE *buffer, UPINT buffer_size);
  57 static UPINT StrLen(const TEXT *s);
  58
  59 const TEXT template[] =
  60    "SSID/K,KEY/K,TEXTKEY/K,NOKEY/S,MANAGED/S,ADHOC/S,CHANNEL/K/N";
  61 const TEXT version_string[] = "$VER: SetPrism2Defaults 1.2 (23.7.2005)";
  62 const TEXT dos_name[] = DOSNAME;
  63 const TEXT utility_name[] = UTILITYNAME;
  64 const TEXT options_name[] = "Prism 2 options";
  65 static const struct TagItem tag_list_template[] =
  66 {
  67    {P2OPT_SSID, 0},
  68    {P2OPT_WEPKey, 0},
  69    {P2OPT_Encryption, S2ENC_NONE},
  70    {P2OPT_PortType, S2PORT_MANAGED},
  71    {P2OPT_Channel, 0},
  72    {TAG_END, 0}
  73 };
  74 static const struct TagItem name_tag_list[] =
  75 {
  76    {ANO_NameSpace, TRUE},   /* Work-around for old MorphOS bug */
  77    {TAG_END, 0}
  78 };
  79
  80
  81 LONG Main(VOID)
  82 {
  83    struct RDArgs *read_args;
  84    LONG error = 0, result = RETURN_OK;
  85    UBYTE key_buffer[IEEE802_11_WEP128LEN];
  86    struct
  87    {
  88       TEXT *ssid;
  89       TEXT *key;
  90       TEXT *textkey;
  91       PINT nokey;
  92       PINT managed;
  93       PINT adhoc;
  94       PINT *channel;
  95    }
  96    args = {NULL, NULL, NULL, FALSE, FALSE, FALSE, NULL};
  97    struct NamedObject *options;
  98    struct TagItem *tag_list, *tag_item;
  99    TEXT *ssid;
 100    UPINT length;
 101    struct WEPKey *key;
 102    UWORD key_option_count = 0;
 103
 104    /* Open libraries */
 105
 106 #ifdef __mc68000
 107    SysBase = AbsExecBase;
 108 #endif
 109    DOSBase = (struct DosLibrary *)OpenLibrary(dos_name, DOS_VERSION);
 110    if(DOSBase == NULL)
 111       return RETURN_FAIL;
 112    UtilityBase =
 113       (struct UtilityBase *)OpenLibrary(utility_name, UTILITY_VERSION);
 114
 115    if(UtilityBase == NULL)
 116       error = IoErr();
 117
 118    /* Parse arguments */
 119
 120    read_args = ReadArgs(template, (PINT *)&args, NULL);
 121    if(read_args == NULL)
 122       error = IoErr();
 123    else
 124    {
 125       if(args.key != NULL)
 126          key_option_count++;
 127       if(args.textkey != NULL)
 128          key_option_count++;
 129       if(args.nokey)
 130          key_option_count++;
 131       if(key_option_count > 1 || args.managed && args.adhoc)
 132          error = ERROR_TOO_MANY_ARGS;
 133    }
 134
 135    /* Get pre-existing options object or create a new one */
 136
 137    if(error == 0)
 138    {
 139       options = FindNamedObject(NULL, options_name, NULL);
 140
 141       if(options == NULL)
 142       {
 143          options = AllocNamedObjectA(options_name, name_tag_list);
 144          if(options != NULL)
 145          {
 146             if(AddNamedObject(NULL, options))
 147             {
 148                tag_list = CloneTagItems(tag_list_template);
 149                if(tag_list != NULL)
 150                {
 151                   options->no_Object = tag_list;
 152                   ssid = AllocMem(IEEE802_11_MAXIDLEN,
 153                      MEMF_PUBLIC | MEMF_CLEAR);
 154                   if(ssid == NULL)
 155                      error = IoErr();
 156                   key = AllocMem(sizeof(struct WEPKey),
 157                      MEMF_PUBLIC | MEMF_CLEAR);
 158                   if(key == NULL)
 159                      error = IoErr();
 160                   if(error == 0)
 161                   {
 162                      key->length = IEEE802_11_WEP64LEN;
 163                      tag_item = FindTagItem(P2OPT_SSID, tag_list);
 164                      tag_item->ti_Data = (UPINT)ssid;
 165                      tag_item = FindTagItem(P2OPT_WEPKey, tag_list);
 166                      tag_item->ti_Data = (UPINT)key;
 167                   }
 168                }
 169                else
 170                   error = IoErr();
 171             }
 172             else
 173             {
 174                error = IoErr();
 175                FreeNamedObject(options);
 176             }
 177          }
 178          else
 179             error = IoErr();
 180       }
 181    }
 182
 183    /* Set new options */
 184
 185    if(error == 0)
 186    {
 187       tag_list = (APTR)options->no_Object;
 188
 189       if(args.ssid != NULL)
 190       {
 191          tag_item = FindTagItem(P2OPT_SSID, tag_list);
 192          length = StrLen(args.ssid);
 193          if(length <= IEEE802_11_MAXIDLEN)
 194             CopyMem(args.ssid, (APTR)tag_item->ti_Data, length);
 195          else
 196             error = IoErr();
 197       }
 198
 199       if(args.key != NULL)
 200       {
 201          tag_item = FindTagItem(P2OPT_WEPKey, tag_list);
 202          length =
 203             ParseHexString(args.key, key_buffer, IEEE802_11_WEP128LEN);
 204          if(length == 0)
 205             error = ERROR_BAD_NUMBER;
 206          else if(length != IEEE802_11_WEP64LEN &&
 207             length != IEEE802_11_WEP128LEN)
 208             error = ERROR_BAD_NUMBER;
 209          else
 210          {
 211             key = (APTR)tag_item->ti_Data;
 212             key->length = length;
 213             CopyMem(key_buffer, key->key, length);
 214          }
 215       }
 216
 217       if(args.textkey != NULL)
 218       {
 219          tag_item = FindTagItem(P2OPT_WEPKey, tag_list);
 220          length = StrLen(args.textkey);
 221          if(length == 0)
 222             error = ERROR_INVALID_COMPONENT_NAME;
 223          else if(length != IEEE802_11_WEP64LEN &&
 224             length != IEEE802_11_WEP128LEN)
 225             error = ERROR_INVALID_COMPONENT_NAME;
 226          else
 227          {
 228             key = (APTR)tag_item->ti_Data;
 229             key->length = length;
 230             CopyMem(args.textkey, key->key, length);
 231          }
 232       }
 233    }
 234
 235    if(error == 0)
 236    {
 237       tag_item = FindTagItem(P2OPT_Encryption, tag_list);
 238       if(args.key != NULL || args.textkey != NULL)
 239          tag_item->ti_Data = S2ENC_WEP;
 240       else if(args.nokey)
 241          tag_item->ti_Data = S2ENC_NONE;
 242
 243       tag_item = FindTagItem(P2OPT_PortType, tag_list);
 244       if(args.managed)
 245          tag_item->ti_Data = S2PORT_MANAGED;
 246       else if(args.adhoc)
 247          tag_item->ti_Data = S2PORT_ADHOC;
 248
 249       if(args.channel != NULL)
 250       {
 251          tag_item = FindTagItem(P2OPT_Channel, tag_list);
 252          if(*args.channel >= 3 && *args.channel <= 14)
 253             tag_item->ti_Data = *args.channel;
 254          else
 255             error = ERROR_BAD_NUMBER;
 256       }
 257    }
 258
 259    FreeArgs(read_args);
 260
 261    /* Print error message */
 262
 263 #ifdef USE_HACKS
 264    SetIoErr(error);
 265 #endif
 266    PrintFault(error, NULL);
 267
 268    if(error != 0)
 269       result = RETURN_FAIL;
 270
 271    /* Close libraries and exit */
 272
 273    CloseLibrary((struct Library *)UtilityBase);
 274    CloseLibrary((struct Library *)DOSBase);
 275
 276    return result;
 277 }
 278
 279
 280
 281 static UPINT ParseHexString(TEXT *str, UBYTE *buffer, UPINT buffer_size)
 282 {
 283    BOOL success = TRUE;
 284    UBYTE n = 0, *end;
 285    TEXT ch;
 286    UPINT i = 0;
 287
 288    end = buffer + buffer_size;
 289    while((ch = *str++) != '\0' && buffer < end)
 290    {
 291       n <<= 4;
 292
 293       ch = ToUpper(ch);
 294       if(ch != '-' && ch != ':' && ch != ' ')
 295       {
 296          if(ch >= '0' && ch <= '9')
 297             n |= ch - '0';
 298          else if(ch >= 'A' && ch <= 'F')
 299             n |= ch - 'A' + 10;
 300          else
 301             success = FALSE;
 302
 303          if((++i & 0x1) == 0)
 304          {
 305             *buffer++ = n;
 306             n = 0;
 307          }
 308       }
 309    }
 310
 311    if((i & 0x1) != 0)
 312       success = FALSE;
 313
 314    if(!success)
 315       i = 0;
 316
 317    return i >> 1;
 318 }
 319
 320
 321
 322 static UPINT StrLen(const TEXT *s)
 323 {
 324    const TEXT *p;
 325
 326    for(p = s; *p != '\0'; p++);
 327    return p - s;
 328 }
 329
 330
 331