b1269cc94c569b74855b2abcb0bc68a442ac77e7
[openafs.git] / src / WINNT / afsclass / c_svr.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 extern "C" {
11 #include <afs/param.h>
12 #include <afs/stds.h>
13 }
14
15 #include <WINNT/afsclass.h>
16 #include "internal.h"
17
18
19 /*
20  * DEFINITIONS ________________________________________________________________
21  *
22  */
23
24          // Each SERVER object maintains a list of aggregates and a list
25          // of services; those lists have hashtables placed across their
26          // names (and, for aggregates, their IDs) for faster lookup.
27          // The default table size in a HASHLIST is 1000 elements--that's
28          // too large for a list of aggregates or services on a server,
29          // as it's enough to handle up to 30,000 objects before the table
30          // would need to resize iteself (see the documentation in
31          // hashlist.cpp for info). Instead, we choose a more reasonable
32          // default table size.
33          //
34 #define cKEYAGGREGATENAME_TABLESIZE  100
35 #define cKEYAGGREGATEID_TABLESIZE    100
36
37 #define cKEYSERVICENAME_TABLESIZE    50
38
39
40 /*
41  * VARIABLES __________________________________________________________________
42  *
43  */
44
45
46 /*
47  * PROTOTYPES _________________________________________________________________
48  *
49  */
50
51
52 /*
53  * ROUTINES ___________________________________________________________________
54  *
55  */
56
57
58 SERVER::SERVER (LPCELL lpCellParent, LPTSTR pszName)
59 {
60    m_lpiCell = lpCellParent->GetIdentifier();
61
62    lstrcpy (m_szName, pszName);
63
64    m_lpCellBOS = NULL;
65    m_hCellBOS = NULL;
66    m_hBOS = NULL;
67    m_cReqBOS = 0;
68
69    m_hCellVOS = NULL;
70    m_hVOS = NULL;
71    m_cReqVOS = 0;
72
73    m_fCanGetAggregates = TRUE;
74    m_fAggregatesOutOfDate = TRUE;
75    m_lAggregates = New (HASHLIST);
76    m_lAggregates->SetCriticalSection (AfsClass_GetCriticalSection());
77    m_lkAggregateName = m_lAggregates->CreateKey ("Aggregate Name", SERVER::KeyAggregateName_Compare, SERVER::KeyAggregateName_HashObject, SERVER::KeyAggregateName_HashData, cKEYAGGREGATENAME_TABLESIZE);
78    m_lkAggregateID = m_lAggregates->CreateKey ("Aggregate ID", SERVER::KeyAggregateID_Compare, SERVER::KeyAggregateID_HashObject, SERVER::KeyAggregateID_HashData, cKEYAGGREGATEID_TABLESIZE);
79
80    m_fCanGetServices = TRUE;
81    m_fServicesOutOfDate = TRUE;
82    m_lServices = New (HASHLIST);
83    m_lServices->SetCriticalSection (AfsClass_GetCriticalSection());
84    m_lkServiceName = m_lServices->CreateKey ("Service Name", SERVER::KeyServiceName_Compare, SERVER::KeyServiceName_HashObject, SERVER::KeyServiceName_HashData, cKEYSERVICENAME_TABLESIZE);
85
86    m_wGhost = 0;
87    m_lpiThis = NULL;
88    m_fMonitor = TRUE;
89    m_fDelete = FALSE;
90    m_lastStatus = 0;
91
92    m_fStatusOutOfDate = TRUE;
93    memset (&m_ss, 0x00, sizeof(SERVERSTATUS));
94 }
95
96
97 SERVER::~SERVER (void)
98 {
99    if (!m_fMonitor)
100       {
101       LPCELL lpCell;
102       if ((lpCell = m_lpiCell->OpenCell()) != NULL)
103          {
104          (lpCell->m_nServersUnmonitored)--;
105          lpCell->Close();
106          }
107       }
108
109    if (m_lpiThis)
110       m_lpiThis->m_cRef --;
111
112    FreeAll();
113    Delete (m_lAggregates);
114    Delete (m_lServices);
115 }
116
117
118 void SERVER::FreeAll (void)
119 {
120    if (m_cReqBOS)
121       {
122       m_cReqBOS = 1;
123       CloseBosObject();
124       }
125    if (m_cReqVOS)
126       {
127       m_cReqVOS = 1;
128       CloseVosObject();
129       }
130
131    FreeAggregates();
132    FreeServices();
133 }
134
135
136 void SERVER::FreeAggregates (void)
137 {
138    for (LPENUM pEnum = m_lAggregates->FindLast(); pEnum; pEnum = pEnum->FindPrevious())
139       {
140       LPAGGREGATE lpAggregate = (LPAGGREGATE)(pEnum->GetObject());
141       m_lAggregates->Remove (lpAggregate);
142       Delete (lpAggregate);
143       }
144 }
145
146
147 void SERVER::FreeServices (void)
148 {
149    for (LPENUM pEnum = m_lServices->FindLast(); pEnum; pEnum = pEnum->FindPrevious())
150       {
151       LPSERVICE lpService = (LPSERVICE)(pEnum->GetObject());
152       m_lServices->Remove (lpService);
153       Delete (lpService);
154       }
155 }
156
157
158 void SERVER::SendDeleteNotifications (void)
159 {
160    for (LPENUM pEnum = m_lAggregates->FindFirst(); pEnum; pEnum = pEnum->FindNext())
161       {
162       LPAGGREGATE lpAggregate = (LPAGGREGATE)(pEnum->GetObject());
163       lpAggregate->SendDeleteNotifications ();
164       }
165
166    for (pEnum = m_lServices->FindFirst(); pEnum; pEnum = pEnum->FindNext())
167       {
168       LPSERVICE lpService = (LPSERVICE)(pEnum->GetObject());
169       lpService->SendDeleteNotifications();
170       }
171
172    NOTIFYCALLBACK::SendNotificationToAll (evtDestroy, GetIdentifier());
173 }
174
175
176 void SERVER::Close (void)
177 {
178    AfsClass_Leave();
179 }
180
181
182 LPIDENT SERVER::GetIdentifier (void)
183 {
184    if (m_lpiThis == NULL)
185       {
186       if ((m_lpiThis = IDENT::FindIdent (this)) == NULL)
187          m_lpiThis = New2 (IDENT,(this));
188       m_lpiThis->m_cRef ++;
189       }
190
191    return m_lpiThis;
192 }
193
194
195 PVOID SERVER::OpenBosObject (PVOID *phCell, ULONG *pStatus)
196 {
197    if (!m_hBOS)
198       {
199       if ((m_lpCellBOS = m_lpiCell->OpenCell (pStatus)) != NULL)
200          {
201          if ((m_hCellBOS = m_lpCellBOS->GetCellObject (pStatus)) != NULL)
202             {
203             TCHAR szCell[ cchNAME ];
204             m_lpiCell->GetCellName (szCell);
205
206             WORKERPACKET wp;
207             wp.wpBosServerOpen.hCell = m_hCellBOS;
208             wp.wpBosServerOpen.pszServer = m_szName;
209             if (Worker_DoTask (wtaskBosServerOpen, &wp, pStatus))
210                m_hBOS = wp.wpBosServerOpen.hServer;
211             }
212
213          if (!m_hBOS)
214             {
215             m_lpCellBOS->Close();
216             m_lpCellBOS = NULL;
217             m_hCellBOS = NULL;
218             }
219          }
220       }
221
222    if (m_hBOS)
223       {
224       if (phCell)
225          *phCell = m_hCellBOS;
226       ++m_cReqBOS;
227       }
228    return m_hBOS;
229 }
230
231
232 BOOL SERVER::CloseBosObject (ULONG *pStatus)
233 {
234    BOOL rc = TRUE;
235
236    if ((m_cReqBOS > 0) && ((--m_cReqBOS) == 0))
237       {
238       if (m_hBOS != NULL)
239          {
240          WORKERPACKET wp;
241          wp.wpBosServerClose.hServer = m_hBOS;
242          if (!Worker_DoTask (wtaskBosServerClose, &wp, pStatus))
243             rc = FALSE;
244          m_hBOS = NULL;
245          }
246       if (m_lpCellBOS != NULL)
247          {
248          m_lpCellBOS->Close();
249          m_lpCellBOS = NULL;
250          }
251       }
252
253    return rc;
254 }
255
256
257 PVOID SERVER::OpenVosObject (PVOID *phCell, ULONG *pStatus)
258 {
259    if (!m_hCellVOS)
260       {
261       LPCELL lpCell;
262       if ((lpCell = m_lpiCell->OpenCell (pStatus)) != NULL)
263          {
264          m_hCellVOS = lpCell->GetCellObject (pStatus);
265          lpCell->Close();
266          }
267       }
268
269    if (m_hCellVOS && !m_hVOS)
270       {
271       TCHAR szCell[ cchNAME ];
272       m_lpiCell->GetCellName (szCell);
273
274       WORKERPACKET wp;
275       wp.wpVosServerOpen.hCell = m_hCellVOS;
276       wp.wpVosServerOpen.pszServer = m_szName;
277       if (Worker_DoTask (wtaskVosServerOpen, &wp, pStatus))
278          m_hVOS = wp.wpVosServerOpen.hServer;
279       }
280
281    if (m_hVOS)
282       {
283       if (phCell)
284          *phCell = m_hCellVOS;
285       ++m_cReqVOS;
286       }
287    return m_hVOS;
288 }
289
290
291 BOOL SERVER::CloseVosObject (ULONG *pStatus)
292 {
293    BOOL rc = TRUE;
294
295    if ((m_cReqVOS > 0) && ((--m_cReqVOS) == 0))
296       {
297       if (m_hVOS != NULL)
298          {
299          WORKERPACKET wp;
300          wp.wpVosServerClose.hServer = m_hVOS;
301          if (!Worker_DoTask (wtaskVosServerClose, &wp, pStatus))
302             rc = FALSE;
303          }
304
305       m_hVOS = NULL;
306       m_hCellVOS = NULL;
307       }
308
309    return rc;
310 }
311
312
313 void SERVER::Invalidate (void)
314 {
315    if (!m_fAggregatesOutOfDate || !m_fServicesOutOfDate || !m_fStatusOutOfDate)
316       {
317       if (m_wGhost & GHOST_HAS_SERVER_ENTRY)
318          {
319          m_fAggregatesOutOfDate = TRUE;
320          m_fServicesOutOfDate = TRUE;
321          m_fStatusOutOfDate = TRUE;
322          }
323
324       NOTIFYCALLBACK::SendNotificationToAll (evtInvalidate, GetIdentifier());
325       }
326 }
327
328
329 void SERVER::InvalidateStatus (void)
330 {
331    if (!m_fStatusOutOfDate)
332       {
333       if (m_wGhost & GHOST_HAS_SERVER_ENTRY)
334          {
335          m_fStatusOutOfDate = TRUE;
336          }
337
338       NOTIFYCALLBACK::SendNotificationToAll (evtInvalidate, GetIdentifier());
339       }
340 }
341
342
343 void SERVER::InvalidateServices (void)
344 {
345    if (!m_fServicesOutOfDate)
346       {
347       if (m_wGhost & GHOST_HAS_SERVER_ENTRY)
348          {
349          m_fServicesOutOfDate = TRUE;
350          }
351
352       NOTIFYCALLBACK::SendNotificationToAll (evtInvalidate, GetIdentifier());
353       }
354 }
355
356
357 BOOL SERVER::RefreshAggregates (BOOL fNotify, ULONG *pStatus)
358 {
359    BOOL rc = TRUE;
360    DWORD status = 0;
361
362    if (m_fAggregatesOutOfDate)
363       {
364       m_fAggregatesOutOfDate = FALSE;
365
366       if (fIsMonitored())
367          {
368          if (fNotify)
369             NOTIFYCALLBACK::SendNotificationToAll (evtRefreshAggregatesBegin, GetIdentifier());
370
371          // First thing is to forget about what aggregates we think we have
372          // now.
373          //
374          for (LPENUM pEnum = m_lAggregates->FindLast(); pEnum; pEnum = pEnum->FindPrevious())
375             {
376             LPAGGREGATE lpAggregate = (LPAGGREGATE)(pEnum->GetObject());
377             lpAggregate->SendDeleteNotifications();
378             m_lAggregates->Remove (lpAggregate);
379             Delete (lpAggregate);
380             }
381
382          // Next, the harder part: look through the server to find a list
383          // of aggregates.
384          //
385          PVOID hCell;
386          PVOID hVOS;
387          if ((hVOS = OpenVosObject (&hCell, &status)) == NULL)
388             rc = FALSE;
389          else
390             {
391             WORKERPACKET wpBegin;
392             wpBegin.wpVosPartitionGetBegin.hCell = hCell;
393             wpBegin.wpVosPartitionGetBegin.hServer = hVOS;
394
395             if (!Worker_DoTask (wtaskVosPartitionGetBegin, &wpBegin, &status))
396                rc = FALSE;
397             else
398                {
399                for (;;)
400                   {
401                   WORKERPACKET wpNext;
402                   wpNext.wpVosPartitionGetNext.hEnum = wpBegin.wpVosPartitionGetBegin.hEnum;
403                   if (!Worker_DoTask (wtaskVosPartitionGetNext, &wpNext, &status))
404                      {
405                      if (status == ADMITERATORDONE)
406                         status = 0;
407                      else
408                         rc = FALSE;
409                      break;
410                      }
411
412                   vos_partitionEntry_p pData = &wpNext.wpVosPartitionGetNext.Data;
413
414                   LPTSTR pszName = AnsiToString (pData->name);
415                   LPTSTR pszDevice = AnsiToString (pData->deviceName);
416
417                   LPAGGREGATE lpAggregate = New2 (AGGREGATE,(this, pszName, pszDevice));
418
419                   lpAggregate->m_as.dwID = lpAggregate->GetID();
420
421                   FreeString (pszDevice, pData->deviceName);
422                   FreeString (pszName,   pData->name);
423
424                   lpAggregate->m_wGhost |= GHOST_HAS_SERVER_ENTRY;
425                   lpAggregate->m_as.ckStorageTotal = pData->totalSpace;
426                   lpAggregate->m_as.ckStorageFree = pData->totalFreeSpace;
427                   m_lAggregates->Add (lpAggregate);
428
429                   NOTIFYCALLBACK::SendNotificationToAll (evtCreate, lpAggregate->GetIdentifier());
430                   }
431
432                WORKERPACKET wpDone;
433                wpDone.wpVosPartitionGetDone.hEnum = wpBegin.wpVosPartitionGetBegin.hEnum;
434                Worker_DoTask (wtaskVosPartitionGetDone, &wpDone);
435                }
436
437             CloseVosObject();
438             }
439
440          if (fNotify)
441             NOTIFYCALLBACK::SendNotificationToAll (evtRefreshAggregatesEnd, GetIdentifier(), ((rc) ? 0 : status));
442          }
443       }
444
445    if (pStatus && !rc)
446       *pStatus = status;
447    return TRUE;
448 }
449
450
451 BOOL SERVER::RefreshServices (BOOL fNotify, ULONG *pStatus)
452 {
453    BOOL rc = TRUE;
454    DWORD status = 0;
455
456    if (m_fServicesOutOfDate)
457       {
458       m_fServicesOutOfDate = FALSE;
459
460       if (fIsMonitored())
461          {
462          if (fNotify)
463             NOTIFYCALLBACK::SendNotificationToAll (evtRefreshServicesBegin, GetIdentifier());
464
465          // First thing is to forget about what services we think we have now.
466          //
467          for (LPENUM pEnum = m_lServices->FindLast(); pEnum; pEnum = pEnum->FindPrevious())
468             {
469             LPSERVICE lpService = (LPSERVICE)(pEnum->GetObject());
470             lpService->SendDeleteNotifications();
471             m_lServices->Remove (lpService);
472             Delete (lpService);
473             }
474
475          // Next, the harder part: look through the server to find a list
476          // of services.
477          //
478          PVOID hCell;
479          PVOID hBOS;
480          if ((hBOS = OpenBosObject (&hCell, &status)) == NULL)
481             rc = FALSE;
482          else
483             {
484             WORKERPACKET wpBegin;
485             wpBegin.wpBosProcessNameGetBegin.hServer = hBOS;
486             if (!Worker_DoTask (wtaskBosProcessNameGetBegin, &wpBegin, &status))
487                rc = FALSE;
488             else
489                {
490                LPSERVICE lpService = New2 (SERVICE,(this, TEXT("BOS")));
491                m_lServices->Add (lpService);
492                NOTIFYCALLBACK::SendNotificationToAll (evtCreate, lpService->GetIdentifier());
493
494                for (;;)
495                   {
496                   TCHAR szServiceName[ cchNAME ];
497
498                   WORKERPACKET wpNext;
499                   wpNext.wpBosProcessNameGetNext.hEnum = wpBegin.wpBosProcessNameGetBegin.hEnum;
500                   wpNext.wpBosProcessNameGetNext.pszService = szServiceName;
501
502                   if (!Worker_DoTask (wtaskBosProcessNameGetNext, &wpNext, &status))
503                      {
504                      if (status == ADMITERATORDONE)
505                         status = 0;
506                      else
507                         rc = FALSE;
508                      break;
509                      }
510
511                   lpService = New2 (SERVICE,(this, wpNext.wpBosProcessNameGetNext.pszService));
512                   m_lServices->Add (lpService);
513                   NOTIFYCALLBACK::SendNotificationToAll (evtCreate, lpService->GetIdentifier());
514                   }
515
516                WORKERPACKET wpDone;
517                wpDone.wpBosProcessNameGetDone.hEnum = wpBegin.wpBosProcessNameGetBegin.hEnum;
518                Worker_DoTask (wtaskBosProcessNameGetDone, &wpDone);
519                }
520
521             CloseBosObject();
522             }
523
524          if (fNotify)
525             NOTIFYCALLBACK::SendNotificationToAll (evtRefreshServicesEnd, GetIdentifier(), ((rc) ? 0 : status));
526          }
527       }
528
529    if (pStatus && !rc)
530       *pStatus = status;
531    return TRUE;
532 }
533
534
535 BOOL SERVER::RefreshStatus (BOOL fNotify, ULONG *pStatus)
536 {
537    BOOL rc = TRUE;
538    DWORD status = 0;
539
540    if (m_fStatusOutOfDate)
541       {
542       m_fStatusOutOfDate = FALSE;
543
544       if (fNotify)
545          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshStatusBegin, GetIdentifier());
546
547       LPCELL lpCell;
548       if ((lpCell = OpenCell (&status)) == NULL)
549          rc = FALSE;
550       else
551          {
552          PVOID hCell;
553          if ((hCell = lpCell->GetCellObject (&status)) == NULL)
554             rc = FALSE;
555          else
556             {
557             WORKERPACKET wp;
558             wp.wpClientAFSServerGet.hCell = hCell;
559             wp.wpClientAFSServerGet.pszServer = m_szName;
560
561             if (!Worker_DoTask (wtaskClientAFSServerGet, &wp, &status))
562                rc = FALSE;
563             else
564                {
565                m_ss.nAddresses = 0;
566
567                for (size_t iAddr = 0; iAddr < AFS_MAX_SERVER_ADDRESS; ++iAddr)
568                   {
569                   if (wp.wpClientAFSServerGet.Entry.serverAddress[ iAddr ] == 0)
570                      continue;
571                   AfsClass_IntToAddress (&m_ss.aAddresses[ m_ss.nAddresses++ ], wp.wpClientAFSServerGet.Entry.serverAddress[ iAddr ]);
572                   }
573
574                lpCell->m_lServers->Update (this); // That update affected a hashlistkey
575                }
576             }
577          lpCell->Close();
578          }
579
580       if (fNotify)
581          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshStatusEnd, GetIdentifier(), ((rc) ? 0 : status));
582       }
583
584    if (pStatus && !rc)
585       *pStatus = status;
586    return TRUE;
587 }
588
589
590 void SERVER::GetName (LPTSTR pszName)
591 {
592    SERVER::ShortenName (pszName, m_szName);
593 }
594
595
596 void SERVER::GetLongName (LPTSTR pszName)
597 {
598    lstrcpy (pszName, m_szName);
599 }
600
601
602 LPCELL SERVER::OpenCell (ULONG *pStatus)
603 {
604    return m_lpiCell->OpenCell (pStatus);
605 }
606
607 BOOL SERVER::GetStatus (LPSERVERSTATUS lpss, BOOL fNotify, ULONG *pStatus)
608 {
609    BOOL rc = TRUE;
610
611    if (m_fMonitor)
612       rc = RefreshStatus (fNotify, pStatus);
613
614    memcpy (lpss, &m_ss, sizeof(SERVERSTATUS));
615    return rc;
616 }
617
618
619 short SERVER::GetGhostStatus (void)
620 {
621    return m_wGhost;
622 }
623
624
625 PVOID SERVER::GetUserParam (void)
626 {
627    return GetIdentifier()->GetUserParam();
628 }
629
630
631 void SERVER::SetUserParam (PVOID pUserNew)
632 {
633    GetIdentifier()->SetUserParam (pUserNew);
634 }
635
636
637 void SERVER::ShortenName (LPTSTR pszTarget, LPTSTR pszSource, BOOL fForce)
638 {
639    lstrcpy (pszTarget, pszSource);
640
641    if (fForce || !fLongServerNames)
642       {
643       // If the name is really an IP address, don't shorten it.
644       //
645       BOOL fIsIPAddress = TRUE;
646       for (LPTSTR pch = pszTarget; *pch && fIsIPAddress; ++pch)
647          {
648          if (!isdigit(*pch) && !(*pch == TEXT('.')))
649             fIsIPAddress = FALSE;
650          }
651
652       if (!fIsIPAddress)
653          {
654          if ((pszTarget = (LPTSTR)lstrchr (pszTarget, TEXT('.'))) != NULL)
655             *pszTarget = TEXT('\0');
656          }
657       }
658 }
659
660
661 BOOL SERVER::fIsMonitored (void)
662 {
663    return m_fMonitor;
664 }
665
666
667 BOOL SERVER::SetMonitor (BOOL fShouldMonitor, ULONG *pStatus)
668 {
669    BOOL rc = TRUE;
670    ULONG status = 0;
671
672    if (m_fMonitor != fShouldMonitor)
673       {
674       LPCELL lpCell;
675       if ((lpCell = m_lpiCell->OpenCell (&status)) == NULL)
676          rc = FALSE;
677       else
678          {
679          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshStatusBegin, GetIdentifier());
680
681          if ((m_fMonitor = fShouldMonitor) == FALSE)
682             {
683             FreeAll();
684             (lpCell->m_nServersUnmonitored)++;
685             }
686          else // (fMonitor == TRUE)
687             {
688             (lpCell->m_nServersUnmonitored)--;
689             Invalidate();
690             rc = RefreshAll (&status);
691             }
692
693          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshStatusEnd, GetIdentifier(), m_lastStatus);
694          lpCell->Close();
695          }
696       }
697
698    if (!rc && pStatus)
699       *pStatus = status;
700    return rc;
701 }
702
703
704 /*
705  * REFRESHALL __________________________________________________________________
706  *
707  * If a server is down, or doesn't have an VOS process running, it could
708  * take some time before we time out trying to talk to the server.  During
709  * the course of a refresh, the first timeout-and-fail that we will hit is
710  * our call to wtaskVosPartitionGetBegin; since this call is very quick if
711  * it's going to be successful, we can safely perform this call once up-front
712  * to test to see if the server is listening at all.  That test is performed
713  * on a separate thread, so that in the event the request times out, we can
714  * simply discard the thread and let it terminate on its own.
715  *
716  */
717
718 typedef struct
719    {
720    BOOL fInUse;
721    BOOL fCanceled;
722    LPSERVER lpServer;
723    PVOID hCell;
724    } REFRESHSECTION, *LPREFRESHSECTION;
725
726 static REFRESHSECTION    *aRefSec = NULL;
727 static size_t             cRefSec = 0;
728 static LPCRITICAL_SECTION pcsRefSec = NULL;
729
730 void AfsClass_InitRefreshSections (void)
731 {
732    if (pcsRefSec == NULL)
733       {
734       pcsRefSec = New (CRITICAL_SECTION);
735       InitializeCriticalSection (pcsRefSec);
736       }
737 }
738
739
740 void AfsClass_SkipRefresh (int idSection)
741 {
742    AfsClass_InitRefreshSections();
743    EnterCriticalSection (pcsRefSec);
744
745    if (aRefSec && (idSection < (int)cRefSec))
746       {
747       if (aRefSec[ idSection ].fInUse)
748          {
749          aRefSec[ idSection ].fCanceled = TRUE;
750          }
751       }
752
753    LeaveCriticalSection (pcsRefSec);
754 }
755
756
757 DWORD WINAPI SERVER::CanTalkToServer_ThreadProc (PVOID lp)
758 {
759    int idSection = (int)lp;
760
761    // Until we post a notification saying that we've entered
762    // a section, we don't need to worry about the aRefSec[] entry
763    // being invalid. Once that post is made, the user can skip
764    // the section at any time--so we'll have to check frequently,
765    // always under the pcsRefSec critical section.
766    //
767    NOTIFYCALLBACK::SendNotificationToAll (evtRefreshAllSectionStart, NULL, NULL, NULL, NULL, idSection, 0);
768
769    BOOL fAggregatesOK = FALSE;
770    BOOL fServicesOK = FALSE;
771    BOOL fContinue = TRUE;
772
773    // Try to get the BOS object for this server.  Remember, there's
774    // a catch here: we can only assume that the aRefSec[idSection].lpServer
775    // pointer is valid so long as we're within the pcsRefSec critical
776    // section! (if we're in that critsec, we can verify that no one
777    // has canceled the operation--and if no one has, there is a thread
778    // hanging around which holds the library's critsec, which ensures
779    // the lpServer pointer won't have been freed.)
780    // 
781    PVOID hCell;
782    PVOID hBOS;
783    PVOID hVOS;
784
785    TCHAR szServer[ cchNAME ];
786
787    EnterCriticalSection (pcsRefSec);
788    if ( ((!aRefSec[ idSection ].fInUse) || (aRefSec[ idSection ].fCanceled)) )
789       fContinue = FALSE;
790    else
791       {
792       hCell = aRefSec[ idSection ].hCell;
793       aRefSec[ idSection ].lpServer->GetLongName (szServer);
794       }
795    LeaveCriticalSection (pcsRefSec);
796
797    if (fContinue)
798       {
799       WORKERPACKET wp;
800       wp.wpBosServerOpen.hCell = hCell;
801       wp.wpBosServerOpen.pszServer = szServer;
802
803       ULONG status;
804       fContinue = Worker_DoTask (wtaskBosServerOpen, &wp, &status);
805
806       EnterCriticalSection (pcsRefSec);
807       if ( ((!aRefSec[ idSection ].fInUse) || (aRefSec[ idSection ].fCanceled)) )
808          fContinue = FALSE;
809       else if (!fContinue)
810          aRefSec[ idSection ].lpServer->m_lastStatus = status;
811       else
812          hBOS = wp.wpBosServerOpen.hServer;
813       LeaveCriticalSection (pcsRefSec);
814       }
815
816    if (fContinue)
817       {
818       WORKERPACKET wpBegin;
819       wpBegin.wpBosProcessNameGetBegin.hServer = hBOS;
820
821       ULONG status;
822       fContinue = Worker_DoTask (wtaskBosProcessNameGetBegin, &wpBegin, &status);
823
824       EnterCriticalSection (pcsRefSec);
825       if ( ((!aRefSec[ idSection ].fInUse) || (aRefSec[ idSection ].fCanceled)) )
826          fContinue = FALSE;
827       else if (fContinue)
828          aRefSec[ idSection ].lpServer->m_lastStatus = status;
829       LeaveCriticalSection (pcsRefSec);
830
831       if (fContinue)
832          {
833          WORKERPACKET wpDone;
834          wpDone.wpBosProcessNameGetDone.hEnum = wpBegin.wpBosProcessNameGetBegin.hEnum;
835          Worker_DoTask (wtaskBosProcessNameGetDone, &wpDone);
836
837          // We can talk to BOS!
838          fServicesOK = TRUE;
839          }
840       }
841
842    // If we couldn't talk to BOS, it's a sure bet the server is down--
843    // and regardless, if BOS isn't around, VOS isn't either.  So
844    // we may not even have to test that.
845    //
846    if (fContinue)
847       {
848       WORKERPACKET wp;
849       wp.wpVosServerOpen.hCell = hCell;
850       wp.wpVosServerOpen.pszServer = szServer;
851
852       ULONG status;
853       fContinue = Worker_DoTask (wtaskVosServerOpen, &wp, &status);
854
855       EnterCriticalSection (pcsRefSec);
856       if ( ((!aRefSec[ idSection ].fInUse) || (aRefSec[ idSection ].fCanceled)) )
857          fContinue = FALSE;
858       else if (!fContinue)
859          aRefSec[ idSection ].lpServer->m_lastStatus = status;
860       else
861          hVOS = wp.wpVosServerOpen.hServer;
862       LeaveCriticalSection (pcsRefSec);
863       }
864
865    if (fContinue)
866       {
867       WORKERPACKET wpBegin;
868       wpBegin.wpVosPartitionGetBegin.hCell = hCell;
869       wpBegin.wpVosPartitionGetBegin.hServer = hVOS;
870
871       ULONG status;
872       fContinue = Worker_DoTask (wtaskVosPartitionGetBegin, &wpBegin, &status);
873
874       EnterCriticalSection (pcsRefSec);
875       if ( ((!aRefSec[ idSection ].fInUse) || (aRefSec[ idSection ].fCanceled)) )
876          fContinue = FALSE;
877       else if (fContinue)
878          aRefSec[ idSection ].lpServer->m_lastStatus = status;
879       LeaveCriticalSection (pcsRefSec);
880
881       if (fContinue)
882          {
883          WORKERPACKET wpDone;
884          wpDone.wpVosPartitionGetDone.hEnum = wpBegin.wpVosPartitionGetBegin.hEnum;
885          Worker_DoTask (wtaskVosPartitionGetDone, &wpDone);
886
887          // We can talk to VOS!
888          fAggregatesOK = TRUE;
889          }
890       }
891
892    // Close the VOS and BOS objects we obtained.
893    //
894    if (hBOS)
895       {
896       WORKERPACKET wp;
897       wp.wpBosServerClose.hServer = hBOS;
898       Worker_DoTask (wtaskBosServerClose, &wp);
899       }
900    if (hVOS)
901       {
902       WORKERPACKET wp;
903       wp.wpVosServerClose.hServer = hVOS;
904       Worker_DoTask (wtaskVosServerClose, &wp);
905       }
906
907    // Return our entry in the RefSec array back to the pool.
908    // If the request was never canceled, there is another
909    // thread waiting to hear our results--update the server
910    // entry specified by RefSec before leaving.
911    //
912    NOTIFYCALLBACK::SendNotificationToAll (evtRefreshAllSectionEnd, NULL, NULL, NULL, NULL, idSection, 0);
913
914    EnterCriticalSection (pcsRefSec);
915    if ( (aRefSec[ idSection ].fInUse) && (!aRefSec[ idSection ].fCanceled) )
916       {
917       aRefSec[ idSection ].lpServer->m_fCanGetAggregates = fAggregatesOK;
918       aRefSec[ idSection ].lpServer->m_fCanGetServices = fServicesOK;
919       }
920    aRefSec[ idSection ].fInUse = FALSE;
921    LeaveCriticalSection (pcsRefSec);
922    return 1;
923 }
924
925
926 BOOL SERVER::CanTalkToServer (ULONG *pStatus)
927 {
928    // Ensure the server exists in the cell at all--
929    // this call just updates the server's IP addresses
930    // etc (information it gets from the database servers)
931    // and doesn't require talking to the server itself.
932    //
933    if (!RefreshStatus (FALSE, pStatus))
934       return FALSE;
935
936    // Find a new refsec array element to use...
937    //
938    AfsClass_InitRefreshSections();
939    EnterCriticalSection (pcsRefSec);
940
941    for (int idSection = 0; idSection < (int)cRefSec; ++idSection)
942       {
943       if (!aRefSec[ idSection ].fInUse)
944          break;
945       }
946    if (idSection == (int)cRefSec)
947       {
948       if (!REALLOC (aRefSec, cRefSec, 1+idSection, 4))
949          {
950          if (pStatus)
951             *pStatus = GetLastError();
952          LeaveCriticalSection (pcsRefSec);
953          return FALSE;
954          }
955       }
956    aRefSec[ idSection ].fInUse = TRUE;
957    aRefSec[ idSection ].fCanceled = FALSE;
958    aRefSec[ idSection ].lpServer = this;
959    aRefSec[ idSection ].hCell = NULL;
960
961    LPCELL lpCell;
962    if ((lpCell = OpenCell()) != NULL)
963       {
964       aRefSec[ idSection ].hCell = lpCell->GetCellObject();
965       lpCell->Close();
966       }
967
968    LeaveCriticalSection (pcsRefSec);
969
970    // Until we find out differently, assume that we won't be
971    // able to query VOS or BOS on this server.
972    //
973    m_fCanGetAggregates = FALSE;
974    m_fCanGetServices = FALSE;
975    m_lastStatus = 0;
976
977    // Fork a separate thread, on which to quickly try to talk
978    // to the server.
979    //
980    DWORD dwThreadID;
981    HANDLE hThread;
982    if ((hThread = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE)CanTalkToServer_ThreadProc, (PVOID)idSection, 0, &dwThreadID)) == NULL)
983       {
984       EnterCriticalSection (pcsRefSec);
985       aRefSec[ idSection ].fInUse = FALSE;
986       LeaveCriticalSection (pcsRefSec);
987       if (pStatus)
988          *pStatus = GetLastError();
989       return FALSE;
990       }
991    SetThreadPriority (hThread, THREAD_PRIORITY_BELOW_NORMAL);
992
993    // Wait for that thread to terminate, or for our
994    // newly-allocated RefSec entry to be marked Canceled.
995    //
996    for (DWORD dw = STILL_ACTIVE; dw == STILL_ACTIVE; )
997       {
998       EnterCriticalSection (pcsRefSec);
999
1000       GetExitCodeThread (hThread, &dw);
1001       if (dw == STILL_ACTIVE)
1002          {
1003          if ( (aRefSec[ idSection ].fInUse) &&
1004               (aRefSec[ idSection ].lpServer == this) &&
1005               (aRefSec[ idSection ].fCanceled) )
1006             {
1007             if (m_lastStatus == 0)
1008                m_lastStatus = ERROR_CANCELLED;
1009             dw = 0;
1010             }
1011          }
1012
1013       LeaveCriticalSection (pcsRefSec);
1014
1015       if (dw == STILL_ACTIVE)
1016          Sleep(100);    // wait another brief instant
1017       }
1018
1019    // dw == 0 : user canceled operation (thread is still running!)
1020    // dw == 1 : thread completed successfully, and set fCanTalkTo* flags.
1021    //
1022    // Note that the thread will clear aRefSec[idSection].fInUse when it
1023    // terminates (so, if dw!=-1, it has already done so).
1024    //
1025    if (pStatus)
1026       *pStatus = m_lastStatus;
1027    return (dw == 0) ? FALSE : TRUE;
1028 }
1029
1030
1031 BOOL SERVER::RefreshAll (ULONG *pStatus, double dInit, double dFactor)
1032 {
1033    BOOL rc = TRUE;
1034    ULONG status = 0;
1035
1036    if (m_fAggregatesOutOfDate || m_fServicesOutOfDate)
1037       {
1038       if ((++cRefreshAllReq) == 1)
1039          {
1040          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshAllBegin, GetIdentifier(), 0);
1041          }
1042
1043       double perAGGREGATES = 65.0; // % of time spent finding aggs & sets
1044       double perSERVICES   = 25.0; // % of time spent finding services
1045       double perVLDB       = 10.0; // % of time spent finding VLDB info
1046
1047       if (cRefreshAllReq >= 2) // being called as part of a cell-wide op?
1048          {
1049          perAGGREGATES = 80.0; // % of time spent finding aggs & sets
1050          perSERVICES   = 20.0; // % of time spent finding services
1051          perVLDB       = 0.0;  // we won't query VLDB stuff ourself.
1052          }
1053
1054       NOTIFYCALLBACK::SendNotificationToAll (evtRefreshStatusBegin, GetIdentifier());
1055
1056       if (!CanTalkToServer (&status))  // Determines fCanGetAggregates, fCanGetServices
1057          {
1058          if (m_fMonitor)
1059             SetMonitor (FALSE);
1060          rc = FALSE;
1061          }
1062       else
1063          {
1064          if (!m_fCanGetAggregates)
1065             {
1066             FreeAggregates();
1067             m_fAggregatesOutOfDate = FALSE;
1068             }
1069          else
1070             {
1071             size_t nAggregates = 0;
1072             size_t iAggregate = 0;
1073             HENUM hEnum;
1074             for (LPAGGREGATE lpAggregate = AggregateFindFirst (&hEnum); lpAggregate; lpAggregate = AggregateFindNext (&hEnum))
1075                {
1076                ++nAggregates;
1077                lpAggregate->Close();
1078                }
1079                
1080             if (nAggregates)
1081                {
1082                for (lpAggregate = AggregateFindFirst (&hEnum); lpAggregate; lpAggregate = AggregateFindNext (&hEnum))
1083                   {
1084                   ULONG perComplete = (ULONG)( ((double)perAGGREGATES / 100.0) * ((double)iAggregate * 100.0 / nAggregates) );
1085                   NOTIFYCALLBACK::SendNotificationToAll (evtRefreshAllUpdate, lpAggregate->GetIdentifier(), NULL, NULL, NULL, (ULONG)( 100.0 * dInit + dFactor * (double)perComplete ), 0);
1086
1087                   lpAggregate->RefreshFilesets (TRUE);
1088                   lpAggregate->Close();
1089
1090                   ++iAggregate;
1091                   }
1092                }
1093             }
1094
1095          if (!m_fCanGetServices)
1096             {
1097             FreeServices();
1098             m_fServicesOutOfDate = FALSE;
1099             }
1100          else
1101             {
1102             size_t nServices = 0;
1103             size_t iService = 0;
1104             HENUM hEnum;
1105             for (LPSERVICE lpService = ServiceFindFirst (&hEnum); lpService; lpService = ServiceFindNext (&hEnum))
1106                {
1107                ++nServices;
1108                lpService->Close();
1109                }
1110
1111             if (nServices)
1112                {
1113                for (lpService = ServiceFindFirst (&hEnum); lpService; lpService = ServiceFindNext (&hEnum))
1114                   {
1115                   ULONG perComplete = (ULONG)( (double)perAGGREGATES + ((double)perSERVICES / 100.0) * ((double)iService * 100.0 / nServices) );
1116                   NOTIFYCALLBACK::SendNotificationToAll (evtRefreshAllUpdate, lpService->GetIdentifier(), NULL, NULL, NULL, (ULONG)( 100.0 * dInit + dFactor * (double)perComplete ), 0);
1117
1118                   lpService->RefreshStatus (TRUE);
1119                   lpService->Close();
1120
1121                   ++iService;
1122                   }
1123                }
1124             }
1125
1126          if (cRefreshAllReq == 1) // not being called as part of a cell-wide op?
1127             {
1128             LPCELL lpCell;
1129             if ((lpCell = OpenCell()) != NULL)
1130                {
1131                lpCell->RefreshVLDB (GetIdentifier(), TRUE, NULL);
1132                lpCell->Close();
1133                }
1134             }
1135          }
1136
1137       NOTIFYCALLBACK::SendNotificationToAll (evtRefreshStatusEnd, GetIdentifier(), m_lastStatus);
1138
1139       if ((--cRefreshAllReq) == 0)
1140          {
1141          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshAllEnd, GetIdentifier(), NULL, NULL, NULL, 100, m_lastStatus);
1142          }
1143       }
1144
1145    if (rc && m_lastStatus)
1146       rc = FALSE;
1147    if (!rc && pStatus)
1148       *pStatus = status;
1149    return rc;
1150 }
1151
1152
1153 /*
1154  * AGGREGATES _________________________________________________________________
1155  *
1156  */
1157
1158 LPAGGREGATE SERVER::OpenAggregate (LPTSTR pszName, ULONG *pStatus)
1159 {
1160    if (!RefreshAggregates (TRUE, pStatus))
1161       return NULL;
1162
1163    LPAGGREGATE lpAggregate;
1164    if ((lpAggregate = (LPAGGREGATE)(m_lkAggregateName->GetFirstObject (pszName))) != NULL)
1165       AfsClass_Enter();
1166
1167    return lpAggregate;
1168 }
1169
1170
1171 LPAGGREGATE SERVER::OpenAggregate (ULONG dwID, ULONG *pStatus)
1172 {
1173    if (!RefreshAggregates (TRUE, pStatus))
1174       return NULL;
1175
1176    LPAGGREGATE lpAggregate;
1177    if ((lpAggregate = (LPAGGREGATE)(m_lkAggregateID->GetFirstObject (&dwID))) != NULL)
1178       AfsClass_Enter();
1179
1180    return lpAggregate;
1181 }
1182
1183
1184 LPAGGREGATE SERVER::AggregateFindFirst (HENUM *phEnum, BOOL fNotify, ULONG *pStatus)
1185 {
1186    return AggregateFindFirst (phEnum, NULL, fNotify, pStatus);
1187 }
1188
1189
1190 LPAGGREGATE SERVER::AggregateFindFirst (HENUM *phEnum, LPIDENT lpiFind, BOOL fNotify, ULONG *pStatus)
1191 {
1192    LPAGGREGATE lpAggregate = NULL;
1193
1194    if (!RefreshAggregates (fNotify, pStatus))
1195       return NULL;
1196
1197    if (lpiFind != NULL)
1198       {
1199       lpAggregate = lpiFind->OpenAggregate();
1200       *phEnum = NULL;
1201       }
1202    else if ((*phEnum = m_lAggregates->FindFirst()) != NULL)
1203       {
1204       lpAggregate = (LPAGGREGATE)( (*phEnum)->GetObject() );
1205       AfsClass_Enter();
1206       }
1207
1208    if (!lpAggregate && pStatus)
1209       *pStatus = ERROR_FILE_NOT_FOUND;
1210    return lpAggregate;
1211 }
1212
1213
1214 LPAGGREGATE SERVER::AggregateFindNext (HENUM *phEnum)
1215 {
1216    LPAGGREGATE lpAggregate = NULL;
1217
1218    if (*phEnum)
1219       {
1220       if ((*phEnum = (*phEnum)->FindNext()) != NULL)
1221          {
1222          lpAggregate = (LPAGGREGATE)( (*phEnum)->GetObject() );
1223          AfsClass_Enter();
1224          }
1225       }
1226
1227    return lpAggregate;
1228 }
1229
1230
1231 void SERVER::AggregateFindClose (HENUM *phEnum)
1232 {
1233    if (*phEnum)
1234       {
1235       Delete (*phEnum);
1236       *phEnum = NULL;
1237       }
1238 }
1239
1240
1241 /*
1242  * SERVICES ___________________________________________________________________
1243  *
1244  */
1245
1246 LPSERVICE SERVER::OpenService (LPTSTR pszName, ULONG *pStatus)
1247 {
1248    if (!RefreshServices (TRUE, pStatus))
1249       return NULL;
1250
1251    LPSERVICE lpService;
1252    if ((lpService = (LPSERVICE)(m_lkServiceName->GetFirstObject (pszName))) != NULL)
1253       AfsClass_Enter();
1254
1255    return lpService;
1256 }
1257
1258
1259 LPSERVICE SERVER::ServiceFindFirst (HENUM *phEnum, BOOL fNotify, ULONG *pStatus)
1260 {
1261    return ServiceFindFirst (phEnum, NULL, fNotify, pStatus);
1262 }
1263
1264
1265 LPSERVICE SERVER::ServiceFindFirst (HENUM *phEnum, LPIDENT lpiFind, BOOL fNotify, ULONG *pStatus)
1266 {
1267    LPSERVICE lpService = NULL;
1268
1269    if (!RefreshServices (fNotify, pStatus))
1270       return NULL;
1271
1272    if (lpiFind != NULL)
1273       {
1274       lpService = lpiFind->OpenService();
1275       *phEnum = NULL;
1276       }
1277    else if ((*phEnum = m_lServices->FindFirst()) != NULL)
1278       {
1279       lpService = (LPSERVICE)( (*phEnum)->GetObject() );
1280       AfsClass_Enter();
1281       }
1282
1283    if (!lpService && pStatus)
1284       *pStatus = ERROR_FILE_NOT_FOUND;
1285    return lpService;
1286 }
1287
1288
1289 LPSERVICE SERVER::ServiceFindNext (HENUM *phEnum)
1290 {
1291    LPSERVICE lpService = NULL;
1292
1293    if (*phEnum)
1294       {
1295       if ((*phEnum = (*phEnum)->FindNext()) != NULL)
1296          {
1297          lpService = (LPSERVICE)( (*phEnum)->GetObject() );
1298          AfsClass_Enter();
1299          }
1300       }
1301
1302    return lpService;
1303 }
1304
1305
1306 void SERVER::ServiceFindClose (HENUM *phEnum)
1307 {
1308    if (*phEnum)
1309       {
1310       Delete (*phEnum);
1311       *phEnum = NULL;
1312       }
1313 }
1314
1315
1316 /*
1317  * HASH KEYS __________________________________________________________________
1318  *
1319  */
1320
1321 BOOL CALLBACK SERVER::KeyAggregateName_Compare (LPHASHLISTKEY pKey, PVOID pObject, PVOID pData)
1322 {
1323    return !lstrcmp (((LPAGGREGATE)pObject)->m_szName, (LPTSTR)pData);
1324 }
1325
1326 HASHVALUE CALLBACK SERVER::KeyAggregateName_HashObject (LPHASHLISTKEY pKey, PVOID pObject)
1327 {
1328    return SERVER::KeyAggregateName_HashData (pKey, ((LPAGGREGATE)pObject)->m_szName);
1329 }
1330
1331 HASHVALUE CALLBACK SERVER::KeyAggregateName_HashData (LPHASHLISTKEY pKey, PVOID pData)
1332 {
1333    return HashString ((LPTSTR)pData);
1334 }
1335
1336
1337 BOOL CALLBACK SERVER::KeyAggregateID_Compare (LPHASHLISTKEY pKey, PVOID pObject, PVOID pData)
1338 {
1339    return (((LPAGGREGATE)pObject)->m_as.dwID == *(ULONG*)pData);
1340 }
1341
1342 HASHVALUE CALLBACK SERVER::KeyAggregateID_HashObject (LPHASHLISTKEY pKey, PVOID pObject)
1343 {
1344    return SERVER::KeyAggregateID_HashData (pKey, &((LPAGGREGATE)pObject)->m_as.dwID);
1345 }
1346
1347 HASHVALUE CALLBACK SERVER::KeyAggregateID_HashData (LPHASHLISTKEY pKey, PVOID pData)
1348 {
1349    return (HASHVALUE)*(ULONG*)pData;
1350 }
1351
1352
1353 BOOL CALLBACK SERVER::KeyServiceName_Compare (LPHASHLISTKEY pKey, PVOID pObject, PVOID pData)
1354 {
1355    return !lstrcmp (((LPSERVICE)pObject)->m_szName, (LPTSTR)pData);
1356 }
1357
1358 HASHVALUE CALLBACK SERVER::KeyServiceName_HashObject (LPHASHLISTKEY pKey, PVOID pObject)
1359 {
1360    return SERVER::KeyServiceName_HashData (pKey, ((LPSERVICE)pObject)->m_szName);
1361 }
1362
1363 HASHVALUE CALLBACK SERVER::KeyServiceName_HashData (LPHASHLISTKEY pKey, PVOID pData)
1364 {
1365    return HashString ((LPTSTR)pData);
1366 }
1367