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         STRPTR p;
1483         service = FilePart((STRPTR)control_args[ARG_SERVICE]);
1484         SetServerService(server, service);
1485         service--;
1486         *service = '\0';
1487         host = (STRPTR)control_args[ARG_SERVICE] + 2;
1488         SetServerHost(server, host);
1489
1490         p = (STRPTR)control_args[ARG_USERNAME];
1491         SetServerUser(server, (p != NULL ? p : (STRPTR)""));
1492         p = (STRPTR)control_args[ARG_WORKGROUP];
1493         SetServerGroup(server, (p != NULL ? p : (STRPTR)""));
1494         p = (STRPTR)control_args[ARG_PASSWORD];
1495         SetServerPass(server, (p != NULL ? p : (STRPTR)""));
1496     }
1497
1498     if (control_rdargs != NULL)
1499     {
1500         FreeArgs(control_rdargs);
1501         FreeDosObject(DOS_RDARGS, control_rdargs);
1502     }
1503
1504     if (mount_rdargs != NULL)
1505     {
1506         FreeArgs(mount_rdargs);
1507         FreeDosObject(DOS_RDARGS, mount_rdargs);
1508     }
1509
1510     return success;
1511 }
1512
1513
1514 void InitNetworkPrefs(CONST_STRPTR directory, BOOL use, BOOL save)
1515 {
1516     SetDefaultNetworkPrefsValues();
1517     SetDefaultWirelessPrefsValues();
1518     SetDefaultMobilePrefsValues();
1519
1520     ReadNetworkPrefs(directory);
1521     ReadWirelessPrefs(WIRELESS_PATH_ENV);
1522     ReadMobilePrefs(MOBILEBB_PATH_ENV);
1523     ReadServers();
1524
1525     if (save)
1526     {
1527         SaveNetworkPrefs();
1528         return; /* save equals to use */
1529     }
1530
1531     if (use)
1532     {
1533         UseNetworkPrefs();
1534     }
1535 }
1536
1537 // check if 'str' contains only characters from 'accept'
1538 BOOL IsLegal(STRPTR str, STRPTR accept)
1539 {
1540     int i, len;
1541
1542     if ((str == NULL) || (accept == NULL) || (str[0] == '\0'))
1543     {
1544         return FALSE;
1545     }
1546
1547     len = strlen(str);
1548     for (i = 0; i < len; i++)
1549     {
1550         if (strchr(accept, str[i]) == NULL)
1551         {
1552             return FALSE;
1553         }
1554     }
1555     return TRUE;
1556 }
1557
1558
1559 /* Getters */
1560
1561 struct Interface * GetInterface(LONG index)
1562 {
1563     return &prefs.interface[index];
1564 }
1565
1566 STRPTR GetName(struct Interface *iface)
1567 {
1568     return iface->name;
1569 }
1570
1571 BOOL GetIfDHCP(struct Interface *iface)
1572 {
1573     return iface->ifDHCP;
1574 }
1575
1576 STRPTR GetIP(struct Interface *iface)
1577 {
1578     return iface->IP;
1579 }
1580
1581 STRPTR GetMask(struct Interface *iface)
1582 {
1583     return iface->mask;
1584 }
1585
1586 STRPTR GetDevice(struct Interface *iface)
1587 {
1588     return iface->device;
1589 }
1590
1591 LONG GetUnit(struct Interface *iface)
1592 {
1593     return iface->unit;
1594 }
1595
1596 BOOL GetUp(struct Interface *iface)
1597 {
1598     return iface->up;
1599 }
1600
1601 STRPTR GetGate(void)
1602 {
1603     return prefs.gate;
1604 }
1605
1606 STRPTR GetDNS(LONG m)
1607 {
1608     return prefs.DNS[m];
1609 }
1610
1611 STRPTR GetHostname(void)
1612 {
1613     return prefs.host;
1614 }
1615
1616 STRPTR GetDomain(void)
1617 {
1618     return prefs.domain;
1619 }
1620
1621 LONG GetInterfaceCount(void)
1622 {
1623     return prefs.interfacecount;
1624 }
1625
1626 BOOL GetAutostart(void)
1627 {
1628     return prefs.autostart;
1629 }
1630
1631 BOOL GetDHCP(void)
1632 {
1633     return prefs.DHCP;
1634 }
1635
1636
1637 /* Setters */
1638
1639 void SetInterface
1640 (
1641     struct Interface *iface, STRPTR name, BOOL dhcp, STRPTR IP, STRPTR mask,
1642     STRPTR device, LONG unit, BOOL up
1643 )
1644 {
1645     SetName(iface, name);
1646     SetIfDHCP(iface, dhcp);
1647     SetIP(iface, IP);
1648     SetMask(iface, mask);
1649     SetDevice(iface, device);
1650     SetUnit(iface, unit);
1651     SetUp(iface, up);
1652 }
1653
1654 void SetName(struct Interface *iface, STRPTR w)
1655 {
1656     if (!IsLegal(w, NAMECHARS))
1657     {
1658         w = DEFAULTNAME;
1659     }
1660     strlcpy(iface->name, w, NAMEBUFLEN);
1661 }
1662
1663 void SetIfDHCP(struct Interface *iface, BOOL w)
1664 {
1665     iface->ifDHCP = w;
1666 }
1667
1668 void SetIP(struct Interface *iface, STRPTR w)
1669 {
1670     if (!IsLegal(w, IPCHARS))
1671     {
1672         w = DEFAULTIP;
1673     }
1674     strlcpy(iface->IP, w, IPBUFLEN);
1675 }
1676
1677 void SetMask(struct Interface *iface, STRPTR  w)
1678 {
1679     if (!IsLegal(w, IPCHARS))
1680     {
1681         w = DEFAULTMASK;
1682     }
1683     strlcpy(iface->mask, w, IPBUFLEN);
1684 }
1685
1686 void SetDevice(struct Interface *iface, STRPTR w)
1687 {
1688     if (w == NULL || w[0] == '\0')
1689     {
1690         w = DEFAULTDEVICE;
1691     }
1692     strlcpy(iface->device, w, NAMEBUFLEN);
1693 }
1694
1695 void SetUnit(struct Interface *iface, LONG w)
1696 {
1697     iface->unit = w;
1698 }
1699
1700 void SetUp(struct Interface *iface, BOOL w)
1701 {
1702     iface->up = w;
1703 }
1704
1705 void SetGate(STRPTR  w)
1706 {
1707     if (!IsLegal(w, IPCHARS))
1708     {
1709         w = DEFAULTGATE;
1710     }
1711     strlcpy(prefs.gate, w, IPBUFLEN);
1712 }
1713
1714 void SetDNS(LONG m, STRPTR w)
1715 {
1716     if (!IsLegal(w, IPCHARS))
1717     {
1718         w = DEFAULTDNS;
1719     }
1720     strlcpy(prefs.DNS[m], w, IPBUFLEN);
1721 }
1722
1723 void SetHostname(STRPTR w)
1724 {
1725     if (!IsLegal(w, NAMECHARS))
1726     {
1727         w = DEFAULTHOST;
1728     }
1729     strlcpy(prefs.host, w, NAMEBUFLEN);
1730 }
1731
1732 void SetDomain(STRPTR w)
1733 {
1734     if (!IsLegal(w, NAMECHARS))
1735     {
1736         w = DEFAULTDOMAIN;
1737     }
1738     strlcpy(prefs.domain, w, NAMEBUFLEN);
1739 }
1740
1741 void SetInterfaceCount(LONG w)
1742 {
1743     prefs.interfacecount = w;
1744 }
1745
1746 void SetAutostart(BOOL w)
1747 {
1748     prefs.autostart = w;
1749 }
1750
1751 void SetDHCP(BOOL w)
1752 {
1753     prefs.DHCP = w;
1754 }
1755
1756 void InitHost(struct Host *host)
1757 {
1758     SetHostNames(host, "");
1759     SetHostAddress(host, "");
1760 }
1761
1762 void InitNetwork(struct Network *net)
1763 {
1764     SetNetworkName(net, "");
1765     SetKey(net, "", FALSE);
1766     SetEncType(net, 0);
1767     SetAdHoc(net, FALSE);
1768 }
1769
1770 void InitServer(struct Server *server, char *workgroup)
1771 {
1772     if ((workgroup == NULL) && ((workgroup = GetDomain()) == NULL))
1773         workgroup = "workgroup";
1774
1775     SetServerDevice(server, DEFAULTSERVERDEV);
1776     SetServerHost(server, "");
1777     SetServerGroup(server, workgroup);
1778     SetServerService(server, "share");
1779     SetServerUser(server, "guest");
1780     SetServerPass(server, "");
1781     SetServerActive(server, TRUE);
1782 }
1783
1784
1785 /* Getters */
1786
1787 struct Host *GetHost(LONG index)
1788 {
1789     return &prefs.hosts[index];
1790 }
1791
1792 STRPTR GetHostNames(struct Host *host)
1793 {
1794     return host->names;
1795 }
1796
1797 STRPTR GetHostAddress(struct Host *host)
1798 {
1799     return host->address;
1800 }
1801
1802 LONG GetHostCount(void)
1803 {
1804     return prefs.hostCount;
1805 }
1806
1807 struct Network *GetNetwork(LONG index)
1808 {
1809     return &prefs.networks[index];
1810 }
1811
1812 STRPTR GetNetworkName(struct Network *net)
1813 {
1814     return net->name;
1815 }
1816
1817 UWORD GetEncType(struct Network *net)
1818 {
1819     return net->encType;
1820 }
1821
1822 STRPTR GetKey(struct Network *net)
1823 {
1824     return net->key;
1825 }
1826
1827 BOOL GetHidden(struct Network *net)
1828 {
1829     return net->hidden;
1830 }
1831
1832 BOOL GetAdHoc(struct Network *net)
1833 {
1834     return net->adHoc;
1835 }
1836
1837 LONG GetNetworkCount(void)
1838 {
1839     return prefs.networkCount;
1840 }
1841
1842 STRPTR GetWirelessDevice(void)
1843 {
1844     return prefs.wirelessDevice;
1845 }
1846
1847 LONG GetWirelessUnit(void)
1848 {
1849     return prefs.wirelessUnit;
1850 }
1851
1852 BOOL GetMobile_Autostart(void)
1853 {
1854     return prefs.mobile.autostart;
1855 }
1856
1857 STRPTR GetMobile_atcommand(ULONG i)
1858 {
1859     if (i < MAXATCOMMANDS)
1860         return prefs.mobile.atcommand[i];
1861     else return "";
1862 }
1863
1864 LONG GetMobile_atcommandcount(void)
1865 {
1866     ULONG count=0;
1867     ULONG i;
1868     for (i = 0; i < MAXATCOMMANDS; i++)
1869     {
1870         if (prefs.mobile.atcommand[i][0] != 0) count++;
1871     }
1872     return count;
1873 }
1874
1875 STRPTR GetMobile_devicename(void)
1876 {
1877     return prefs.mobile.devicename;
1878 }
1879
1880 STRPTR GetMobile_username(void)
1881 {
1882     return prefs.mobile.username;
1883 }
1884
1885 STRPTR GetMobile_password(void)
1886 {
1887     return prefs.mobile.password;
1888 }
1889
1890 LONG GetMobile_unit(void)
1891 {
1892     return prefs.mobile.unit;
1893 }
1894
1895 LONG GetMobile_timeout(void)
1896 {
1897     return prefs.mobile.timeout;
1898 }
1899
1900 struct Server *GetServer(LONG index)
1901 {
1902     return &prefs.servers[index];
1903 }
1904
1905 STRPTR GetServerDevice(struct Server *server)
1906 {
1907     return server->device;
1908 }
1909
1910 STRPTR GetServerHost(struct Server *server)
1911 {
1912     return server->host;
1913 }
1914
1915 STRPTR GetServerService(struct Server *server)
1916 {
1917     return server->service;
1918 }
1919
1920 STRPTR GetServerUser(struct Server *server)
1921 {
1922     return server->user;
1923 }
1924
1925 STRPTR GetServerGroup(struct Server *server)
1926 {
1927     return server->group;
1928 }
1929
1930 STRPTR GetServerPass(struct Server *server)
1931 {
1932     return server->pass;
1933 }
1934
1935 BOOL GetServerActive(struct Server *server)
1936 {
1937     return server->active;
1938 }
1939
1940 LONG GetServerCount(void)
1941 {
1942     return prefs.serverCount;
1943 }
1944
1945 /* Setters */
1946
1947 void SetHost
1948 (
1949     struct Host *host, STRPTR name, STRPTR address
1950 )
1951 {
1952     SetHostNames(host, name);
1953     SetHostAddress(host, address);
1954 }
1955
1956 void SetHostNames(struct Host *host, STRPTR w)
1957 {
1958     strlcpy(host->names, w, NAMEBUFLEN);
1959 }
1960
1961 void AddHostName(struct Host *host, STRPTR w)
1962 {
1963     if (host->names[0] != '\0')
1964         strlcat(host->names, " ", NAMEBUFLEN);
1965     strlcat(host->names, w, NAMEBUFLEN);
1966 }
1967
1968 void SetHostAddress(struct Host *host, STRPTR w)
1969 {
1970     strlcpy(host->address, w, IPBUFLEN);
1971 }
1972
1973 void SetHostCount(LONG w)
1974 {
1975     prefs.hostCount = w;
1976 }
1977
1978 void SetNetwork
1979 (
1980     struct Network *net, STRPTR name, UWORD encType, STRPTR key,
1981     BOOL keyIsHex, BOOL hidden, BOOL adHoc
1982 )
1983 {
1984     SetNetworkName(net, name);
1985     SetEncType(net, encType);
1986     SetKey(net, key, keyIsHex);
1987     SetHidden(net, hidden);
1988     SetAdHoc(net, adHoc);
1989 }
1990
1991 void SetNetworkName(struct Network *net, STRPTR w)
1992 {
1993     strlcpy(net->name, w, SSIDBUFLEN);
1994 }
1995
1996 void SetEncType(struct Network *net, UWORD w)
1997 {
1998     net->encType = w;
1999 }
2000
2001 void SetKey(struct Network *net, STRPTR w, BOOL keyIsHex)
2002 {
2003     strlcpy(net->key, w, KEYBUFLEN);
2004     net->keyIsHex = keyIsHex;
2005 }
2006
2007 void SetHidden(struct Network *net, BOOL w)
2008 {
2009     net->hidden = w;
2010 }
2011
2012 void SetAdHoc(struct Network *net, BOOL w)
2013 {
2014     net->adHoc = w;
2015 }
2016
2017 void SetNetworkCount(LONG w)
2018 {
2019     prefs.networkCount = w;
2020 }
2021
2022 void SetWirelessDevice(STRPTR w)
2023 {
2024     prefs.wirelessDevice = w;
2025 }
2026
2027 void SetWirelessUnit(LONG w)
2028 {
2029     prefs.wirelessUnit = w;
2030 }
2031
2032 void SetMobile_Autostart(BOOL w)
2033 {
2034     prefs.mobile.autostart = w;
2035 }
2036
2037 void SetMobile_atcommand(ULONG i,STRPTR w)
2038 {
2039     if (strlen(w) < NAMEBUFLEN && i >= 0 && i < MAXATCOMMANDS)
2040         strcpy(prefs.mobile.atcommand[i], w);
2041 }
2042
2043 void SetMobile_devicename(STRPTR w)
2044 {
2045     if (strlen(w) < NAMEBUFLEN)
2046         strcpy(prefs.mobile.devicename, w);
2047 }
2048
2049 void SetMobile_username(STRPTR w)
2050 {
2051     if (strlen(w) < NAMEBUFLEN)
2052         strcpy(prefs.mobile.username, w);
2053 }
2054
2055 void SetMobile_password(STRPTR w)
2056 {
2057     if (strlen(w) < NAMEBUFLEN)
2058         strcpy(prefs.mobile.password, w);
2059 }
2060
2061 void SetMobile_unit(LONG w)
2062 {
2063     prefs.mobile.unit = w;
2064 }
2065
2066 void SetMobile_timeout(LONG w)
2067 {
2068     prefs.mobile.timeout = w;
2069 }
2070
2071 void SetServer
2072 (
2073     struct Server *server, STRPTR device, STRPTR host, STRPTR service,
2074     STRPTR user, STRPTR group, STRPTR pass, BOOL active
2075 )
2076 {
2077     SetServerDevice(server, device);
2078     SetServerHost(server, host);
2079     SetServerService(server, service);
2080     SetServerUser(server, user);
2081     SetServerGroup(server, group);
2082     SetServerPass(server, pass);
2083     SetServerActive(server, active);
2084 }
2085
2086 void SetServerDevice(struct Server *server, STRPTR w)
2087 {
2088     strlcpy(server->device, w, SMBBUFLEN);
2089 }
2090
2091 void SetServerHost(struct Server *server, STRPTR w)
2092 {
2093     strlcpy(server->host, w, NAMEBUFLEN);
2094 }
2095
2096 void SetServerService(struct Server *server, STRPTR w)
2097 {
2098     strlcpy(server->service, w, SMBBUFLEN);
2099 }
2100
2101 void SetServerUser(struct Server *server, STRPTR w)
2102 {
2103     strlcpy(server->user, w, SMBBUFLEN);
2104 }
2105
2106 void SetServerGroup(struct Server *server, STRPTR w)
2107 {
2108     strlcpy(server->group, w, SMBBUFLEN);
2109 }
2110
2111 void SetServerPass(struct Server *server, STRPTR w)
2112 {
2113     strlcpy(server->pass, w, SMBBUFLEN);
2114 }
2115
2116 void SetServerActive(struct Server *server, BOOL w)
2117 {
2118     server->active = w;
2119 }
2120
2121 void SetServerCount(LONG w)
2122 {
2123     prefs.serverCount = w;
2124 }
2125