src/WINNT/afsd/cm_daemon.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 #include <windows.h>
  14 #include <winsock2.h>
  15 #include <iphlpapi.h>
  16 #include <stdlib.h>
  17 #include <malloc.h>
  18 #include <string.h>
  19
  20 #include "afsd.h"
  21
  22 #include <rx/rx.h>
  23 #include <rx/rx_prototypes.h>
  24 #include <WINNT/afsreg.h>
  25
  26 #include "afsicf.h"
  27
  28 /* in seconds */
  29 long cm_daemonCheckDownInterval  = 180;
  30 long cm_daemonCheckUpInterval    = 600;
  31 long cm_daemonCheckVolInterval   = 3600;
  32 long cm_daemonCheckCBInterval    = 60;
  33 long cm_daemonCheckLockInterval  = 60;
  34 long cm_daemonTokenCheckInterval = 180;
  35
  36 osi_rwlock_t cm_daemonLock;
  37
  38 long cm_bkgQueueCount;          /* # of queued requests */
  39
  40 int cm_bkgWaitingForCount;      /* true if someone's waiting for cm_bkgQueueCount to drop */
  41
  42 cm_bkgRequest_t *cm_bkgListp;           /* first elt in the list of requests */
  43 cm_bkgRequest_t *cm_bkgListEndp;        /* last elt in the list of requests */
  44
  45 static int daemon_ShutdownFlag = 0;
  46
  47 void cm_IpAddrDaemon(long parm)
  48 {
  49     extern void smb_CheckVCs(void);
  50
  51     rx_StartClientThread();
  52
  53     while (daemon_ShutdownFlag == 0) {
  54         DWORD Result = NotifyAddrChange(NULL,NULL);
  55         if (Result == NO_ERROR && daemon_ShutdownFlag == 0) {
  56             osi_Log0(afsd_logp, "cm_IpAddrDaemon CheckDownServers");
  57             Sleep(2500);
  58             cm_ForceNewConnectionsAllServers();
  59             cm_CheckServers(CM_FLAG_CHECKUPSERVERS | CM_FLAG_CHECKDOWNSERVERS, NULL);
  60             smb_CheckVCs();
  61         }
  62     }
  63 }
  64
  65 void cm_BkgDaemon(long parm)
  66 {
  67     cm_bkgRequest_t *rp;
  68
  69     rx_StartClientThread();
  70
  71     lock_ObtainWrite(&cm_daemonLock);
  72     while (daemon_ShutdownFlag == 0) {
  73         if (!cm_bkgListEndp) {
  74             osi_SleepW((LONG_PTR)&cm_bkgListp, &cm_daemonLock);
  75             lock_ObtainWrite(&cm_daemonLock);
  76             continue;
  77         }
  78
  79         /* we found a request */
  80         rp = cm_bkgListEndp;
  81         cm_bkgListEndp = (cm_bkgRequest_t *) osi_QPrev(&rp->q);
  82         osi_QRemove((osi_queue_t **) &cm_bkgListp, &rp->q);
  83         osi_assert(cm_bkgQueueCount-- > 0);
  84         lock_ReleaseWrite(&cm_daemonLock);
  85
  86         osi_Log2(afsd_logp,"cm_BkgDaemon (before) scp 0x%x ref %d",rp->scp, rp->scp->refCount);
  87
  88         (*rp->procp)(rp->scp, rp->p1, rp->p2, rp->p3, rp->p4, rp->userp);
  89
  90         osi_Log2(afsd_logp,"cm_BkgDaemon (after) scp 0x%x ref %d",rp->scp, rp->scp->refCount);
  91
  92         cm_ReleaseUser(rp->userp);
  93         cm_ReleaseSCache(rp->scp);
  94         free(rp);
  95
  96         lock_ObtainWrite(&cm_daemonLock);
  97     }
  98     lock_ReleaseWrite(&cm_daemonLock);
  99 }
 100
 101 void cm_QueueBKGRequest(cm_scache_t *scp, cm_bkgProc_t *procp, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, afs_uint32 p4,
 102         cm_user_t *userp)
 103 {
 104     cm_bkgRequest_t *rp;
 105
 106     rp = malloc(sizeof(*rp));
 107     memset(rp, 0, sizeof(*rp));
 108
 109     cm_HoldSCache(scp);
 110     rp->scp = scp;
 111     cm_HoldUser(userp);
 112     rp->userp = userp;
 113     rp->procp = procp;
 114     rp->p1 = p1;
 115     rp->p2 = p2;
 116     rp->p3 = p3;
 117     rp->p4 = p4;
 118
 119     lock_ObtainWrite(&cm_daemonLock);
 120     cm_bkgQueueCount++;
 121     osi_QAdd((osi_queue_t **) &cm_bkgListp, &rp->q);
 122     if (!cm_bkgListEndp)
 123         cm_bkgListEndp = rp;
 124     lock_ReleaseWrite(&cm_daemonLock);
 125
 126     osi_Wakeup((LONG_PTR) &cm_bkgListp);
 127 }
 128
 129 static int
 130 IsWindowsFirewallPresent(void)
 131 {
 132     SC_HANDLE scm;
 133     SC_HANDLE svc;
 134     BOOLEAN flag;
 135     BOOLEAN result = FALSE;
 136     LPQUERY_SERVICE_CONFIG pConfig = NULL;
 137     DWORD BufSize;
 138     LONG status;
 139
 140     /* Open services manager */
 141     scm = OpenSCManager(NULL, NULL, GENERIC_READ);
 142     if (!scm) return FALSE;
 143
 144     /* Open Windows Firewall service */
 145     svc = OpenService(scm, "MpsSvc", SERVICE_QUERY_CONFIG);
 146     if (!svc) {
 147         afsi_log("MpsSvc Service could not be opened for query: 0x%x", GetLastError());
 148         svc = OpenService(scm, "SharedAccess", SERVICE_QUERY_CONFIG);
 149         if (!svc)
 150             afsi_log("SharedAccess Service could not be opened for query: 0x%x", GetLastError());
 151     }
 152     if (!svc)
 153         goto close_scm;
 154
 155     /* Query Windows Firewall service config, first just to get buffer size */
 156     /* Expected to fail, so don't test return value */
 157     (void) QueryServiceConfig(svc, NULL, 0, &BufSize);
 158     status = GetLastError();
 159     if (status != ERROR_INSUFFICIENT_BUFFER)
 160         goto close_svc;
 161
 162     /* Allocate buffer */
 163     pConfig = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(GMEM_FIXED,BufSize);
 164     if (!pConfig)
 165         goto close_svc;
 166
 167     /* Query Windows Firewall service config, this time for real */
 168     flag = QueryServiceConfig(svc, pConfig, BufSize, &BufSize);
 169     if (!flag) {
 170         afsi_log("QueryServiceConfig failed: 0x%x", GetLastError());
 171         goto free_pConfig;
 172     }
 173
 174     /* Is it autostart? */
 175     afsi_log("AutoStart 0x%x", pConfig->dwStartType);
 176     if (pConfig->dwStartType < SERVICE_DEMAND_START)
 177         result = TRUE;
 178
 179   free_pConfig:
 180     GlobalFree(pConfig);
 181   close_svc:
 182     CloseServiceHandle(svc);
 183   close_scm:
 184     CloseServiceHandle(scm);
 185
 186     return result;
 187 }
 188
 189 void
 190 cm_DaemonCheckInit(void)
 191 {
 192     HKEY parmKey;
 193     DWORD dummyLen;
 194     DWORD dummy;
 195     DWORD code;
 196
 197     code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
 198                          0, KEY_QUERY_VALUE, &parmKey);
 199     if (code)
 200         return;
 201
 202     dummyLen = sizeof(DWORD);
 203     code = RegQueryValueEx(parmKey, "DownServerCheckInterval", NULL, NULL,
 204                             (BYTE *) &dummy, &dummyLen);
 205     if (code == ERROR_SUCCESS)
 206         cm_daemonCheckDownInterval = dummy;
 207
 208     dummyLen = sizeof(DWORD);
 209     code = RegQueryValueEx(parmKey, "UpServerCheckInterval", NULL, NULL,
 210                             (BYTE *) &dummy, &dummyLen);
 211     if (code == ERROR_SUCCESS)
 212         cm_daemonCheckUpInterval = dummy;
 213
 214     dummyLen = sizeof(DWORD);
 215     code = RegQueryValueEx(parmKey, "VolumeCheckInterval", NULL, NULL,
 216                             (BYTE *) &dummy, &dummyLen);
 217     if (code == ERROR_SUCCESS)
 218         cm_daemonCheckVolInterval = dummy;
 219
 220     dummyLen = sizeof(DWORD);
 221     code = RegQueryValueEx(parmKey, "CallbackCheckInterval", NULL, NULL,
 222                             (BYTE *) &dummy, &dummyLen);
 223     if (code == ERROR_SUCCESS)
 224         cm_daemonCheckCBInterval = dummy;
 225
 226     dummyLen = sizeof(DWORD);
 227     code = RegQueryValueEx(parmKey, "LockCheckInterval", NULL, NULL,
 228                             (BYTE *) &dummy, &dummyLen);
 229     if (code == ERROR_SUCCESS)
 230         cm_daemonCheckLockInterval = dummy;
 231
 232     dummyLen = sizeof(DWORD);
 233     code = RegQueryValueEx(parmKey, "TokenCheckInterval", NULL, NULL,
 234                             (BYTE *) &dummy, &dummyLen);
 235     if (code == ERROR_SUCCESS)
 236         cm_daemonTokenCheckInterval = dummy;
 237
 238     RegCloseKey(parmKey);
 239 }
 240
 241 /* periodic check daemon */
 242 void cm_Daemon(long parm)
 243 {
 244     time_t now;
 245     time_t lastLockCheck;
 246     time_t lastVolCheck;
 247     time_t lastCBExpirationCheck;
 248     time_t lastDownServerCheck;
 249     time_t lastUpServerCheck;
 250     time_t lastTokenCacheCheck;
 251     char thostName[200];
 252     unsigned long code;
 253     struct hostent *thp;
 254     HMODULE hHookDll;
 255     int configureFirewall = IsWindowsFirewallPresent();
 256
 257     if (!configureFirewall) {
 258         afsi_log("No Windows Firewall detected");
 259     }
 260
 261     /* ping all file servers, up or down, with unauthenticated connection,
 262      * to find out whether we have all our callbacks from the server still.
 263      * Also, ping down VLDBs.
 264      */
 265     /*
 266      * Seed the random number generator with our own address, so that
 267      * clients starting at the same time don't all do vol checks at the
 268      * same time.
 269      */
 270     gethostname(thostName, sizeof(thostName));
 271     thp = gethostbyname(thostName);
 272     if (thp == NULL)    /* In djgpp, gethostname returns the netbios
 273                            name of the machine.  gethostbyname will fail
 274                            looking this up if it differs from DNS name. */
 275         code = 0;
 276     else
 277         memcpy(&code, thp->h_addr_list[0], 4);
 278
 279     srand(ntohl(code));
 280
 281     cm_DaemonCheckInit();
 282
 283     now = osi_Time();
 284     lastVolCheck = now - cm_daemonCheckVolInterval/2 + (rand() % cm_daemonCheckVolInterval);
 285     lastCBExpirationCheck = now - cm_daemonCheckCBInterval/2 + (rand() % cm_daemonCheckCBInterval);
 286     lastLockCheck = now - cm_daemonCheckLockInterval/2 + (rand() % cm_daemonCheckLockInterval);
 287     lastDownServerCheck = now - cm_daemonCheckDownInterval/2 + (rand() % cm_daemonCheckDownInterval);
 288     lastUpServerCheck = now - cm_daemonCheckUpInterval/2 + (rand() % cm_daemonCheckUpInterval);
 289     lastTokenCacheCheck = now - cm_daemonTokenCheckInterval/2 + (rand() % cm_daemonTokenCheckInterval);
 290
 291     while (daemon_ShutdownFlag == 0) {
 292         if (configureFirewall) {
 293             /* Open Microsoft Firewall to allow in port 7001 */
 294             switch (icf_CheckAndAddAFSPorts(AFS_PORTSET_CLIENT)) {
 295             case 0:
 296                 afsi_log("Windows Firewall Configuration succeeded");
 297                 configureFirewall = 0;
 298                 break;
 299             case 1:
 300                 afsi_log("Invalid Windows Firewall Port Set");
 301                 break;
 302             case 2:
 303                 afsi_log("Unable to open Windows Firewall Profile");
 304                 break;
 305             case 3:
 306                 afsi_log("Unable to create/modify Windows Firewall Port entries");
 307                 break;
 308             default:
 309                 afsi_log("Unknown Windows Firewall Configuration error");
 310             }
 311         }
 312
 313         /* find out what time it is */
 314         now = osi_Time();
 315
 316         /* check down servers */
 317         if (now > lastDownServerCheck + cm_daemonCheckDownInterval) {
 318             lastDownServerCheck = now;
 319             osi_Log0(afsd_logp, "cm_Daemon CheckDownServers");
 320             cm_CheckServers(CM_FLAG_CHECKDOWNSERVERS, NULL);
 321             now = osi_Time();
 322         }
 323
 324         /* check up servers */
 325         if (now > lastUpServerCheck + cm_daemonCheckUpInterval) {
 326             lastUpServerCheck = now;
 327             osi_Log0(afsd_logp, "cm_Daemon CheckUpServers");
 328             cm_CheckServers(CM_FLAG_CHECKUPSERVERS, NULL);
 329             now = osi_Time();
 330         }
 331
 332         if (now > lastVolCheck + cm_daemonCheckVolInterval) {
 333             lastVolCheck = now;
 334             cm_CheckVolumes();
 335             now = osi_Time();
 336         }
 337
 338         if (now > lastCBExpirationCheck + cm_daemonCheckCBInterval) {
 339             lastCBExpirationCheck = now;
 340             cm_CheckCBExpiration();
 341             now = osi_Time();
 342         }
 343
 344         if (now > lastLockCheck + cm_daemonCheckLockInterval) {
 345             lastLockCheck = now;
 346             cm_CheckLocks();
 347             now = osi_Time();
 348         }
 349
 350         if (now > lastTokenCacheCheck + cm_daemonTokenCheckInterval) {
 351             lastTokenCacheCheck = now;
 352             cm_CheckTokenCache(now);
 353             now = osi_Time();
 354         }
 355
 356         /* allow an exit to be called prior to stopping the service */
 357         hHookDll = LoadLibrary(AFSD_HOOK_DLL);
 358         if (hHookDll)
 359         {
 360             BOOL hookRc = TRUE;
 361             AfsdDaemonHook daemonHook = ( AfsdDaemonHook ) GetProcAddress(hHookDll, AFSD_DAEMON_HOOK);
 362             if (daemonHook)
 363             {
 364                 hookRc = daemonHook();
 365             }
 366             FreeLibrary(hHookDll);
 367             hHookDll = NULL;
 368
 369             if (hookRc == FALSE)
 370             {
 371                 SetEvent(WaitToTerminate);
 372             }
 373         }
 374
 375         thrd_Sleep(30 * 1000);          /* sleep 30 seconds */
 376         if (daemon_ShutdownFlag == 1)
 377             return;
 378     }
 379 }
 380
 381 void cm_DaemonShutdown(void)
 382 {
 383     daemon_ShutdownFlag = 1;
 384 }
 385
 386 void cm_InitDaemon(int nDaemons)
 387 {
 388     static osi_once_t once;
 389     long pid;
 390     thread_t phandle;
 391     int i;
 392
 393     if (osi_Once(&once)) {
 394         lock_InitializeRWLock(&cm_daemonLock, "cm_daemonLock");
 395         osi_EndOnce(&once);
 396
 397         /* creating IP Address Change monitor daemon */
 398         phandle = thrd_Create((SecurityAttrib) 0, 0,
 399                                (ThreadFunc) cm_IpAddrDaemon, 0, 0, &pid, "cm_IpAddrDaemon");
 400         osi_assert(phandle != NULL);
 401         thrd_CloseHandle(phandle);
 402
 403         /* creating pinging daemon */
 404         phandle = thrd_Create((SecurityAttrib) 0, 0,
 405                                (ThreadFunc) cm_Daemon, 0, 0, &pid, "cm_Daemon");
 406         osi_assert(phandle != NULL);
 407         thrd_CloseHandle(phandle);
 408
 409         for(i=0; i < nDaemons; i++) {
 410             phandle = thrd_Create((SecurityAttrib) 0, 0,
 411                                    (ThreadFunc) cm_BkgDaemon, 0, 0, &pid,
 412                                    "cm_BkgDaemon");
 413             osi_assert(phandle != NULL);
 414             thrd_CloseHandle(phandle);
 415         }
 416     }
 417 }