workbench/prefs/network/prefsdata.c

   1 /*
   2     Copyright © 2009, 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 static struct TCPPrefs prefs;
  14
  15 struct Tokenizer
  16 {
  17     STRPTR tokenizerLine;
  18     STRPTR token;
  19     FILE * tokenizedFile;
  20     BOOL newline;
  21     BOOL fend;
  22 };
  23
  24 void OpenTokenFile(struct Tokenizer * tok, STRPTR FileName)
  25 {
  26         tok->tokenizedFile = fopen(FileName, "r");
  27         tok->token = NULL;
  28         tok->newline = TRUE;
  29         if (!tok->tokenizedFile)
  30                 tok->fend = TRUE;
  31         else{
  32                 tok->tokenizerLine = malloc(8192);
  33                 tok->fend = FALSE;
  34                 tok->newline = TRUE;
  35         }
  36 }
  37
  38 void CloseTokenFile(struct Tokenizer * tok)
  39 {
  40         if (tok->tokenizedFile) {
  41                 fclose(tok->tokenizedFile);
  42                 free(tok->tokenizerLine);
  43                 tok->fend = TRUE;
  44                 tok->token = NULL;
  45         }
  46 }
  47
  48 void GetNextToken(struct Tokenizer * tok, STRPTR tk)
  49 {
  50         tok->newline = FALSE;
  51         if (tok->token != NULL) {
  52                 tok->token = strtok(NULL, tk);
  53                 if (!tok->token)
  54                         GetNextToken(tok, tk);
  55         }else {
  56                 tok->newline = TRUE;
  57                 if (!feof(tok->tokenizedFile)) {
  58                         tok->tokenizerLine[0] = 0;
  59                         fgets(tok->tokenizerLine, 8192, tok->tokenizedFile);
  60                         if (tok->tokenizerLine == NULL) {
  61                                 tok->token = NULL;
  62                                 GetNextToken(tok, tk);
  63                         }else
  64                                 tok->token = strtok(tok->tokenizerLine, tk);
  65                 }else
  66                         tok->fend = TRUE;
  67         }
  68 }
  69
  70 void SetDefaultNetworkPrefsValues()
  71 {
  72         SetIP("192.168.0.188");
  73         SetMask("255.255.255.0");
  74         SetGate("192.168.0.1");
  75         SetDNS(0, "192.168.0.1");
  76         SetDNS(1, "192.168.0.1");
  77         SetDevice("DEVS:networks/pcnet32.device");
  78         SetHost("arosbox");
  79         SetDomain("arosnet");
  80         SetDHCP(FALSE);
  81     SetAutostart(FALSE);
  82 }
  83
  84 /* Returns TRUE if directory has been created or already existed */
  85 BOOL RecursiveCreateDir(CONST_STRPTR dirpath)
  86 {
  87     /* Will create directory even if top level directory does not exist */
  88
  89     BPTR lock = NULL;
  90     ULONG lastdirseparator = 0;
  91     ULONG dirpathlen = strlen(dirpath);
  92     STRPTR tmpdirpath = AllocVec(dirpathlen + 2, MEMF_CLEAR | MEMF_PUBLIC);
  93
  94     CopyMem(dirpath, tmpdirpath, dirpathlen);
  95
  96     /* Recurvice directory creation */
  97     while(TRUE)
  98     {
  99         if (lastdirseparator >= dirpathlen) break;
 100
 101         for (; lastdirseparator < dirpathlen; lastdirseparator++)
 102             if (tmpdirpath[lastdirseparator] == '/') break;
 103
 104         tmpdirpath[lastdirseparator] = '\0'; /* cut */
 105
 106         /* Unlock any lock from previous interation. Last iteration lock will be returned. */
 107         if (lock != NULL)
 108         {
 109             UnLock(lock);
 110             lock = NULL;
 111         }
 112
 113         /* Check if directory exists */
 114         lock = Lock(tmpdirpath, SHARED_LOCK);
 115         if (lock == NULL)
 116         {
 117             lock = CreateDir(tmpdirpath);
 118             if (lock == NULL)
 119                 break; /* Error with creation */
 120         }
 121
 122         tmpdirpath[lastdirseparator] = '/'; /* restore */
 123         lastdirseparator++;
 124     }
 125
 126     FreeVec(tmpdirpath);
 127
 128     if (lock == NULL)
 129         return FALSE;
 130     else
 131     {
 132         UnLock(lock);
 133         lock = NULL;
 134         return TRUE;
 135     }
 136 }
 137
 138 /* Puts part 1 into empy buffer */
 139 VOID CombinePath1P(STRPTR dstbuffer, ULONG dstbufferlen, CONST_STRPTR part1)
 140 {
 141     dstbuffer[0] = '\0'; /* Make sure buffer is treated as empty */
 142     AddPart(dstbuffer, part1, dstbufferlen);
 143 }
 144
 145 /* Combines part1 with part2 into an empty buffer */
 146 VOID CombinePath2P(STRPTR dstbuffer, ULONG dstbufferlen, CONST_STRPTR part1, CONST_STRPTR part2)
 147 {
 148     CombinePath1P(dstbuffer, dstbufferlen, part1);
 149     AddPart(dstbuffer, part2, dstbufferlen);
 150 }
 151
 152 /* Combines part1 with part2 with part3 into an empty buffer */
 153 VOID CombinePath3P(STRPTR dstbuffer, ULONG dstbufferlen, CONST_STRPTR part1, CONST_STRPTR part2, CONST_STRPTR part3)
 154 {
 155     CombinePath2P(dstbuffer, dstbufferlen, part1, part2);
 156     AddPart(dstbuffer, part3, dstbufferlen);
 157 }
 158
 159 BOOL WriteNetworkPrefs(CONST_STRPTR  destdir)
 160 {
 161     FILE *ConfFile;
 162     ULONG filenamelen = strlen(destdir) + 4 + 20;
 163     TEXT filename[filenamelen];
 164     ULONG destdbdirlen = strlen(destdir) + 3 + 1;
 165     TEXT destdbdir[destdbdirlen];
 166
 167     CombinePath2P(destdbdir, destdbdirlen, destdir, "db");
 168
 169     /* Create necessary directories */
 170     if(!RecursiveCreateDir(destdir)) return FALSE;
 171     if(!RecursiveCreateDir(destdbdir)) return FALSE;
 172
 173     /* Write variables */
 174     CombinePath2P(filename, filenamelen, destdir, "Config");
 175     ConfFile = fopen(filename, "w");
 176     if (!ConfFile) return FALSE;
 177     fprintf(ConfFile, "%s/db", PREFS_PATH_ENV);
 178     fclose(ConfFile);
 179
 180     CombinePath2P(filename, filenamelen, destdir, "AutoRun");
 181     ConfFile = fopen(filename, "w");
 182     if (!ConfFile) return FALSE;
 183     fprintf(ConfFile, "%s", (GetAutostart()) ? "True" : "False");
 184     fclose(ConfFile);
 185
 186     /* Write configuration files */
 187     CombinePath2P(filename, filenamelen, destdbdir, "general.config");
 188     ConfFile = fopen(filename, "w");
 189     if (!ConfFile) return FALSE;
 190     fprintf(ConfFile, "USELOOPBACK=YES\n");
 191     fprintf(ConfFile, "DEBUGSANA=NO\n");
 192     fprintf(ConfFile, "USENS=SECOND\n");
 193     fprintf(ConfFile, "GATEWAY=NO\n");
 194     fprintf(ConfFile, "HOSTNAME=%s.%s\n", GetHost(), GetDomain());
 195     fprintf(ConfFile, "LOG FILTERFILE=5\n");
 196     fprintf(ConfFile, "GUI PANEL=MUI\n");
 197     fprintf(ConfFile, "OPENGUI=YES\n");
 198     fclose(ConfFile);
 199
 200     CombinePath2P(filename, filenamelen, destdbdir, "interfaces");
 201     ConfFile = fopen(filename, "w");
 202     if (!ConfFile) return FALSE;
 203     fprintf(ConfFile,"eth0 DEV=%s UNIT=0 NOTRACKING IP=%s NETMASK=%s UP\n", GetDevice(),
 204         (GetDHCP() ? (CONST_STRPTR)"DHCP" : GetIP()), GetMask());
 205
 206     fclose(ConfFile);
 207
 208     CombinePath2P(filename, filenamelen, destdbdir, "netdb-myhost");
 209     ConfFile = fopen(filename, "w");
 210     if (!ConfFile) return FALSE;
 211     fprintf(ConfFile, "HOST %s %s.%s %s\n", GetIP(), GetHost(), GetDomain(), GetHost());
 212     fprintf(ConfFile, "HOST %s gateway\n", GetGate());
 213     fprintf(ConfFile, "; Domain names\n");
 214     fprintf(ConfFile, "; Name servers\n");
 215     fprintf(ConfFile, "NAMESERVER %s\n", GetDNS(0));
 216     fprintf(ConfFile, "NAMESERVER %s\n", GetDNS(1));
 217     fclose(ConfFile);
 218
 219     CombinePath2P(filename, filenamelen, destdbdir, "static-routes");
 220     ConfFile = fopen(filename, "w");
 221     if (!ConfFile) return FALSE;
 222     fprintf(ConfFile, "DEFAULT GATEWAY %s\n", GetGate());
 223     fclose(ConfFile);
 224
 225     return TRUE;
 226 }
 227
 228 #define BUFSIZE 2048
 229 BOOL CopyFile(CONST_STRPTR srcfile, CONST_STRPTR dstfile)
 230 {
 231     BPTR from = NULL, to = NULL;
 232     TEXT buffer[BUFSIZE];
 233
 234     if((from = Open(srcfile, MODE_OLDFILE)))
 235     {
 236         if((to = Open(dstfile, MODE_NEWFILE)))
 237         {
 238             LONG        s=0;
 239
 240             do
 241             {
 242                     if ((s = Read(from, buffer, BUFSIZE)) == -1)
 243                     {
 244                             Close(to);
 245                             Close(from);
 246                     return FALSE;
 247                     }
 248
 249                     if (Write(to, buffer, s) == -1)
 250                     {
 251                             Close(to);
 252                             Close(from);
 253                     return FALSE;
 254                     }
 255             } while (s == BUFSIZE);
 256
 257             Close(to);
 258             Close(from);
 259             return TRUE;
 260         }
 261
 262         Close(from);
 263     }
 264
 265     return FALSE;
 266 }
 267
 268 CONST_STRPTR GetDefaultStackLocation()
 269 {
 270     /* Use static variable so that it is initialized only once (and can be returned) */
 271     static TEXT path [1024] = {0};
 272
 273     /* Load path if needed - this will happen only once */
 274     if (path[0] == '\0')
 275     {
 276         GetVar(AROSTCP_PACKAGE_VARIABLE, path, 1024, LV_VAR);
 277     }
 278
 279     return path;
 280 }
 281
 282 BOOL IsStackRunning()
 283 {
 284     struct Library * socketlib = NULL;
 285
 286     if ((socketlib = OpenLibrary("bsdsocket.library", 0L)) != NULL)
 287     {
 288         CloseLibrary(socketlib);
 289         return TRUE;
 290     }
 291
 292     return FALSE;
 293 }
 294
 295 BOOL RestartStack()
 296 {
 297     ULONG trycount = 0;
 298
 299
 300     /* Shutdown */
 301     if (IsStackRunning())
 302     {
 303         struct Task * arostcptask = FindTask("bsdsocket.library");
 304         if (arostcptask != NULL)
 305             Signal(arostcptask, SIGBREAKF_CTRL_C);
 306     }
 307
 308     /* Check if shutdown successfull */
 309     trycount = 0;
 310     while(IsStackRunning())
 311     {
 312         if (trycount > 4) return FALSE;
 313         Delay(50);
 314         trycount++;
 315     }
 316
 317     /* Startup */
 318     {
 319         CONST_STRPTR srcdir = GetDefaultStackLocation();
 320         ULONG arostcppathlen = strlen(srcdir) + 3 + 20;
 321         TEXT arostcppath[arostcppathlen];
 322         struct TagItem tags[] =
 323         {
 324             { SYS_Input,        (IPTR)NULL          },
 325             { SYS_Output,       (IPTR)NULL          },
 326             { SYS_Error,        (IPTR)NULL          },
 327             { SYS_Asynch,       (IPTR)TRUE          },
 328             { TAG_DONE,         0                   }
 329         };
 330
 331         CombinePath3P(arostcppath, arostcppathlen, srcdir, "C", "AROSTCP");
 332
 333         SystemTagList(arostcppath, tags);
 334     }
 335
 336
 337     /* Check if startup successfull */
 338     trycount = 0;
 339     while(!IsStackRunning())
 340     {
 341         if (trycount > 9) return FALSE;
 342         Delay(50);
 343         trycount++;
 344     }
 345
 346     /* All ok */
 347     return TRUE;
 348 }
 349
 350 /* This is not a general use function! It assumes destinations directory exists */
 351 BOOL AddFileFromDefaultStackLocation(CONST_STRPTR filename, CONST_STRPTR dstdir)
 352 {
 353     /* Build paths */
 354     CONST_STRPTR srcdir = GetDefaultStackLocation();
 355     ULONG srcfilelen = strlen(srcdir) + 4 + strlen(filename) + 1;
 356     TEXT srcfile[srcfilelen];
 357     ULONG dstfilelen = strlen(dstdir) + 4 + strlen(filename) + 1;
 358     TEXT dstfile[dstfilelen];
 359     BPTR dstlock = NULL;
 360
 361     CombinePath3P(srcfile, srcfilelen, srcdir, "db", filename);
 362     CombinePath3P(dstfile, dstfilelen, dstdir, "db", filename);
 363
 364     /* Check if the destination file already exists. If yes, do not copy */
 365     dstlock = Lock(dstfile, SHARED_LOCK);
 366     if (dstlock != NULL)
 367     {
 368         UnLock(dstlock);
 369         return TRUE;
 370     }
 371
 372     return CopyFile(srcfile, dstfile);
 373 }
 374
 375 /* Copies files not created by prefs but needed to start stack */
 376 BOOL CopyDefaultConfiguration(CONST_STRPTR destdir)
 377 {
 378     ULONG destdbdirlen = strlen(destdir) + 3 + 1;
 379     TEXT destdbdir[destdbdirlen];
 380     CombinePath2P(destdbdir, destdbdirlen, destdir, "db");
 381
 382     /* Create necessary directories */
 383     if (!RecursiveCreateDir(destdir)) return FALSE;
 384     if (!RecursiveCreateDir(destdbdir)) return FALSE;
 385
 386     /* Copy files */
 387     if (!AddFileFromDefaultStackLocation("hosts", destdir)) return FALSE;
 388     if (!AddFileFromDefaultStackLocation("inet.access", destdir)) return FALSE;
 389     if (!AddFileFromDefaultStackLocation("netdb", destdir)) return FALSE;
 390     if (!AddFileFromDefaultStackLocation("networks", destdir)) return FALSE;
 391     if (!AddFileFromDefaultStackLocation("protocols", destdir)) return FALSE;
 392     if (!AddFileFromDefaultStackLocation("services", destdir)) return FALSE;
 393
 394     return TRUE;
 395 }
 396
 397 enum ErrorCode SaveNetworkPrefs()
 398 {
 399     if (!CopyDefaultConfiguration(PREFS_PATH_ENVARC)) return NOT_COPIED_FILES_ENVARC;
 400     if (!WriteNetworkPrefs(PREFS_PATH_ENVARC)) return NOT_SAVED_PREFS_ENVARC;
 401     return UseNetworkPrefs();
 402 }
 403
 404 enum ErrorCode UseNetworkPrefs()
 405 {
 406     if (!CopyDefaultConfiguration(PREFS_PATH_ENV)) return NOT_COPIED_FILES_ENV;
 407     if (!WriteNetworkPrefs(PREFS_PATH_ENV)) return NOT_SAVED_PREFS_ENV;
 408     if (!RestartStack()) return NOT_RESTARTED_STACK;
 409     return ALL_OK;
 410 }
 411
 412 /* Directory points to top of config, so to AAA/AROSTCP not to AAA/AROSTCP/db */
 413 void ReadNetworkPrefs(CONST_STRPTR directory)
 414 {
 415     ULONG filenamelen = strlen(directory) + 4 + 20;
 416     TEXT filename[filenamelen];
 417     BOOL comment = FALSE;
 418     STRPTR tstring;
 419     struct Tokenizer tok;
 420
 421     /* This function will not fail. It will load as much data as possible. Rest will be defaul values */
 422
 423     CombinePath3P(filename, filenamelen, directory, "db", "general.config");
 424     OpenTokenFile(&tok, filename);
 425     while (!tok.fend) {
 426             if (tok.newline) { // read tokens from the beginning of line
 427                     if (tok.token) {
 428                             if (strcmp(tok.token, "HOSTNAME") == 0) {
 429                                     GetNextToken(&tok, "=\n");
 430                                     tstring = strchr(tok.token, '.');
 431                     SetDomain(tstring + 1);
 432                                     tstring[0] = 0;
 433                     SetHost(tok.token);
 434                             }
 435                     }
 436             }
 437             GetNextToken(&tok, "=\n");
 438     }
 439     CloseTokenFile(&tok);
 440
 441     CombinePath3P(filename, filenamelen, directory, "db", "interfaces");
 442     OpenTokenFile(&tok, filename);
 443     /* Reads only first uncommented interface */
 444     while (!tok.fend) {
 445             GetNextToken(&tok, " \n");
 446             if (tok.token) {
 447                     if (tok.newline) comment = FALSE;
 448                     if (strncmp(tok.token, "#", 1) == 0) comment = TRUE;
 449
 450                     if (!comment) {
 451                             if (strncmp(tok.token, "DEV=", 4) == 0) {
 452                                     tstring = strchr(tok.token, '=');
 453                     SetDevice(tstring + 1);
 454                             }
 455                             if (strncmp(tok.token, "IP=", 3) == 0) {
 456                                     tstring = strchr(tok.token, '=');
 457                     if (strncmp(tstring + 1, "DHCP", 4) == 0)
 458                     {
 459                         SetDHCP(TRUE);
 460                         SetIP("192.168.0.188");
 461                     }
 462                     else
 463                     {
 464                         SetIP(tstring + 1);
 465                         SetDHCP(FALSE);
 466                     }
 467                             }
 468                             if (strncmp(tok.token, "NETMASK=", 8) == 0) {
 469                                     tstring = strchr(tok.token, '=');
 470                     SetMask(tstring + 1);
 471                             }
 472                     }
 473             }
 474     }
 475     CloseTokenFile(&tok);
 476
 477     CombinePath3P(filename, filenamelen, directory, "db", "netdb-myhost");
 478     OpenTokenFile(&tok, filename);
 479     int dnsc = 0;
 480     while (!tok.fend) {
 481             GetNextToken(&tok, " \n");
 482             if (tok.token) {
 483                     if (strncmp(tok.token, "NAMESERVER", 4) == 0) {
 484                             GetNextToken(&tok, " \n");
 485                 SetDNS(dnsc, tok.token);
 486                             dnsc++;
 487                             if (dnsc > 1) dnsc = 1;
 488                     }
 489             }
 490     }
 491     CloseTokenFile(&tok);
 492
 493     CombinePath3P(filename, filenamelen, directory, "db", "static-routes");
 494     OpenTokenFile(&tok, filename);
 495     while (!tok.fend) {
 496             GetNextToken(&tok, " \n");
 497             if (tok.token) {
 498                     if (strncmp(tok.token, "DEFAULT", 4) == 0) {
 499                             GetNextToken(&tok, " \n");
 500                             if (strncmp(tok.token, "GATEWAY", 4) == 0) {
 501                                     GetNextToken(&tok, " \n");
 502                     SetGate(tok.token);
 503                             }
 504                     }
 505             }
 506     }
 507     CloseTokenFile(&tok);
 508
 509     CombinePath2P(filename, filenamelen, directory, "Autorun");
 510     OpenTokenFile(&tok, filename);
 511     while (!tok.fend)
 512     {
 513         GetNextToken(&tok, " \n");
 514         if (tok.token)
 515         {
 516             if (strncmp(tok.token, "True", 4) == 0)
 517             {
 518                 SetAutostart(TRUE);
 519                 break;
 520             }
 521             else
 522             {
 523                 SetAutostart(FALSE);
 524                 break;
 525             }
 526         }
 527     }
 528     CloseTokenFile(&tok);
 529 }
 530
 531 void InitNetworkPrefs(CONST_STRPTR directory, BOOL use, BOOL save)
 532 {
 533     SetDefaultNetworkPrefsValues();
 534
 535     ReadNetworkPrefs(directory);
 536
 537     if (save)
 538     {
 539         SaveNetworkPrefs();
 540         return; /* save equals to use */
 541     }
 542
 543     if (use)
 544     {
 545         UseNetworkPrefs();
 546     }
 547 }
 548
 549 /* Getters */
 550
 551 STRPTR GetIP()
 552 {
 553         return prefs.IP;
 554 }
 555
 556 STRPTR GetMask()
 557 {
 558         return prefs.mask;
 559 }
 560
 561 STRPTR GetGate()
 562 {
 563         return prefs.gate;
 564 }
 565
 566 STRPTR GetDNS(LONG m)
 567 {
 568         return prefs.DNS[m];
 569 }
 570
 571 BOOL GetDHCP()
 572 {
 573         return prefs.DHCP;
 574 }
 575
 576 STRPTR GetDevice()
 577 {
 578         return prefs.device;
 579 }
 580
 581 STRPTR GetHost()
 582 {
 583         return prefs.host;
 584 }
 585
 586 STRPTR GetDomain()
 587 {
 588         return prefs.domain;
 589 }
 590
 591 BOOL GetAutostart()
 592 {
 593     return prefs.autostart;
 594 }
 595
 596 void SetIP(STRPTR w)
 597 {
 598         strlcpy(prefs.IP, w,63);
 599 }
 600
 601 /* Setters */
 602
 603 void SetMask(STRPTR  w)
 604 {
 605         strlcpy(prefs.mask, w,63);
 606 }
 607
 608 void SetGate(STRPTR  w)
 609 {
 610         strlcpy(prefs.gate, w,63);
 611 }
 612
 613 void SetDNS(LONG m, STRPTR w)
 614 {
 615         strlcpy(prefs.DNS[m], w,63);
 616 }
 617
 618 void SetDHCP(BOOL w)
 619 {
 620         prefs.DHCP = w;
 621 }
 622
 623 void SetDevice(STRPTR w)
 624 {
 625         strlcpy(prefs.device, w,511);
 626 }
 627
 628 void SetHost(STRPTR w)
 629 {
 630         strlcpy(prefs.host, w,511);
 631 }
 632
 633 void SetDomain(STRPTR w)
 634 {
 635         strlcpy(prefs.domain, w,511);
 636 }
 637 void SetAutostart(BOOL w)
 638 {
 639     prefs.autostart = w;
 640 }
 641