clang-10: use AFS_FALLTHROUGH for case fallthrough
[openafs.git] / src / WINNT / afsadmsvr / TaAfsAdmSvrGeneral.cpp
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 <winsock2.h>
11 #include <ws2tcpip.h>
12
13 extern "C" {
14 #include <afsconfig.h>
15 #include <afs/param.h>
16 #include <afs/stds.h>
17 #include <roken.h>
18 }
19
20 #include "TaAfsAdmSvrInternal.h"
21
22 extern "C" {
23 #include <afs/afs_AdminErrors.h>
24 } // extern "C"
25
26
27 /*
28  * VARIABLES __________________________________________________________________
29  *
30  */
31
32 #define cminREQ_CLIENT_PING   (csecAFSADMSVR_CLIENT_PING * 2L / 60L)
33
34 #define cREALLOC_CLIENTS          1
35 #define cREALLOC_OPERATIONS      16
36
37 #define cminAUTO_SHUTDOWN         2 // stop if idle for more than 2min
38 #define cminAUTO_SHUTDOWN_SLEEP   1 // test for stop every minute
39
40 typedef struct
41    {
42    TCHAR szName[ cchSTRING ];
43    SOCKADDR_IN ipAddress;
44    DWORD timeLastPing;
45    } CLIENTINFO, *LPCLIENTINFO;
46
47 typedef struct
48    {
49    BOOL fInUse;
50    UINT_PTR idClient;
51    LPASACTION pAction;
52    DWORD dwTickStart;
53    } OPERATION, *LPOPERATION;
54
55 static struct
56    {
57    BOOL fOperational;
58    LPCRITICAL_SECTION pcsAfsAdmSvr;
59
60    LPCLIENTINFO *aClients;
61    size_t cClients;
62    size_t cClientsAllocated;
63
64    LPNOTIFYCALLBACK pNotify;
65
66    BOOL fAutoShutdown;
67    HANDLE hThreadShutdown;
68    DWORD timeLastIdleStart;
69
70    OPERATION *aOperations;
71    size_t cOperations;
72    size_t cOperationsAllocated;
73    DWORD idActionLast;
74
75    DWORD dwScopeMin;
76    } l;
77
78
79 /*
80  * PROTOTYPES _________________________________________________________________
81  *
82  */
83
84 void AfsAdmSvr_TestShutdown (void);
85 DWORD WINAPI AfsAdmSvr_AutoShutdownThread (LPVOID lp);
86
87
88 /*
89  * SYNCHRONIZATION ____________________________________________________________
90  *
91  */
92
93 void AfsAdmSvr_Enter (void)
94 {
95    if (!l.pcsAfsAdmSvr)
96       {
97       l.pcsAfsAdmSvr = New (CRITICAL_SECTION);
98       InitializeCriticalSection (l.pcsAfsAdmSvr);
99       }
100    EnterCriticalSection (l.pcsAfsAdmSvr);
101 }
102
103 void AfsAdmSvr_Leave (void)
104 {
105    LeaveCriticalSection (l.pcsAfsAdmSvr);
106 }
107
108
109 /*
110  * CLIENT INFORMATION _________________________________________________________
111  *
112  */
113
114 BOOL AfsAdmSvr_fIsValidClient (UINT_PTR idClient)
115 {
116    BOOL rc = FALSE;
117    AfsAdmSvr_Enter();
118
119    for (size_t iClient = 0; !rc && iClient < l.cClientsAllocated; ++iClient)
120       {
121       if (idClient == (UINT_PTR)l.aClients[ iClient ])
122          {
123          if (l.aClients[ iClient ]->timeLastPing + cminREQ_CLIENT_PING > AfsAdmSvr_GetCurrentTime())
124             rc = TRUE;
125          }
126       }
127
128    AfsAdmSvr_Leave();
129    return rc;
130 }
131
132
133 BOOL AfsAdmSvr_AttachClient (LPCTSTR pszName, PVOID *pidClient, ULONG *pStatus)
134 {
135    AfsAdmSvr_Enter();
136    size_t iClient;
137    for (iClient = 0; iClient < l.cClientsAllocated; ++iClient)
138       {
139       if (!l.aClients[ iClient ])
140          break;
141       }
142    if (!REALLOC (l.aClients, l.cClientsAllocated, 1+iClient, cREALLOC_CLIENTS))
143       {
144       *pidClient = NULL;
145       return FALSE;
146       }
147    if ((l.aClients[ iClient ] = New (CLIENTINFO)) == NULL)
148       {
149       *pidClient = NULL;
150       return FALSE;
151       }
152    memset (l.aClients[ iClient ], 0x00, sizeof(CLIENTINFO));
153    lstrcpy (l.aClients[ iClient ]->szName, pszName);
154    l.aClients[ iClient ]->timeLastPing = AfsAdmSvr_GetCurrentTime();
155    l.cClients ++;
156
157    if (!AfsAdmSvr_ResolveName (&l.aClients[ iClient ]->ipAddress, l.aClients[ iClient ]->szName))
158       memset (&l.aClients[ iClient ]->ipAddress, 0x00, sizeof(SOCKADDR_IN));
159
160    *pidClient = (PVOID)(l.aClients[ iClient ]);
161    AfsAdmSvr_Leave();
162    return TRUE;
163 }
164
165
166 void AfsAdmSvr_DetachClient (UINT_PTR idClient)
167 {
168    AfsAdmSvr_Enter();
169    size_t iClient;
170    for (iClient = 0; iClient < l.cClientsAllocated; ++iClient)
171       {
172       if (idClient == (UINT_PTR)(l.aClients[ iClient ]))
173          break;
174       }
175    if (iClient < l.cClientsAllocated)
176       {
177       Delete (l.aClients[ iClient ]);
178       l.aClients[ iClient ] = NULL;
179       l.cClients --;
180       }
181    AfsAdmSvr_TestShutdown();
182    AfsAdmSvr_Leave();
183 }
184
185
186 LPCTSTR AfsAdmSvr_GetClientName (UINT_PTR idClient)
187 {
188    static TCHAR szName[ cchSTRING ];
189    LPCTSTR pszName = NULL;
190    AfsAdmSvr_Enter();
191
192    for (size_t iClient = 0; !pszName && iClient < l.cClientsAllocated; ++iClient)
193       {
194       if (idClient == (UINT_PTR)(l.aClients[ iClient ]))
195          {
196          lstrcpy (szName, l.aClients[ iClient ]->szName);
197          pszName = szName;
198          }
199       }
200
201    AfsAdmSvr_Leave();
202    return pszName;
203 }
204
205
206 LPSOCKADDR_IN AfsAdmSvr_GetClientAddress (UINT_PTR idClient)
207 {
208    static SOCKADDR_IN ipAddress;
209    LPSOCKADDR_IN pAddress = NULL;
210    AfsAdmSvr_Enter();
211
212    for (size_t iClient = 0; !pAddress && iClient < l.cClientsAllocated; ++iClient)
213       {
214       if (idClient == (UINT_PTR)(l.aClients[ iClient ]))
215          {
216          memcpy (&ipAddress, &l.aClients[ iClient ]->ipAddress, sizeof(SOCKADDR_IN));
217          pAddress = &ipAddress;
218          }
219       }
220
221    AfsAdmSvr_Leave();
222    return pAddress;
223 }
224
225
226 void AfsAdmSvr_PingClient (UINT_PTR idClient)
227 {
228    AfsAdmSvr_Enter();
229
230    for (size_t iClient = 0; iClient < l.cClientsAllocated; ++iClient)
231       {
232       if (idClient == (UINT_PTR)(l.aClients[ iClient ]))
233          {
234          l.aClients[ iClient ]->timeLastPing = AfsAdmSvr_GetCurrentTime();
235          }
236       }
237
238    AfsAdmSvr_Leave();
239 }
240
241
242 DWORD AfsAdmSvr_GetCurrentTime (void) // returns counter in ~minute increments
243 {
244    static WORD wMonthish = 0;  // One "Monthish" is 49.7 days
245    static WORD wTickLast = 0;
246    DWORD dwTick = GetTickCount();
247    WORD wTickNow = HIWORD(dwTick);
248    if (wTickNow < wTickLast)  // wrapped over a Monthish?
249       ++wMonthish;
250    wTickLast = wTickNow;
251    return MAKELONG(wTickNow,wMonthish);
252 }
253
254
255 /*
256  * STARTUP/SHUTDOWN ___________________________________________________________
257  *
258  */
259
260 void AfsAdmSvr_Startup (void)
261 {
262    l.pNotify = New2 (NOTIFYCALLBACK,(AfsAdmSvr_NotifyCallback, 0));
263    l.fOperational = FALSE;
264
265    ULONG status;
266    if (AfsClass_Initialize (&status))
267       l.fOperational = TRUE;
268    else
269       {
270       Print (dlERROR, TEXT("Could not initialize AfsClass (fatal error 0x%08lX)"), status);
271       Print (dlERROR, TEXT("Remaining active to tell potential clients about the problem"));
272       }
273
274    if (!l.hThreadShutdown)
275       {
276       DWORD dwThreadID;
277       l.hThreadShutdown = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE)AfsAdmSvr_AutoShutdownThread, (LPVOID)0, 0, &dwThreadID);
278       }
279 }
280
281
282 void AfsAdmSvr_Shutdown (void)
283 {
284    Delete (l.pNotify);
285    l.pNotify = NULL;
286    l.fOperational = FALSE;
287 }
288
289
290 /*
291  * GENERAL ____________________________________________________________________
292  *
293  */
294
295 BOOL FALSE_ (ULONG status, ULONG *pStatus, size_t iOp)
296 {
297    if (pStatus)
298       *pStatus = status;
299    if (iOp != (size_t)-2)
300       AfsAdmSvr_EndOperation (iOp);
301    return FALSE;
302 }
303
304 BOOL Leave_FALSE_ (ULONG status, ULONG *pStatus, size_t iOp)
305 {
306    AfsAdmSvr_Leave();
307    if (pStatus)
308       *pStatus = status;
309    if (iOp != (size_t)-2)
310       AfsAdmSvr_EndOperation (iOp);
311    return FALSE;
312 }
313
314 PVOID NULL_ (ULONG status, ULONG *pStatus, size_t iOp)
315 {
316    if (pStatus)
317       *pStatus = status;
318    if (iOp != (size_t)-2)
319       AfsAdmSvr_EndOperation (iOp);
320    return NULL;
321 }
322
323 PVOID Leave_NULL_ (ULONG status, ULONG *pStatus, size_t iOp)
324 {
325    AfsAdmSvr_Leave();
326    if (pStatus)
327       *pStatus = status;
328    if (iOp != (size_t)-2)
329       AfsAdmSvr_EndOperation (iOp);
330    return NULL;
331 }
332
333 BOOL TRUE_ (ULONG *pStatus, size_t iOp)
334 {
335    if (pStatus)
336       *pStatus = 0;
337    if (iOp != (size_t)-2)
338       AfsAdmSvr_EndOperation (iOp);
339    return TRUE;
340 }
341
342 BOOL Leave_TRUE_ (ULONG *pStatus, size_t iOp)
343 {
344    AfsAdmSvr_Leave();
345    if (pStatus)
346       *pStatus = 0;
347    if (iOp != (size_t)-2)
348       AfsAdmSvr_EndOperation (iOp);
349    return TRUE;
350 }
351
352 IDENTTYPE GetAsidType (ASID idObject)
353 {
354    IDENTTYPE iType;
355    try {
356       iType = ((LPIDENT)idObject)->GetType();
357    } catch(...) {
358       iType = itUNUSED;
359    }
360    return iType;
361 }
362
363
364 BOOL AfsAdmSvr_ResolveName (LPSOCKADDR_IN pAddress, LPTSTR pszName)
365 {
366    if ((pszName[0] >= TEXT('0')) && (pszName[0] <= TEXT('9')))
367       {
368       int ipAddress;
369       if ((ipAddress = inet_addr (pszName)) == INADDR_NONE)
370          return FALSE;
371
372       memset (pAddress, 0x00, sizeof(SOCKADDR_IN));
373       pAddress->sin_family = AF_INET;
374       pAddress->sin_addr.s_addr = ipAddress;
375
376       HOSTENT *pEntry;
377       if ((pEntry = gethostbyaddr ((char*)&ipAddress, sizeof(ipAddress), AF_INET)) != NULL)
378          lstrcpy (pszName, pEntry->h_name);
379       }
380    else // (!isdigit(szServer[0]))
381       {
382       HOSTENT *pEntry;
383       if ((pEntry = gethostbyname (pszName)) == NULL)
384          return FALSE;
385
386       memset (pAddress, 0x00, sizeof(SOCKADDR_IN));
387       pAddress->sin_family = AF_INET;
388       pAddress->sin_addr.s_addr = *(int *)pEntry->h_addr;
389
390       lstrcpy (pszName, pEntry->h_name);
391       }
392
393    return TRUE;
394 }
395
396
397 /*
398  * AUTO-SHUTDOWN ______________________________________________________________
399  *
400  */
401
402 DWORD WINAPI AfsAdmSvr_AutoShutdownThread (LPVOID lp)
403 {
404    for (;;)
405       {
406       AfsAdmSvr_Enter();
407
408       BOOL fShutdown = l.fAutoShutdown;
409
410       // If there are any clients connected, forcably disconnect any
411       // that haven't pinged us for too long
412       //
413       for (size_t iClient = 0; iClient < l.cClientsAllocated; ++iClient)
414          {
415          if (!l.aClients[ iClient ])
416             continue;
417          if (l.aClients[ iClient ]->timeLastPing + cminREQ_CLIENT_PING <= AfsAdmSvr_GetCurrentTime())
418             {
419             Print (dlCONNECTION, "Client 0x%08lX idle for too long; detaching", l.aClients[ iClient ]);
420             AfsAdmSvr_DetachClient ((UINT_PTR)l.aClients[ iClient ]);
421             }
422          }
423
424       // If any operations are in progress, we can't shutdown.
425       //
426       if (l.cOperations)
427          fShutdown = FALSE;
428
429       // If any clients are still connected, we can't shutdown.
430       //
431       if (l.cClients)
432          fShutdown = FALSE;
433
434       // If we haven't been idle long enough, we can't shutdown
435       //
436       if (!l.timeLastIdleStart)
437          fShutdown = FALSE;
438       else if (l.timeLastIdleStart + cminAUTO_SHUTDOWN > AfsAdmSvr_GetCurrentTime())
439          fShutdown = FALSE;
440
441       // That's it; can we stop now?
442       //
443       if (fShutdown)
444          {
445          Print ("Idle for too long; shutting down.");
446          RpcMgmtStopServerListening (NULL);
447          AfsAdmSvr_StopCallbackManagers();
448          }
449
450       AfsAdmSvr_Leave();
451
452       if (fShutdown)
453          break;
454
455       Sleep (cminAUTO_SHUTDOWN_SLEEP * 60L * 1000L);
456       }
457
458    return 0;
459 }
460
461
462
463 void AfsAdmSvr_EnableAutoShutdown (BOOL fEnable)
464 {
465    AfsAdmSvr_Enter();
466
467    l.fAutoShutdown = fEnable;
468
469    if (fEnable)
470       Print (dlDETAIL, TEXT("Auto-shutdown enabled, trigger = %lu minutes idle time"), cminAUTO_SHUTDOWN);
471    else
472       Print (dlDETAIL, TEXT("Auto-shutdown on idle disabled"));
473
474    AfsAdmSvr_Leave();
475 }
476
477
478 void AfsAdmSvr_TestShutdown (void)
479 {
480    if (!l.cOperations && !l.cClients)
481       {
482       l.timeLastIdleStart = AfsAdmSvr_GetCurrentTime();
483       }
484 }
485
486
487 size_t AfsAdmSvr_BeginOperation (UINT_PTR idClient, LPASACTION pAction)
488 {
489    AfsAdmSvr_Enter();
490
491    ++l.cOperations;
492
493    size_t iOp;
494    for (iOp = 0; iOp < l.cOperationsAllocated; ++iOp)
495       {
496       if (!l.aOperations[ iOp ].fInUse)
497          break;
498       }
499    if (!REALLOC (l.aOperations, l.cOperationsAllocated, 1+iOp, cREALLOC_OPERATIONS))
500       {
501       AfsAdmSvr_Leave();
502       return (size_t)(-1);
503       }
504
505    l.aOperations[ iOp ].idClient = idClient;
506    l.aOperations[ iOp ].pAction = NULL;
507    l.aOperations[ iOp ].fInUse = TRUE;
508
509    if (pAction)
510       {
511       l.aOperations[ iOp ].pAction = New (ASACTION);
512       memcpy (l.aOperations[ iOp ].pAction, pAction, sizeof(ASACTION));
513       l.aOperations[ iOp ].pAction->idAction = ++l.idActionLast;
514       l.aOperations[ iOp ].pAction->idClient = idClient;
515       l.aOperations[ iOp ].pAction->csecActive = 0;
516
517       TCHAR szDesc[256];
518       switch (l.aOperations[ iOp ].pAction->Action)
519          {
520          case ACTION_REFRESH:
521             wsprintf (szDesc, TEXT("Refresh (scope=0x%08lX)"), l.aOperations[ iOp ].pAction->u.Refresh.idScope);
522             break;
523          case ACTION_SCOUT:
524             wsprintf (szDesc, TEXT("Scout (scope=0x%08lX)"), l.aOperations[ iOp ].pAction->u.Refresh.idScope);
525             break;
526          case ACTION_USER_CHANGE:
527             wsprintf (szDesc, TEXT("ChangeUser (user=0x%08lX)"), l.aOperations[ iOp ].pAction->u.User_Change.idUser);
528             break;
529          case ACTION_USER_PW_CHANGE:
530             wsprintf (szDesc, TEXT("SetUserPassword (user=0x%08lX)"), l.aOperations[ iOp ].pAction->u.User_Pw_Change.idUser);
531             break;
532          case ACTION_USER_UNLOCK:
533             wsprintf (szDesc, TEXT("UnlockUser (user=0x%08lX)"), l.aOperations[ iOp ].pAction->u.User_Unlock.idUser);
534             break;
535          case ACTION_USER_CREATE:
536             wsprintf (szDesc, TEXT("CreateUser (user=%s)"), l.aOperations[ iOp ].pAction->u.User_Create.szUser);
537             break;
538          case ACTION_USER_DELETE:
539             wsprintf (szDesc, TEXT("CreateUser (user=0x%08lX)"), l.aOperations[ iOp ].pAction->u.User_Delete.idUser);
540             break;
541          case ACTION_GROUP_CHANGE:
542             wsprintf (szDesc, TEXT("ChangeGroup (group=0x%08lX)"), l.aOperations[ iOp ].pAction->u.Group_Change.idGroup);
543             break;
544          case ACTION_GROUP_MEMBER_ADD:
545             wsprintf (szDesc, TEXT("AddGroupMember (group=0x%08lX, user=0x%08lX)"), l.aOperations[ iOp ].pAction->u.Group_Member_Add.idGroup, l.aOperations[ iOp ].pAction->u.Group_Member_Add.idUser);
546             break;
547          case ACTION_GROUP_MEMBER_REMOVE:
548             wsprintf (szDesc, TEXT("RemoveGroupMember (group=0x%08lX, user=0x%08lX)"), l.aOperations[ iOp ].pAction->u.Group_Member_Remove.idGroup, l.aOperations[ iOp ].pAction->u.Group_Member_Remove.idUser);
549             break;
550          case ACTION_GROUP_RENAME:
551             wsprintf (szDesc, TEXT("RenameGroup (group=0x%08lX, new name=%s)"), l.aOperations[ iOp ].pAction->u.Group_Rename.idGroup, l.aOperations[ iOp ].pAction->u.Group_Rename.szNewName);
552             break;
553          case ACTION_GROUP_DELETE:
554             wsprintf (szDesc, TEXT("CreateGroup (group=0x%08lX)"), l.aOperations[ iOp ].pAction->u.Group_Delete.idGroup);
555             break;
556          case ACTION_CELL_CHANGE:
557             wsprintf (szDesc, TEXT("ChangeCell (cell=0x%08lX)"), l.aOperations[ iOp ].pAction->idCell);
558             break;
559          default:
560             wsprintf (szDesc, TEXT("Unknown Action (#%lu)"), l.aOperations[ iOp ].pAction->Action);
561             break;
562          }
563       Print (dlOPERATION, TEXT("Starting action 0x%08lX: %s"), l.aOperations[ iOp ].pAction->idAction, szDesc);
564
565       AfsAdmSvr_PostCallback (cbtACTION, FALSE, l.aOperations[ iOp ].pAction);
566       }
567
568    l.aOperations[ iOp ].dwTickStart = GetTickCount();
569    AfsAdmSvr_Leave();
570    return iOp;
571 }
572
573
574 void AfsAdmSvr_EndOperation (size_t iOp)
575 {
576    AfsAdmSvr_Enter();
577
578    if ((iOp != (size_t)-1) && (iOp < l.cOperationsAllocated) && (l.aOperations[ iOp ].fInUse))
579       {
580       if (l.aOperations[ iOp ].pAction)
581          {
582          Print (dlOPERATION, TEXT("Ending action 0x%08lX"), l.aOperations[ iOp ].pAction->idAction);
583          AfsAdmSvr_PostCallback (cbtACTION, TRUE, l.aOperations[ iOp ].pAction);
584          Delete (l.aOperations[ iOp ].pAction);
585          }
586       memset (&l.aOperations[ iOp ], 0x00, sizeof(l.aOperations[ iOp ]));
587       l.cOperations --;
588       }
589
590    AfsAdmSvr_TestShutdown();
591    AfsAdmSvr_Leave();
592 }
593
594
595 BOOL AfsAdmSvr_GetOperation (DWORD idAction, LPASACTION pAction)
596 {
597    AfsAdmSvr_Enter();
598
599    for (size_t iOp = 0; iOp < l.cOperationsAllocated; ++iOp)
600       {
601       if (!l.aOperations[ iOp ].fInUse)
602          continue;
603       if (!l.aOperations[ iOp ].pAction)
604          continue;
605       if (l.aOperations[ iOp ].pAction->idAction != idAction)
606          continue;
607
608       memcpy (pAction, l.aOperations[ iOp ].pAction, sizeof(ASACTION));
609       pAction->csecActive = (GetTickCount() - l.aOperations[ iOp ].dwTickStart) / 1000;
610       AfsAdmSvr_Leave();
611       return TRUE;
612       }
613
614    AfsAdmSvr_Leave();
615    return FALSE;
616 }
617
618
619 LPASACTIONLIST AfsAdmSvr_GetOperations (UINT_PTR idClientSearch, ASID idCellSearch)
620 {
621    LPASACTIONLIST pList = AfsAdmSvr_CreateActionList();
622    AfsAdmSvr_Enter();
623
624    for (WORD iOp = 0; iOp < l.cOperationsAllocated; ++iOp)
625       {
626       if (!l.aOperations[ iOp ].fInUse)
627          continue;
628       if (!l.aOperations[ iOp ].pAction)
629          continue;
630       if (idClientSearch && ((UINT_PTR)idClientSearch != l.aOperations[ iOp ].pAction->idClient))
631          continue;
632       if (idCellSearch && (idCellSearch != l.aOperations[ iOp ].pAction->idCell))
633          continue;
634
635       ASACTION Action;
636       memcpy (&Action, l.aOperations[ iOp ].pAction, sizeof(ASACTION));
637       Action.csecActive = (GetTickCount() - l.aOperations[ iOp ].dwTickStart) / 1000;
638       if (!AfsAdmSvr_AddToActionList (&pList, &Action))
639          {
640          AfsAdmSvr_FreeActionList (&pList);
641          break;
642          }
643       }
644
645    AfsAdmSvr_Leave();
646    return pList;
647 }
648
649
650 void AfsAdmSvr_Action_StartRefresh (ASID idScope)
651 {
652    switch (GetAsidType (idScope))
653       {
654       case itCELL:
655          AfsAdmSvr_MarkRefreshThread (idScope);
656          AFS_FALLTHROUGH;
657
658       case itSERVER:
659          ASACTION Action;
660          memset (&Action, 0x00, sizeof(Action));
661          Action.Action = ACTION_REFRESH;
662          Action.idCell = (ASID)( ((LPIDENT)idScope)->GetCell() );
663          Action.u.Refresh.idScope = idScope;
664          (void)AfsAdmSvr_BeginOperation (0, &Action);
665          break;
666
667       default:
668          // Don't bother listing status-refreshes as ongoing operations
669          // for any granularity smaller than the server; they'll occur
670          // really frequently, and finish really quickly.
671          break;
672       }
673 }
674
675
676 void AfsAdmSvr_Action_StopRefresh (ASID idScope)
677 {
678    AfsAdmSvr_Enter();
679
680    for (size_t iOp = 0; iOp < l.cOperationsAllocated; ++iOp)
681       {
682       if (!l.aOperations[ iOp ].fInUse)
683          continue;
684       if (!l.aOperations[ iOp ].pAction)
685          continue;
686       if (l.aOperations[ iOp ].pAction->Action != ACTION_REFRESH)
687          continue;
688       if (l.aOperations[ iOp ].pAction->u.Refresh.idScope != idScope)
689          continue;
690
691       AfsAdmSvr_EndOperation (iOp);
692       break;
693       }
694
695    if (GetAsidType (idScope) == itCELL)
696       {
697       AfsAdmSvr_MarkRefreshThread (idScope);
698       }
699
700    AfsAdmSvr_Leave();
701 }
702
703
704 DWORD WINAPI AfsAdmSvr_AutoOpen_ThreadProc (PVOID lp)
705 {
706    DWORD dwScope = PtrToUlong(lp);
707    ULONG status;
708
709    if (!l.fOperational)
710       return 0;
711
712    // First we'll have to find out which cell to open
713    //
714    TCHAR szCell[ cchNAME ];
715    if (!CELL::GetDefaultCell (szCell, &status))
716       {
717       Print (dlERROR, TEXT("CELL::GetDefaultCell failed; error 0x%08lX"), status);
718       }
719    else
720       {
721       // Then try to actually open the cell
722       //
723       Print (dlSTANDARD, TEXT("Auto-opening cell %s; scope=%s"), szCell, (dwScope == (AFSADMSVR_SCOPE_VOLUMES | AFSADMSVR_SCOPE_USERS)) ? TEXT("full") : (dwScope == AFSADMSVR_SCOPE_VOLUMES) ? TEXT("volumes") : TEXT("users"));
724
725       LPIDENT lpiCell;
726       if ((lpiCell = CELL::OpenCell ((LPTSTR)szCell, &status)) == NULL)
727          {
728          Print (dlERROR, TEXT("Auto-open of cell %s failed; error 0x%08lX"), szCell, status);
729          }
730       else
731          {
732          LPCELL lpCell;
733          if ((lpCell = lpiCell->OpenCell (&status)) == NULL)
734             {
735             Print (dlERROR, TEXT("Auto-open: OpenCell failed; error 0x%08lX"), status);
736             }
737          else
738             {
739             AfsAdmSvr_AddToMinScope (dwScope);
740             if (!lpCell->RefreshAll (&status))
741                Print (dlERROR, TEXT("Auto-open: RefreshCell failed; error 0x%08lX"), status);
742             else
743                Print (dlSTANDARD, TEXT("Auto-open of cell %s successful"), szCell);
744             lpCell->Close();
745
746             // We intentionally do not call CELL::CloseCell() here--as would
747             // ordinarily be necessary to balance our CELL::OpenCell() call
748             // above--because we never want to close our cache for this cell.
749             // The point of calling AutoOpen() up front is to keep an admin
750             // server alive and ready for use on a particular cell--calling
751             // CELL::CloseCell() here negates that purpose.
752
753             }
754          }
755       }
756
757    return 0;
758 }
759
760
761 void AfsAdmSvr_AddToMinScope (DWORD dwScope)
762 {
763    l.dwScopeMin |= dwScope;
764    AfsClass_SpecifyRefreshDomain (l.dwScopeMin);
765 }
766
767
768 void AfsAdmSvr_SetMinScope (DWORD dwScope)
769 {
770    l.dwScopeMin = dwScope;
771 }
772
773
774 DWORD AfsAdmSvr_GetMinScope (void)
775 {
776    return l.dwScopeMin;
777 }
778