src/WINNT/afsd/cm_config.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afs/param.h>
  11 #include <afs/stds.h>
  12
  13 #ifndef DJGPP
  14 #include <windows.h>
  15 #include <winsock2.h>
  16 #else
  17 #include <sys/socket.h>
  18 #include <netdb.h>
  19 #endif /* !DJGPP */
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23
  24 #include "cm_config.h"
  25 #ifdef AFS_AFSDB_ENV
  26 #include "cm_dns.h"
  27 #include <afs/afsint.h>
  28 #endif
  29
  30 char AFSConfigKeyName[] =
  31         "SYSTEM\\CurrentControlSet\\Services\\TransarcAFSDaemon\\Parameters";
  32
  33 #define AFS_THISCELL "ThisCell"
  34 #define AFS_CELLSERVDB_UNIX "CellServDB"
  35 #define AFS_CELLSERVDB_NT "afsdcell.ini"
  36 #define AFSDIR_CLIENT_ETC_DIRPATH "c:/afs"
  37 #if defined(DJGPP) || defined(AFS_WIN95_ENV)
  38 #define AFS_CELLSERVDB AFS_CELLSERVDB_UNIX
  39 #ifdef DJGPP
  40 extern char cm_confDir[];
  41 extern int errno;
  42 #endif /* DJGPP */
  43 #else
  44 #define AFS_CELLSERVDB AFS_CELLSERVDB_NT
  45 #endif /* DJGPP || WIN95 */
  46
  47
  48 static long cm_ParsePair(char *lineBufferp, char *leftp, char *rightp)
  49 {
  50         char *tp;
  51         char tc;
  52         int sawEquals;
  53         int sawBracket;
  54
  55         sawEquals = 0;
  56         sawBracket = 0;
  57         for(tp = lineBufferp; *tp; tp++) {
  58                 tc = *tp;
  59
  60                 if (sawBracket) {
  61                         if (tc == ']')
  62                                 sawBracket = 0;
  63                         continue;
  64                 }
  65
  66                 /* comment or line end */
  67                 if (tc == '#' || tc == '\r' || tc == '\n') break;
  68
  69                 /* square bracket comment -- look for closing delim
  70                 if (tc == '[') {sawBracket = 1; continue;}
  71
  72                 /* space or tab */
  73                 if (tc == ' ' || tc == '\t') continue;
  74
  75                 if (tc == '=') {
  76                         sawEquals = 1;
  77                         continue;
  78                 }
  79
  80                 /* now we have a real character, put it in the appropriate bucket */
  81                 if (sawEquals == 0) {
  82                         *leftp++ = tc;
  83                 }
  84                 else {
  85                         *rightp++ = tc;
  86                 }
  87         }
  88
  89         /* null terminate the strings */
  90         *leftp = 0;
  91         *rightp = 0;
  92
  93         return 0;       /* and return success */
  94 }
  95
  96 /* search for a cell, and either return an error code if we don't find it,
  97  * or return 0 if we do, in which case we also fill in the addresses in
  98  * the cellp field.
  99  *
 100  * new feature:  we can handle abbreviations and are insensitive to case.
 101  * If the caller wants the "real" cell name, it puts a non-null pointer in
 102  * newCellNamep.  Anomaly:  if cellNamep is ambiguous, we may modify
 103  * newCellNamep but return an error code.
 104  */
 105 long cm_SearchCellFile(char *cellNamep, char *newCellNamep,
 106         cm_configProc_t *procp, void *rockp)
 107 {
 108         char wdir[256];
 109         int tlen;
 110         FILE *tfilep, *bestp, *tempp;
 111         char *tp;
 112         char lineBuffer[256];
 113         struct hostent *thp;
 114         char *valuep;
 115         struct sockaddr_in vlSockAddr;
 116         int inRightCell;
 117         int foundCell;
 118         long code;
 119         int tracking = 1, partial = 0;
 120 #if defined(DJGPP) || defined(AFS_WIN95_ENV)
 121         long ip_addr;
 122         int c1, c2, c3, c4;
 123         char aname[256];
 124 #endif
 125         char *afsconf_path;
 126
 127         foundCell = 0;
 128
 129 #if !defined(DJGPP)
 130         code = GetWindowsDirectory(wdir, sizeof(wdir));
 131         if (code == 0 || code > sizeof(wdir)) return -1;
 132
 133         /* add trailing backslash, if required */
 134         tlen = strlen(wdir);
 135         if (wdir[tlen-1] != '\\') strcat(wdir, "\\");
 136 #else
 137         strcpy(wdir, cm_confDir);
 138         strcat(wdir,"/");
 139 #endif /* !DJGPP */
 140
 141         strcat(wdir, AFS_CELLSERVDB);
 142
 143         tfilep = fopen(wdir, "r");
 144
 145         if (!tfilep) {
 146           /* If we are using DJGPP client, cellservdb will be in afsconf dir. */
 147           /* If we are in Win95 here, we are linking with klog etc. and are
 148              using DJGPP client even though DJGPP is not defined.  So we still
 149              need to check AFSCONF for location. */
 150             afsconf_path = getenv("AFSCONF");
 151             if (!afsconf_path)
 152                strcpy(wdir, AFSDIR_CLIENT_ETC_DIRPATH);
 153             else
 154                strcpy(wdir, afsconf_path);
 155             strcat(wdir, "/");
 156             strcat(wdir, AFS_CELLSERVDB_UNIX);
 157             /*fprintf(stderr, "opening cellservdb file %s\n", wdir);*/
 158             tfilep = fopen(wdir, "r");
 159             if (!tfilep) return -2;
 160         }
 161
 162         bestp = fopen(wdir, "r");
 163
 164         /* have we seen the cell line for the guy we're looking for? */
 165         inRightCell = 0;
 166         while (1) {
 167                 tp = fgets(lineBuffer, sizeof(lineBuffer), tfilep);
 168                 if (tracking)
 169                         (void) fgets(lineBuffer, sizeof(lineBuffer), bestp);
 170                 if (tp == NULL) {
 171                         if (feof(tfilep)) {
 172                                 /* hit EOF */
 173                                 if (partial) {
 174                                         /*
 175                                          * found partial match earlier;
 176                                          * now go back to it
 177                                          */
 178                                         tempp = bestp;
 179                                         bestp = tfilep;
 180                                         tfilep = tempp;
 181                                         inRightCell = 1;
 182                                         partial = 0;
 183                                         continue;
 184                                 }
 185                                 else {
 186                                         fclose(tfilep);
 187                                         fclose(bestp);
 188                                         return (foundCell? 0 : -3);
 189                                 }
 190                         }
 191                 }
 192
 193                 /* turn trailing cr or lf into null */
 194                 tp = strchr(lineBuffer, '\r');
 195                 if (tp) *tp = 0;
 196                 tp = strchr(lineBuffer, '\n');
 197                 if (tp) *tp = 0;
 198
 199                 /* skip blank lines */
 200                 if (lineBuffer[0] == 0) continue;
 201
 202                 if (lineBuffer[0] == '>') {
 203                         /* trim off at white space or '#' chars */
 204                         tp = strchr(lineBuffer, ' ');
 205                         if (tp) *tp = 0;
 206                         tp = strchr(lineBuffer, '\t');
 207                         if (tp) *tp = 0;
 208                         tp = strchr(lineBuffer, '#');
 209                         if (tp) *tp = 0;
 210
 211                         /* now see if this is the right cell */
 212                         if (stricmp(lineBuffer+1, cellNamep) == 0) {
 213                                 /* found the cell we're looking for */
 214                                 if (newCellNamep)
 215                                         strcpy(newCellNamep, lineBuffer+1);
 216                                 inRightCell = 1;
 217                                 tracking = 0;
 218                         }
 219                         else if (strnicmp(lineBuffer+1, cellNamep,
 220                                           strlen(cellNamep)) == 0) {
 221                                 /* partial match */
 222                                 if (partial) {  /* ambiguous */
 223                                         fclose(tfilep);
 224                                         fclose(bestp);
 225                                         return -5;
 226                                 }
 227                                 if (newCellNamep)
 228                                         strcpy(newCellNamep, lineBuffer+1);
 229                                 inRightCell = 0;
 230                                 tracking = 0;
 231                                 partial = 1;
 232                         }
 233                         else inRightCell = 0;
 234                 }
 235                 else {
 236 #if !defined(DJGPP) && !defined(AFS_WIN95_ENV)
 237                         valuep = strchr(lineBuffer, '#');
 238                         if (valuep == NULL) {
 239                                 fclose(tfilep);
 240                                 fclose(bestp);
 241                                 return -4;
 242                         }
 243                         valuep++;       /* skip the "#" */
 244
 245                         valuep += strspn(valuep, " \t"); /* skip SP & TAB */
 246                         /* strip spaces and tabs in the end. They should not be there according to CellServDB format
 247                         so do this just in case                        */
 248                         while (valuep[strlen(valuep) - 1] == ' ' || valuep[strlen(valuep) - 1] == '\t') valuep[strlen(valuep) - 1] = '\0';
 249
 250 #endif /* !DJGPP */
 251                         if (inRightCell) {
 252 #if !defined(DJGPP) && !defined(AFS_WIN95_ENV)
 253                                 /* add the server to the VLDB list */
 254                                 thp = gethostbyname(valuep);
 255                                 if (thp) {
 256                                         memcpy(&vlSockAddr.sin_addr.s_addr, thp->h_addr,
 257                                                 sizeof(long));
 258                                         vlSockAddr.sin_family = AF_INET;
 259                                         /* sin_port supplied by connection code */
 260                                         if (procp)
 261                                                 (*procp)(rockp, &vlSockAddr, valuep);
 262                                         foundCell = 1;
 263                                 }
 264 #else
 265                                 /* For DJGPP, we will read IP address instead
 266                                    of name/comment field */
 267                                 code = sscanf(lineBuffer, "%d.%d.%d.%d #%s",
 268                                               &c1, &c2, &c3, &c4, aname);
 269                                 tp = (char *) &ip_addr;
 270                                 *tp++ = c1;
 271                                 *tp++ = c2;
 272                                 *tp++ = c3;
 273                                 *tp++ = c4;
 274                                 memcpy(&vlSockAddr.sin_addr.s_addr, &ip_addr,
 275                                                 sizeof(long));
 276                                 vlSockAddr.sin_family = AF_INET;
 277                                 /* sin_port supplied by connection code */
 278                                 if (procp)
 279                                   (*procp)(rockp, &vlSockAddr, valuep);
 280                                 foundCell = 1;
 281 #endif /* !DJGPP */
 282                         }
 283                 }       /* a vldb line */
 284         }               /* while loop processing all lines */
 285 }
 286
 287 long cm_SearchCellByDNS(char *cellNamep, char *newCellNamep, int *ttl,
 288                cm_configProc_t *procp, void *rockp)
 289 {
 290 #ifdef AFS_AFSDB_ENV
 291      int rc;
 292      int cellHosts[AFSMAXCELLHOSTS];
 293      int numServers;
 294      int i;
 295      struct sockaddr_in vlSockAddr;
 296
 297      rc = getAFSServer(cellNamep, cellHosts, &numServers, ttl);
 298      if (rc == 0 && numServers > 0) {     /* found the cell */
 299        for (i = 0; i < numServers; i++) {
 300            memcpy(&vlSockAddr.sin_addr.s_addr, &cellHosts[i],
 301                sizeof(long));
 302            vlSockAddr.sin_family = AF_INET;
 303            /* sin_port supplied by connection code */
 304            if (procp)
 305           (*procp)(rockp, &vlSockAddr, NULL);
 306            if(newCellNamep)
 307           strcpy(newCellNamep,cellNamep);
 308        }
 309        return 0;   /* found cell */
 310      }
 311      else
 312 #endif /* AFS_AFSDB_ENV */
 313        return -1;  /* not found */
 314 }
 315
 316 #if !defined(DJGPP) && !defined(AFS_WIN95_ENV)
 317 /* look up the root cell's name in the Registry */
 318 long cm_GetRootCellName(char *cellNamep)
 319 {
 320         DWORD code, dummyLen;
 321         HKEY parmKey;
 322
 323         code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSConfigKeyName,
 324                                 0, KEY_QUERY_VALUE, &parmKey);
 325         if (code != ERROR_SUCCESS)
 326                 return -1;
 327
 328         dummyLen = 256;
 329         code = RegQueryValueEx(parmKey, "Cell", NULL, NULL,
 330                                 cellNamep, &dummyLen);
 331         RegCloseKey (parmKey);
 332         if (code != ERROR_SUCCESS)
 333                 return -1;
 334
 335         return 0;
 336 }
 337 #else
 338 /* look up the root cell's name in the THISCELL file */
 339 long cm_GetRootCellName(char *cellNamep)
 340 {
 341         FILE *thisCell;
 342         char thisCellPath[256];
 343         char *afsconf_path;
 344         char *newline;
 345
 346 #ifdef DJGPP
 347         strcpy(thisCellPath, cm_confDir);
 348 #else
 349         /* Win 95 */
 350         afsconf_path = getenv("AFSCONF");
 351         if (!afsconf_path)
 352           strcpy(thisCellPath, AFSDIR_CLIENT_ETC_DIRPATH);
 353         else
 354           strcpy(thisCellPath, afsconf_path);
 355 #endif
 356         strcat(thisCellPath,"/");
 357
 358         strcat(thisCellPath, AFS_THISCELL);
 359         thisCell = fopen(thisCellPath, "r");
 360         if (thisCell == NULL)
 361           return -1;
 362
 363         fgets(cellNamep, 256, thisCell);
 364         fclose(thisCell);
 365
 366         newline = strrchr(cellNamep,'\n');
 367         if (newline) *newline = '\0';
 368         newline = strrchr(cellNamep,'\r');
 369         if (newline) *newline = '\0';
 370
 371         return 0;
 372 }
 373 #endif /* !DJGPP */
 374
 375 cm_configFile_t *cm_CommonOpen(char *namep, char *rwp)
 376 {
 377         char wdir[256];
 378         long code;
 379         long tlen;
 380         FILE *tfilep;
 381         char *afsconf_path;
 382
 383 #if !defined(DJGPP) && !defined(AFS_WIN95_ENV)
 384         code = GetWindowsDirectory(wdir, sizeof(wdir));
 385         if (code == 0 || code > sizeof(wdir)) return NULL;
 386
 387         /* add trailing backslash, if required */
 388         tlen = strlen(wdir);
 389         if (wdir[tlen-1] != '\\') strcat(wdir, "\\");
 390 #else
 391 #ifdef DJGPP
 392         strcpy(wdir,cm_confDir);
 393 #else
 394         afsconf_path = getenv("AFSCONF");
 395         if (!afsconf_path)
 396           strcpy(wdir, AFSDIR_CLIENT_ETC_DIRPATH);
 397         else
 398           strcpy(wdir, afsconf_path);
 399 #endif /* !DJGPP */
 400         strcat(wdir,"/");
 401 #endif /* DJGPP || WIN95 */
 402
 403         strcat(wdir, namep);
 404
 405         tfilep = fopen(wdir, rwp);
 406
 407         return ((cm_configFile_t *) tfilep);
 408 }
 409
 410 #ifndef DJGPP
 411 long cm_WriteConfigString(char *labelp, char *valuep)
 412 {
 413         DWORD code, dummyDisp;
 414         HKEY parmKey;
 415
 416         code = RegCreateKeyEx(HKEY_LOCAL_MACHINE, AFSConfigKeyName,
 417                                 0, "container", 0, KEY_SET_VALUE, NULL,
 418                                 &parmKey, &dummyDisp);
 419         if (code != ERROR_SUCCESS)
 420                 return -1;
 421
 422         code = RegSetValueEx(parmKey, labelp, 0, REG_SZ,
 423                              valuep, strlen(valuep) + 1);
 424         RegCloseKey (parmKey);
 425         if (code != ERROR_SUCCESS)
 426                 return -1;
 427
 428         return 0;
 429 }
 430 #endif /* !DJGPP */
 431
 432 #ifndef DJGPP
 433 long cm_WriteConfigInt(char *labelp, long value)
 434 {
 435         DWORD code, dummyDisp;
 436         HKEY parmKey;
 437
 438         code = RegCreateKeyEx(HKEY_LOCAL_MACHINE, AFSConfigKeyName,
 439                                 0, "container", 0, KEY_SET_VALUE, NULL,
 440                                 &parmKey, &dummyDisp);
 441         if (code != ERROR_SUCCESS)
 442                 return -1;
 443
 444         code = RegSetValueEx(parmKey, labelp, 0, REG_DWORD,
 445                              (LPBYTE)&value, sizeof(value));
 446         RegCloseKey (parmKey);
 447         if (code != ERROR_SUCCESS)
 448                 return -1;
 449
 450         return 0;
 451 }
 452 #endif /* !DJGPP */
 453
 454 cm_configFile_t *cm_OpenCellFile(void)
 455 {
 456         cm_configFile_t *cfp;
 457
 458         cfp = cm_CommonOpen("afsdcel2.ini", "w");
 459         return cfp;
 460 }
 461
 462 long cm_AppendPrunedCellList(cm_configFile_t *ofp, char *cellNamep)
 463 {
 464         cm_configFile_t *tfilep;        /* input file */
 465         char *tp;
 466         char lineBuffer[256];
 467         char *valuep;
 468         int inRightCell;
 469         int foundCell;
 470
 471         tfilep = cm_CommonOpen(AFS_CELLSERVDB, "r");
 472         if (!tfilep) return -1;
 473
 474         foundCell = 0;
 475
 476         /* have we seen the cell line for the guy we're looking for? */
 477         inRightCell = 0;
 478         while (1) {
 479                 tp = fgets(lineBuffer, sizeof(lineBuffer), (FILE *)tfilep);
 480                 if (tp == NULL) {
 481                         if (feof((FILE *)tfilep)) {
 482                                 /* hit EOF */
 483                                 fclose((FILE *)tfilep);
 484                                 return 0;
 485                         }
 486                 }
 487
 488                 /* turn trailing cr or lf into null */
 489                 tp = strchr(lineBuffer, '\r');
 490                 if (tp) *tp = 0;
 491                 tp = strchr(lineBuffer, '\n');
 492                 if (tp) *tp = 0;
 493
 494                 /* skip blank lines */
 495                 if (lineBuffer[0] == 0) {
 496                         fprintf((FILE *)ofp, "%s\n", lineBuffer);
 497                         continue;
 498                 }
 499
 500                 if (lineBuffer[0] == '>') {
 501                         /* trim off at white space or '#' chars */
 502                         tp = strchr(lineBuffer, ' ');
 503                         if (tp) *tp = 0;
 504                         tp = strchr(lineBuffer, '\t');
 505                         if (tp) *tp = 0;
 506                         tp = strchr(lineBuffer, '#');
 507                         if (tp) *tp = 0;
 508
 509                         /* now see if this is the right cell */
 510                         if (strcmp(lineBuffer+1, cellNamep) == 0) {
 511                                 /* found the cell we're looking for */
 512                                 inRightCell = 1;
 513                         }
 514                         else {
 515                                 inRightCell = 0;
 516                                 fprintf((FILE *)ofp, "%s\n", lineBuffer);
 517                         }
 518                 }
 519                 else {
 520                         valuep = strchr(lineBuffer, '#');
 521                         if (valuep == NULL) return -2;
 522                         valuep++;       /* skip the "#" */
 523                         if (!inRightCell) {
 524                                 fprintf((FILE *)ofp, "%s\n", lineBuffer);
 525                         }
 526                 }       /* a vldb line */
 527         }               /* while loop processing all lines */
 528 }
 529
 530 long cm_AppendNewCell(cm_configFile_t *filep, char *cellNamep)
 531 {
 532         fprintf((FILE *)filep, ">%s\n", cellNamep);
 533         return 0;
 534 }
 535
 536 long cm_AppendNewCellLine(cm_configFile_t *filep, char *linep)
 537 {
 538         fprintf((FILE *)filep, "%s\n", linep);
 539         return 0;
 540 }
 541
 542 long cm_CloseCellFile(cm_configFile_t *filep)
 543 {
 544         char wdir[256];
 545         char sdir[256];
 546         long code;
 547         long closeCode;
 548         int tlen;
 549         char *afsconf_path;
 550
 551         closeCode = fclose((FILE *)filep);
 552
 553 #if !defined(DJGPP) && !defined(AFS_WIN95_ENV)
 554         code = GetWindowsDirectory(wdir, sizeof(wdir));
 555         if (code == 0 || code > sizeof(wdir)) return NULL;
 556
 557         /* add trailing backslash, if required */
 558         tlen = strlen(wdir);
 559         if (wdir[tlen-1] != '\\') strcat(wdir, "\\");
 560 #else
 561 #ifdef DJGPP
 562         strcpy(wdir,cm_confDir);
 563 #else
 564         afsconf_path = getenv("AFSCONF");
 565         if (!afsconf_path)
 566           strcpy(wdir, AFSDIR_CLIENT_ETC_DIRPATH);
 567         else
 568           strcpy(wdir, afsconf_path);
 569 #endif /* !DJGPP */
 570         strcat(wdir,"/");
 571 #endif /* DJGPP || WIN95 */
 572
 573         strcpy(sdir, wdir);
 574
 575         if (closeCode != 0) {
 576                 /* something went wrong, preserve original database */
 577                 strcat(wdir, "afsdcel2.ini");
 578                 unlink(wdir);
 579                 return closeCode;
 580         }
 581
 582         strcat(wdir, AFS_CELLSERVDB);
 583         strcat(sdir, "afsdcel2.ini");   /* new file */
 584
 585         unlink(wdir);                   /* delete old file */
 586
 587         code = rename(sdir, wdir);      /* do the rename */
 588
 589         if (code) code = errno;
 590
 591         return code;
 592 }
 593
 594 void cm_GetConfigDir(char *dir)
 595 {
 596         char wdir[256];
 597      char *afsconf_path;
 598      int code;
 599      int tlen;
 600
 601 #if !defined(DJGPP) && !defined(AFS_WIN95_ENV)
 602         code = GetWindowsDirectory(wdir, sizeof(wdir));
 603       if (code == 0 || code > sizeof(wdir)) wdir[0] = 0;
 604
 605         /* add trailing backslash, if required */
 606         tlen = strlen(wdir);
 607         if (wdir[tlen-1] != '\\') strcat(wdir, "\\");
 608 #else
 609 #ifdef DJGPP
 610         strcpy(wdir,cm_confDir);
 611 #else
 612         afsconf_path = getenv("AFSCONF");
 613         if (!afsconf_path)
 614           strcpy(wdir, AFSDIR_CLIENT_ETC_DIRPATH);
 615         else
 616           strcpy(wdir, afsconf_path);
 617 #endif /* !DJGPP */
 618         strcat(wdir,"\\");
 619 #endif /* DJGPP || WIN95 */
 620         strcpy(dir, wdir);
 621 }