workbench/prefs/network/prefsdata.c

   1 /*
   2     Copyright © 2009-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <proto/dos.h>
   7 #include <proto/exec.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <stdio.h>
  11 #include "prefsdata.h"
  12
  13 #include <aros/debug.h>
  14
  15 #define EX_BUF_SIZE 256
  16
  17 enum
  18 {
  19     ARG_HANDLER,
  20     ARG_EHANDLER,
  21     ARG_FILESYSTEM,
  22     ARG_DEVICE,
  23     ARG_UNIT,
  24     ARG_FLAGS,
  25     ARG_BLOCKSIZE,
  26     ARG_SURFACES,
  27     ARG_BLOCKSPERTRACK,
  28     ARG_SECTORSPERBLOCK,
  29     ARG_RESERVED,
  30     ARG_PREALLOC,
  31     ARG_INTERLEAVE,
  32     ARG_LOWCYL,
  33     ARG_HIGHCYL,
  34     ARG_BUFFERS,
  35     ARG_BUFMEMTYPE,
  36     ARG_MAXTRANSFER,
  37     ARG_MASK,
  38     ARG_BOOTPRI,
  39     ARG_DOSTYPE,
  40     ARG_BAUD,
  41     ARG_CONTROL,
  42     ARG_STACKSIZE,
  43     ARG_PRIORITY,
  44     ARG_GLOBVEC,
  45     ARG_STARTUP,
  46     ARG_ACTIVATE,
  47     ARG_FORCELOAD,
  48     NUM_MOUNTARGS
  49 };
  50
  51 static const TEXT mount_template[] =
  52     "HANDLER/K,"
  53     "EHANDLER/K,"
  54     "FILESYSTEM/K,"
  55     "DEVICE/K,"
  56     "UNIT/K,"
  57     "FLAGS/K,"
  58     "SECTORSIZE=BLOCKSIZE/K,"
  59     "SURFACES/K,"
  60     "SECTORSPERTRACK=BLOCKSPERTRACK/K,"
  61     "SECTORSPERBLOCK/K,"
  62     "RESERVED/K,"
  63     "PREALLOC/K,"
  64     "INTERLEAVE/K,"
  65     "LOWCYL/K,"
  66     "HIGHCYL/K,"
  67     "BUFFERS/K,"
  68     "BUFMEMTYPE/K,"
  69     "MAXTRANSFER/K,"
  70     "MASK/K,"
  71     "BOOTPRI/K,"
  72     "DOSTYPE/K,"
  73     "BAUD/K,"
  74     "CONTROL/K,"
  75     "STACKSIZE/K,"
  76     "PRIORITY/K,"
  77     "GLOBVEC/K,"
  78     "STARTUP/K,"
  79     "MOUNT=ACTIVATE/K,"
  80     "FORCELOAD/K";
  81
  82 enum
  83 {
  84     ARG_WORKGROUP,
  85     ARG_USERNAME,
  86     ARG_PASSWORD,
  87     ARG_CHANGECASE,
  88     ARG_CASESENSITIVE,
  89     ARG_OMITHIDDEN,
  90     ARG_QUIET,
  91     ARG_CLIENTNAME,
  92     ARG_SERVERNAME,
  93     ARG_DEVICENAME,
  94     ARG_VOLUMENAME,
  95     ARG_CACHESIZE,
  96     ARG_DEBUGLEVEL,
  97     ARG_TIMEZONEOFFSET,
  98     ARG_DSTOFFSET,
  99     ARG_TRANSLATIONFILE,
 100     ARG_SERVICE,
 101     NUM_CONTROLARGS
 102 };
 103
 104 static const TEXT control_template[] =
 105     "DOMAIN=WORKGROUP/K,"
 106     "USER=USERNAME/K,"
 107     "PASSWORD/K,"
 108     "CHANGECASE/S,"
 109     "CASE=CASESENSITIVE/S,"
 110     "OMITHIDDEN/S,"
 111     "QUIET/S,"
 112     "CLIENT=CLIENTNAME/K,"
 113     "SERVER=SERVERNAME/K,"
 114     "DEVICE=DEVICENAME/K,"
 115     "VOLUME=VOLUMENAME/K,"
 116     "CACHE=CACHESIZE/N/K,"
 117     "DEBUGLEVEL=DEBUG/N/K,"
 118     "TZ=TIMEZONEOFFSET/N/K,"
 119     "DST=DSTOFFSET/N/K,"
 120     "TRANSLATE=TRANSLATIONFILE/K,"
 121     "SERVICE/A";
 122
 123 static struct TCPPrefs prefs;
 124
 125 struct Tokenizer
 126 {
 127     STRPTR tokenizerLine;
 128     STRPTR token;
 129     FILE * tokenizedFile;
 130     BOOL newline;
 131     BOOL fend;
 132 };
 133
 134 /* List of devices that require NOTRACKING option */
 135 static STRPTR notrackingdevices[] = {"prm-rtl8029.device", NULL};
 136
 137 static BOOL ReadServer(struct Server *server, BPTR file, LONG size);
 138 static CONST_STRPTR GetActiveServers();
 139
 140 void OpenTokenFile(struct Tokenizer * tok, STRPTR FileName)
 141 {
 142     tok->tokenizedFile = fopen(FileName, "r");
 143     tok->token = NULL;
 144     tok->newline = TRUE;
 145     if (!tok->tokenizedFile)
 146         tok->fend = TRUE;
 147     else
 148     {
 149         tok->tokenizerLine = malloc(8192);
 150         tok->fend = FALSE;
 151         tok->newline = TRUE;
 152     }
 153 }
 154
 155 void CloseTokenFile(struct Tokenizer * tok)
 156 {
 157     if (tok->tokenizedFile)
 158     {
 159         fclose(tok->tokenizedFile);
 160         free(tok->tokenizerLine);
 161         tok->fend = TRUE;
 162         tok->token = NULL;
 163     }
 164 }
 165
 166 void GetNextToken(struct Tokenizer * tok, STRPTR tk)
 167 {
 168     tok->newline = FALSE;
 169     if (tok->token != NULL)
 170     {
 171         tok->token = strtok(NULL, tk);
 172         if (!tok->token)
 173             GetNextToken(tok, tk);
 174     }
 175     else
 176     {
 177         tok->newline = TRUE;
 178         if (!feof(tok->tokenizedFile))
 179         {
 180             tok->tokenizerLine[0] = 0;
 181             fgets(tok->tokenizerLine, 8192, tok->tokenizedFile);
 182             if (tok->tokenizerLine == NULL)
 183             {
 184                 tok->token = NULL;
 185                 GetNextToken(tok, tk);
 186             }
 187             else
 188                 tok->token = strtok(tok->tokenizerLine, tk);
 189         }
 190         else
 191             tok->fend = TRUE;
 192     }
 193 }
 194
 195 void SetDefaultNetworkPrefsValues()
 196 {
 197     LONG i;
 198     for (i = 0; i < MAXINTERFACES; i++)
 199     {
 200         InitInterface(GetInterface(i));
 201     }
 202     SetInterfaceCount(0);
 203     SetDomain(DEFAULTDOMAIN);
 204     SetHostname(DEFAULTHOST);
 205     SetGate(DEFAULTGATE);
 206     SetDNS(0, DEFAULTDNS);
 207     SetDNS(1, DEFAULTDNS);
 208     SetDHCP(FALSE);
 209
 210     SetAutostart(FALSE);
 211
 212     for (i = 0; i < MAXHOSTS; i++)
 213     {
 214         InitHost(GetHost(i));
 215     }
 216     SetHostCount(0);
 217 }
 218
 219 void SetDefaultWirelessPrefsValues()
 220 {
 221     LONG i;
 222     for (i = 0; i < MAXNETWORKS; i++)
 223     {
 224         InitNetwork(GetNetwork(i));
 225     }
 226     SetNetworkCount(0);
 227
 228     SetWirelessDevice(NULL);
 229 }
 230
 231 void SetDefaultMobilePrefsValues()
 232 {
 233     LONG i;
 234     for (i = 0; i < MAXATCOMMANDS; i++)
 235     {
 236         prefs.mobile.atcommand[i][0] = 0;
 237     }
 238     SetMobile_atcommand(0,"AT+CGDCONT=1,\"IP\",\"insert.your.apn.here\"");
 239     SetMobile_atcommand(1,"ATDT*99***1#");
 240     SetMobile_timeout( 10 );
 241     SetMobile_Autostart(FALSE);
 242     SetMobile_devicename( "usbmodem.device" );
 243     SetMobile_unit( 0 );
 244     SetMobile_username("");
 245     SetMobile_password("");
 246 }
 247
 248 void InitInterface(struct Interface *iface)
 249 {
 250     SetName(iface, DEFAULTNAME);
 251     SetIfDHCP(iface, TRUE);
 252     SetIP(iface, DEFAULTIP);
 253     SetMask(iface, DEFAULTMASK);
 254     SetDevice(iface, DEFAULTDEVICE);
 255     SetUnit(iface, 0);
 256     SetUp(iface, FALSE);
 257 }
 258
 259 /* Returns TRUE if directory has been created or already existed */
 260 BOOL RecursiveCreateDir(CONST_STRPTR dirpath)
 261 {
 262     /* Will create directory even if top level directory does not exist */
 263
 264     BPTR lock = BNULL;
 265     ULONG lastdirseparator = 0;
 266     ULONG dirpathlen = strlen(dirpath);
 267     STRPTR tmpdirpath = AllocVec(dirpathlen + 2, MEMF_CLEAR | MEMF_PUBLIC);
 268
 269     CopyMem(dirpath, tmpdirpath, dirpathlen);
 270
 271     /* Recurvice directory creation */
 272     while (TRUE)
 273     {
 274         if (lastdirseparator >= dirpathlen) break;
 275
 276         for (; lastdirseparator < dirpathlen; lastdirseparator++)
 277             if (tmpdirpath[lastdirseparator] == '/') break;
 278
 279         tmpdirpath[lastdirseparator] = '\0'; /* cut */
 280
 281         /* Unlock any lock from previous interation. Last iteration lock will be returned. */
 282         if (lock != BNULL)
 283         {
 284             UnLock(lock);
 285             lock = BNULL;
 286         }
 287
 288         /* Check if directory exists */
 289         lock = Lock(tmpdirpath, SHARED_LOCK);
 290         if (lock == BNULL)
 291         {
 292             lock = CreateDir(tmpdirpath);
 293             if (lock == BNULL)
 294                 break; /* Error with creation */
 295         }
 296
 297         tmpdirpath[lastdirseparator] = '/'; /* restore */
 298         lastdirseparator++;
 299     }
 300
 301     FreeVec(tmpdirpath);
 302
 303     if (lock == BNULL)
 304         return FALSE;
 305     else
 306     {
 307         UnLock(lock);
 308         lock = BNULL;
 309         return TRUE;
 310     }
 311 }
 312
 313 /* Returns TRUE if selected device needs to use NOTRACKING option */
 314 BOOL GetNoTracking(struct Interface *iface)
 315 {
 316     STRPTR devicename = NULL;
 317     LONG pos = 0;
 318     TEXT devicepath[strlen(GetDevice(iface)) + 1];
 319     strcpy(devicepath, GetDevice(iface));
 320     strupr(devicepath);
 321
 322     while ((devicename = notrackingdevices[pos++]) != NULL)
 323     {
 324         /* Comparison is done on upper case string so it is case insensitive */
 325         strupr(devicename);
 326         if (strstr(devicepath, devicename) != NULL)
 327             return TRUE;
 328     }
 329
 330     return FALSE;
 331 }
 332
 333 /* Puts part 1 into empty buffer */
 334 VOID CombinePath1P(STRPTR dstbuffer, ULONG dstbufferlen, CONST_STRPTR part1)
 335 {
 336     dstbuffer[0] = '\0'; /* Make sure buffer is treated as empty */
 337     AddPart(dstbuffer, part1, dstbufferlen);
 338 }
 339
 340 /* Combines part1 with part2 into an empty buffer */
 341 VOID CombinePath2P(STRPTR dstbuffer, ULONG dstbufferlen, CONST_STRPTR part1, CONST_STRPTR part2)
 342 {
 343     CombinePath1P(dstbuffer, dstbufferlen, part1);
 344     AddPart(dstbuffer, part2, dstbufferlen);
 345 }
 346
 347 /* Combines part1 with part2 with part3 into an empty buffer */
 348 VOID CombinePath3P(STRPTR dstbuffer, ULONG dstbufferlen, CONST_STRPTR part1, CONST_STRPTR part2, CONST_STRPTR part3)
 349 {
 350     CombinePath2P(dstbuffer, dstbufferlen, part1, part2);
 351     AddPart(dstbuffer, part3, dstbufferlen);
 352 }
 353
 354 BOOL WriteNetworkPrefs(CONST_STRPTR  destdir)
 355 {
 356     FILE *ConfFile;
 357     LONG i;
 358     struct Interface *iface;
 359     struct Host *host;
 360     ULONG filenamelen = strlen(destdir) + 4 + 20;
 361     TEXT filename[filenamelen];
 362     ULONG destdbdirlen = strlen(destdir) + 3 + 1;
 363     TEXT destdbdir[destdbdirlen];
 364     LONG interfacecount = GetInterfaceCount();
 365     LONG hostcount = GetHostCount();
 366
 367     CombinePath2P(destdbdir, destdbdirlen, destdir, "db");
 368
 369     /* Create necessary directories */
 370     if (!RecursiveCreateDir(destdir)) return FALSE;
 371     if (!RecursiveCreateDir(destdbdir)) return FALSE;
 372
 373     /* Write configuration files */
 374     CombinePath2P(filename, filenamelen, destdbdir, "general.config");
 375     ConfFile = fopen(filename, "w");
 376     if (!ConfFile) return FALSE;
 377     fprintf(ConfFile, "USELOOPBACK=YES\n");
 378     fprintf(ConfFile, "DEBUGSANA=NO\n");
 379     fprintf(ConfFile, "USENS=SECOND\n");
 380     fprintf(ConfFile, "GATEWAY=NO\n");
 381     fprintf(ConfFile, "HOSTNAME=%s.%s\n", GetHostname(), GetDomain());
 382     fprintf(ConfFile, "LOG FILTERFILE=5\n");
 383     fprintf(ConfFile, "GUI PANEL=MUI\n");
 384     fprintf(ConfFile, "OPENGUI=YES\n");
 385     fclose(ConfFile);
 386
 387     CombinePath2P(filename, filenamelen, destdbdir, "interfaces");
 388     ConfFile = fopen(filename, "w");
 389     if (!ConfFile) return FALSE;
 390     for (i = 0; i < interfacecount; i++)
 391     {
 392         iface = GetInterface(i);
 393         fprintf
 394         (
 395             ConfFile, "%s DEV=%s UNIT=%d %s IP=%s NETMASK=%s %s\n",
 396             GetName(iface), GetDevice(iface), (int)GetUnit(iface),
 397             (GetNoTracking(iface) ? (CONST_STRPTR)"NOTRACKING" : (CONST_STRPTR)""),
 398             (GetIfDHCP(iface) ?
 399                 (strstr(GetDevice(iface), "ppp.device") == NULL ?
 400                     (CONST_STRPTR)"DHCP" : (CONST_STRPTR)"0.0.0.0") :
 401                 GetIP(iface)),
 402             GetMask(iface),
 403             (GetUp(iface) ? (CONST_STRPTR)"UP" : (CONST_STRPTR)"")
 404         );
 405         if (strstr(GetDevice(iface), "atheros5000.device") != NULL
 406             || strstr(GetDevice(iface), "prism2.device") != NULL
 407             || strstr(GetDevice(iface), "realtek8180.device") != NULL)
 408         {
 409             SetWirelessDevice(GetDevice(iface));
 410             SetWirelessUnit(GetUnit(iface));
 411         }
 412         else if (strstr(GetDevice(iface), "ppp.device") != NULL)
 413             SetMobile_Autostart(TRUE);
 414     }
 415     fclose(ConfFile);
 416
 417     CombinePath2P(filename, filenamelen, destdbdir, "netdb-myhost");
 418     ConfFile = fopen(filename, "w");
 419     if (!ConfFile) return FALSE;
 420
 421     for (i = 0; i < interfacecount; i++)
 422     {
 423         iface = GetInterface(i);
 424         if (!GetIfDHCP(iface))
 425         {
 426             fprintf
 427             (
 428                 ConfFile, "HOST %s %s.%s %s\n",
 429                 GetIP(iface), GetHostname(), GetDomain(), GetHostname()
 430             );
 431         }
 432     }
 433
 434     if (!GetDHCP())
 435     {
 436         // FIXME: old version wrote Gateway even when DHCP was enabled
 437         fprintf(ConfFile, "HOST %s gateway\n", GetGate());
 438         fprintf(ConfFile, "; Domain names\n");
 439         fprintf(ConfFile, "; Name servers\n");
 440         fprintf(ConfFile, "NAMESERVER %s\n", GetDNS(0));
 441         fprintf(ConfFile, "NAMESERVER %s\n", GetDNS(1));
 442     }
 443     fclose(ConfFile);
 444
 445     CombinePath2P(filename, filenamelen, destdbdir, "static-routes");
 446     ConfFile = fopen(filename, "w");
 447     if (!ConfFile) return FALSE;
 448     if (!GetDHCP())
 449     {
 450         // FIXME: old version wrote Gateway even when DHCP was enabled
 451         fprintf(ConfFile, "DEFAULT GATEWAY %s\n", GetGate());
 452     }
 453     fclose(ConfFile);
 454
 455     /* Write variables */
 456     CombinePath2P(filename, filenamelen, destdir, "Config");
 457     ConfFile = fopen(filename, "w");
 458     if (!ConfFile) return FALSE;
 459     fprintf(ConfFile, "%s/db", PREFS_PATH_ENV);
 460     fclose(ConfFile);
 461
 462     CombinePath2P(filename, filenamelen, destdir, "AutoRun");
 463     ConfFile = fopen(filename, "w");
 464     if (!ConfFile) return FALSE;
 465     fprintf(ConfFile, "%s", (GetAutostart()) ? "True" : "False");
 466     fclose(ConfFile);
 467
 468     CombinePath2P(filename, filenamelen, destdir, "MobileAutorun");
 469     ConfFile = fopen(filename, "w");
 470     if (!ConfFile) return FALSE;
 471     fprintf(ConfFile, "%s", (GetMobile_Autostart()) ? "True" : "False");
 472     fclose(ConfFile);
 473
 474     CombinePath2P(filename, filenamelen, destdir, "WirelessAutoRun");
 475     ConfFile = fopen(filename, "w");
 476     if (!ConfFile) return FALSE;
 477     fprintf(ConfFile, "%s", (GetWirelessDevice() != NULL) ? "True" : "False");
 478     fclose(ConfFile);
 479
 480     if (GetWirelessDevice() != NULL)
 481     {
 482         CombinePath2P(filename, filenamelen, destdir, "WirelessDevice");
 483         ConfFile = fopen(filename, "w");
 484         if (!ConfFile) return FALSE;
 485         fprintf(ConfFile, "%s UNIT %ld", GetWirelessDevice(),
 486             (long int)GetWirelessUnit());
 487         fclose(ConfFile);
 488     }
 489
 490     CombinePath2P(filename, filenamelen, destdbdir, "hosts");
 491     ConfFile = fopen(filename, "w");
 492     if (!ConfFile) return FALSE;
 493     for (i = 0; i < hostcount; i++)
 494     {
 495         host = GetHost(i);
 496         fprintf
 497         (
 498             ConfFile, "%s %s\n",
 499             GetHostAddress(host), GetHostNames(host)
 500         );
 501     }
 502     fclose(ConfFile);
 503
 504     return TRUE;
 505 }
 506
 507 BOOL WriteWirelessPrefs(CONST_STRPTR destdir)
 508 {
 509     FILE *ConfFile;
 510     LONG i;
 511     struct Network *net;
 512     ULONG filenamelen = strlen(destdir) + 4 + 20;
 513     TEXT filename[filenamelen];
 514
 515     /* Write wireless config */
 516     CombinePath2P(filename, filenamelen, destdir, "Wireless.prefs");
 517     if (prefs.networkCount > 0)
 518     {
 519         ConfFile = fopen(filename, "w");
 520         if (!ConfFile) return FALSE;
 521
 522         for (i = 0; i < prefs.networkCount; i++)
 523         {
 524             net = &prefs.networks[i];
 525             fprintf(ConfFile, "network={\n");
 526             if (net->name[0] != '\0')
 527                 fprintf(ConfFile, "\tssid=\"%s\"\n", net->name);
 528             switch (net->encType)
 529             {
 530                 case 2:
 531                     if (net->keyIsHex)
 532                         fprintf(ConfFile, "\tpsk=%s\n", net->key);
 533                     else
 534                         fprintf(ConfFile, "\tpsk=\"%s\"\n", net->key);
 535                     fprintf(ConfFile, "\tkey_mgmt=WPA-PSK\n");
 536                     break;
 537                 case 1:
 538                     if (net->keyIsHex)
 539                         fprintf(ConfFile, "\twep_key0=%s\n", net->key);
 540                     else
 541                         fprintf(ConfFile, "\twep_key0=\"%s\"\n", net->key);
 542                     fprintf(ConfFile, "\twep_tx_keyidx=0\n");
 543                 default:
 544                     fprintf(ConfFile, "\tkey_mgmt=NONE\n");
 545             }
 546             if (net->hidden)
 547                 fprintf(ConfFile, "\tscan_ssid=1\n");
 548             if (net->adHoc)
 549                 fprintf(ConfFile, "\tmode=1\n");
 550             fprintf(ConfFile, "}\n\n");
 551         }
 552
 553         fclose(ConfFile);
 554     }
 555     else
 556         DeleteFile(filename);
 557
 558     return TRUE;
 559 }
 560
 561
 562 BOOL WriteMobilePrefs(CONST_STRPTR destdir)
 563 {
 564     FILE *ConfFile;
 565     LONG i;
 566     ULONG filenamelen = strlen(destdir) + 4 + 30;
 567     TEXT filename[filenamelen];
 568
 569     CombinePath2P(filename, filenamelen, destdir, "MobileBroadband.prefs");
 570     ConfFile = fopen(filename, "w");
 571     if (!ConfFile) return FALSE;
 572
 573     if (strlen(GetMobile_devicename()) > 0)
 574         fprintf(ConfFile, "DEVICE %s\n", GetMobile_devicename());
 575     fprintf(ConfFile, "UNIT %d\n" , (int)GetMobile_unit() );
 576     if (strlen(GetMobile_username()) > 0)
 577         fprintf(ConfFile, "USERNAME %s\n", GetMobile_username());
 578     if (strlen(GetMobile_password()) > 0)
 579         fprintf(ConfFile, "PASSWORD %s\n", GetMobile_password());
 580
 581     for (i = 0; i < MAXATCOMMANDS; i++)
 582     {
 583         if (strlen( GetMobile_atcommand(i) ) > 0)
 584             fprintf(ConfFile, "SEND %s\n", GetMobile_atcommand(i));
 585     }
 586
 587     fclose(ConfFile);
 588
 589     return TRUE;
 590 }
 591
 592
 593 BOOL WriteServers(CONST_STRPTR destdir, CONST_STRPTR envdir)
 594 {
 595     FILE *mount_file, *env_file;
 596     LONG i;
 597     struct Server *server;
 598     ULONG filenamelen = strlen(destdir) + 4 + 20;
 599     TEXT filename[filenamelen];
 600
 601     CombinePath2P(filename, filenamelen, envdir, "ServerAutoMounts");
 602     env_file = fopen(filename, "w");
 603     if (!env_file) return FALSE;
 604
 605     for (i = 0; i < prefs.serverCount; i++)
 606     {
 607         server = &prefs.servers[i];
 608         CombinePath2P(filename, filenamelen, destdir, server->device);
 609         mount_file = fopen(filename, "w");
 610         if (!mount_file)
 611         {
 612             fclose(env_file);
 613              return FALSE;
 614         }
 615
 616         fprintf(mount_file, "EHandler = " SERVER_HANDLER "\nActivate = 1\n");
 617         fprintf(mount_file, "Control = \"");
 618         if (server->user[0] != '\0')
 619             fprintf(mount_file, "USER=*\"%s*\" ", server->user);
 620         if (server->group[0] != '\0')
 621             fprintf(mount_file, "WORKGROUP=*\"%s*\" ", server->group);
 622         if (server->pass[0] != '\0')
 623             fprintf(mount_file, "PASSWORD=*\"%s*\" ", server->pass);
 624         fprintf(mount_file, "SERVICE=*\"//%s/%s*\"\"\n", server->host,
 625             server->service);
 626         fclose(mount_file);
 627
 628         if (server->active)
 629             fprintf(env_file, "%s: ", server->device);
 630     }
 631
 632     fclose(env_file);
 633
 634     return TRUE;
 635 }
 636
 637
 638 #define BUFSIZE 2048
 639 BOOL CopyFile(CONST_STRPTR srcfile, CONST_STRPTR dstfile)
 640 {
 641     BPTR from = BNULL, to = BNULL;
 642     TEXT buffer[BUFSIZE];
 643
 644     if ((from = Open(srcfile, MODE_OLDFILE)))
 645     {
 646         if ((to = Open(dstfile, MODE_NEWFILE)))
 647         {
 648             LONG s = 0;
 649
 650             do
 651             {
 652                 if ((s = Read(from, buffer, BUFSIZE)) == -1)
 653                 {
 654                     Close(to);
 655                     Close(from);
 656                     return FALSE;
 657                 }
 658
 659                 if (Write(to, buffer, s) == -1)
 660                 {
 661                     Close(to);
 662                     Close(from);
 663                     return FALSE;
 664                 }
 665             } while (s == BUFSIZE);
 666
 667             Close(to);
 668             Close(from);
 669             return TRUE;
 670         }
 671
 672         Close(from);
 673     }
 674
 675     return FALSE;
 676 }
 677
 678 CONST_STRPTR GetDefaultStackLocation()
 679 {
 680     /* Use static variable so that it is initialized only once (and can be returned) */
 681     static TEXT path [1024] = {0};
 682
 683     /* Load path if needed - this will happen only once */
 684     if (path[0] == '\0')
 685     {
 686         GetVar(AROSTCP_PACKAGE_VARIABLE, path, 1024, LV_VAR);
 687     }
 688
 689     return path;
 690 }
 691
 692 BOOL IsStackRunning()
 693 {
 694     return FindTask("bsdsocket.library") != NULL;
 695 }
 696
 697 BOOL RestartStack()
 698 {
 699     ULONG trycount = 0;
 700
 701     /* Shutdown */
 702     if (IsStackRunning())
 703     {
 704         struct Task * arostcptask = FindTask("bsdsocket.library");
 705         if (arostcptask != NULL)
 706             Signal(arostcptask, SIGBREAKF_CTRL_C);
 707     }
 708
 709     /* Check if shutdown successful */
 710     trycount = 0;
 711     while (IsStackRunning())
 712     {
 713         if (trycount > 4) return FALSE;
 714         Delay(50);
 715         trycount++;
 716     }
 717
 718     /* Startup */
 719     {
 720         CONST_STRPTR srcdir = GetDefaultStackLocation();
 721         ULONG arostcppathlen = strlen(srcdir) + 3 + 20;
 722         TEXT arostcppath[arostcppathlen];
 723         struct TagItem tags[] =
 724         {
 725             { SYS_Input,        (IPTR)NULL          },
 726             { SYS_Output,       (IPTR)NULL          },
 727             { SYS_Error,        (IPTR)NULL          },
 728             { SYS_Asynch,       (IPTR)TRUE          },
 729             { TAG_DONE,         0                   }
 730         };
 731
 732         CombinePath3P(arostcppath, arostcppathlen, srcdir, "C", "AROSTCP");
 733
 734         SystemTagList(arostcppath, tags);
 735     }
 736
 737     /* Check if startup successful */
 738     trycount = 0;
 739     while (!IsStackRunning())
 740     {
 741         if (trycount > 9) return FALSE;
 742         Delay(50);
 743         trycount++;
 744     }
 745
 746     /* All ok */
 747     return TRUE;
 748 }
 749
 750 BOOL StopWireless()
 751 {
 752     ULONG trycount = 0;
 753
 754     /* Shutdown */
 755     {
 756         struct Task *task = FindTask("C:WirelessManager");
 757         if (task != NULL)
 758             Signal(task, SIGBREAKF_CTRL_C);
 759     }
 760
 761     /* Check if shutdown successful */
 762     trycount = 0;
 763     while (FindTask("C:WirelessManager") != NULL)
 764     {
 765         if (trycount > 4) return FALSE;
 766         Delay(50);
 767         trycount++;
 768     }
 769
 770     /* All ok */
 771     return TRUE;
 772 }
 773
 774 BOOL StartWireless()
 775 {
 776     ULONG trycount = 0;
 777     TEXT command[80];
 778
 779     /* Startup */
 780     {
 781         struct TagItem tags[] =
 782         {
 783             { SYS_Input,        (IPTR)NULL          },
 784             { SYS_Output,       (IPTR)NULL          },
 785             { SYS_Error,        (IPTR)NULL          },
 786             { SYS_Asynch,       (IPTR)TRUE          },
 787             { TAG_DONE,         0                   }
 788         };
 789
 790         snprintf(command, 80, "C:WirelessManager \"%s\" UNIT %ld\n",
 791             GetWirelessDevice(), (long int)GetWirelessUnit());
 792         SystemTagList(command, tags);
 793     }
 794
 795     /* Check if startup successful */
 796     trycount = 0;
 797     while (FindTask("C:WirelessManager") == NULL)
 798     {
 799         if (trycount > 9) return FALSE;
 800         Delay(50);
 801         trycount++;
 802     }
 803
 804     /* All ok */
 805     return TRUE;
 806 }
 807
 808 BOOL StopMobile()
 809 {
 810     ULONG trycount = 0;
 811
 812     /* Shutdown */
 813     {
 814         struct Task *task = FindTask("C:ModemManager");
 815         if (task != NULL)
 816             Signal(task, SIGBREAKF_CTRL_C);
 817     }
 818
 819     /* Check if shutdown successful */
 820     trycount = 0;
 821     while (FindTask("C:ModemManager") != NULL)
 822     {
 823         if (trycount > 4) return FALSE;
 824         Delay(50);
 825         trycount++;
 826     }
 827
 828     /* All ok */
 829     return TRUE;
 830 }
 831
 832 BOOL StartMobile()
 833 {
 834     ULONG trycount = 0;
 835
 836     /* Startup */
 837     {
 838         struct TagItem tags[] =
 839         {
 840             { SYS_Input,        (IPTR)NULL          },
 841             { SYS_Output,       (IPTR)NULL          },
 842             { SYS_Error,        (IPTR)NULL          },
 843             { SYS_Asynch,       (IPTR)TRUE          },
 844             { TAG_DONE,         0                   }
 845         };
 846
 847         SystemTagList("C:ModemManager", tags);
 848     }
 849
 850     /* Check if startup successful */
 851     trycount = 0;
 852     while (FindTask("C:ModemManager") == NULL)
 853     {
 854         if (trycount > 9) return FALSE;
 855         Delay(50);
 856         trycount++;
 857     }
 858
 859     /* All ok */
 860     return TRUE;
 861 }
 862
 863 static CONST_STRPTR GetActiveServers()
 864 {
 865     /* Use static variable so that it is initialized only once (and can be returned) */
 866     static TEXT servers [256] = {0};
 867
 868     /* Load variable if needed - this will happen only once */
 869     if (servers[0] == '\0')
 870     {
 871         GetVar(AUTOMOUNT_VARIABLE, servers, 256, LV_VAR);
 872     }
 873
 874     return servers;
 875 }
 876
 877 BOOL MountServers()
 878 {
 879     BPTR dir;
 880
 881     dir = Lock(SERVER_PATH_ENV, SHARED_LOCK);
 882     if (dir == BNULL)
 883         return FALSE;
 884
 885     /* Startup */
 886     if (GetServerCount() > 0)
 887     {
 888         struct TagItem tags[] =
 889         {
 890             { SYS_Input,        (IPTR)NULL          },
 891             { SYS_Output,       (IPTR)NULL          },
 892             { SYS_Error,        (IPTR)NULL          },
 893             { SYS_Asynch,       (IPTR)TRUE          },
 894             { NP_CurrentDir,    (IPTR)dir           },
 895             { TAG_DONE,         0                   }
 896         };
 897
 898         SystemTagList("C:Mount ${AROSTCP/ServerAutoMounts}\n", tags);
 899     }
 900
 901     /* All ok */
 902     return TRUE;
 903 }
 904
 905 /* This is not a general use function! It assumes destinations directory exists */
 906 BOOL AddFileFromDefaultStackLocation(CONST_STRPTR filename, CONST_STRPTR dstdir)
 907 {
 908     /* Build paths */
 909     CONST_STRPTR srcdir = GetDefaultStackLocation();
 910     ULONG srcfilelen = strlen(srcdir) + 4 + strlen(filename) + 1;
 911     TEXT srcfile[srcfilelen];
 912     ULONG dstfilelen = strlen(dstdir) + 4 + strlen(filename) + 1;
 913     TEXT dstfile[dstfilelen];
 914     BPTR dstlock = BNULL;
 915
 916     CombinePath3P(srcfile, srcfilelen, srcdir, "db", filename);
 917     CombinePath3P(dstfile, dstfilelen, dstdir, "db", filename);
 918
 919     /* Check if the destination file already exists. If yes, do not copy */
 920     dstlock = Lock(dstfile, SHARED_LOCK);
 921     if (dstlock != BNULL)
 922     {
 923         UnLock(dstlock);
 924         return TRUE;
 925     }
 926
 927     return CopyFile(srcfile, dstfile);
 928 }
 929
 930 /* Copies files not created by prefs but needed to start stack */
 931 BOOL CopyDefaultConfiguration(CONST_STRPTR destdir)
 932 {
 933     ULONG destdbdirlen = strlen(destdir) + 3 + 1;
 934     TEXT destdbdir[destdbdirlen];
 935     CombinePath2P(destdbdir, destdbdirlen, destdir, "db");
 936
 937     /* Create necessary directories */
 938     if (!RecursiveCreateDir(destdir)) return FALSE;
 939     if (!RecursiveCreateDir(destdbdir)) return FALSE;
 940
 941     /* Copy files */
 942     if (!AddFileFromDefaultStackLocation("inet.access", destdir)) return FALSE;
 943     if (!AddFileFromDefaultStackLocation("netdb", destdir)) return FALSE;
 944     if (!AddFileFromDefaultStackLocation("networks", destdir)) return FALSE;
 945     if (!AddFileFromDefaultStackLocation("protocols", destdir)) return FALSE;
 946     if (!AddFileFromDefaultStackLocation("services", destdir)) return FALSE;
 947
 948     return TRUE;
 949 }
 950
 951 enum ErrorCode SaveNetworkPrefs()
 952 {
 953     if (!CopyDefaultConfiguration(PREFS_PATH_ENVARC)) return NOT_COPIED_FILES_ENVARC;
 954     if (!WriteNetworkPrefs(PREFS_PATH_ENVARC)) return NOT_SAVED_PREFS_ENVARC;
 955     if (!WriteWirelessPrefs(WIRELESS_PATH_ENVARC)) return NOT_SAVED_PREFS_ENVARC;
 956     if (!WriteMobilePrefs(MOBILEBB_PATH_ENVARC)) return NOT_SAVED_PREFS_ENVARC;
 957     if (!WriteServers(SERVER_PATH_STORAGE, PREFS_PATH_ENVARC))
 958         return NOT_SAVED_PREFS_ENVARC;
 959
 960     return UseNetworkPrefs();
 961 }
 962
 963 enum ErrorCode UseNetworkPrefs()
 964 {
 965     if (!CopyDefaultConfiguration(PREFS_PATH_ENV)) return NOT_COPIED_FILES_ENV;
 966     if (!WriteNetworkPrefs(PREFS_PATH_ENV)) return NOT_SAVED_PREFS_ENV;
 967     if (!WriteWirelessPrefs(WIRELESS_PATH_ENV)) return NOT_SAVED_PREFS_ENV;
 968     if (!WriteMobilePrefs(MOBILEBB_PATH_ENV)) return NOT_SAVED_PREFS_ENV;
 969     if (!RecursiveCreateDir(SERVER_PATH_ENV)) return NOT_SAVED_PREFS_ENV;
 970     if (!WriteServers(SERVER_PATH_ENV, PREFS_PATH_ENV))
 971         return NOT_SAVED_PREFS_ENV;
 972
 973     if (StopWireless())
 974         if (GetWirelessDevice() != NULL)
 975             if (!StartWireless()) return NOT_RESTARTED_WIRELESS;
 976     if (!RestartStack()) return NOT_RESTARTED_STACK;
 977     if (StopMobile())
 978         if (GetMobile_Autostart())
 979             if (!StartMobile()) return NOT_RESTARTED_MOBILE;
 980     MountServers();
 981
 982     return ALL_OK;
 983 }
 984
 985 /* Directory points to top of config, so to AAA/AROSTCP not to AAA/AROSTCP/db */
 986 void ReadNetworkPrefs(CONST_STRPTR directory)
 987 {
 988     ULONG filenamelen = strlen(directory) + 4 + 20;
 989     TEXT filename[filenamelen];
 990     BOOL comment = FALSE;
 991     STRPTR tstring;
 992     struct Tokenizer tok;
 993     LONG interfacecount, hostcount;
 994     struct Interface *iface = NULL;
 995     struct Host *host = NULL;
 996
 997     /* This function will not fail. It will load as much data as possible. Rest will be default values */
 998
 999     SetDHCP(FALSE);
1000
1001     CombinePath3P(filename, filenamelen, directory, "db", "general.config");
1002     OpenTokenFile(&tok, filename);
1003     while (!tok.fend)
1004     {
1005         if (tok.newline)
1006         { // read tokens from the beginning of line
1007             if (tok.token)
1008             {
1009                 if (strcmp(tok.token, "HOSTNAME") == 0)
1010                 {
1011                     GetNextToken(&tok, "=\n");
1012                     tstring = strchr(tok.token, '.');
1013                     SetDomain(tstring + 1);
1014                     tstring[0] = 0;
1015                     SetHostname(tok.token);
1016                 }
1017             }
1018         }
1019         GetNextToken(&tok, "=\n");
1020     }
1021     CloseTokenFile(&tok);
1022
1023     CombinePath3P(filename, filenamelen, directory, "db", "interfaces");
1024     OpenTokenFile(&tok, filename);
1025
1026     SetInterfaceCount(0);
1027     interfacecount = 0;
1028
1029     while (!tok.fend && (interfacecount < MAXINTERFACES))
1030     {
1031         GetNextToken(&tok, " \n");
1032         if (tok.token)
1033         {
1034             if (tok.newline) comment = FALSE;
1035             if (strncmp(tok.token, "#", 1) == 0) comment = TRUE;
1036
1037             if (!comment)
1038             {
1039                 if (tok.newline)
1040                 {
1041                     iface = GetInterface(interfacecount);
1042                     SetName(iface, tok.token);
1043                     interfacecount++;
1044                     SetInterfaceCount(interfacecount);
1045                 }
1046                 else if (strncmp(tok.token, "DEV=", 4) == 0)
1047                 {
1048                     tstring = strchr(tok.token, '=');
1049                     SetDevice(iface, tstring + 1);
1050                 }
1051                 else if (strncmp(tok.token, "UNIT=", 5) == 0)
1052                 {
1053                     tstring = strchr(tok.token, '=');
1054                     SetUnit(iface, atol(tstring + 1));
1055                 }
1056                 else if (strncmp(tok.token, "IP=", 3) == 0)
1057                 {
1058                     tstring = strchr(tok.token, '=');
1059                     if (strncmp(tstring + 1, "DHCP", 4) == 0
1060                         || strstr(GetDevice(iface), "ppp.device") != NULL)
1061                     {
1062                         SetIfDHCP(iface, TRUE);
1063                         SetIP(iface, DEFAULTIP);
1064                     }
1065                     else
1066                     {
1067                         SetIP(iface, tstring + 1);
1068                         SetIfDHCP(iface, FALSE);
1069                     }
1070                 }
1071                 else if (strncmp(tok.token, "NETMASK=", 8) == 0)
1072                 {
1073                     tstring = strchr(tok.token, '=');
1074                     SetMask(iface, tstring + 1);
1075                 }
1076                 else if (strncmp(tok.token, "UP", 2) == 0)
1077                 {
1078                     SetUp(iface, TRUE);
1079                 }
1080             }
1081         }
1082     }
1083     CloseTokenFile(&tok);
1084
1085     CombinePath3P(filename, filenamelen, directory, "db", "netdb-myhost");
1086     OpenTokenFile(&tok, filename);
1087     int dnsc = 0;
1088     while (!tok.fend)
1089     {
1090         GetNextToken(&tok, " \n");
1091         if (tok.token)
1092         {
1093             // Host and Domain are already read from general.config
1094             if (strncmp(tok.token, "NAMESERVER", 10) == 0)
1095             {
1096                 GetNextToken(&tok, " \n");
1097                 SetDNS(dnsc, tok.token);
1098                 dnsc++;
1099                 if (dnsc > 1) dnsc = 1;
1100             }
1101         }
1102     }
1103     // Assume DHCP if there is no nameserver
1104     if (dnsc == 0)
1105     {
1106         SetDHCP(TRUE);
1107     }
1108     CloseTokenFile(&tok);
1109
1110     CombinePath3P(filename, filenamelen, directory, "db", "static-routes");
1111     OpenTokenFile(&tok, filename);
1112     while (!tok.fend)
1113     {
1114         GetNextToken(&tok, " \n");
1115         if (tok.token)
1116         {
1117             if (strncmp(tok.token, "DEFAULT", 7) == 0)
1118             {
1119                 GetNextToken(&tok, " \n");
1120                 if (strncmp(tok.token, "GATEWAY", 7) == 0)
1121                 {
1122                     GetNextToken(&tok, " \n");
1123                     SetGate(tok.token);
1124                 }
1125             }
1126         }
1127     }
1128     CloseTokenFile(&tok);
1129
1130     CombinePath2P(filename, filenamelen, directory, "Autorun");
1131     OpenTokenFile(&tok, filename);
1132     while (!tok.fend)
1133     {
1134         GetNextToken(&tok, " \n");
1135         if (tok.token)
1136         {
1137             if (strncmp(tok.token, "True", 4) == 0)
1138             {
1139                 SetAutostart(TRUE);
1140                 break;
1141             }
1142             else
1143             {
1144                 SetAutostart(FALSE);
1145                 break;
1146             }
1147         }
1148     }
1149     CloseTokenFile(&tok);
1150
1151     CombinePath3P(filename, filenamelen, directory, "db", "hosts");
1152     OpenTokenFile(&tok, filename);
1153
1154     SetHostCount(0);
1155     hostcount = 0;
1156
1157     while (!tok.fend && (hostcount < MAXHOSTS))
1158     {
1159         GetNextToken(&tok, " \n");
1160         if (tok.token)
1161         {
1162             if (tok.newline) comment = FALSE;
1163             if (strncmp(tok.token, "#", 1) == 0) comment = TRUE;
1164
1165             if (!comment)
1166             {
1167                 if (tok.newline)
1168                 {
1169                     host = GetHost(hostcount);
1170                     SetHostAddress(host, tok.token);
1171                     hostcount++;
1172                     SetHostCount(hostcount);
1173                 }
1174                 else
1175                 {
1176                     AddHostName(host, tok.token);
1177                 }
1178             }
1179         }
1180     }
1181     CloseTokenFile(&tok);
1182 }
1183
1184 void ReadWirelessPrefs(CONST_STRPTR directory)
1185 {
1186     ULONG filenamelen = strlen(directory) + 4 + 20;
1187     TEXT filename[filenamelen];
1188     BOOL comment = FALSE;
1189     STRPTR tstring;
1190     struct Tokenizer tok;
1191     LONG networkCount;
1192     struct Network *net = NULL;
1193     BOOL keyIsHex;
1194
1195     CombinePath2P(filename, filenamelen, directory, "Wireless.prefs");
1196     OpenTokenFile(&tok, filename);
1197
1198     SetNetworkCount(0);
1199     networkCount = 0;
1200
1201     while (!tok.fend && (networkCount < MAXNETWORKS))
1202     {
1203         GetNextToken(&tok, "\n\t");
1204         if (tok.token)
1205         {
1206             if (tok.newline) comment = FALSE;
1207             if (strncmp(tok.token, "#", 1) == 0) comment = TRUE;
1208
1209             if (!comment)
1210             {
1211                 if (strncmp(tok.token, "network=", 8) == 0)
1212                 {
1213                     net = GetNetwork(networkCount);
1214                     net->adHoc = FALSE;
1215                     net->hidden = FALSE;
1216                     networkCount++;
1217                     SetNetworkCount(networkCount);
1218                 }
1219                 else if (strncmp(tok.token, "ssid=", 5) == 0)
1220                 {
1221                     tstring = strchr(tok.token, '=') + 2;
1222                     *strchr(tstring, '\"') = '\0';
1223                     SetNetworkName(net, tstring);
1224                 }
1225                 else if (strncmp(tok.token, "psk=", 4) == 0
1226                     || strncmp(tok.token, "wep_key0=", 9) == 0)
1227                 {
1228                     tstring = strchr(tok.token, '=') + 1;
1229                     if (*tstring == '\"')
1230                     {
1231                         keyIsHex = FALSE;
1232                         tstring++;
1233                         *strchr(tstring, '\"') = '\0';
1234                     }
1235                     else
1236                         keyIsHex = TRUE;
1237                     SetKey(net, tstring, keyIsHex);
1238                     SetEncType(net, (*tok.token == 'p') ? 2 : 1);
1239                 }
1240                 else if (strncmp(tok.token, "scan_ssid=", 10) == 0)
1241                 {
1242                     tstring = strchr(tok.token, '=') + 1;
1243                     SetHidden(net, *tstring == '1');
1244                 }
1245                 else if (strncmp(tok.token, "mode=", 5) == 0)
1246                 {
1247                     tstring = strchr(tok.token, '=') + 1;
1248                     SetAdHoc(net, *tstring == '1');
1249                 }
1250             }
1251         }
1252     }
1253     CloseTokenFile(&tok);
1254 }
1255
1256
1257 void ReadMobilePrefs(CONST_STRPTR directory)
1258 {
1259     ULONG filenamelen = strlen(directory) + 4 + 30;
1260     TEXT filename[filenamelen];
1261     struct Tokenizer tok;
1262     LONG command=0;
1263
1264     CombinePath2P(filename, filenamelen, directory, "MobileBroadband.prefs");
1265     OpenTokenFile(&tok, filename);
1266     while (!tok.fend)
1267     {
1268         GetNextToken(&tok, " \n");
1269         if (tok.token)
1270         {
1271             if ( tok.newline && tok.token[0] == '#' ) continue;
1272
1273             if (tok.newline)
1274             {
1275                 if (strcasecmp( tok.token, "SEND" ) == 0)
1276                 {
1277                     GetNextToken(&tok, "\n");
1278                     if ( tok.token && ! tok.newline )
1279                     {
1280                         SetMobile_atcommand( command++ , tok.token );
1281                     }
1282                 }
1283                 else if (strcasecmp( tok.token, "DEVICE" ) == 0)
1284                 {
1285                     GetNextToken(&tok, " \n");
1286                     if ( tok.token && ! tok.newline )
1287                     {
1288                         SetMobile_devicename( tok.token );
1289                     }
1290                 }
1291                 else if (strcasecmp( tok.token, "USERNAME" ) == 0)
1292                 {
1293                     GetNextToken(&tok, " \n");
1294                     if ( tok.token && ! tok.newline )
1295                     {
1296                         SetMobile_username( tok.token );
1297                     }
1298                 }
1299                 else if (strcasecmp( tok.token, "PASSWORD" ) == 0)
1300                 {
1301                     GetNextToken(&tok, " \n");
1302                     if ( tok.token && ! tok.newline )
1303                     {
1304                         SetMobile_password( tok.token );
1305                     }
1306                 }
1307                 else if (strcasecmp( tok.token, "UNIT" ) == 0)
1308                 {
1309                     GetNextToken(&tok, " \n");
1310                     if ( tok.token && ! tok.newline )
1311                     {
1312                         SetMobile_unit( atoi( tok.token ) );
1313                     }
1314                 }
1315             }
1316         }
1317     }
1318     CloseTokenFile(&tok);
1319 }
1320
1321
1322 BOOL ReadServers()
1323 {
1324     BPTR dir, file;
1325     APTR ex_buffer = NULL;
1326     struct ExAllControl *ex_control = NULL;
1327     struct ExAllData *entry;
1328     BOOL success = TRUE, more = TRUE;
1329     LONG i = 0;
1330     struct Server *server;
1331
1332     dir = Lock(SERVER_PATH_ENV, SHARED_LOCK);
1333     if (dir == BNULL)
1334     {
1335         dir = Lock(SERVER_PATH_STORAGE, SHARED_LOCK);
1336         if (dir == BNULL)
1337             success = FALSE;
1338         else
1339         {
1340             D(bug("[Network Prefs/ReadServers] scan directory " SERVER_PATH_STORAGE "\n"));
1341         }
1342     }
1343     else
1344     {
1345         D(bug("[Network Prefs/ReadServers] scan directory " SERVER_PATH_ENV "\n"));
1346     }
1347
1348     if (success)
1349     {
1350         ex_buffer = AllocVec(EX_BUF_SIZE, MEMF_PUBLIC);
1351         if (ex_buffer == NULL)
1352             success = FALSE;
1353
1354         ex_control = AllocDosObject(DOS_EXALLCONTROL, NULL);
1355         if (ex_control == NULL)
1356             success = FALSE;
1357     }
1358
1359     if (success)
1360     {
1361         ex_control->eac_LastKey = 0;
1362         while (more && i < MAXSERVERS)
1363         {
1364             more = ExAll(dir, ex_buffer, EX_BUF_SIZE, ED_SIZE, ex_control);
1365
1366             if (!more && (IoErr() != ERROR_NO_MORE_ENTRIES))
1367                 break;
1368             if (ex_control->eac_Entries == 0)
1369                 continue;
1370
1371             entry = ex_buffer;
1372             while (entry != NULL)
1373             {
1374                 if (entry->ed_Type < 0)
1375                 {
1376                     dir = CurrentDir(dir);
1377                     D(bug("[Network Prefs/ReadServers] filename %s\n", entry->ed_Name));
1378                     file = Open(entry->ed_Name, MODE_OLDFILE);
1379                     if (file != BNULL)
1380                     {
1381                         server = &prefs.servers[i];
1382                         if (ReadServer(server, file, entry->ed_Size))
1383                         {
1384                             i++;
1385                             SetServerDevice(server, entry->ed_Name);
1386                             if (strstr(GetActiveServers(), entry->ed_Name)
1387                                 != NULL)
1388                                 SetServerActive(server, TRUE);
1389                         }
1390                         Close(file);
1391                     }
1392                     dir = CurrentDir(dir);
1393                 }
1394                 entry = entry->ed_Next;
1395             }
1396         }
1397         prefs.serverCount = i;
1398     }
1399
1400     if (ex_control != NULL)
1401     {
1402         FreeDosObject(DOS_EXALLCONTROL, ex_control);
1403     }
1404
1405     FreeVec(ex_buffer);
1406
1407     return success;
1408 }
1409
1410
1411 /* Read and parse a server mount file */
1412 static BOOL ReadServer(struct Server *server, BPTR file, LONG size)
1413 {
1414     BOOL success = TRUE;
1415     UBYTE *mount_buffer;
1416     IPTR mount_args[NUM_MOUNTARGS] = {0}, control_args[NUM_CONTROLARGS] = {0};
1417     struct RDArgs *mount_rdargs = NULL, *control_rdargs = NULL;
1418     LONG i;
1419     STRPTR host, service;
1420
1421     /* Allocate buffer for entire mount file */
1422     mount_buffer = AllocVec(size+100, MEMF_ANY|MEMF_CLEAR);
1423     if (mount_buffer == NULL)
1424         success = FALSE;
1425
1426     /* Read mount file into buffer */
1427     if (success)
1428     {
1429         if (FRead(file, mount_buffer, size, 1) != 1)
1430             success = FALSE;
1431     }
1432
1433     if (success)
1434     {
1435         for (i = 0; i < size; i++)
1436             if (mount_buffer[i] == '\n')
1437                 mount_buffer[i] = ' ';
1438
1439         mount_rdargs = AllocDosObject(DOS_RDARGS, NULL);
1440         control_rdargs = AllocDosObject(DOS_RDARGS, NULL);
1441         if (mount_rdargs == NULL || control_rdargs == NULL)
1442             success = FALSE;
1443     }
1444
1445     /* Parse mount parameters */
1446     if (success)
1447     {
1448         mount_rdargs->RDA_Source.CS_Buffer = mount_buffer;
1449         mount_rdargs->RDA_Source.CS_Length = size+1;
1450         mount_rdargs->RDA_Flags = RDAF_NOPROMPT;
1451         mount_rdargs =
1452             ReadArgs(mount_template, (IPTR *)&mount_args, mount_rdargs);
1453         if (mount_rdargs == NULL)
1454             success = FALSE;
1455     }
1456
1457     /* Check if this is a server mount */
1458     if (success)
1459     {
1460         if ((char *)mount_args[ARG_EHANDLER] == NULL)
1461             success = FALSE;
1462         else if (strcasecmp((char *)mount_args[ARG_EHANDLER],
1463             SERVER_HANDLER) != 0)
1464             success = FALSE;
1465     }
1466
1467     /* Parse control parameters */
1468     if (success)
1469     {
1470         control_rdargs->RDA_Source.CS_Buffer = (UBYTE *)mount_args[ARG_CONTROL];
1471         control_rdargs->RDA_Source.CS_Length =
1472             strlen((STRPTR)mount_args[ARG_CONTROL]);
1473         control_rdargs =
1474             ReadArgs(control_template, (IPTR *)&control_args, control_rdargs);
1475         if (control_rdargs == NULL)
1476             success = FALSE;
1477     }
1478
1479     /* Extract needed control parameters */
1480     if (success)
1481     {
1482         service = FilePart((STRPTR)control_args[ARG_SERVICE]);
1483         SetServerService(server, service);
1484         service--;
1485         *service = '\0';
1486         host = (STRPTR)control_args[ARG_SERVICE] + 2;
1487         SetServerHost(server, host);
1488
1489         SetServerUser(server, (STRPTR)control_args[ARG_USERNAME]);
1490         SetServerGroup(server, (STRPTR)control_args[ARG_WORKGROUP]);
1491         SetServerPass(server, (STRPTR)control_args[ARG_PASSWORD]);
1492     }
1493
1494     if (control_rdargs != NULL)
1495     {
1496         FreeArgs(control_rdargs);
1497         FreeDosObject(DOS_RDARGS, control_rdargs);
1498     }
1499
1500     if (mount_rdargs != NULL)
1501     {
1502         FreeArgs(mount_rdargs);
1503         FreeDosObject(DOS_RDARGS, mount_rdargs);
1504     }
1505
1506     return success;
1507 }
1508
1509
1510 void InitNetworkPrefs(CONST_STRPTR directory, BOOL use, BOOL save)
1511 {
1512     SetDefaultNetworkPrefsValues();
1513     SetDefaultWirelessPrefsValues();
1514     SetDefaultMobilePrefsValues();
1515
1516     ReadNetworkPrefs(directory);
1517     ReadWirelessPrefs(WIRELESS_PATH_ENV);
1518     ReadMobilePrefs(MOBILEBB_PATH_ENV);
1519     ReadServers();
1520
1521     if (save)
1522     {
1523         SaveNetworkPrefs();
1524         return; /* save equals to use */
1525     }
1526
1527     if (use)
1528     {
1529         UseNetworkPrefs();
1530     }
1531 }
1532
1533 // check if 'str' contains only characters from 'accept'
1534 BOOL IsLegal(STRPTR str, STRPTR accept)
1535 {
1536     int i, len;
1537
1538     if ((str == NULL) || (accept == NULL) || (str[0] == '\0'))
1539     {
1540         return FALSE;
1541     }
1542
1543     len = strlen(str);
1544     for (i = 0; i < len; i++)
1545     {
1546         if (strchr(accept, str[i]) == NULL)
1547         {
1548             return FALSE;
1549         }
1550     }
1551     return TRUE;
1552 }
1553
1554
1555 /* Getters */
1556
1557 struct Interface * GetInterface(LONG index)
1558 {
1559     return &prefs.interface[index];
1560 }
1561
1562 STRPTR GetName(struct Interface *iface)
1563 {
1564     return iface->name;
1565 }
1566
1567 BOOL GetIfDHCP(struct Interface *iface)
1568 {
1569     return iface->ifDHCP;
1570 }
1571
1572 STRPTR GetIP(struct Interface *iface)
1573 {
1574     return iface->IP;
1575 }
1576
1577 STRPTR GetMask(struct Interface *iface)
1578 {
1579     return iface->mask;
1580 }
1581
1582 STRPTR GetDevice(struct Interface *iface)
1583 {
1584     return iface->device;
1585 }
1586
1587 LONG GetUnit(struct Interface *iface)
1588 {
1589     return iface->unit;
1590 }
1591
1592 BOOL GetUp(struct Interface *iface)
1593 {
1594     return iface->up;
1595 }
1596
1597 STRPTR GetGate(void)
1598 {
1599     return prefs.gate;
1600 }
1601
1602 STRPTR GetDNS(LONG m)
1603 {
1604     return prefs.DNS[m];
1605 }
1606
1607 STRPTR GetHostname(void)
1608 {
1609     return prefs.host;
1610 }
1611
1612 STRPTR GetDomain(void)
1613 {
1614     return prefs.domain;
1615 }
1616
1617 LONG GetInterfaceCount(void)
1618 {
1619     return prefs.interfacecount;
1620 }
1621
1622 BOOL GetAutostart(void)
1623 {
1624     return prefs.autostart;
1625 }
1626
1627 BOOL GetDHCP(void)
1628 {
1629     return prefs.DHCP;
1630 }
1631
1632
1633 /* Setters */
1634
1635 void SetInterface
1636 (
1637     struct Interface *iface, STRPTR name, BOOL dhcp, STRPTR IP, STRPTR mask,
1638     STRPTR device, LONG unit, BOOL up
1639 )
1640 {
1641     SetName(iface, name);
1642     SetIfDHCP(iface, dhcp);
1643     SetIP(iface, IP);
1644     SetMask(iface, mask);
1645     SetDevice(iface, device);
1646     SetUnit(iface, unit);
1647     SetUp(iface, up);
1648 }
1649
1650 void SetName(struct Interface *iface, STRPTR w)
1651 {
1652     if (!IsLegal(w, NAMECHARS))
1653     {
1654         w = DEFAULTNAME;
1655     }
1656     strlcpy(iface->name, w, NAMEBUFLEN);
1657 }
1658
1659 void SetIfDHCP(struct Interface *iface, BOOL w)
1660 {
1661     iface->ifDHCP = w;
1662 }
1663
1664 void SetIP(struct Interface *iface, STRPTR w)
1665 {
1666     if (!IsLegal(w, IPCHARS))
1667     {
1668         w = DEFAULTIP;
1669     }
1670     strlcpy(iface->IP, w, IPBUFLEN);
1671 }
1672
1673 void SetMask(struct Interface *iface, STRPTR  w)
1674 {
1675     if (!IsLegal(w, IPCHARS))
1676     {
1677         w = DEFAULTMASK;
1678     }
1679     strlcpy(iface->mask, w, IPBUFLEN);
1680 }
1681
1682 void SetDevice(struct Interface *iface, STRPTR w)
1683 {
1684     if (w == NULL || w[0] == '\0')
1685     {
1686         w = DEFAULTDEVICE;
1687     }
1688     strlcpy(iface->device, w, NAMEBUFLEN);
1689 }
1690
1691 void SetUnit(struct Interface *iface, LONG w)
1692 {
1693     iface->unit = w;
1694 }
1695
1696 void SetUp(struct Interface *iface, BOOL w)
1697 {
1698     iface->up = w;
1699 }
1700
1701 void SetGate(STRPTR  w)
1702 {
1703     if (!IsLegal(w, IPCHARS))
1704     {
1705         w = DEFAULTGATE;
1706     }
1707     strlcpy(prefs.gate, w, IPBUFLEN);
1708 }
1709
1710 void SetDNS(LONG m, STRPTR w)
1711 {
1712     if (!IsLegal(w, IPCHARS))
1713     {
1714         w = DEFAULTDNS;
1715     }
1716     strlcpy(prefs.DNS[m], w, IPBUFLEN);
1717 }
1718
1719 void SetHostname(STRPTR w)
1720 {
1721     if (!IsLegal(w, NAMECHARS))
1722     {
1723         w = DEFAULTHOST;
1724     }
1725     strlcpy(prefs.host, w, NAMEBUFLEN);
1726 }
1727
1728 void SetDomain(STRPTR w)
1729 {
1730     if (!IsLegal(w, NAMECHARS))
1731     {
1732         w = DEFAULTDOMAIN;
1733     }
1734     strlcpy(prefs.domain, w, NAMEBUFLEN);
1735 }
1736
1737 void SetInterfaceCount(LONG w)
1738 {
1739     prefs.interfacecount = w;
1740 }
1741
1742 void SetAutostart(BOOL w)
1743 {
1744     prefs.autostart = w;
1745 }
1746
1747 void SetDHCP(BOOL w)
1748 {
1749     prefs.DHCP = w;
1750 }
1751
1752 void InitHost(struct Host *host)
1753 {
1754     SetHostNames(host, "");
1755     SetHostAddress(host, "");
1756 }
1757
1758 void InitNetwork(struct Network *net)
1759 {
1760     SetNetworkName(net, "");
1761     SetKey(net, "", FALSE);
1762     SetEncType(net, 0);
1763     SetAdHoc(net, FALSE);
1764 }
1765
1766 void InitServer(struct Server *server, char *workgroup)
1767 {
1768     if ((workgroup == NULL) && ((workgroup = GetDomain()) == NULL))
1769         workgroup = "workgroup";
1770
1771     SetServerDevice(server, DEFAULTSERVERDEV);
1772     SetServerHost(server, "");
1773     SetServerGroup(server, workgroup);
1774     SetServerService(server, "share");
1775     SetServerUser(server, "guest");
1776     SetServerPass(server, "");
1777     SetServerActive(server, TRUE);
1778 }
1779
1780
1781 /* Getters */
1782
1783 struct Host *GetHost(LONG index)
1784 {
1785     return &prefs.hosts[index];
1786 }
1787
1788 STRPTR GetHostNames(struct Host *host)
1789 {
1790     return host->names;
1791 }
1792
1793 STRPTR GetHostAddress(struct Host *host)
1794 {
1795     return host->address;
1796 }
1797
1798 LONG GetHostCount(void)
1799 {
1800     return prefs.hostCount;
1801 }
1802
1803 struct Network *GetNetwork(LONG index)
1804 {
1805     return &prefs.networks[index];
1806 }
1807
1808 STRPTR GetNetworkName(struct Network *net)
1809 {
1810     return net->name;
1811 }
1812
1813 UWORD GetEncType(struct Network *net)
1814 {
1815     return net->encType;
1816 }
1817
1818 STRPTR GetKey(struct Network *net)
1819 {
1820     return net->key;
1821 }
1822
1823 BOOL GetHidden(struct Network *net)
1824 {
1825     return net->hidden;
1826 }
1827
1828 BOOL GetAdHoc(struct Network *net)
1829 {
1830     return net->adHoc;
1831 }
1832
1833 LONG GetNetworkCount(void)
1834 {
1835     return prefs.networkCount;
1836 }
1837
1838 STRPTR GetWirelessDevice(void)
1839 {
1840     return prefs.wirelessDevice;
1841 }
1842
1843 LONG GetWirelessUnit(void)
1844 {
1845     return prefs.wirelessUnit;
1846 }
1847
1848 BOOL GetMobile_Autostart(void)
1849 {
1850     return prefs.mobile.autostart;
1851 }
1852
1853 STRPTR GetMobile_atcommand(ULONG i)
1854 {
1855     if (i < MAXATCOMMANDS)
1856         return prefs.mobile.atcommand[i];
1857     else return "";
1858 }
1859
1860 LONG GetMobile_atcommandcount(void)
1861 {
1862     ULONG count=0;
1863     ULONG i;
1864     for (i = 0; i < MAXATCOMMANDS; i++)
1865     {
1866         if (prefs.mobile.atcommand[i][0] != 0) count++;
1867     }
1868     return count;
1869 }
1870
1871 STRPTR GetMobile_devicename(void)
1872 {
1873     return prefs.mobile.devicename;
1874 }
1875
1876 STRPTR GetMobile_username(void)
1877 {
1878     return prefs.mobile.username;
1879 }
1880
1881 STRPTR GetMobile_password(void)
1882 {
1883     return prefs.mobile.password;
1884 }
1885
1886 LONG GetMobile_unit(void)
1887 {
1888     return prefs.mobile.unit;
1889 }
1890
1891 LONG GetMobile_timeout(void)
1892 {
1893     return prefs.mobile.timeout;
1894 }
1895
1896 struct Server *GetServer(LONG index)
1897 {
1898     return &prefs.servers[index];
1899 }
1900
1901 STRPTR GetServerDevice(struct Server *server)
1902 {
1903     return server->device;
1904 }
1905
1906 STRPTR GetServerHost(struct Server *server)
1907 {
1908     return server->host;
1909 }
1910
1911 STRPTR GetServerService(struct Server *server)
1912 {
1913     return server->service;
1914 }
1915
1916 STRPTR GetServerUser(struct Server *server)
1917 {
1918     return server->user;
1919 }
1920
1921 STRPTR GetServerGroup(struct Server *server)
1922 {
1923     return server->group;
1924 }
1925
1926 STRPTR GetServerPass(struct Server *server)
1927 {
1928     return server->pass;
1929 }
1930
1931 BOOL GetServerActive(struct Server *server)
1932 {
1933     return server->active;
1934 }
1935
1936 LONG GetServerCount(void)
1937 {
1938     return prefs.serverCount;
1939 }
1940
1941 /* Setters */
1942
1943 void SetHost
1944 (
1945     struct Host *host, STRPTR name, STRPTR address
1946 )
1947 {
1948     SetHostNames(host, name);
1949     SetHostAddress(host, address);
1950 }
1951
1952 void SetHostNames(struct Host *host, STRPTR w)
1953 {
1954     strlcpy(host->names, w, NAMEBUFLEN);
1955 }
1956
1957 void AddHostName(struct Host *host, STRPTR w)
1958 {
1959     if (host->names[0] != '\0')
1960         strlcat(host->names, " ", NAMEBUFLEN);
1961     strlcat(host->names, w, NAMEBUFLEN);
1962 }
1963
1964 void SetHostAddress(struct Host *host, STRPTR w)
1965 {
1966     strlcpy(host->address, w, IPBUFLEN);
1967 }
1968
1969 void SetHostCount(LONG w)
1970 {
1971     prefs.hostCount = w;
1972 }
1973
1974 void SetNetwork
1975 (
1976     struct Network *net, STRPTR name, UWORD encType, STRPTR key,
1977     BOOL keyIsHex, BOOL hidden, BOOL adHoc
1978 )
1979 {
1980     SetNetworkName(net, name);
1981     SetEncType(net, encType);
1982     SetKey(net, key, keyIsHex);
1983     SetHidden(net, hidden);
1984     SetAdHoc(net, adHoc);
1985 }
1986
1987 void SetNetworkName(struct Network *net, STRPTR w)
1988 {
1989     strlcpy(net->name, w, SSIDBUFLEN);
1990 }
1991
1992 void SetEncType(struct Network *net, UWORD w)
1993 {
1994     net->encType = w;
1995 }
1996
1997 void SetKey(struct Network *net, STRPTR w, BOOL keyIsHex)
1998 {
1999     strlcpy(net->key, w, KEYBUFLEN);
2000     net->keyIsHex = keyIsHex;
2001 }
2002
2003 void SetHidden(struct Network *net, BOOL w)
2004 {
2005     net->hidden = w;
2006 }
2007
2008 void SetAdHoc(struct Network *net, BOOL w)
2009 {
2010     net->adHoc = w;
2011 }
2012
2013 void SetNetworkCount(LONG w)
2014 {
2015     prefs.networkCount = w;
2016 }
2017
2018 void SetWirelessDevice(STRPTR w)
2019 {
2020     prefs.wirelessDevice = w;
2021 }
2022
2023 void SetWirelessUnit(LONG w)
2024 {
2025     prefs.wirelessUnit = w;
2026 }
2027
2028 void SetMobile_Autostart(BOOL w)
2029 {
2030     prefs.mobile.autostart = w;
2031 }
2032
2033 void SetMobile_atcommand(ULONG i,STRPTR w)
2034 {
2035     if (strlen(w) < NAMEBUFLEN && i >= 0 && i < MAXATCOMMANDS)
2036         strcpy(prefs.mobile.atcommand[i], w);
2037 }
2038
2039 void SetMobile_devicename(STRPTR w)
2040 {
2041     if (strlen(w) < NAMEBUFLEN)
2042         strcpy(prefs.mobile.devicename, w);
2043 }
2044
2045 void SetMobile_username(STRPTR w)
2046 {
2047     if (strlen(w) < NAMEBUFLEN)
2048         strcpy(prefs.mobile.username, w);
2049 }
2050
2051 void SetMobile_password(STRPTR w)
2052 {
2053     if (strlen(w) < NAMEBUFLEN)
2054         strcpy(prefs.mobile.password, w);
2055 }
2056
2057 void SetMobile_unit(LONG w)
2058 {
2059     prefs.mobile.unit = w;
2060 }
2061
2062 void SetMobile_timeout(LONG w)
2063 {
2064     prefs.mobile.timeout = w;
2065 }
2066
2067 void SetServer
2068 (
2069     struct Server *server, STRPTR device, STRPTR host, STRPTR service,
2070     STRPTR user, STRPTR group, STRPTR pass, BOOL active
2071 )
2072 {
2073     SetServerDevice(server, device);
2074     SetServerHost(server, host);
2075     SetServerService(server, service);
2076     SetServerUser(server, user);
2077     SetServerGroup(server, group);
2078     SetServerPass(server, pass);
2079     SetServerActive(server, active);
2080 }
2081
2082 void SetServerDevice(struct Server *server, STRPTR w)
2083 {
2084     strlcpy(server->device, w, SMBBUFLEN);
2085 }
2086
2087 void SetServerHost(struct Server *server, STRPTR w)
2088 {
2089     strlcpy(server->host, w, NAMEBUFLEN);
2090 }
2091
2092 void SetServerService(struct Server *server, STRPTR w)
2093 {
2094     strlcpy(server->service, w, SMBBUFLEN);
2095 }
2096
2097 void SetServerUser(struct Server *server, STRPTR w)
2098 {
2099     strlcpy(server->user, w, SMBBUFLEN);
2100 }
2101
2102 void SetServerGroup(struct Server *server, STRPTR w)
2103 {
2104     strlcpy(server->group, w, SMBBUFLEN);
2105 }
2106
2107 void SetServerPass(struct Server *server, STRPTR w)
2108 {
2109     strlcpy(server->pass, w, SMBBUFLEN);
2110 }
2111
2112 void SetServerActive(struct Server *server, BOOL w)
2113 {
2114     server->active = w;
2115 }
2116
2117 void SetServerCount(LONG w)
2118 {
2119     prefs.serverCount = w;
2120 }
2121