src/WINNT/afsd/afsd_init.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 #include <afs/afs_args.h>
  13
  14 #include <windows.h>
  15 #include <string.h>
  16 #include <nb30.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <winsock2.h>
  20
  21 #include <osi.h>
  22 #include "afsd.h"
  23 #include <rx\rx.h>
  24 #include <rx\rx_null.h>
  25
  26 #include <WINNT/syscfg.h>
  27
  28 #include "smb.h"
  29 #include "cm_rpc.h"
  30
  31 extern int RXAFSCB_ExecuteRequest();
  32 extern int RXSTATS_ExecuteRequest();
  33
  34 extern afs_int32 cryptall;
  35
  36 char AFSConfigKeyName[] =
  37         "SYSTEM\\CurrentControlSet\\Services\\TransarcAFSDaemon\\Parameters";
  38
  39 osi_log_t *afsd_logp;
  40
  41 char cm_rootVolumeName[64];
  42 DWORD cm_rootVolumeNameLen;
  43 cm_volume_t *cm_rootVolumep = NULL;
  44 cm_cell_t *cm_rootCellp = NULL;
  45 cm_fid_t cm_rootFid;
  46 cm_scache_t *cm_rootSCachep;
  47 char cm_mountRoot[1024];
  48 DWORD cm_mountRootLen;
  49 int cm_logChunkSize;
  50 int cm_chunkSize;
  51 #ifdef AFS_FREELANCE_CLIENT
  52 char *cm_FakeRootDir;
  53 #endif /* freelance */
  54
  55 int smb_UseV3;
  56
  57 int LANadapter;
  58
  59 int numBkgD;
  60 int numSvThreads;
  61
  62 int traceOnPanic = 0;
  63
  64 int logReady = 0;
  65
  66 char cm_HostName[200];
  67 long cm_HostAddr;
  68
  69 char cm_CachePath[200];
  70 DWORD cm_CachePathLen;
  71
  72 BOOL isGateway = FALSE;
  73
  74 BOOL reportSessionStartups = FALSE;
  75
  76 cm_initparams_v1 cm_initParams;
  77
  78 /*
  79  * AFSD Initialization Log
  80  *
  81  * This is distinct from the regular debug logging facility.
  82  * Log items go directly to a file, not to an array in memory, so that even
  83  * if AFSD crashes, the log can be inspected.
  84  */
  85
  86 HANDLE afsi_file;
  87
  88 #ifdef AFS_AFSDB_ENV
  89 int cm_dnsEnabled = 1;
  90 #endif
  91
  92 char cm_NetBiosName[32];
  93
  94 void cm_InitFakeRootDir();
  95
  96 void
  97 afsi_start()
  98 {
  99         char wd[100];
 100         char t[100], u[100];
 101         int zilch;
 102         int code;
 103
 104         afsi_file = INVALID_HANDLE_VALUE;
 105         code = GetWindowsDirectory(wd, sizeof(wd));
 106         if (code == 0) return;
 107         strcat(wd, "\\afsd_init.log");
 108         GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, NULL, NULL, t, sizeof(t));
 109         afsi_file = CreateFile(wd, GENERIC_WRITE, FILE_SHARE_READ, NULL,
 110                            OPEN_ALWAYS, FILE_FLAG_WRITE_THROUGH, NULL);
 111     SetFilePointer(afsi_file, 0, NULL, FILE_END);
 112         GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, NULL, NULL, u, sizeof(u));
 113         strcat(t, ": Create log file\n");
 114         strcat(u, ": Created log file\n");
 115         WriteFile(afsi_file, t, strlen(t), &zilch, NULL);
 116         WriteFile(afsi_file, u, strlen(u), &zilch, NULL);
 117 }
 118
 119 static int afsi_log_useTimestamp = 1;
 120
 121 void
 122 afsi_log(char *pattern, ...)
 123 {
 124         char s[100], t[100], u[100];
 125         int zilch;
 126         va_list ap;
 127         va_start(ap, pattern);
 128
 129         vsprintf(s, pattern, ap);
 130     if ( afsi_log_useTimestamp ) {
 131         GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, NULL, NULL, t, sizeof(t));
 132         sprintf(u, "%s: %s\n", t, s);
 133         if (afsi_file != INVALID_HANDLE_VALUE)
 134             WriteFile(afsi_file, u, strlen(u), &zilch, NULL);
 135     } else {
 136         if (afsi_file != INVALID_HANDLE_VALUE)
 137             WriteFile(afsi_file, s, strlen(s), &zilch, NULL);
 138     }
 139 }
 140
 141 /*
 142  * Standard AFSD trace
 143  */
 144
 145 void afsd_ForceTrace(BOOL flush)
 146 {
 147         HANDLE handle;
 148         int len;
 149         char buf[100];
 150
 151         if (!logReady) return;
 152
 153         len = GetTempPath(99, buf);
 154         strcpy(&buf[len], "/afsd.log");
 155         handle = CreateFile(buf, GENERIC_WRITE, FILE_SHARE_READ,
 156                             NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 157         if (handle == INVALID_HANDLE_VALUE) {
 158                 logReady = 0;
 159                 osi_panic("Cannot create log file", __FILE__, __LINE__);
 160         }
 161         osi_LogPrint(afsd_logp, handle);
 162         if (flush)
 163                 FlushFileBuffers(handle);
 164         CloseHandle(handle);
 165 }
 166
 167 /*
 168  * AFSD Initialization
 169  */
 170
 171 int afsd_InitCM(char **reasonP)
 172 {
 173         osi_uid_t debugID;
 174         long cacheBlocks;
 175         long cacheSize;
 176         long logChunkSize;
 177         long stats;
 178         long traceBufSize;
 179         long ltt, ltto;
 180         char rootCellName[256];
 181         struct rx_service *serverp;
 182         static struct rx_securityClass *nullServerSecurityClassp;
 183         struct hostent *thp;
 184         char *msgBuf;
 185         char buf[200];
 186         HKEY parmKey;
 187         DWORD dummyLen;
 188         long code;
 189         /*int freelanceEnabled;*/
 190         WSADATA WSAjunk;
 191
 192         WSAStartup(0x0101, &WSAjunk);
 193
 194         /* setup osidebug server at RPC slot 1000 */
 195         osi_LongToUID(1000, &debugID);
 196         code = osi_InitDebug(&debugID);
 197         afsi_log("osi_InitDebug code %d", code);
 198 //      osi_LockTypeSetDefault("stat"); /* comment this out for speed *
 199         if (code != 0) {
 200                 *reasonP = "unknown error";
 201                 return -1;
 202         }
 203
 204         /* who are we ? */
 205         gethostname(cm_HostName, sizeof(cm_HostName));
 206         afsi_log("gethostname %s", cm_HostName);
 207         thp = gethostbyname(cm_HostName);
 208         memcpy(&cm_HostAddr, thp->h_addr_list[0], 4);
 209
 210         /* seed random number generator */
 211         srand(ntohl(cm_HostAddr));
 212
 213         /* Look up configuration parameters in Registry */
 214
 215         code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSConfigKeyName,
 216                                 0, KEY_QUERY_VALUE, &parmKey);
 217         if (code != ERROR_SUCCESS) {
 218                 FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
 219                                 | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 220                               NULL, code, 0, (LPTSTR)&msgBuf, 0, NULL);
 221                 sprintf(buf,
 222                         "Failure in configuration while opening Registry: %s",
 223                         msgBuf);
 224                 osi_panic(buf, __FILE__, __LINE__);
 225         }
 226
 227         dummyLen = sizeof(LANadapter);
 228         code = RegQueryValueEx(parmKey, "LANadapter", NULL, NULL,
 229                                 (BYTE *) &LANadapter, &dummyLen);
 230         if (code == ERROR_SUCCESS)
 231                 afsi_log("LAN adapter number %d", LANadapter);
 232         else {
 233                 LANadapter = -1;
 234                 afsi_log("Default LAN adapter number");
 235         }
 236
 237         dummyLen = sizeof(cacheSize);
 238         code = RegQueryValueEx(parmKey, "CacheSize", NULL, NULL,
 239                                 (BYTE *) &cacheSize, &dummyLen);
 240         if (code == ERROR_SUCCESS)
 241                 afsi_log("Cache size %d", cacheSize);
 242         else {
 243                 cacheSize = CM_CONFIGDEFAULT_CACHESIZE;
 244                 afsi_log("Default cache size %d", cacheSize);
 245         }
 246
 247         dummyLen = sizeof(logChunkSize);
 248         code = RegQueryValueEx(parmKey, "ChunkSize", NULL, NULL,
 249                                 (BYTE *) &logChunkSize, &dummyLen);
 250         if (code == ERROR_SUCCESS) {
 251                 if (logChunkSize < 12 || logChunkSize > 30) {
 252                         afsi_log("Invalid chunk size %d, using default",
 253                                  logChunkSize);
 254                         logChunkSize = CM_CONFIGDEFAULT_CHUNKSIZE;
 255                 }
 256                 afsi_log("Chunk size %d", logChunkSize);
 257         } else {
 258                 logChunkSize = CM_CONFIGDEFAULT_CHUNKSIZE;
 259                 afsi_log("Default chunk size %d", logChunkSize);
 260         }
 261         cm_logChunkSize = logChunkSize;
 262         cm_chunkSize = 1 << logChunkSize;
 263
 264         dummyLen = sizeof(numBkgD);
 265         code = RegQueryValueEx(parmKey, "Daemons", NULL, NULL,
 266                                 (BYTE *) &numBkgD, &dummyLen);
 267         if (code == ERROR_SUCCESS)
 268                 afsi_log("%d background daemons", numBkgD);
 269         else {
 270                 numBkgD = CM_CONFIGDEFAULT_DAEMONS;
 271                 afsi_log("Defaulting to %d background daemons", numBkgD);
 272         }
 273
 274         dummyLen = sizeof(numSvThreads);
 275         code = RegQueryValueEx(parmKey, "ServerThreads", NULL, NULL,
 276                                 (BYTE *) &numSvThreads, &dummyLen);
 277         if (code == ERROR_SUCCESS)
 278                 afsi_log("%d server threads", numSvThreads);
 279         else {
 280                 numSvThreads = CM_CONFIGDEFAULT_SVTHREADS;
 281                 afsi_log("Defaulting to %d server threads", numSvThreads);
 282         }
 283
 284         dummyLen = sizeof(stats);
 285         code = RegQueryValueEx(parmKey, "Stats", NULL, NULL,
 286                                 (BYTE *) &stats, &dummyLen);
 287         if (code == ERROR_SUCCESS)
 288                 afsi_log("Status cache size %d", stats);
 289         else {
 290                 stats = CM_CONFIGDEFAULT_STATS;
 291                 afsi_log("Default status cache size %d", stats);
 292         }
 293
 294         dummyLen = sizeof(ltt);
 295         code = RegQueryValueEx(parmKey, "LogoffTokenTransfer", NULL, NULL,
 296                                 (BYTE *) &ltt, &dummyLen);
 297         if (code == ERROR_SUCCESS)
 298                 afsi_log("Logoff token transfer %s",  (ltt ? "on" : "off"));
 299         else {
 300                 ltt = 1;
 301                 afsi_log("Logoff token transfer on by default");
 302         }
 303         smb_LogoffTokenTransfer = ltt;
 304
 305         if (ltt) {
 306                 dummyLen = sizeof(ltto);
 307                 code = RegQueryValueEx(parmKey, "LogoffTokenTransferTimeout",
 308                                         NULL, NULL, (BYTE *) &ltto, &dummyLen);
 309                 if (code == ERROR_SUCCESS)
 310                         afsi_log("Logoff token tranfer timeout %d seconds",
 311                                  ltto);
 312                 else {
 313                         ltto = 10;
 314                         afsi_log("Default logoff token transfer timeout 10 seconds");
 315                 }
 316         }
 317         smb_LogoffTransferTimeout = ltto;
 318
 319         dummyLen = sizeof(cm_rootVolumeName);
 320         code = RegQueryValueEx(parmKey, "RootVolume", NULL, NULL,
 321                                 cm_rootVolumeName, &dummyLen);
 322         if (code == ERROR_SUCCESS)
 323                 afsi_log("Root volume %s", cm_rootVolumeName);
 324         else {
 325                 strcpy(cm_rootVolumeName, "root.afs");
 326                 afsi_log("Default root volume name root.afs");
 327         }
 328
 329         cm_mountRootLen = sizeof(cm_mountRoot);
 330         code = RegQueryValueEx(parmKey, "Mountroot", NULL, NULL,
 331                                 cm_mountRoot, &cm_mountRootLen);
 332         if (code == ERROR_SUCCESS) {
 333                 afsi_log("Mount root %s", cm_mountRoot);
 334                 cm_mountRootLen = strlen(cm_mountRoot);
 335         } else {
 336                 strcpy(cm_mountRoot, "/afs");
 337                 cm_mountRootLen = 4;
 338                 /* Don't log */
 339         }
 340
 341         dummyLen = sizeof(cm_CachePath);
 342         code = RegQueryValueEx(parmKey, "CachePath", NULL, NULL,
 343                                 cm_CachePath, &dummyLen);
 344         if (code == ERROR_SUCCESS)
 345                 afsi_log("Cache path %s", cm_CachePath);
 346         else {
 347                 GetWindowsDirectory(cm_CachePath, sizeof(cm_CachePath));
 348                 cm_CachePath[2] = 0;    /* get drive letter only */
 349                 strcat(cm_CachePath, "\\AFSCache");
 350                 afsi_log("Default cache path %s", cm_CachePath);
 351         }
 352
 353         dummyLen = sizeof(traceOnPanic);
 354         code = RegQueryValueEx(parmKey, "TrapOnPanic", NULL, NULL,
 355                                 (BYTE *) &traceOnPanic, &dummyLen);
 356         if (code == ERROR_SUCCESS)
 357                 afsi_log("Set to %s on panic",
 358                          traceOnPanic ? "trap" : "not trap");
 359         else {
 360                 traceOnPanic = 0;
 361                 /* Don't log */
 362         }
 363
 364         dummyLen = sizeof(isGateway);
 365         code = RegQueryValueEx(parmKey, "IsGateway", NULL, NULL,
 366                                 (BYTE *) &isGateway, &dummyLen);
 367         if (code == ERROR_SUCCESS)
 368                 afsi_log("Set for %s service",
 369                          isGateway ? "gateway" : "stand-alone");
 370         else {
 371                 isGateway = 0;
 372                 /* Don't log */
 373         }
 374
 375         dummyLen = sizeof(reportSessionStartups);
 376         code = RegQueryValueEx(parmKey, "ReportSessionStartups", NULL, NULL,
 377                                 (BYTE *) &reportSessionStartups, &dummyLen);
 378         if (code == ERROR_SUCCESS)
 379                 afsi_log("Session startups %s be recorded in the Event Log",
 380                          reportSessionStartups ? "will" : "will not");
 381         else {
 382                 reportSessionStartups = 0;
 383                 /* Don't log */
 384         }
 385
 386         dummyLen = sizeof(traceBufSize);
 387         code = RegQueryValueEx(parmKey, "TraceBufferSize", NULL, NULL,
 388                                 (BYTE *) &traceBufSize, &dummyLen);
 389         if (code == ERROR_SUCCESS)
 390                 afsi_log("Trace Buffer size %d", traceBufSize);
 391         else {
 392                 traceBufSize = CM_CONFIGDEFAULT_TRACEBUFSIZE;
 393                 afsi_log("Default trace buffer size %d", traceBufSize);
 394         }
 395
 396         dummyLen = sizeof(cm_sysName);
 397         code = RegQueryValueEx(parmKey, "SysName", NULL, NULL,
 398                                 cm_sysName, &dummyLen);
 399         if (code == ERROR_SUCCESS)
 400                 afsi_log("Sys name %s", cm_sysName);
 401         else {
 402                 strcat(cm_sysName, "i386_nt40");
 403                 afsi_log("Default sys name %s", cm_sysName);
 404         }
 405
 406         dummyLen = sizeof(cryptall);
 407         code = RegQueryValueEx(parmKey, "SecurityLevel", NULL, NULL,
 408                                 (BYTE *) &cryptall, &dummyLen);
 409         if (code == ERROR_SUCCESS)
 410                 afsi_log("SecurityLevel is %s", cryptall?"crypt":"clear");
 411         else {
 412                 cryptall = rxkad_clear;
 413                 afsi_log("Default SecurityLevel is clear");
 414         }
 415
 416 #ifdef AFS_AFSDB_ENV
 417         dummyLen = sizeof(cm_dnsEnabled);
 418         code = RegQueryValueEx(parmKey, "UseDNS", NULL, NULL,
 419                                 (BYTE *) &cm_dnsEnabled, &dummyLen);
 420         if (code == ERROR_SUCCESS) {
 421                 afsi_log("DNS %s be used to find AFS cell servers",
 422                          cm_dnsEnabled ? "will" : "will not");
 423         }
 424         else {
 425           cm_dnsEnabled = 1;   /* default on */
 426           afsi_log("Default to use DNS to find AFS cell servers");
 427         }
 428 #else /* AFS_AFSDB_ENV */
 429         afsi_log("AFS not built with DNS support to find AFS cell servers");
 430 #endif /* AFS_AFSDB_ENV */
 431
 432 #ifdef AFS_FREELANCE_CLIENT
 433         dummyLen = sizeof(cm_freelanceEnabled);
 434         code = RegQueryValueEx(parmKey, "FreelanceClient", NULL, NULL,
 435                                 (BYTE *) &cm_freelanceEnabled, &dummyLen);
 436         if (code == ERROR_SUCCESS) {
 437                 afsi_log("Freelance client feature %s activated",
 438                          cm_freelanceEnabled ? "is" : "is not");
 439         }
 440         else {
 441           cm_freelanceEnabled = 0;  /* default off */
 442         }
 443 #endif /* AFS_FREELANCE_CLIENT */
 444
 445     dummyLen = sizeof(cm_NetBiosName);
 446     code = RegQueryValueEx(parmKey, "NetbiosName", NULL, NULL,
 447                            (BYTE *) &cm_NetBiosName, &dummyLen);
 448     if (code == ERROR_SUCCESS) {
 449         afsi_log("Explicit NetBios name is used %s", cm_NetBiosName);
 450     }
 451     else {
 452         cm_NetBiosName[0] = 0;   /* default off */
 453     }
 454
 455         RegCloseKey (parmKey);
 456
 457         /* setup early variables */
 458         /* These both used to be configurable. */
 459         smb_UseV3 = 1;
 460         buf_bufferSize = CM_CONFIGDEFAULT_BLOCKSIZE;
 461
 462         /* turn from 1024 byte units into memory blocks */
 463         cacheBlocks = (cacheSize * 1024) / buf_bufferSize;
 464
 465         /* setup and enable debug log */
 466         afsd_logp = osi_LogCreate("afsd", traceBufSize);
 467         afsi_log("osi_LogCreate log addr %x", afsd_logp);
 468         osi_LogEnable(afsd_logp);
 469         logReady = 1;
 470
 471         /* get network related info */
 472         cm_noIPAddr = CM_MAXINTERFACE_ADDR;
 473         code = syscfg_GetIFInfo(&cm_noIPAddr,
 474                                 cm_IPAddr, cm_SubnetMask,
 475                                 cm_NetMtu, cm_NetFlags);
 476
 477         if ( (cm_noIPAddr <= 0) || (code <= 0 ) )
 478             afsi_log("syscfg_GetIFInfo error code %d", code);
 479         else
 480             afsi_log("First Network address %x SubnetMask %x",
 481                      cm_IPAddr[0], cm_SubnetMask[0]);
 482
 483         /*
 484          * Save client configuration for GetCacheConfig requests
 485          */
 486         cm_initParams.nChunkFiles = 0;
 487         cm_initParams.nStatCaches = stats;
 488         cm_initParams.nDataCaches = 0;
 489         cm_initParams.nVolumeCaches = 0;
 490         cm_initParams.firstChunkSize = cm_chunkSize;
 491         cm_initParams.otherChunkSize = cm_chunkSize;
 492         cm_initParams.cacheSize = cacheSize;
 493         cm_initParams.setTime = 0;
 494         cm_initParams.memCache = 0;
 495
 496         /* initialize RX, and tell it to listen to port 7001, which is used for
 497          * callback RPC messages.
 498          */
 499         code = rx_Init(htons(7001));
 500         afsi_log("rx_Init code %x", code);
 501         if (code != 0) {
 502                 *reasonP = "afsd: failed to init rx client on port 7001";
 503                 return -1;
 504         }
 505
 506         /* Initialize the RPC server for session keys */
 507         RpcInit();
 508
 509         /* create an unauthenticated service #1 for callbacks */
 510         nullServerSecurityClassp = rxnull_NewServerSecurityObject();
 511         serverp = rx_NewService(0, 1, "AFS", &nullServerSecurityClassp, 1,
 512                 RXAFSCB_ExecuteRequest);
 513         afsi_log("rx_NewService addr %x", serverp);
 514         if (serverp == NULL) {
 515                 *reasonP = "unknown error";
 516                 return -1;
 517         }
 518
 519         nullServerSecurityClassp = rxnull_NewServerSecurityObject();
 520         serverp = rx_NewService(0, RX_STATS_SERVICE_ID, "rpcstats",
 521                 &nullServerSecurityClassp, 1, RXSTATS_ExecuteRequest);
 522         afsi_log("rx_NewService addr %x", serverp);
 523         if (serverp == NULL) {
 524                 *reasonP = "unknown error";
 525                 return -1;
 526         }
 527
 528         /* start server threads, *not* donating this one to the pool */
 529         rx_StartServer(0);
 530         afsi_log("rx_StartServer");
 531
 532         /* init user daemon, and other packages */
 533         cm_InitUser();
 534
 535         cm_InitACLCache(2*stats);
 536
 537         cm_InitConn();
 538
 539         cm_InitCell();
 540
 541         cm_InitServer();
 542
 543         cm_InitVolume();
 544
 545         cm_InitIoctl();
 546
 547         smb_InitIoctl();
 548
 549         cm_InitCallback();
 550
 551         cm_InitSCache(stats);
 552
 553         code = cm_InitDCache(0, cacheBlocks);
 554         afsi_log("cm_InitDCache code %x", code);
 555         if (code != 0) {
 556                 *reasonP = "error initializing cache";
 557                 return -1;
 558         }
 559
 560 #ifdef AFS_AFSDB_ENV
 561         if (cm_InitDNS(cm_dnsEnabled) == -1)
 562           cm_dnsEnabled = 0;  /* init failed, so deactivate */
 563         afsi_log("cm_InitDNS %d", cm_dnsEnabled);
 564 #endif
 565
 566         code = cm_GetRootCellName(rootCellName);
 567         afsi_log("cm_GetRootCellName code %d rcn %s", code,
 568                  (code ? "<none>" : rootCellName));
 569         if (code != 0 && !cm_freelanceEnabled) {
 570             *reasonP = "can't find root cell name in afsd.ini";
 571             return -1;
 572         }
 573         else if (cm_freelanceEnabled)
 574           cm_rootCellp = NULL;
 575
 576         if (code == 0 && !cm_freelanceEnabled) {
 577           cm_rootCellp = cm_GetCell(rootCellName, CM_FLAG_CREATE);
 578           afsi_log("cm_GetCell addr %x", cm_rootCellp);
 579           if (cm_rootCellp == NULL) {
 580             *reasonP = "can't find root cell in afsdcell.ini";
 581             return -1;
 582           }
 583         }
 584
 585 #ifdef AFS_FREELANCE_CLIENT
 586         if (cm_freelanceEnabled)
 587           cm_InitFreelance();
 588 #endif
 589
 590         return 0;
 591 }
 592
 593 int afsd_InitDaemons(char **reasonP)
 594 {
 595         long code;
 596         cm_req_t req;
 597
 598         cm_InitReq(&req);
 599
 600         /* this should really be in an init daemon from here on down */
 601
 602         if (!cm_freelanceEnabled) {
 603           code = cm_GetVolumeByName(cm_rootCellp, cm_rootVolumeName, cm_rootUserp,
 604                                     &req, CM_FLAG_CREATE, &cm_rootVolumep);
 605           afsi_log("cm_GetVolumeByName code %x root vol %x", code,
 606                    (code ? 0xffffffff : cm_rootVolumep));
 607           if (code != 0) {
 608             *reasonP = "can't find root volume in root cell";
 609             return -1;
 610           }
 611         }
 612
 613         /* compute the root fid */
 614         if (!cm_freelanceEnabled) {
 615           cm_rootFid.cell = cm_rootCellp->cellID;
 616           cm_rootFid.volume = cm_GetROVolumeID(cm_rootVolumep);
 617           cm_rootFid.vnode = 1;
 618           cm_rootFid.unique = 1;
 619         }
 620         else
 621           cm_FakeRootFid(&cm_rootFid);
 622
 623         code = cm_GetSCache(&cm_rootFid, &cm_rootSCachep, cm_rootUserp, &req);
 624         afsi_log("cm_GetSCache code %x scache %x", code,
 625                  (code ? 0xffffffff : cm_rootSCachep));
 626         if (code != 0) {
 627                 *reasonP = "unknown error";
 628                 return -1;
 629         }
 630
 631         cm_InitDaemon(numBkgD);
 632         afsi_log("cm_InitDaemon");
 633
 634         return 0;
 635 }
 636
 637 int afsd_InitSMB(char **reasonP, void *aMBfunc)
 638 {
 639         char hostName[200];
 640         char *ctemp;
 641
 642         /* Do this last so that we don't handle requests before init is done.
 643      * Here we initialize the SMB listener.
 644      */
 645     if (!cm_NetBiosName[0])
 646     {
 647         strcpy(hostName, cm_HostName);
 648         ctemp = strchr(hostName, '.');  /* turn ntdfs.* into ntdfs */
 649         if (ctemp) *ctemp = 0;
 650             hostName[11] = 0; /* ensure that even after adding the -A, we
 651                                * leave one byte free for the netbios server
 652                                * type.
 653                                */
 654         strcat(hostName, "-AFS");
 655     } else {
 656         strcpy(hostName, cm_NetBiosName);
 657     }
 658     _strupr(hostName);
 659
 660     smb_Init(afsd_logp, hostName, smb_UseV3, LANadapter, numSvThreads,
 661              aMBfunc);
 662         afsi_log("smb_Init");
 663
 664         return 0;
 665 }
 666
 667 #ifdef ReadOnly
 668 #undef ReadOnly
 669 #endif
 670
 671 #ifdef File
 672 #undef File
 673 #endif
 674
 675 #pragma pack( push, before_imagehlp, 8 )
 676 #include <imagehlp.h>
 677 #pragma pack( pop, before_imagehlp )
 678
 679 #define MAXNAMELEN 1024
 680
 681 void afsd_printStack(HANDLE hThread, CONTEXT *c)
 682 {
 683     HANDLE hProcess = GetCurrentProcess();
 684     int frameNum;
 685     DWORD offset;
 686     DWORD symOptions;
 687     char functionName[MAXNAMELEN];
 688
 689     IMAGEHLP_MODULE Module;
 690     IMAGEHLP_LINE Line;
 691
 692     STACKFRAME s;
 693     IMAGEHLP_SYMBOL *pSym;
 694
 695     afsi_log_useTimestamp = 0;
 696
 697     pSym = (IMAGEHLP_SYMBOL *) GlobalAlloc(0, sizeof (IMAGEHLP_SYMBOL) + MAXNAMELEN);
 698
 699     memset( &s, '\0', sizeof s );
 700     if (!SymInitialize(hProcess, NULL, 1) )
 701     {
 702         afsi_log("SymInitialize(): GetLastError() = %lu\n", GetLastError() );
 703
 704         SymCleanup( hProcess );
 705         GlobalFree(pSym);
 706
 707         return;
 708     }
 709
 710     symOptions = SymGetOptions();
 711     symOptions |= SYMOPT_LOAD_LINES;
 712     symOptions &= ~SYMOPT_UNDNAME;
 713     SymSetOptions( symOptions );
 714
 715     /*
 716      * init STACKFRAME for first call
 717      * Notes: AddrModeFlat is just an assumption. I hate VDM debugging.
 718      * Notes: will have to be #ifdef-ed for Alphas; MIPSes are dead anyway,
 719      * and good riddance.
 720      */
 721 #if defined (_ALPHA_) || defined (_MIPS_) || defined (_PPC_)
 722 #error The STACKFRAME initialization in afsd_printStack() for this platform
 723 #error must be properly configured
 724 #else
 725     s.AddrPC.Offset = c->Eip;
 726     s.AddrPC.Mode = AddrModeFlat;
 727     s.AddrFrame.Offset = c->Ebp;
 728     s.AddrFrame.Mode = AddrModeFlat;
 729 #endif
 730
 731     memset( pSym, '\0', sizeof (IMAGEHLP_SYMBOL) + MAXNAMELEN );
 732     pSym->SizeOfStruct = sizeof (IMAGEHLP_SYMBOL);
 733     pSym->MaxNameLength = MAXNAMELEN;
 734
 735     memset( &Line, '\0', sizeof Line );
 736     Line.SizeOfStruct = sizeof Line;
 737
 738     memset( &Module, '\0', sizeof Module );
 739     Module.SizeOfStruct = sizeof Module;
 740
 741     offset = 0;
 742
 743     afsi_log("\n--# FV EIP----- RetAddr- FramePtr StackPtr Symbol\n" );
 744
 745     for ( frameNum = 0; ; ++ frameNum )
 746     {
 747         /*
 748          * get next stack frame (StackWalk(), SymFunctionTableAccess(),
 749          * SymGetModuleBase()). if this returns ERROR_INVALID_ADDRESS (487) or
 750          * ERROR_NOACCESS (998), you can assume that either you are done, or
 751          * that the stack is so hosed that the next deeper frame could not be
 752          * found.
 753          */
 754         if ( ! StackWalk( IMAGE_FILE_MACHINE_I386, hProcess, hThread, &s, c,
 755                           NULL, SymFunctionTableAccess, SymGetModuleBase,
 756                           NULL ) )
 757             break;
 758
 759         /* display its contents */
 760         afsi_log("\n%3d %c%c %08lx %08lx %08lx %08lx ",
 761                  frameNum, s.Far? 'F': '.', s.Virtual? 'V': '.',
 762                  s.AddrPC.Offset, s.AddrReturn.Offset,
 763                  s.AddrFrame.Offset, s.AddrStack.Offset );
 764
 765         if ( s.AddrPC.Offset == 0 )
 766         {
 767             afsi_log("(-nosymbols- PC == 0)\n" );
 768         }
 769         else
 770         {
 771             /* show procedure info from a valid PC */
 772             if (!SymGetSymFromAddr(hProcess, s.AddrPC.Offset, &offset, pSym))
 773             {
 774                 if ( GetLastError() != ERROR_INVALID_ADDRESS )
 775                 {
 776                     afsi_log("SymGetSymFromAddr(): errno = %lu\n",
 777                              GetLastError());
 778                 }
 779             }
 780             else
 781             {
 782                 UnDecorateSymbolName(pSym->Name, functionName, MAXNAMELEN,
 783                                      UNDNAME_NAME_ONLY);
 784                 afsi_log("%s", functionName );
 785
 786                 if ( offset != 0 )
 787                 {
 788                     afsi_log(" %+ld bytes\n", (long) offset);
 789                 }
 790             }
 791
 792             if (!SymGetLineFromAddr(hProcess, s.AddrPC.Offset, &offset, &Line))
 793             {
 794                 if (GetLastError() != ERROR_INVALID_ADDRESS)
 795                 {
 796                     afsi_log("Error: SymGetLineFromAddr(): errno = %lu\n",
 797                              GetLastError());
 798                 }
 799             }
 800             else
 801             {
 802                 afsi_log("    Line: %s(%lu) %+ld bytes\n", Line.FileName,
 803                          Line.LineNumber, offset);
 804             }
 805
 806         }
 807
 808         /* no return address means no deeper stackframe */
 809         if (s.AddrReturn.Offset == 0)
 810         {
 811             SetLastError(0);
 812             break;
 813         }
 814     }
 815
 816     if (GetLastError() != 0)
 817     {
 818         afsi_log("\nStackWalk(): errno = %lu\n", GetLastError());
 819     }
 820
 821     SymCleanup(hProcess);
 822     GlobalFree(pSym);
 823 }
 824
 825 #ifdef _DEBUG
 826 static DWORD *afsd_crtDbgBreakCurrent = NULL;
 827 static DWORD afsd_crtDbgBreaks[256];
 828 #endif
 829
 830 LONG __stdcall afsd_ExceptionFilter(EXCEPTION_POINTERS *ep)
 831 {
 832     CONTEXT context;
 833 #ifdef _DEBUG
 834     BOOL allocRequestBrk = FALSE;
 835 #endif
 836
 837     afsi_log("UnhandledException : code : 0x%x, address: 0x%x\n",
 838              ep->ExceptionRecord->ExceptionCode,
 839              ep->ExceptionRecord->ExceptionAddress);
 840
 841 #ifdef _DEBUG
 842     if (afsd_crtDbgBreakCurrent &&
 843         *afsd_crtDbgBreakCurrent == _CrtSetBreakAlloc(*afsd_crtDbgBreakCurrent))
 844     {
 845         allocRequestBrk = TRUE;
 846         afsi_log("Breaking on alloc request # %d\n", *afsd_crtDbgBreakCurrent);
 847     }
 848 #endif
 849
 850     /* save context if we want to print the stack information */
 851     context = *ep->ContextRecord;
 852
 853     afsd_printStack(GetCurrentThread(), &context);
 854
 855     if (ep->ExceptionRecord->ExceptionCode == EXCEPTION_BREAKPOINT)
 856     {
 857         afsi_log("EXCEPTION_BREAKPOINT - continue execition ...\n");
 858
 859 #ifdef _DEBUG
 860         if (allocRequestBrk)
 861         {
 862             afsd_crtDbgBreakCurrent++;
 863             _CrtSetBreakAlloc(*afsd_crtDbgBreakCurrent);
 864         }
 865 #endif
 866
 867         ep->ContextRecord->Eip++;
 868         return EXCEPTION_CONTINUE_EXECUTION;
 869     }
 870     else
 871     {
 872         return EXCEPTION_CONTINUE_SEARCH;
 873     }
 874 }
 875
 876 void afsd_SetUnhandledExceptionFilter()
 877 {
 878     SetUnhandledExceptionFilter(afsd_ExceptionFilter);
 879 }
 880
 881 #ifdef _DEBUG
 882 void afsd_DbgBreakAllocInit()
 883 {
 884     memset(afsd_crtDbgBreaks, -1, sizeof(afsd_crtDbgBreaks));
 885     afsd_crtDbgBreakCurrent = afsd_crtDbgBreaks;
 886 }
 887
 888 void afsd_DbgBreakAdd(DWORD requestNumber)
 889 {
 890     int i;
 891     for (i = 0; i < sizeof(afsd_crtDbgBreaks) - 1; i++)
 892         {
 893         if (afsd_crtDbgBreaks[i] == -1)
 894             {
 895             break;
 896             }
 897         }
 898     afsd_crtDbgBreaks[i] = requestNumber;
 899
 900     _CrtSetBreakAlloc(afsd_crtDbgBreaks[0]);
 901 }
 902 #endif