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 <windows.h>
  11 #include <winsock2.h>
  12 #include <shlwapi.h>
  13 #include <stdlib.h>
  14 #include <stdio.h>
  15 #include <string.h>
  16 #include <strsafe.h>
  17
  18 #include "afsd.h"
  19 #include <WINNT\afssw.h>
  20 #include <WINNT\afsreg.h>
  21
  22 #include <afs/param.h>
  23 #include <afs/stds.h>
  24 #include <afs/cellconfig.h>
  25
  26 #include "cm_dns.h"
  27 #include <afs/afsint.h>
  28
  29 static long cm_ParsePair(char *lineBufferp, char *leftp, char *rightp)
  30 {
  31     char *tp;
  32     char tc;
  33     int sawEquals;
  34     int sawBracket;
  35
  36     sawEquals = 0;
  37     sawBracket = 0;
  38     for(tp = lineBufferp; *tp; tp++) {
  39         tc = *tp;
  40
  41         if (sawBracket) {
  42             if (tc == ']')
  43                 sawBracket = 0;
  44             continue;
  45         }
  46
  47         /* comment or line end */
  48         if (tc == '#' || tc == '\r' || tc == '\n')
  49             break;
  50
  51         /* square bracket comment -- look for closing delim */
  52         if (tc == '[') {
  53             sawBracket = 1;
  54             continue;
  55         }
  56
  57         /* space or tab */
  58         if (tc == ' ' || tc == '\t')
  59             continue;
  60
  61         if (tc == '=') {
  62             sawEquals = 1;
  63             continue;
  64         }
  65
  66         /* now we have a real character, put it in the appropriate bucket */
  67         if (sawEquals == 0) {
  68             *leftp++ = tc;
  69         }
  70         else {
  71             *rightp++ = tc;
  72         }
  73     }
  74
  75     /* null terminate the strings */
  76     *leftp = 0;
  77     *rightp = 0;
  78
  79     return 0;   /* and return success */
  80 }
  81
  82 static int
  83 IsWindowsModule(const char * name)
  84 {
  85     const char * p;
  86     int i;
  87
  88     /* Do not perform searches for probable Windows modules */
  89     for (p = name, i=0; *p; p++) {
  90         if ( *p == '.' )
  91             i++;
  92     }
  93     p = strrchr(name, '.');
  94     if (p) {
  95         /* as of 2009-09-04 these are not valid ICANN ccTLDs */
  96         if (i == 1 &&
  97             (!cm_stricmp_utf8N(p,".dll") ||
  98              !cm_stricmp_utf8N(p,".exe") ||
  99              !cm_stricmp_utf8N(p,".ini") ||
 100              !cm_stricmp_utf8N(p,".db") ||
 101              !cm_stricmp_utf8N(p,".drv")))
 102             return 1;
 103     }
 104     return 0;
 105 }
 106
 107 /* search for a cell, and either return an error code if we don't find it,
 108  * or return 0 if we do, in which case we also fill in the addresses in
 109  * the cellp field.
 110  *
 111  * new feature:  we can handle abbreviations and are insensitive to case.
 112  * If the caller wants the "real" cell name, it puts a non-null pointer in
 113  * newCellNamep.  Anomaly:  if cellNamep is ambiguous, we may modify
 114  * newCellNamep but return an error code.
 115  *
 116  * Linked Cells: the CellServDB format permits linked cells
 117  *   >cell [linked-cell] #Description
 118  *
 119  * newCellNamep and linkedNamep are required to be CELL_MAXNAMELEN in size.
 120  */
 121 long cm_SearchCellFile(char *cellNamep, char *newCellNamep,
 122                        cm_configProc_t *procp, void *rockp)
 123 {
 124     return cm_SearchCellFileEx(cellNamep, newCellNamep, NULL, procp, rockp);
 125 }
 126
 127 long cm_SearchCellFileEx(char *cellNamep, char *newCellNamep,
 128                          char *linkedNamep,
 129                          cm_configProc_t *procp, void *rockp)
 130 {
 131     char wdir[MAX_PATH]="";
 132     FILE *tfilep = NULL, *bestp, *tempp;
 133     char *tp, *linkp;
 134     char lineBuffer[257];
 135     struct hostent *thp;
 136     char *valuep;
 137     struct sockaddr_in vlSockAddr;
 138     int inRightCell = 0;
 139     int foundCell = 0;
 140     long code;
 141     int tracking = 1, partial = 0;
 142     size_t len;
 143
 144     if ( IsWindowsModule(cellNamep) )
 145         return -3;
 146
 147     cm_GetCellServDB(wdir, sizeof(wdir));
 148     if (*wdir)
 149         tfilep = fopen(wdir, "r");
 150
 151     if (!tfilep)
 152         return -2;
 153
 154     bestp = fopen(wdir, "r");
 155
 156 #ifdef CELLSERV_DEBUG
 157     osi_Log2(afsd_logp,"cm_searchfile fopen handle[%p], wdir[%s]", bestp,
 158              osi_LogSaveString(afsd_logp,wdir));
 159 #endif
 160     /* have we seen the cell line for the guy we're looking for? */
 161     while (1) {
 162         linkp = NULL;
 163         tp = fgets(lineBuffer, sizeof(lineBuffer), tfilep);
 164         if (tracking)
 165             (void) fgets(lineBuffer, sizeof(lineBuffer), bestp);
 166         if (tp == NULL) {
 167             if (feof(tfilep)) {
 168                 /* hit EOF */
 169                 if (partial) {
 170                     /*
 171                      * found partial match earlier;
 172                      * now go back to it
 173                      */
 174                     tempp = bestp;
 175                     bestp = tfilep;
 176                     tfilep = tempp;
 177                     inRightCell = 1;
 178                     partial = 0;
 179                     continue;
 180                 }
 181                 else {
 182                     fclose(tfilep);
 183                     fclose(bestp);
 184                     return (foundCell? 0 : -3);
 185                 }
 186             }
 187         }
 188
 189         /* turn trailing cr or lf into null */
 190         tp = strrchr(lineBuffer, '\r');
 191         if (tp) *tp = 0;
 192         tp = strrchr(lineBuffer, '\n');
 193         if (tp) *tp = 0;
 194
 195         /* skip blank lines */
 196         if (lineBuffer[0] == 0) continue;
 197
 198         /*
 199          * The format is:
 200          *   >[cell] [linked-cell] #[Description]
 201          * where linked-cell and Description are optional
 202          */
 203         if (lineBuffer[0] == '>') {
 204             if (inRightCell) {
 205                 fclose(tfilep);
 206                 fclose(bestp);
 207                 return(foundCell ? 0 : -6);
 208             }
 209
 210             /*
 211              * terminate the cellname at the first white space
 212              * leaving 'tp' pointing to the next string if any
 213              */
 214             for (tp = &lineBuffer[1]; tp && !isspace(*tp); tp++);
 215             if (tp) {
 216                 *tp = '\0';
 217                 for (tp++ ;tp && isspace(*tp); tp++);
 218                 if (*tp != '#') {
 219                     linkp = tp;
 220                     for (; tp && !isspace(*tp); tp++);
 221                     if (tp)
 222                         *tp = '\0';
 223                 }
 224             }
 225
 226             /* now see if this is the right cell */
 227             if (stricmp(lineBuffer+1, cellNamep) == 0) {
 228                 /* found the cell we're looking for */
 229                 if (newCellNamep) {
 230                     if (FAILED(StringCchCopy(newCellNamep, CELL_MAXNAMELEN, lineBuffer+1))) {
 231                         fclose(tfilep);
 232                         fclose(bestp);
 233                         return(-1);
 234                     }
 235                     strlwr(newCellNamep);
 236                 }
 237                 if (linkedNamep) {
 238                     if (FAILED(StringCchCopy(linkedNamep, CELL_MAXNAMELEN, linkp ? linkp : ""))) {
 239                         fclose(tfilep);
 240                         fclose(bestp);
 241                         return(-1);
 242                     }
 243                     strlwr(linkedNamep);
 244                 }
 245                 inRightCell = 1;
 246                 tracking = 0;
 247 #ifdef CELLSERV_DEBUG
 248                 osi_Log2(afsd_logp, "cm_searchfile is cell inRightCell[%p], linebuffer[%s]",
 249                          inRightCell, osi_LogSaveString(afsd_logp,lineBuffer));
 250 #endif
 251             }
 252             else if (cm_stricmp_utf8(lineBuffer+1, cellNamep) == 0) {
 253                 /* partial match */
 254                 if (partial) {  /* ambiguous */
 255                     fclose(tfilep);
 256                     fclose(bestp);
 257                     return -5;
 258                 }
 259                 if (newCellNamep) {
 260                     if (FAILED(StringCchCopy(newCellNamep, CELL_MAXNAMELEN, lineBuffer+1))) {
 261                         fclose(tfilep);
 262                         fclose(bestp);
 263                         return(-1);
 264                     }
 265                     strlwr(newCellNamep);
 266                 }
 267                 if (linkedNamep) {
 268                     if (FAILED(StringCchCopy(linkedNamep, CELL_MAXNAMELEN, linkp ? linkp : ""))) {
 269                         fclose(tfilep);
 270                         fclose(bestp);
 271                         return(-1);
 272                     }
 273                     strlwr(linkedNamep);
 274                 }
 275                 inRightCell = 0;
 276                 tracking = 0;
 277                 partial = 1;
 278             }
 279             else inRightCell = 0;
 280         }
 281         else {
 282             valuep = strchr(lineBuffer, '#');
 283             if (valuep == NULL) {
 284                 fclose(tfilep);
 285                 fclose(bestp);
 286                 return -4;
 287             }
 288             valuep++;   /* skip the "#" */
 289
 290             valuep += strspn(valuep, " \t"); /* skip SP & TAB */
 291             /*
 292              * strip spaces and tabs in the end. They should not be there according to CellServDB format
 293              * so do this just in case
 294              */
 295             if(FAILED(StringCchLength(valuep, sizeof(lineBuffer), &len))) {
 296                 fclose(tfilep);
 297                 fclose(bestp);
 298                 return(-1);
 299             } else {
 300                 len--;
 301                 while(isspace(valuep[len]))
 302                     valuep[len--] = '\0';
 303                 while(isspace(*valuep))
 304                     valuep++;
 305             }
 306
 307             if (inRightCell) {
 308                 char hostname[256];
 309                 int  i, isClone = 0;
 310
 311                 isClone = (lineBuffer[0] == '[');
 312
 313                 /* copy just the first word and ignore trailing white space */
 314                 for ( i=0; valuep[i] && !isspace(valuep[i]) && i<sizeof(hostname); i++)
 315                     hostname[i] = valuep[i];
 316                 hostname[i] = '\0';
 317
 318                 /* add the server to the VLDB list */
 319                 WSASetLastError(0);
 320                 thp = gethostbyname(hostname);
 321 #ifdef CELLSERV_DEBUG
 322                 osi_Log3(afsd_logp,"cm_searchfile inRightCell thp[%p], valuep[%s], WSAGetLastError[%d]",
 323                          thp, osi_LogSaveString(afsd_logp,hostname), WSAGetLastError());
 324 #endif
 325                 if (thp) {
 326                     int foundAddr = 0;
 327                     for (i=0 ; thp->h_addr_list[i]; i++) {
 328                         if (thp->h_addrtype != AF_INET)
 329                             continue;
 330                         memcpy(&vlSockAddr.sin_addr.s_addr, thp->h_addr_list[i],
 331                                sizeof(long));
 332                         vlSockAddr.sin_port = htons(7003);
 333                         vlSockAddr.sin_family = AF_INET;
 334                         /* sin_port supplied by connection code */
 335                         if (procp)
 336                             (*procp)(rockp, &vlSockAddr, hostname, 0);
 337                         foundAddr = 1;
 338                     }
 339                     /* if we didn't find a valid address, force the use of the specified one */
 340                     if (!foundAddr)
 341                         thp = NULL;
 342                 }
 343                 if (!thp) {
 344                     afs_uint32 ip_addr;
 345                     unsigned int c1, c2, c3, c4;
 346
 347                     /* Since there is no gethostbyname() data
 348                      * available we will read the IP address
 349                      * stored in the CellServDB file
 350                      */
 351                     if (isClone)
 352                         code = sscanf(lineBuffer, "[%u.%u.%u.%u]",
 353                                       &c1, &c2, &c3, &c4);
 354                     else
 355                         code = sscanf(lineBuffer, " %u.%u.%u.%u",
 356                                       &c1, &c2, &c3, &c4);
 357                     if (code == 4 && c1<256 && c2<256 && c3<256 && c4<256) {
 358                         tp = (unsigned char *) &ip_addr;
 359                         *tp++ = c1;
 360                         *tp++ = c2;
 361                         *tp++ = c3;
 362                         *tp++ = c4;
 363                         memcpy(&vlSockAddr.sin_addr.s_addr, &ip_addr,
 364                                 sizeof(long));
 365                         vlSockAddr.sin_port = htons(7003);
 366                         vlSockAddr.sin_family = AF_INET;
 367                         /* sin_port supplied by connection code */
 368                         if (procp)
 369                             (*procp)(rockp, &vlSockAddr, hostname, 0);
 370                     }
 371                 }
 372                 foundCell = 1;
 373             }
 374         }       /* a vldb line */
 375     }           /* while loop processing all lines */
 376
 377     /* if for some unknown reason cell is not found, return negative code (-11) ??? */
 378     return (foundCell) ? 0 : -11;
 379 }
 380
 381 long
 382 cm_EnumerateCellFile(afs_uint32 client, cm_enumCellProc_t *procp, void *rockp)
 383 {
 384     char wdir[MAX_PATH]="";
 385     FILE *tfilep = NULL;
 386     char *tp;
 387     char lineBuffer[257];
 388
 389     if (!procp)
 390         return 0;
 391
 392     cm_GetCellServDB(wdir, sizeof(wdir));
 393     if (*wdir)
 394         tfilep = fopen(wdir, "r");
 395
 396     if (!tfilep)
 397         return -2;
 398
 399 #ifdef CELLSERV_DEBUG
 400     osi_Log2(afsd_logp,"cm_enumfile fopen handle[%p], wdir[%s]", tfilep,
 401              osi_LogSaveString(afsd_logp,wdir));
 402 #endif
 403     while (1) {
 404         tp = fgets(lineBuffer, sizeof(lineBuffer), tfilep);
 405         if (tp == NULL && feof(tfilep)) {
 406             /* hit EOF */
 407             fclose(tfilep);
 408             return (0);
 409         }
 410
 411         /* turn trailing cr or lf into null */
 412         tp = strrchr(lineBuffer, '\r');
 413         if (tp) *tp = 0;
 414         tp = strrchr(lineBuffer, '\n');
 415         if (tp) *tp = 0;
 416
 417         /* skip blank lines */
 418         if (lineBuffer[0] == 0)
 419             continue;
 420
 421         /*
 422          * The format is:
 423          *   >[cell] [linked-cell] #[Description]
 424          * where linked-cell and Description are optional
 425          * but we are only going to use the initial cell name
 426          */
 427         if (lineBuffer[0] == '>') {
 428             /*
 429              * terminate the cellname at the first white space
 430              * leaving 'tp' pointing to the next string if any
 431              */
 432             for (tp = &lineBuffer[1]; tp && !isspace(*tp); tp++);
 433             if (tp)
 434                 *tp = '\0';
 435
 436             /* Now process the cell */
 437             (*procp)(rockp, &lineBuffer[1]);
 438         }
 439     }           /* while loop processing all lines */
 440
 441     return 0;
 442 }
 443
 444 /*
 445  * The CellServDB registry schema is as follows:
 446  *
 447  * HKLM\SOFTWARE\OpenAFS\Client\CellServDB\[cellname]\
 448  *   "LinkedCell"    REG_SZ "[cellname]"
 449  *   "Description"   REG_SZ "[comment]"
 450  *   "ForceDNS"      DWORD  {0,1}
 451  *
 452  * HKLM\SOFTWARE\OpenAFS\Client\CellServDB\[cellname]\[servername]\
 453  *   "HostName"      REG_SZ "[hostname]"
 454  *   "IPv4Address"   REG_SZ "[address]"
 455  *   "IPv6Address"   REG_SZ "[address]"   <future>
 456  *   "Comment"       REG_SZ "[comment]"
 457  *   "Rank"          DWORD  "0..65535"
 458  *   "Clone"         DWORD  "{0,1}"
 459  *   "vlserver"      DWORD  "7003"        <future>
 460  *   "ptserver"      DWORD  "7002"        <future>
 461  *
 462  * ForceDNS is implied non-zero if there are no [servername]
 463  * keys under the [cellname] key.  Otherwise, ForceDNS is zero.
 464  * If [servername] keys are specified and none of them evaluate
 465  * to a valid server configuration, the return code is success.
 466  * This prevents failover to the CellServDB file or DNS.
 467  */
 468 long cm_SearchCellRegistry(afs_uint32 client,
 469                            char *cellNamep, char *newCellNamep,
 470                            char *linkedNamep,
 471                            cm_configProc_t *procp, void *rockp)
 472 {
 473     HKEY hkCellServDB = 0, hkCellName = 0, hkServerName = 0;
 474     DWORD dwType, dwSize;
 475     DWORD dwCells, dwServers, dwForceDNS;
 476     DWORD dwIndex, dwRank, dwPort;
 477     unsigned short ipRank;
 478     unsigned short vlPort;
 479     LONG code;
 480     FILETIME ftLastWriteTime;
 481     char szCellName[CELL_MAXNAMELEN];
 482     char szServerName[MAXHOSTCHARS];
 483     char szHostName[MAXHOSTCHARS];
 484     char szAddr[64];
 485     struct hostent *thp;
 486     struct sockaddr_in vlSockAddr;
 487     char * s;
 488     size_t len;
 489
 490     if ( IsWindowsModule(cellNamep) )
 491         return -1;
 492
 493     /* No Server CellServDB list (yet) */
 494     if ( !client )
 495         return CM_ERROR_NOSUCHCELL;
 496
 497     if (RegOpenKeyEx( HKEY_LOCAL_MACHINE,
 498                       AFSREG_CLT_OPENAFS_SUBKEY "\\CellServDB",
 499                       0,
 500                       KEY_READ|KEY_QUERY_VALUE,
 501                       &hkCellServDB) != ERROR_SUCCESS)
 502         return CM_ERROR_NOSUCHCELL;
 503
 504     if (RegOpenKeyEx( hkCellServDB,
 505                       cellNamep,
 506                       0,
 507                       KEY_READ|KEY_QUERY_VALUE,
 508                       &hkCellName) != ERROR_SUCCESS) {
 509         BOOL bFound = 0;
 510
 511         /* We did not find an exact match.  Much search for partial matches. */
 512
 513         code = RegQueryInfoKey( hkCellServDB,
 514                                 NULL,  /* lpClass */
 515                                 NULL,  /* lpcClass */
 516                                 NULL,  /* lpReserved */
 517                                 &dwCells,  /* lpcSubKeys */
 518                                 NULL,  /* lpcMaxSubKeyLen */
 519                                 NULL,  /* lpcMaxClassLen */
 520                                 NULL,  /* lpcValues */
 521                                 NULL,  /* lpcMaxValueNameLen */
 522                                 NULL,  /* lpcMaxValueLen */
 523                                 NULL,  /* lpcbSecurityDescriptor */
 524                                 &ftLastWriteTime /* lpftLastWriteTime */
 525                                 );
 526         if (code != ERROR_SUCCESS)
 527             dwCells = 0;
 528
 529         /*
 530          * We search the entire list to ensure that there is only
 531          * one prefix match.  If there is more than one, we return none.
 532          */
 533         for ( dwIndex = 0; dwIndex < dwCells; dwIndex++ ) {
 534             dwSize = CELL_MAXNAMELEN;
 535             code = RegEnumKeyEx( hkCellServDB, dwIndex, szCellName, &dwSize, NULL,
 536                                  NULL, NULL, &ftLastWriteTime);
 537             if (code != ERROR_SUCCESS)
 538                 continue;
 539             szCellName[CELL_MAXNAMELEN-1] = '\0';
 540             strlwr(szCellName);
 541
 542             /* if not a prefix match, try the next key */
 543             if (FAILED(StringCchLength(cellNamep, CELL_MAXNAMELEN, &len)))
 544                 continue;
 545
 546             if (strncmp(cellNamep, szCellName, len))
 547                 continue;
 548
 549             /* If we have a prefix match and we already found another
 550              * match, return neither */
 551             if (hkCellName) {
 552                 bFound = 0;
 553                 RegCloseKey( hkCellName);
 554                 break;
 555             }
 556
 557             if (RegOpenKeyEx( hkCellServDB,
 558                               szCellName,
 559                               0,
 560                               KEY_READ|KEY_QUERY_VALUE,
 561                               &hkCellName) != ERROR_SUCCESS)
 562                 continue;
 563
 564             if (newCellNamep) {
 565                 if (FAILED(StringCchCopy(newCellNamep, CELL_MAXNAMELEN, cellNamep)))
 566                     goto done;
 567             }
 568             bFound = 1;
 569         }
 570
 571         if ( !bFound ) {
 572             RegCloseKey(hkCellServDB);
 573             return CM_ERROR_NOSUCHCELL;
 574         }
 575     } else if (newCellNamep) {
 576         strncpy(newCellNamep, cellNamep, CELL_MAXNAMELEN);
 577         newCellNamep[CELL_MAXNAMELEN-1] = '\0';
 578         strlwr(newCellNamep);
 579     }
 580
 581     if (linkedNamep) {
 582         dwSize = CELL_MAXNAMELEN;
 583         code = RegQueryValueEx(hkCellName, "LinkedCell", NULL, &dwType,
 584                                 (BYTE *) linkedNamep, &dwSize);
 585         if (code == ERROR_SUCCESS && dwType == REG_SZ) {
 586             linkedNamep[CELL_MAXNAMELEN-1] = '\0';
 587             strlwr(linkedNamep);
 588         } else {
 589             linkedNamep[0] = '\0';
 590         }
 591     }
 592
 593     /* Check to see if DNS lookups are required */
 594     dwSize = sizeof(DWORD);
 595     code = RegQueryValueEx(hkCellName, "ForceDNS", NULL, &dwType,
 596                             (BYTE *) &dwForceDNS, &dwSize);
 597     if (code == ERROR_SUCCESS && dwType == REG_DWORD) {
 598         if (dwForceDNS)
 599             goto done;
 600     } else {
 601         dwForceDNS = 0;
 602     }
 603
 604     /*
 605      * Using the defined server list.  Enumerate and populate
 606      * the server list for the cell.
 607      */
 608     code = RegQueryInfoKey( hkCellName,
 609                             NULL,  /* lpClass */
 610                             NULL,  /* lpcClass */
 611                             NULL,  /* lpReserved */
 612                             &dwServers,  /* lpcSubKeys */
 613                             NULL,  /* lpcMaxSubKeyLen */
 614                             NULL,  /* lpcMaxClassLen */
 615                             NULL,  /* lpcValues */
 616                             NULL,  /* lpcMaxValueNameLen */
 617                             NULL,  /* lpcMaxValueLen */
 618                             NULL,  /* lpcbSecurityDescriptor */
 619                             &ftLastWriteTime /* lpftLastWriteTime */
 620                             );
 621     if (code != ERROR_SUCCESS)
 622         dwServers = 0;
 623
 624     for ( dwIndex = 0; dwIndex < dwServers; dwIndex++ ) {
 625         dwSize = MAXHOSTCHARS;
 626         code = RegEnumKeyEx( hkCellName, dwIndex, szServerName, &dwSize, NULL,
 627                              NULL, NULL, &ftLastWriteTime);
 628         if (code != ERROR_SUCCESS)
 629             continue;
 630
 631         szServerName[MAXHOSTCHARS-1] = '\0';
 632         if (RegOpenKeyEx( hkCellName,
 633                           szServerName,
 634                           0,
 635                           KEY_READ|KEY_QUERY_VALUE,
 636                           &hkServerName) != ERROR_SUCCESS)
 637             continue;
 638
 639         /* We have a handle to a valid server key.  Now we need
 640          * to add the server to the cell */
 641
 642         /* First, see if there is an alternate hostname specified */
 643         dwSize = MAXHOSTCHARS;
 644         code = RegQueryValueEx(hkServerName, "HostName", NULL, &dwType,
 645                                 (BYTE *) szHostName, &dwSize);
 646         if (code == ERROR_SUCCESS && dwType == REG_SZ) {
 647             szHostName[MAXHOSTCHARS-1] = '\0';
 648             strlwr(szHostName);
 649             s = szHostName;
 650         } else {
 651             s = szServerName;
 652         }
 653
 654         dwSize = sizeof(DWORD);
 655         code = RegQueryValueEx(hkServerName, "Rank", NULL, &dwType,
 656                                 (BYTE *) &dwRank, &dwSize);
 657         if (code == ERROR_SUCCESS && dwType == REG_DWORD) {
 658             ipRank = (unsigned short)(dwRank <= 65535 ? dwRank : 65535);
 659         } else {
 660             ipRank = 0;
 661         }
 662
 663         dwSize = sizeof(szAddr);
 664         code = RegQueryValueEx(hkServerName, "IPv4Address", NULL, &dwType,
 665                                 (BYTE *) szAddr, &dwSize);
 666         if (code == ERROR_SUCCESS && dwType == REG_SZ) {
 667             szAddr[63] = '\0';
 668         } else {
 669             szAddr[0] = '\0';
 670         }
 671
 672         dwSize = sizeof(DWORD);
 673         code = RegQueryValueEx(hkServerName, "vlserver", NULL, &dwType,
 674                                 (BYTE *) &dwPort, &dwSize);
 675         if (code == ERROR_SUCCESS && dwType == REG_DWORD) {
 676             vlPort = htons((unsigned short)dwPort);
 677         } else {
 678             vlPort = htons(7003);
 679         }
 680
 681         WSASetLastError(0);
 682         thp = gethostbyname(s);
 683         if (thp) {
 684             memcpy(&vlSockAddr.sin_addr.s_addr, thp->h_addr, sizeof(long));
 685             vlSockAddr.sin_port = htons(7003);
 686             vlSockAddr.sin_family = AF_INET;
 687             /* sin_port supplied by connection code */
 688             if (procp)
 689                 (*procp)(rockp, &vlSockAddr, s, ipRank);
 690         } else if (szAddr[0]) {
 691             afs_uint32 ip_addr;
 692             unsigned int c1, c2, c3, c4;
 693
 694             /* Since there is no gethostbyname() data
 695              * available we will read the IP address
 696              * stored in the CellServDB file
 697              */
 698             code = sscanf(szAddr, " %u.%u.%u.%u",
 699                            &c1, &c2, &c3, &c4);
 700             if (code == 4 && c1<256 && c2<256 && c3<256 && c4<256) {
 701                 unsigned char * tp = (unsigned char *) &ip_addr;
 702                 *tp++ = c1;
 703                 *tp++ = c2;
 704                 *tp++ = c3;
 705                 *tp++ = c4;
 706                 memcpy(&vlSockAddr.sin_addr.s_addr, &ip_addr,
 707                         sizeof(long));
 708                 vlSockAddr.sin_port = vlPort;
 709                 vlSockAddr.sin_family = AF_INET;
 710                 /* sin_port supplied by connection code */
 711                 if (procp)
 712                     (*procp)(rockp, &vlSockAddr, s, ipRank);
 713             }
 714         }
 715
 716         RegCloseKey( hkServerName);
 717     }
 718
 719   done:
 720     RegCloseKey(hkCellName);
 721     RegCloseKey(hkCellServDB);
 722
 723     return ((dwForceDNS || dwServers == 0) ? CM_ERROR_FORCE_DNS_LOOKUP : 0);
 724 }
 725
 726 /*
 727  * Following the registry schema listed above, cm_AddCellToRegistry
 728  * will either create or update the registry configuration data for
 729  * the specified cellname.
 730  */
 731 long cm_AddCellToRegistry( char * cellname,
 732                            char * linked_cellname,
 733                            unsigned short vlport,
 734                            afs_uint32 host_count,
 735                            char *hostname[],
 736                            afs_uint32 flags)
 737 {
 738     HKEY hkCellServDB = 0, hkCellName = 0, hkServerName = 0;
 739     DWORD dwPort, dwDisposition;
 740     long code;
 741     unsigned int i;
 742
 743     if (RegCreateKeyEx( HKEY_LOCAL_MACHINE,
 744                         AFSREG_CLT_OPENAFS_SUBKEY "\\CellServDB",
 745                         0,
 746                         NULL,
 747                         REG_OPTION_NON_VOLATILE,
 748                         KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
 749                         NULL,
 750                         &hkCellServDB,
 751                         &dwDisposition) != ERROR_SUCCESS) {
 752         code = CM_ERROR_NOACCESS;
 753         goto done;
 754     }
 755
 756     /* Perform a recursive deletion of the cellname key */
 757     SHDeleteKey( hkCellServDB, cellname);
 758
 759     if (RegCreateKeyEx( hkCellServDB,
 760                         cellname,
 761                         0,
 762                         NULL,
 763                         REG_OPTION_NON_VOLATILE,
 764                         KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
 765                         NULL,
 766                         &hkCellName,
 767                         &dwDisposition) != ERROR_SUCCESS ||
 768         (dwDisposition == REG_OPENED_EXISTING_KEY) ) {
 769         code = CM_ERROR_NOACCESS;
 770         goto done;
 771     }
 772
 773     /* If we get here, hkCellName is a handle to an empty key */
 774
 775     if (linked_cellname && linked_cellname[0]) {
 776         code = RegSetValueEx( hkCellName, "LinkedCell",
 777                               0, REG_SZ,
 778                               (BYTE *) linked_cellname, CELL_MAXNAMELEN);
 779     }
 780
 781     if (flags & CM_CELLFLAG_DNS) {
 782         DWORD dwForceDNS = 1;
 783         code = RegSetValueEx( hkCellName, "ForceDNS",
 784                               0, REG_DWORD,
 785                               (BYTE *) &dwForceDNS, sizeof(DWORD));
 786     }
 787
 788     for ( i = 0; i < host_count; i++ ) {
 789         if (RegCreateKeyEx( hkCellName,
 790                             hostname[i],
 791                             0,
 792                             NULL,
 793                             REG_OPTION_NON_VOLATILE,
 794                             KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
 795                             NULL,
 796                             &hkServerName,
 797                             &dwDisposition) != ERROR_SUCCESS ||
 798              (dwDisposition == REG_OPENED_EXISTING_KEY)) {
 799             code = CM_ERROR_NOACCESS;
 800             goto done;
 801         }
 802
 803         /* We have a handle to a valid server key.  Now we need
 804          * to add the server to the cell */
 805
 806         /* First, see if there is an alternate hostname specified */
 807         code = RegSetValueEx( hkServerName, "HostName",
 808                               0, REG_SZ,
 809                               (BYTE *) hostname[i], (DWORD)strlen(hostname[i]) + 1);
 810
 811         if (vlport) {
 812             dwPort = vlport;
 813             code = RegSetValueEx( hkServerName, "vlserver",
 814                                   0, REG_DWORD,
 815                                   (BYTE *) &dwPort, (DWORD)sizeof(DWORD));
 816         }
 817         RegCloseKey( hkServerName);
 818         hkServerName = 0;
 819     }
 820
 821   done:
 822     if (hkServerName)
 823         RegCloseKey(hkServerName);
 824     if (hkCellName)
 825         RegCloseKey(hkCellName);
 826     if (hkCellServDB)
 827         RegCloseKey(hkCellServDB);
 828
 829     return code;
 830 }
 831
 832 long cm_EnumerateCellRegistry(afs_uint32 client, cm_enumCellProc_t *procp, void *rockp)
 833 {
 834     HKEY hkCellServDB = 0;
 835     DWORD dwSize;
 836     DWORD dwCells;
 837     DWORD dwIndex;
 838     LONG code;
 839     FILETIME ftLastWriteTime;
 840     char szCellName[CELL_MAXNAMELEN];
 841
 842     /* No server CellServDB in the registry. */
 843     if (!client || procp == NULL)
 844         return 0;
 845
 846     if (RegOpenKeyEx( HKEY_LOCAL_MACHINE,
 847                       AFSREG_CLT_OPENAFS_SUBKEY "\\CellServDB",
 848                       0,
 849                       KEY_READ|KEY_WRITE|KEY_QUERY_VALUE,
 850                       &hkCellServDB) != ERROR_SUCCESS)
 851         return 0;
 852
 853     code = RegQueryInfoKey( hkCellServDB,
 854                             NULL,  /* lpClass */
 855                             NULL,  /* lpcClass */
 856                             NULL,  /* lpReserved */
 857                             &dwCells,  /* lpcSubKeys */
 858                             NULL,  /* lpcMaxSubKeyLen */
 859                             NULL,  /* lpcMaxClassLen */
 860                             NULL,  /* lpcValues */
 861                             NULL,  /* lpcMaxValueNameLen */
 862                             NULL,  /* lpcMaxValueLen */
 863                             NULL,  /* lpcbSecurityDescriptor */
 864                             &ftLastWriteTime /* lpftLastWriteTime */
 865                             );
 866     if (code != ERROR_SUCCESS)
 867         dwCells = 0;
 868
 869     /*
 870      * Enumerate each Cell and
 871      */
 872     for ( dwIndex = 0; dwIndex < dwCells; dwIndex++ ) {
 873         dwSize = CELL_MAXNAMELEN;
 874         code = RegEnumKeyEx( hkCellServDB, dwIndex, szCellName, &dwSize, NULL,
 875                              NULL, NULL, &ftLastWriteTime);
 876         if (code != ERROR_SUCCESS)
 877             continue;
 878         szCellName[CELL_MAXNAMELEN-1] = '\0';
 879         strlwr(szCellName);
 880
 881         (*procp)(rockp, szCellName);
 882     }
 883
 884     RegCloseKey(hkCellServDB);
 885     return 0;
 886 }
 887
 888 /* newCellNamep is required to be CELL_MAXNAMELEN in size */
 889 long cm_SearchCellByDNS(char *cellNamep, char *newCellNamep, int *ttl,
 890                         cm_configProc_t *procp, void *rockp)
 891 {
 892     int rc;
 893     int  cellHostAddrs[AFSMAXCELLHOSTS];
 894     char cellHostNames[AFSMAXCELLHOSTS][MAXHOSTCHARS];
 895     unsigned short ipRanks[AFSMAXCELLHOSTS];
 896     unsigned short ports[AFSMAXCELLHOSTS];      /* network byte order */
 897     int numServers;
 898     int i;
 899     struct sockaddr_in vlSockAddr;
 900
 901 #ifdef CELLSERV_DEBUG
 902     osi_Log1(afsd_logp,"SearchCellDNS-Doing search for [%s]", osi_LogSaveString(afsd_logp,cellNamep));
 903 #endif
 904     /*
 905      * Do not perform a DNS lookup if the name is
 906      * either a well-known Windows DLL or directory,
 907      * or if the name does not contain a top-level
 908      * domain, or if the file prefix is the afs pioctl
 909      * file name.
 910      */
 911     if ( IsWindowsModule(cellNamep) ||
 912          cm_FsStrChr(cellNamep, '.') == NULL ||
 913          strncasecmp(cellNamep, CM_IOCTL_FILENAME_NOSLASH, sizeof(CM_IOCTL_FILENAME_NOSLASH)-1) == 0)
 914         return -1;
 915
 916     rc = getAFSServer("afs3-vlserver", "udp", cellNamep, htons(7003),
 917                       cellHostAddrs, cellHostNames, ports, ipRanks, &numServers, ttl);
 918     if (rc == 0 && numServers > 0) {     /* found the cell */
 919         for (i = 0; i < numServers; i++) {
 920             memcpy(&vlSockAddr.sin_addr.s_addr, &cellHostAddrs[i],
 921                    sizeof(long));
 922             vlSockAddr.sin_port = ports[i];
 923             vlSockAddr.sin_family = AF_INET;
 924             if (procp)
 925                 (*procp)(rockp, &vlSockAddr, cellHostNames[i], ipRanks[i]);
 926         }
 927         if (newCellNamep) {
 928             if(FAILED(StringCchCopy(newCellNamep, CELL_MAXNAMELEN, cellNamep)))
 929                 return -1;
 930             strlwr(newCellNamep);
 931         }
 932         return 0;   /* found cell */
 933     }
 934     else
 935        return -1;  /* not found */
 936 }
 937
 938 /* use cm_GetConfigDir() plus AFS_CELLSERVDB to
 939  * generate the fully qualified name of the CellServDB
 940  * file.
 941  */
 942 long cm_GetCellServDB(char *cellNamep, afs_uint32 len)
 943 {
 944     size_t tlen;
 945
 946     cm_GetConfigDir(cellNamep, len);
 947
 948     /* add trailing backslash, if required */
 949     if (FAILED(StringCchLength(cellNamep, len, &tlen)))
 950         return(-1L);
 951
 952     if (tlen) {
 953         if (cellNamep[tlen-1] != '\\') {
 954             if (FAILED(StringCchCat(cellNamep, len, "\\")))
 955                 return(-1L);
 956         }
 957
 958         if (FAILED(StringCchCat(cellNamep, len, AFS_CELLSERVDB)))
 959             return(-1L);
 960     }
 961     return 0;
 962 }
 963
 964 /* look up the root cell's name in the Registry
 965  * Input buffer must be at least CELL_MAXNAMELEN
 966  * in size.  (Defined in cm_cell.h)
 967  */
 968 long cm_GetRootCellName(char *cellNamep)
 969 {
 970     DWORD code, dummyLen;
 971     HKEY parmKey;
 972
 973     code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
 974                         0, KEY_QUERY_VALUE, &parmKey);
 975     if (code != ERROR_SUCCESS)
 976         return -1;
 977
 978     dummyLen = CELL_MAXNAMELEN;
 979     code = RegQueryValueEx(parmKey, "Cell", NULL, NULL,
 980                                 cellNamep, &dummyLen);
 981     RegCloseKey (parmKey);
 982     if (code != ERROR_SUCCESS || cellNamep[0] == 0)
 983         return -1;
 984
 985     return 0;
 986 }
 987
 988 cm_configFile_t *cm_CommonOpen(char *namep, char *rwp)
 989 {
 990     char wdir[MAX_PATH]="";
 991     FILE *tfilep = NULL;
 992
 993     cm_GetConfigDir(wdir, sizeof(wdir));
 994     if (*wdir) {
 995         if (FAILED(StringCchCat(wdir, MAX_PATH, namep)))
 996             return NULL;
 997
 998         tfilep = fopen(wdir, rwp);
 999     }
1000     return ((cm_configFile_t *) tfilep);
1001 }
1002
1003 long cm_WriteConfigString(char *labelp, char *valuep)
1004 {
1005     DWORD code, dummyDisp;
1006     HKEY parmKey;
1007     size_t len;
1008
1009     code = RegCreateKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
1010                            0, "container", 0, KEY_SET_VALUE, NULL,
1011                            &parmKey, &dummyDisp);
1012     if (code != ERROR_SUCCESS)
1013         return -1;
1014
1015     if (FAILED(StringCchLength(valuep, CM_CONFIGDEFAULT_CELLS, &len)))
1016         return -1;
1017
1018     code = RegSetValueEx(parmKey, labelp, 0, REG_SZ, valuep, (DWORD)(len + 1));
1019     RegCloseKey (parmKey);
1020     if (code != ERROR_SUCCESS)
1021         return -1;
1022
1023     return 0;
1024 }
1025
1026 long cm_WriteConfigInt(char *labelp, long value)
1027 {
1028     DWORD code, dummyDisp;
1029     HKEY parmKey;
1030
1031     code = RegCreateKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
1032                            0, "container", 0, KEY_SET_VALUE, NULL,
1033                            &parmKey, &dummyDisp);
1034     if (code != ERROR_SUCCESS)
1035         return -1;
1036
1037     code = RegSetValueEx(parmKey, labelp, 0, REG_DWORD,
1038                           (LPBYTE)&value, sizeof(value));
1039     RegCloseKey (parmKey);
1040     if (code != ERROR_SUCCESS)
1041         return -1;
1042
1043     return 0;
1044 }
1045
1046 cm_configFile_t *cm_OpenCellFile(void)
1047 {
1048     cm_configFile_t *cfp;
1049
1050     cfp = cm_CommonOpen(AFS_CELLSERVDB ".new", "w");
1051     return cfp;
1052 }
1053
1054 long cm_AppendPrunedCellList(cm_configFile_t *ofp, char *cellNamep)
1055 {
1056     cm_configFile_t *tfilep;    /* input file */
1057     char *tp;
1058     char lineBuffer[256];
1059     char *valuep;
1060     int inRightCell;
1061     int foundCell;
1062
1063     tfilep = cm_CommonOpen(AFS_CELLSERVDB, "r");
1064     if (!tfilep)
1065         return -1;
1066
1067     foundCell = 0;
1068
1069     /* have we seen the cell line for the guy we're looking for? */
1070     inRightCell = 0;
1071     while (1) {
1072         tp = fgets(lineBuffer, sizeof(lineBuffer), (FILE *)tfilep);
1073         if (tp == NULL) {
1074             if (feof((FILE *)tfilep)) {
1075                 /* hit EOF */
1076                 fclose((FILE *)tfilep);
1077                 return 0;
1078             }
1079         }
1080
1081         /* turn trailing cr or lf into null */
1082         tp = strchr(lineBuffer, '\r');
1083         if (tp) *tp = 0;
1084         tp = strchr(lineBuffer, '\n');
1085         if (tp) *tp = 0;
1086
1087         /* skip blank lines */
1088         if (lineBuffer[0] == 0) {
1089             fprintf((FILE *)ofp, "%s\n", lineBuffer);
1090             continue;
1091         }
1092
1093         if (lineBuffer[0] == '>') {
1094             /* trim off at white space or '#' chars */
1095             tp = strchr(lineBuffer, ' ');
1096             if (tp) *tp = 0;
1097             tp = strchr(lineBuffer, '\t');
1098             if (tp) *tp = 0;
1099             tp = strchr(lineBuffer, '#');
1100             if (tp) *tp = 0;
1101
1102             /* now see if this is the right cell */
1103             if (strcmp(lineBuffer+1, cellNamep) == 0) {
1104                 /* found the cell we're looking for */
1105                 inRightCell = 1;
1106             }
1107             else {
1108                 inRightCell = 0;
1109                 fprintf((FILE *)ofp, "%s\n", lineBuffer);
1110             }
1111         }
1112         else {
1113             valuep = strchr(lineBuffer, '#');
1114             if (valuep == NULL) return -2;
1115             valuep++;   /* skip the "#" */
1116             if (!inRightCell) {
1117                 fprintf((FILE *)ofp, "%s\n", lineBuffer);
1118             }
1119         }       /* a vldb line */
1120     }           /* while loop processing all lines */
1121 }
1122
1123 long cm_AppendNewCell(cm_configFile_t *filep, char *cellNamep)
1124 {
1125     fprintf((FILE *)filep, ">%s\n", cellNamep);
1126     return 0;
1127 }
1128
1129 long cm_AppendNewCellLine(cm_configFile_t *filep, char *linep)
1130 {
1131     fprintf((FILE *)filep, "%s\n", linep);
1132     return 0;
1133 }
1134
1135 long cm_CloseCellFile(cm_configFile_t *filep)
1136 {
1137     char wdir[MAX_PATH];
1138     char sdir[MAX_PATH];
1139     long code;
1140     long closeCode = fclose((FILE *)filep);
1141
1142     cm_GetConfigDir(wdir, sizeof(wdir));
1143     if (FAILED(StringCchCopy(sdir, sizeof(sdir), wdir)))
1144         return -1;
1145
1146     if (closeCode != 0) {
1147         /* something went wrong, preserve original database */
1148         if (FAILED(StringCchCat(wdir, sizeof(wdir), AFS_CELLSERVDB ".new")))
1149             return -1;
1150         unlink(wdir);
1151         return closeCode;
1152     }
1153
1154     if (FAILED(StringCchCat(wdir, sizeof(wdir), AFS_CELLSERVDB)))
1155         return -1;
1156     if (FAILED(StringCchCat(sdir, sizeof(sdir), AFS_CELLSERVDB ".new"))) /* new file */
1157         return -1;
1158
1159     unlink(sdir);                       /* delete old file */
1160
1161     code = rename(sdir, wdir);  /* do the rename */
1162
1163     if (code)
1164         code = errno;
1165
1166     return code;
1167 }
1168
1169 void cm_GetConfigDir(char *dir, afs_uint32 len)
1170 {
1171     char * dirp = NULL;
1172
1173     if (!afssw_GetClientCellServDBDir(&dirp)) {
1174         if (FAILED(StringCchCopy(dir, len, dirp)))
1175             return;
1176         free(dirp);
1177     } else {
1178         dir[0] = '\0';
1179     }
1180 }