windows-addr-change-mods-20060509

[openafs.git] / src / WINNT / afsd / cm_daemon.c

diff --git a/src/WINNT/afsd/cm_daemon.c b/src/WINNT/afsd/cm_daemon.c
index b0d94da..ac210e1 100644 (file)
--- a/src/WINNT/afsd/cm_daemon.c
+++ b/src/WINNT/afsd/cm_daemon.c
@@ -23,11 +23,17 @@
 
 #include <rx/rx.h>
 #include <rx/rx_prototypes.h>
+#include <WINNT/afsreg.h>
 
 #include "afsd.h"
 #include "afsicf.h"
 
-long cm_daemonCheckInterval = 30;
+/* in seconds */
+long cm_daemonCheckDownInterval  = 180;
+long cm_daemonCheckUpInterval    = 600;
+long cm_daemonCheckVolInterval   = 3600;
+long cm_daemonCheckCBInterval    = 60;
+long cm_daemonCheckLockInterval  = 60;
 long cm_daemonTokenCheckInterval = 180;
 
 osi_rwlock_t cm_daemonLock;
@@ -44,6 +50,8 @@ static int daemon_ShutdownFlag = 0;
 #ifndef DJGPP
 void cm_IpAddrDaemon(long parm)
 {
+    extern void smb_CheckVCs(void);
+
     rx_StartClientThread();
 
     while (daemon_ShutdownFlag == 0) {
@@ -51,8 +59,10 @@ void cm_IpAddrDaemon(long parm)
        if (Result == NO_ERROR && daemon_ShutdownFlag == 0) {
            osi_Log0(afsd_logp, "cm_IpAddrDaemon CheckDownServers");
            Sleep(2500);
-            cm_CheckServers(CM_FLAG_CHECKDOWNSERVERS, NULL);
-       }
+           cm_ForceNewConnectionsAllServers();
+            cm_CheckServers(CM_FLAG_CHECKUPSERVERS | CM_FLAG_CHECKDOWNSERVERS, NULL);
+           smb_CheckVCs();
+       }       
     }
 }
 #endif
@@ -66,7 +76,7 @@ void cm_BkgDaemon(long parm)
     lock_ObtainWrite(&cm_daemonLock);
     while (daemon_ShutdownFlag == 0) {
         if (!cm_bkgListEndp) {
-            osi_SleepW((long) &cm_bkgListp, &cm_daemonLock);
+            osi_SleepW((LONG_PTR)&cm_bkgListp, &cm_daemonLock);
             lock_ObtainWrite(&cm_daemonLock);
             continue;
         }
@@ -114,7 +124,7 @@ void cm_QueueBKGRequest(cm_scache_t *scp, cm_bkgProc_t *procp, long p1, long p2,
         cm_bkgListEndp = rp;
     lock_ReleaseWrite(&cm_daemonLock);
 
-    osi_Wakeup((long) &cm_bkgListp);
+    osi_Wakeup((LONG_PTR) &cm_bkgListp);
 }
 
 static int
@@ -168,16 +178,68 @@ IsWindowsFirewallPresent(void)
     return result;
 }
 
+void
+cm_DaemonCheckInit(void)
+{
+    HKEY parmKey;
+    DWORD dummyLen;
+    DWORD dummy;
+    DWORD code;
+
+    code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
+                         0, KEY_QUERY_VALUE, &parmKey);
+    if (code)
+       return;
+
+    dummyLen = sizeof(DWORD);
+    code = RegQueryValueEx(parmKey, "DownServerCheckInterval", NULL, NULL,
+                           (BYTE *) &dummy, &dummyLen);
+    if (code == ERROR_SUCCESS)
+       cm_daemonCheckDownInterval = dummy;
+    
+    dummyLen = sizeof(DWORD);
+    code = RegQueryValueEx(parmKey, "UpServerCheckInterval", NULL, NULL,
+                           (BYTE *) &dummy, &dummyLen);
+    if (code == ERROR_SUCCESS)
+       cm_daemonCheckUpInterval = dummy;
+    
+    dummyLen = sizeof(DWORD);
+    code = RegQueryValueEx(parmKey, "VolumeCheckInterval", NULL, NULL,
+                           (BYTE *) &dummy, &dummyLen);
+    if (code == ERROR_SUCCESS)
+       cm_daemonCheckVolInterval = dummy;
+    
+    dummyLen = sizeof(DWORD);
+    code = RegQueryValueEx(parmKey, "CallbackCheckInterval", NULL, NULL,
+                           (BYTE *) &dummy, &dummyLen);
+    if (code == ERROR_SUCCESS)
+       cm_daemonCheckCBInterval = dummy;
+    
+    dummyLen = sizeof(DWORD);
+    code = RegQueryValueEx(parmKey, "LockCheckInterval", NULL, NULL,
+                           (BYTE *) &dummy, &dummyLen);
+    if (code == ERROR_SUCCESS)
+       cm_daemonCheckLockInterval = dummy;
+    
+    dummyLen = sizeof(DWORD);
+    code = RegQueryValueEx(parmKey, "TokenCheckInterval", NULL, NULL,
+                           (BYTE *) &dummy, &dummyLen);
+    if (code == ERROR_SUCCESS)
+       cm_daemonTokenCheckInterval = dummy;
+    
+    RegCloseKey(parmKey);
+}
+
 /* periodic check daemon */
 void cm_Daemon(long parm)
 {
-    unsigned long now;
-    unsigned long lastLockCheck;
-    unsigned long lastVolCheck;
-    unsigned long lastCBExpirationCheck;
-    unsigned long lastDownServerCheck;
-    unsigned long lastUpServerCheck;
-    unsigned long lastTokenCacheCheck;
+    time_t now;
+    time_t lastLockCheck;
+    time_t lastVolCheck;
+    time_t lastCBExpirationCheck;
+    time_t lastDownServerCheck;
+    time_t lastUpServerCheck;
+    time_t lastTokenCacheCheck;
     char thostName[200];
     unsigned long code;
     struct hostent *thp;
@@ -201,14 +263,17 @@ void cm_Daemon(long parm)
         code = 0;
     else
         memcpy(&code, thp->h_addr_list[0], 4);
+    
     srand(ntohl(code));
 
+    cm_DaemonCheckInit();
+
     now = osi_Time();
-    lastVolCheck = now - 1800 + (rand() % 3600);
-    lastCBExpirationCheck = now - 60 + (rand() % 60);
-    lastLockCheck = now - 60 + (rand() % 60);
-    lastDownServerCheck = now - cm_daemonCheckInterval/2 + (rand() % cm_daemonCheckInterval);
-    lastUpServerCheck = now - 1800 + (rand() % 3600);
+    lastVolCheck = now - cm_daemonCheckVolInterval/2 + (rand() % cm_daemonCheckVolInterval);
+    lastCBExpirationCheck = now - cm_daemonCheckCBInterval/2 + (rand() % cm_daemonCheckCBInterval);
+    lastLockCheck = now - cm_daemonCheckLockInterval/2 + (rand() % cm_daemonCheckLockInterval);
+    lastDownServerCheck = now - cm_daemonCheckDownInterval/2 + (rand() % cm_daemonCheckDownInterval);
+    lastUpServerCheck = now - cm_daemonCheckUpInterval/2 + (rand() % cm_daemonCheckUpInterval);
     lastTokenCacheCheck = now - cm_daemonTokenCheckInterval/2 + (rand() % cm_daemonTokenCheckInterval);
 
     while (daemon_ShutdownFlag == 0) {
@@ -241,7 +306,7 @@ void cm_Daemon(long parm)
         now = osi_Time();
 
         /* check down servers */
-        if (now > lastDownServerCheck + cm_daemonCheckInterval) {
+        if (now > lastDownServerCheck + cm_daemonCheckDownInterval) {
             lastDownServerCheck = now;
            osi_Log0(afsd_logp, "cm_Daemon CheckDownServers");
             cm_CheckServers(CM_FLAG_CHECKDOWNSERVERS, NULL);
@@ -249,26 +314,26 @@ void cm_Daemon(long parm)
         }
 
         /* check up servers */
-        if (now > lastUpServerCheck + 3600) {
+        if (now > lastUpServerCheck + cm_daemonCheckUpInterval) {
             lastUpServerCheck = now;
            osi_Log0(afsd_logp, "cm_Daemon CheckUpServers");
             cm_CheckServers(CM_FLAG_CHECKUPSERVERS, NULL);
            now = osi_Time();
         }
 
-        if (now > lastVolCheck + 3600) {
+        if (now > lastVolCheck + cm_daemonCheckVolInterval) {
             lastVolCheck = now;
             cm_CheckVolumes();
            now = osi_Time();
         }
 
-        if (now > lastCBExpirationCheck + 60) {
+        if (now > lastCBExpirationCheck + cm_daemonCheckCBInterval) {
             lastCBExpirationCheck = now;
             cm_CheckCBExpiration();
            now = osi_Time();
         }
 
-        if (now > lastLockCheck + 60) {
+        if (now > lastLockCheck + cm_daemonCheckLockInterval) {
             lastLockCheck = now;
             cm_CheckLocks();
            now = osi_Time();