windows-afs-svrmgr-20070719
[openafs.git] / src / WINNT / afsclass / afsclassfn.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 <afs/param.h>
15 #include <afs/stds.h>
16 }
17
18 #include <WINNT/afsclass.h>
19 #include "internal.h"
20
21
22 /*
23  * DEFINITIONS ________________________________________________________________
24  *
25  */
26
27 #define cREALLOC_ADMINLISTENTRIES   32
28
29 #define cREALLOC_HOSTLISTENTRIES    16
30
31 #define cREALLOC_SERVERKEYS         16
32
33 #define ACCOUNTACCESS_TO_USERACCESS(_aa) ( ((_aa) == aaOWNER_ONLY) ? PTS_USER_OWNER_ACCESS : PTS_USER_ANYUSER_ACCESS )
34
35 #define ACCOUNTACCESS_TO_GROUPACCESS(_aa) ( ((_aa) == aaOWNER_ONLY) ? PTS_GROUP_OWNER_ACCESS : ((_aa) == aaGROUP_ONLY) ? PTS_GROUP_ACCESS : PTS_GROUP_ANYUSER_ACCESS )
36
37
38 /*
39  * PROTOTYPES _________________________________________________________________
40  *
41  */
42
43
44 /*
45  * ROUTINES ___________________________________________________________________
46  *
47  */
48
49 BOOL AfsClass_GetServerLogFile (LPIDENT lpiServer, LPTSTR pszLocal, LPTSTR pszRemote, ULONG *pStatus)
50 {
51    BOOL rc = TRUE;
52    ULONG status;
53
54    AfsClass_Enter();
55    NOTIFYCALLBACK::SendNotificationToAll (evtGetServerLogFileBegin, lpiServer, pszRemote, 0);
56
57    PVOID hCell = NULL;
58    PVOID hBOS = NULL;
59    LPSERVER lpServer = NULL;
60    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
61       rc = FALSE;
62    else
63       {
64       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
65          rc = FALSE;
66       lpServer->Close();
67       }
68
69    if (rc)
70       {
71       WORKERPACKET wp;
72       wp.wpBosLogGet.hServer = hBOS;
73       wp.wpBosLogGet.pszLogName = pszRemote;
74       wp.wpBosLogGet.pszLogData = NULL;
75
76       AfsClass_Leave();
77       if ((rc = Worker_DoTask (wtaskBosLogGet, &wp, &status)) == TRUE)
78          {
79          HANDLE fh;
80          if ((fh = CreateFile (pszLocal, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, NULL)) != INVALID_HANDLE_VALUE)
81             {
82             // Write the file a line at a time in order to make
83             // sure that each line ends with "\r\n".  If we encounter
84             // a line which ends in \r\n already, well, leave it alone.
85             //
86             for (LPTSTR psz = wp.wpBosLogGet.pszLogData; psz && *psz; )
87                {
88                LPTSTR pszNext;
89                for (pszNext = psz; *pszNext && (*pszNext != TEXT('\r')) && (*pszNext != TEXT('\n')); ++pszNext)
90                   ;
91                DWORD cbWrite;
92                DWORD cbWrote;
93                if ((cbWrite = (DWORD)(pszNext - psz)) != 0)
94                   WriteFile (fh, psz, cbWrite, &cbWrote, NULL);
95                WriteFile (fh, TEXT("\r\n"), 2, &cbWrote, NULL);
96                psz = (*pszNext == TEXT('\r')) ? (2+pszNext) : (*pszNext == TEXT('\n')) ? (1+pszNext) : NULL;
97                }
98             CloseHandle (fh);
99             }
100
101          Free (wp.wpBosLogGet.pszLogData);
102          }
103
104       AfsClass_Enter();
105       }
106
107    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
108       {
109       lpServer->CloseBosObject();
110       lpServer->Close();
111       }
112
113    NOTIFYCALLBACK::SendNotificationToAll (evtGetServerLogFileEnd, lpiServer, pszRemote, status);
114    AfsClass_Leave();
115
116    if (pStatus && !rc)
117       *pStatus = status;
118    return rc;
119 }
120
121
122 BOOL AfsClass_SetServerAuth (LPIDENT lpiServer, BOOL fEnabled, ULONG *pStatus)
123 {
124    BOOL rc = TRUE;
125    ULONG status;
126
127    AfsClass_Enter();
128    NOTIFYCALLBACK::SendNotificationToAll (evtSetServerAuthBegin, lpiServer);
129
130    PVOID hCell;
131    PVOID hBOS;
132    LPSERVER lpServer;
133    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
134       rc = FALSE;
135    else
136       {
137       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
138          rc = FALSE;
139       lpServer->Close();
140       }
141
142    if (rc)
143       {
144       WORKERPACKET wp;
145       wp.wpBosAuthSet.hServer = hBOS;
146       wp.wpBosAuthSet.fEnableAuth = fEnabled;
147
148       AfsClass_Leave();
149       rc = Worker_DoTask (wtaskBosAuthSet, &wp, &status);
150       AfsClass_Enter();
151       }
152
153    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
154       {
155       lpServer->CloseBosObject();
156       lpServer->Close();
157       }
158
159    NOTIFYCALLBACK::SendNotificationToAll (evtSetServerAuthEnd, lpiServer, status);
160    AfsClass_Leave();
161
162    if (pStatus && !rc)
163       *pStatus = status;
164    return rc;
165 }
166
167
168 BOOL AfsClass_StartService (LPIDENT lpiStart, BOOL fTemporary, ULONG *pStatus)
169 {
170    BOOL rc = TRUE;
171    ULONG status;
172
173    AfsClass_Enter();
174    NOTIFYCALLBACK::SendNotificationToAll (evtStartServiceBegin, lpiStart);
175
176    PVOID hCell;
177    PVOID hBOS;
178    LPSERVER lpServer;
179    if ((lpServer = lpiStart->OpenServer (&status)) == NULL)
180       rc = FALSE;
181    else
182       {
183       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
184          rc = FALSE;
185       lpServer->Close();
186       }
187
188    if (rc)
189       {
190       if (lpiStart->fIsService())
191          {
192          TCHAR szName[ cchNAME ];
193          lpiStart->GetServiceName (szName);
194
195          if (fTemporary)
196             {
197             WORKERPACKET wp;
198             wp.wpBosProcessExecutionStateSetTemporary.hServer = hBOS;
199             wp.wpBosProcessExecutionStateSetTemporary.pszService = szName;
200             wp.wpBosProcessExecutionStateSetTemporary.state = SERVICESTATE_RUNNING;
201
202             AfsClass_Leave();
203             rc = Worker_DoTask (wtaskBosProcessExecutionStateSetTemporary, &wp, &status);
204             AfsClass_Enter();
205             }
206          else
207             {
208             WORKERPACKET wp;
209             wp.wpBosProcessExecutionStateSet.hServer = hBOS;
210             wp.wpBosProcessExecutionStateSet.pszService = szName;
211             wp.wpBosProcessExecutionStateSet.state = SERVICESTATE_RUNNING;
212
213             AfsClass_Leave();
214             rc = Worker_DoTask (wtaskBosProcessExecutionStateSet, &wp, &status);
215             AfsClass_Enter();
216             }
217          }
218       else
219          {
220          WORKERPACKET wp;
221          wp.wpBosProcessAllStart.hServer = hBOS;
222          AfsClass_Leave();
223          rc = Worker_DoTask (wtaskBosProcessAllStart, &wp, &status);
224          AfsClass_Enter();
225          }
226       }
227
228    if (rc)
229       {
230       if (lpiStart->fIsService())
231          {
232          LPSERVICE lpService;
233          if ((lpService = lpiStart->OpenService (&status)) == NULL)
234             rc = FALSE;
235          else
236             {
237             lpService->Invalidate();
238             lpService->RefreshStatus();
239             lpService->Close();
240             }
241          }
242       else
243          {
244          if ((lpServer = lpiStart->OpenServer (&status)) == NULL)
245             rc = FALSE;
246          else
247             {
248             lpServer->Invalidate();
249             lpServer->RefreshAll();
250             lpServer->Close();
251             }
252          }
253       }
254
255    if ((lpServer = lpiStart->OpenServer (&status)) != NULL)
256       {
257       lpServer->CloseBosObject();
258       lpServer->Close();
259       }
260
261    NOTIFYCALLBACK::SendNotificationToAll (evtStartServiceEnd, lpiStart, status);
262    AfsClass_Leave();
263
264    if (pStatus && !rc)
265       *pStatus = status;
266    return rc;
267 }
268
269
270 BOOL AfsClass_StopService (LPIDENT lpiStop, BOOL fTemporary, BOOL fWait, ULONG *pStatus)
271 {
272    BOOL rc = TRUE;
273    ULONG status;
274
275    AfsClass_Enter();
276    NOTIFYCALLBACK::SendNotificationToAll (evtStopServiceBegin, lpiStop);
277
278    PVOID hCell;
279    PVOID hBOS;
280    LPSERVER lpServer;
281    if ((lpServer = lpiStop->OpenServer (&status)) == NULL)
282       rc = FALSE;
283    else
284       {
285       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
286          rc = FALSE;
287       lpServer->Close();
288       }
289
290    if (rc)
291       {
292       if (lpiStop->fIsService())
293          {
294          TCHAR szName[ cchNAME ];
295          lpiStop->GetServiceName (szName);
296
297          if (fTemporary)
298             {
299             WORKERPACKET wp;
300             wp.wpBosProcessExecutionStateSetTemporary.hServer = hBOS;
301             wp.wpBosProcessExecutionStateSetTemporary.pszService = szName;
302             wp.wpBosProcessExecutionStateSetTemporary.state = SERVICESTATE_STOPPED;
303             // TODO: wp.wpStopBosProcessTemporary.fWait = TRUE;
304
305             AfsClass_Leave();
306             rc = Worker_DoTask (wtaskBosProcessExecutionStateSetTemporary, &wp, &status);
307             AfsClass_Enter();
308             }
309          else
310             {
311             WORKERPACKET wp;
312             wp.wpBosProcessExecutionStateSet.hServer = hBOS;
313             wp.wpBosProcessExecutionStateSet.pszService = szName;
314             wp.wpBosProcessExecutionStateSet.state = SERVICESTATE_STOPPED;
315             // TODO: wp.wpStopBosProcess.fWait = TRUE;
316
317             AfsClass_Leave();
318             rc = Worker_DoTask (wtaskBosProcessExecutionStateSet, &wp, &status);
319             AfsClass_Enter();
320             }
321          }
322       else if (fWait)
323          {
324          WORKERPACKET wp;
325          wp.wpBosProcessAllWaitStop.hServer = hBOS;
326
327          AfsClass_Leave();
328          rc = Worker_DoTask (wtaskBosProcessAllWaitStop, &wp, &status);
329          AfsClass_Enter();
330          }
331       else // (!fWait)
332          {
333          WORKERPACKET wp;
334          wp.wpBosProcessAllStop.hServer = hBOS;
335
336          AfsClass_Leave();
337          rc = Worker_DoTask (wtaskBosProcessAllStop, &wp, &status);
338          AfsClass_Enter();
339          }
340       }
341
342    if (rc)
343       {
344       if (lpiStop->fIsService())
345          {
346          LPSERVICE lpService;
347          if ((lpService = lpiStop->OpenService (&status)) == NULL)
348             rc = FALSE;
349          else
350             {
351             lpService->Invalidate();
352             lpService->RefreshStatus();
353             lpService->Close();
354             }
355          }
356       else
357          {
358          LPSERVER lpServer;
359          if ((lpServer = lpiStop->OpenServer (&status)) == NULL)
360             rc = FALSE;
361          else
362             {
363             lpServer->Invalidate();
364             lpServer->RefreshAll();
365             lpServer->Close();
366             }
367          }
368       }
369
370    if ((lpServer = lpiStop->OpenServer (&status)) != NULL)
371       {
372       lpServer->CloseBosObject();
373       lpServer->Close();
374       }
375
376    NOTIFYCALLBACK::SendNotificationToAll (evtStopServiceEnd, lpiStop, status);
377    AfsClass_Leave();
378
379    if (pStatus && !rc)
380       *pStatus = status;
381    return rc;
382 }
383
384
385 BOOL AfsClass_RestartService (LPIDENT lpiRestart, ULONG *pStatus)
386 {
387    BOOL rc = TRUE;
388    ULONG status;
389
390    AfsClass_Enter();
391    NOTIFYCALLBACK::SendNotificationToAll (evtRestartServiceBegin, lpiRestart);
392
393    PVOID hCell = NULL;
394    PVOID hBOS = NULL;
395    LPSERVER lpServer;
396    if ((lpServer = lpiRestart->OpenServer (&status)) == NULL)
397       rc = FALSE;
398    else
399       {
400       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
401          rc = FALSE;
402       lpServer->Close();
403       }
404
405    BOOL fRestartAll = FALSE;
406    if (!lpiRestart->fIsService())
407       fRestartAll = TRUE;
408
409    TCHAR szServiceRestart[ cchNAME ];
410    if (lpiRestart->fIsService())
411       {
412       lpiRestart->GetServiceName (szServiceRestart);
413       if (!lstrcmpi (szServiceRestart, TEXT("BOS")))
414          fRestartAll = TRUE;
415       }
416
417    if (rc)
418       {
419       if (!fRestartAll)
420          {
421          WORKERPACKET wp;
422          wp.wpBosProcessRestart.hServer = hBOS;
423          wp.wpBosProcessRestart.pszService = szServiceRestart;
424
425          AfsClass_Leave();
426          rc = Worker_DoTask (wtaskBosProcessRestart, &wp, &status);
427          AfsClass_Enter();
428          }
429       else // (fRestartAll)
430          {
431          WORKERPACKET wp;
432          wp.wpBosProcessAllStopAndRestart.hServer = hBOS;
433          wp.wpBosProcessAllStopAndRestart.fRestartBOS = TRUE;
434
435          AfsClass_Leave();
436          rc = Worker_DoTask (wtaskBosProcessAllStopAndRestart, &wp, &status);
437          AfsClass_Enter();
438          }
439       }
440
441    if (rc)
442       {
443       if (!fRestartAll)
444          {
445          LPSERVICE lpService;
446          if ((lpService = lpiRestart->OpenService (&status)) == NULL)
447             rc = FALSE;
448          else
449             {
450             lpService->Invalidate();
451             lpService->RefreshStatus();
452             lpService->Close();
453             }
454          }
455       else // (fRestartAll)
456          {
457          LPSERVER lpServer;
458          if ((lpServer = lpiRestart->OpenServer (&status)) == NULL)
459             rc = FALSE;
460          else
461             {
462             lpServer->Invalidate();
463             lpServer->RefreshAll();
464             lpServer->Close();
465             }
466          }
467       }
468
469    if ((lpServer = lpiRestart->OpenServer (&status)) != NULL)
470       {
471       lpServer->CloseBosObject();
472       lpServer->Close();
473       }
474
475    NOTIFYCALLBACK::SendNotificationToAll (evtRestartServiceEnd, lpiRestart, status);
476    AfsClass_Leave();
477
478    if (pStatus && !rc)
479       *pStatus = status;
480    return rc;
481 }
482
483
484 LPIDENT AfsClass_CreateFileset (LPIDENT lpiAggregate, LPTSTR pszFileset, ULONG ckQuota, ULONG *pStatus)
485 {
486    LPIDENT lpiFileset = NULL;
487    ULONG status;
488    BOOL rc = TRUE;
489
490    AfsClass_Enter();
491    NOTIFYCALLBACK::SendNotificationToAll (evtCreateFilesetBegin, lpiAggregate, pszFileset, 0);
492
493    // Obtain hCell and hVOS
494    //
495    PVOID hCell = NULL;
496    PVOID hVOS = NULL;
497    LPSERVER lpServer = NULL;
498    if ((lpServer = lpiAggregate->OpenServer (&status)) == NULL)
499       rc = FALSE;
500    else
501       {
502       if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
503          rc = FALSE;
504       lpServer->Close();
505       }
506
507    // Obtain idPartition
508    //
509    int idPartition;
510    LPAGGREGATE lpAggregate;
511    if ((lpAggregate = lpiAggregate->OpenAggregate (&status)) == NULL)
512       rc = FALSE;
513    else
514       {
515       idPartition = lpAggregate->GetID();
516       lpAggregate->Close();
517       }
518
519    // Perform the actual operation
520    //
521    if (rc)
522       {
523       WORKERPACKET wp;
524       wp.wpVosVolumeCreate.hCell = hCell;
525       wp.wpVosVolumeCreate.hServer = hVOS;
526       wp.wpVosVolumeCreate.idPartition = idPartition;
527       wp.wpVosVolumeCreate.pszVolume = pszFileset;
528       wp.wpVosVolumeCreate.ckQuota = ckQuota;
529
530       AfsClass_Leave();
531       rc = Worker_DoTask (wtaskVosVolumeCreate, &wp, &status);
532       AfsClass_Enter();
533       }
534
535    // Clean up
536    //
537    if (rc)
538       {
539       LPAGGREGATE lpAggregate;
540       if ((lpAggregate = lpiAggregate->OpenAggregate (&status)) == NULL)
541          rc = FALSE;
542       else
543          {
544          lpAggregate->Invalidate();
545          lpAggregate->RefreshFilesets (TRUE, &status);
546          lpAggregate->Close();
547          }
548       }
549
550    if (rc)
551       {
552       LPCELL lpCell;
553       if ((lpCell = lpiAggregate->OpenCell()) == NULL)
554          rc = FALSE;
555       else
556          {
557          lpCell->RefreshVLDB (lpiAggregate);
558          lpCell->Close();
559          }
560       }
561
562    if (rc)
563       {
564       LPAGGREGATE lpAggregate;
565       if ((lpAggregate = lpiAggregate->OpenAggregate (&status)) == NULL)
566          rc = FALSE;
567       else
568          {
569          LPFILESET lpFileset;
570          if ((lpFileset = lpAggregate->OpenFileset (pszFileset, &status)) == NULL)
571             rc = FALSE;
572          else
573             {
574             lpiFileset = lpFileset->GetIdentifier();
575             lpFileset->Close();
576             }
577          lpAggregate->Close();
578          }
579       }
580
581    if (hVOS)
582       {
583       if ((lpServer = lpiAggregate->OpenServer (&status)) != NULL)
584          {
585          lpServer->CloseVosObject();
586          lpServer->Close();
587          }
588       }
589
590    NOTIFYCALLBACK::SendNotificationToAll (evtCreateFilesetEnd, lpiAggregate, pszFileset, status);
591    AfsClass_Leave();
592
593    if (pStatus && !rc)
594       *pStatus = status;
595    return (rc) ? lpiFileset : NULL;
596 }
597
598
599 BOOL AfsClass_DeleteFileset (LPIDENT lpiFileset, BOOL fVLDB, BOOL fServer, ULONG *pStatus)
600 {
601    BOOL rc = TRUE;
602    ULONG status;
603
604    AfsClass_Enter();
605    NOTIFYCALLBACK::SendNotificationToAll (evtDeleteFilesetBegin, lpiFileset);
606
607    // Obtain hCell and hVOS
608    //
609    PVOID hCell = NULL;
610    PVOID hVOS = NULL;
611    LPSERVER lpServer = NULL;
612    if ((lpServer = lpiFileset->OpenServer (&status)) == NULL)
613       rc = FALSE;
614    else
615       {
616       if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
617          rc = FALSE;
618       lpServer->Close();
619       }
620
621    // Does the fileset have a VLDB entry? Does it actually exist on the server?
622    // What's its volume ID?  Its R/W ID?  Its partition ID?
623    //
624    VOLUMEID vidFileset;
625    VOLUMEID vidReadWrite;
626    int wFilesetGhost;
627
628    // Obtain the ID of the fileset's parent aggregate.
629    //
630    int idPartition;
631    LPAGGREGATE lpAggregate;
632    if ((lpAggregate = lpiFileset->OpenAggregate (&status)) == NULL)
633       rc = FALSE;
634    else
635       {
636       if ((idPartition = lpAggregate->GetID()) == NO_PARTITION)
637          rc = FALSE;
638       lpAggregate->Close();
639       }
640
641    if (rc)
642       {
643       LPFILESET lpFileset;
644       if ((lpFileset = lpiFileset->OpenFileset (&status)) == NULL)
645          rc = FALSE;
646       else
647          {
648          wFilesetGhost = lpFileset->GetGhostStatus();
649          lpiFileset->GetFilesetID (&vidFileset);
650
651          FILESETSTATUS fs;
652          if (!lpFileset->GetStatus (&fs))
653             vidReadWrite = vidFileset;
654          else
655             vidReadWrite = fs.idReadWrite;
656
657          lpFileset->Close();
658          }
659       }
660
661    if (!(wFilesetGhost & GHOST_HAS_VLDB_ENTRY))
662       fVLDB = FALSE;
663    if (!(wFilesetGhost & GHOST_HAS_SERVER_ENTRY))
664       fServer = FALSE;
665
666    if (rc && fVLDB && fServer)
667       {
668       WORKERPACKET wp;
669       wp.wpVosVolumeDelete.hCell = hCell;
670       wp.wpVosVolumeDelete.hServer = hVOS;
671       wp.wpVosVolumeDelete.idPartition = idPartition;
672       wp.wpVosVolumeDelete.idVolume = vidFileset;
673
674       AfsClass_Leave();
675       rc = Worker_DoTask (wtaskVosVolumeDelete, &wp, &status);
676       AfsClass_Enter();
677       }
678    else if (rc && fVLDB)
679       {
680       WORKERPACKET wp;
681       wp.wpVosVLDBEntryRemove.hCell = hCell;
682       wp.wpVosVLDBEntryRemove.hServer = hVOS;
683       wp.wpVosVLDBEntryRemove.idPartition = idPartition;
684       wp.wpVosVLDBEntryRemove.idVolume = vidReadWrite;
685
686       AfsClass_Leave();
687       rc = Worker_DoTask (wtaskVosVLDBEntryRemove, &wp, &status);
688       AfsClass_Enter();
689       }
690    else if (rc && fServer)
691       {
692       WORKERPACKET wp;
693       wp.wpVosVolumeZap.hCell = hCell;
694       wp.wpVosVolumeZap.hServer = hVOS;
695       wp.wpVosVolumeZap.idPartition = idPartition;
696       wp.wpVosVolumeZap.idVolume = vidFileset;
697       wp.wpVosVolumeZap.fForce = TRUE;
698
699       AfsClass_Leave();
700       rc = Worker_DoTask (wtaskVosVolumeZap, &wp, &status);
701       AfsClass_Enter();
702       }
703
704    if (rc)
705       {
706       LPAGGREGATE lpAggregate;
707       if ((lpAggregate = lpiFileset->OpenAggregate (&status)) == NULL)
708          rc = FALSE;
709       else
710          {
711          lpAggregate->Invalidate();
712          lpAggregate->RefreshFilesets (TRUE);
713          lpAggregate->Close();
714          }
715       }
716
717    if (rc)
718       {
719       LPCELL lpCell;
720       if ((lpCell = lpiFileset->OpenCell (&status)) == NULL)
721          rc = FALSE;
722       else
723          {
724          lpCell->RefreshVLDB (lpiFileset->GetAggregate(), TRUE);
725          lpCell->Close();
726          }
727       }
728
729    if (hVOS)
730       {
731       if ((lpServer = lpiFileset->OpenServer()) != NULL)
732          {
733          lpServer->CloseVosObject();
734          lpServer->Close();
735          }
736       }
737
738    NOTIFYCALLBACK::SendNotificationToAll (evtDeleteFilesetEnd, lpiFileset, status);
739    AfsClass_Leave();
740
741    if (pStatus && !rc)
742       *pStatus = status;
743    return rc;
744 }
745
746
747 BOOL AfsClass_MoveFileset (LPIDENT lpiFileset, LPIDENT lpiAggregateTarget, ULONG *pStatus)
748 {
749    BOOL rc = TRUE;
750    ULONG status;
751
752    AfsClass_Enter();
753    NOTIFYCALLBACK::SendNotificationToAll (evtMoveFilesetBegin, lpiFileset, lpiAggregateTarget, NULL, NULL, 0, 0);
754
755    LPIDENT lpiAggregateSource = lpiFileset->GetAggregate();
756
757    // Obtain hCell, hVOS and the aggregate name for the source
758    //
759    PVOID hCell;
760    PVOID hVOSSource = NULL;
761    LPSERVER lpServer;
762    if ((lpServer = lpiFileset->OpenServer (&status)) == NULL)
763       rc = FALSE;
764    else
765       {
766       if ((hVOSSource = lpServer->OpenVosObject (&hCell, &status)) == NULL)
767          rc = FALSE;
768       lpServer->Close();
769       }
770
771    // Obtain the ID of the source aggregate
772    //
773    int idPartitionSource;
774    LPAGGREGATE lpAggregate;
775    if ((lpAggregate = lpiFileset->OpenAggregate (&status)) == NULL)
776       rc = FALSE;
777    else
778       {
779       if ((idPartitionSource = lpAggregate->GetID()) == NO_PARTITION)
780          rc = FALSE;
781       lpAggregate->Close();
782       }
783
784    // Obtain hCell, hVOS and the aggregate name for the target
785    //
786    PVOID hVOSTarget = NULL;
787    if ((lpServer = lpiAggregateTarget->OpenServer (&status)) == NULL)
788       rc = FALSE;
789    else
790       {
791       if ((hVOSTarget = lpServer->OpenVosObject (NULL, &status)) == NULL)
792          rc = FALSE;
793       lpServer->Close();
794       }
795
796    // Obtain the ID of the target aggregate
797    //
798    int idPartitionTarget;
799    if ((lpAggregate = lpiAggregateTarget->OpenAggregate (&status)) == NULL)
800       rc = FALSE;
801    else
802       {
803       if ((idPartitionTarget = lpAggregate->GetID()) == NO_PARTITION)
804          rc = FALSE;
805       lpAggregate->Close();
806       }
807
808    if (rc)
809       {
810       WORKERPACKET wp;
811       wp.wpVosVolumeMove.hCell = hCell;
812       wp.wpVosVolumeMove.hServerFrom = hVOSSource;
813       wp.wpVosVolumeMove.idPartitionFrom = idPartitionSource;
814       wp.wpVosVolumeMove.hServerTo = hVOSTarget;
815       wp.wpVosVolumeMove.idPartitionTo = idPartitionTarget;
816       lpiFileset->GetFilesetID (&wp.wpVosVolumeMove.idVolume);
817
818       AfsClass_Leave();
819       rc = Worker_DoTask (wtaskVosVolumeMove, &wp, &status);
820       AfsClass_Enter();
821       }
822
823    if (rc)
824       {
825       LPAGGREGATE lpAggregate;
826       if ((lpAggregate = lpiAggregateSource->OpenAggregate (&status)) == NULL)
827          rc = FALSE;
828       else
829          {
830          lpAggregate->Invalidate();
831          lpAggregate->RefreshFilesets();
832          lpAggregate->Close();
833          }
834       }
835
836    if (rc)
837       {
838       LPAGGREGATE lpAggregate;
839       if ((lpAggregate = lpiAggregateTarget->OpenAggregate (&status)) == NULL)
840          rc = FALSE;
841       else
842          {
843          lpAggregate->Invalidate();
844          lpAggregate->RefreshFilesets();
845          lpAggregate->Close();
846          }
847       }
848
849    if (rc)
850       {
851       LPFILESET lpFileset;
852       if ((lpFileset = lpiFileset->OpenFileset (&status)) == NULL)
853          rc = FALSE;
854       else
855          {
856          lpFileset->Invalidate();
857          lpFileset->RefreshStatus();
858          lpFileset->Close();
859          }
860       }
861
862    if (rc)
863       {
864       LPCELL lpCell;
865       if ((lpCell = lpiFileset->OpenCell (&status)) == NULL)
866          rc = FALSE;
867       else
868          {
869          lpCell->RefreshVLDB (lpiAggregateSource, TRUE);
870          lpCell->RefreshVLDB (lpiAggregateTarget, TRUE);
871          lpCell->Close();
872          }
873       }
874
875    if (hVOSSource)
876       {
877       if ((lpServer = lpiAggregateSource->OpenServer()) != NULL)
878          {
879          lpServer->CloseVosObject();
880          lpServer->Close();
881          }
882       }
883    if (hVOSTarget)
884       {
885       if ((lpServer = lpiAggregateTarget->OpenServer()) != NULL)
886          {
887          lpServer->CloseVosObject();
888          lpServer->Close();
889          }
890       }
891
892    NOTIFYCALLBACK::SendNotificationToAll (evtMoveFilesetEnd, lpiFileset, lpiAggregateTarget, NULL, NULL, 0, status);
893    AfsClass_Leave();
894
895    if (pStatus && !rc)
896       *pStatus = status;
897    return rc;
898 }
899
900
901 BOOL AfsClass_SetFilesetQuota (LPIDENT lpiFileset, size_t ckQuotaNew, ULONG *pStatus)
902 {
903    BOOL rc = TRUE;
904    ULONG status;
905
906    AfsClass_Enter();
907    NOTIFYCALLBACK::SendNotificationToAll (evtSetFilesetQuotaBegin, lpiFileset);
908
909    // Obtain hCell and hVOS for the server where this fileset lives
910    //
911    PVOID hCell;
912    PVOID hVOS = NULL;
913    LPSERVER lpServer;
914    if ((lpServer = lpiFileset->OpenServer (&status)) == NULL)
915       rc = FALSE;
916    else
917       {
918       if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
919          rc = FALSE;
920       lpServer->Close();
921       }
922
923    // Obtain the ID of the fileset's parent aggregate.
924    //
925    int idPartition;
926    if (rc)
927       {
928       LPAGGREGATE lpAggregate;
929       if ((lpAggregate = lpiFileset->OpenAggregate (&status)) == NULL)
930          rc = FALSE;
931       else
932          {
933          if ((idPartition = lpAggregate->GetID()) == NO_PARTITION)
934             rc = FALSE;
935          lpAggregate->Close();
936          }
937       }
938
939    // Change the fileset's quota.
940    //
941    if (rc)
942       {
943       WORKERPACKET wp;
944       wp.wpVosVolumeQuotaChange.hCell = hCell;
945       wp.wpVosVolumeQuotaChange.hServer = hVOS;
946       wp.wpVosVolumeQuotaChange.idPartition = idPartition;
947       lpiFileset->GetFilesetID (&wp.wpVosVolumeQuotaChange.idVolume);
948       wp.wpVosVolumeQuotaChange.ckQuota = ckQuotaNew;
949
950       AfsClass_Leave();
951       rc = Worker_DoTask (wtaskVosVolumeQuotaChange, &wp, &status);
952       AfsClass_Enter();
953       }
954
955    if (rc)
956       {
957       LPFILESET lpFileset;
958       if ((lpFileset = lpiFileset->OpenFileset (&status)) == NULL)
959          rc = FALSE;
960       else
961          {
962          lpFileset->Invalidate();
963          lpFileset->RefreshStatus();
964          lpFileset->Close();
965          }
966       }
967
968    if (rc)
969       {
970       LPAGGREGATE lpAggregate;
971       if ((lpAggregate = lpiFileset->OpenAggregate (&status)) == NULL)
972          rc = FALSE;
973       else
974          {
975          lpAggregate->RefreshStatus();
976          lpAggregate->Close();
977          }
978       }
979
980    if (hVOS != NULL)
981       {
982       if ((lpServer = lpiFileset->OpenServer()) != NULL)
983          {
984          lpServer->CloseVosObject();
985          lpServer->Close();
986          }
987       }
988
989    NOTIFYCALLBACK::SendNotificationToAll (evtSetFilesetQuotaEnd, lpiFileset, status);
990    AfsClass_Leave();
991
992    if (pStatus && !rc)
993       *pStatus = status;
994    return rc;
995 }
996
997
998 BOOL AfsClass_SyncVLDB (LPIDENT lpiSync, BOOL fForce, ULONG *pStatus)
999 {
1000    BOOL rc = TRUE;
1001    ULONG status;
1002
1003    AfsClass_Enter();
1004    NOTIFYCALLBACK::SendNotificationToAll (evtSyncVLDBBegin, lpiSync);
1005
1006    // Obtain hCell and hVOS
1007    //
1008    PVOID hCell;
1009    PVOID hVOS = NULL;
1010    LPSERVER lpServer;
1011    if ((lpServer = lpiSync->OpenServer (&status)) == NULL)
1012       rc = FALSE;
1013    else
1014       {
1015       if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
1016          rc = FALSE;
1017       lpServer->Close();
1018       }
1019
1020    // Obtain the ID of the target aggregate.
1021    //
1022    int idPartition = NO_PARTITION;
1023    if (rc && (lpiSync->fIsAggregate() || lpiSync->fIsFileset()))
1024       {
1025       LPAGGREGATE lpAggregate;
1026       if ((lpAggregate = lpiSync->OpenAggregate (&status)) == NULL)
1027          rc = FALSE;
1028       else
1029          {
1030          if ((idPartition = lpAggregate->GetID()) == NO_PARTITION)
1031             rc = FALSE;
1032          lpAggregate->Close();
1033          }
1034       }
1035
1036    if (rc)
1037       {
1038       WORKERPACKET wp;
1039       wp.wpVosVLDBSync.hCell = hCell;
1040       wp.wpVosVLDBSync.hServer = hVOS;
1041       wp.wpVosVLDBSync.idPartition = idPartition;
1042       wp.wpVosVLDBSync.fForce = fForce;
1043
1044       AfsClass_Leave();
1045       rc = Worker_DoTask (wtaskVosVLDBSync, &wp, &status);
1046       AfsClass_Enter();
1047       }
1048
1049    if (rc)
1050       {
1051       if (lpiSync->fIsServer())
1052          {
1053          LPSERVER lpServer;
1054          if ((lpServer = lpiSync->OpenServer (&status)) == NULL)
1055             rc = FALSE;
1056          else
1057             {
1058             lpServer->Invalidate();
1059             rc = lpServer->RefreshAll (&status);
1060             lpServer->Close();
1061             }
1062          }
1063       else // (lpiSync->fIsAggregate())
1064          {
1065          LPAGGREGATE lpAggregate;
1066          if ((lpAggregate = lpiSync->OpenAggregate (&status)) == NULL)
1067             rc = FALSE;
1068          else
1069             {
1070             lpAggregate->Invalidate();
1071             lpAggregate->RefreshStatus();
1072             lpAggregate->RefreshFilesets();
1073             lpAggregate->Close();
1074
1075             LPCELL lpCell;
1076             if ((lpCell = lpiSync->OpenCell()) == NULL)
1077                rc = FALSE;
1078             else
1079                {
1080                lpCell->RefreshVLDB (lpiSync);
1081                lpCell->Close();
1082                }
1083             }
1084          }
1085       }
1086
1087    if (hVOS)
1088       {
1089       if ((lpServer = lpiSync->OpenServer()) != NULL)
1090          {
1091          lpServer->CloseVosObject();
1092          lpServer->Close();
1093          }
1094       }
1095
1096    NOTIFYCALLBACK::SendNotificationToAll (evtSyncVLDBEnd, lpiSync, status);
1097    AfsClass_Leave();
1098
1099    if (pStatus && !rc)
1100       *pStatus = status;
1101    return rc;
1102 }
1103
1104
1105 BOOL AfsClass_ChangeAddress (LPIDENT lpiServer, LPSOCKADDR_IN pAddrOld, LPSOCKADDR_IN pAddrNew, ULONG *pStatus)
1106 {
1107    BOOL rc = TRUE;
1108    ULONG status;
1109
1110    AfsClass_Enter();
1111    NOTIFYCALLBACK::SendNotificationToAll (evtChangeAddressBegin, lpiServer);
1112
1113    // Obtain hCell
1114    //
1115    PVOID hCell;
1116    LPCELL lpCell;
1117    if ((lpCell = lpiServer->OpenCell (&status)) == NULL)
1118       rc = FALSE;
1119    else
1120       {
1121       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
1122          rc = FALSE;
1123       lpCell->Close();
1124       }
1125
1126    if (rc && pAddrNew)
1127       {
1128       WORKERPACKET wp;
1129       wp.wpVosFileServerAddressChange.hCell = hCell;
1130       wp.wpVosFileServerAddressChange.addrOld = *pAddrOld;
1131       wp.wpVosFileServerAddressChange.addrNew = *pAddrNew;
1132
1133       AfsClass_Leave();
1134       rc = Worker_DoTask (wtaskVosFileServerAddressChange, &wp, &status);
1135       AfsClass_Enter();
1136       }
1137    else if (rc && !pAddrNew)
1138       {
1139       WORKERPACKET wp;
1140       wp.wpVosFileServerAddressRemove.hCell = hCell;
1141       wp.wpVosFileServerAddressRemove.addr = *pAddrOld;
1142
1143       AfsClass_Leave();
1144       rc = Worker_DoTask (wtaskVosFileServerAddressRemove, &wp, &status);
1145       AfsClass_Enter();
1146       }
1147
1148    if (rc)
1149       {
1150       LPSERVER lpServer;
1151       if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
1152          {
1153          lpServer->InvalidateStatus();
1154          lpServer->Close();
1155          }
1156
1157       if ((lpCell = lpiServer->OpenCell (&status)) == NULL)
1158          rc = FALSE;
1159       else
1160          {
1161          lpCell->InvalidateServers ();
1162          rc = lpCell->RefreshServers (TRUE, &status);
1163          lpCell->Close();
1164          }
1165       }
1166
1167    NOTIFYCALLBACK::SendNotificationToAll (evtChangeAddressEnd, lpiServer, status);
1168    AfsClass_Leave();
1169
1170    if (pStatus && !rc)
1171       *pStatus = status;
1172    return rc;
1173 }
1174
1175
1176 BOOL AfsClass_ChangeAddress (LPIDENT lpiServer, LPSERVERSTATUS pStatusOld, LPSERVERSTATUS pStatusNew, ULONG *pStatus)
1177 {
1178    BOOL rc = TRUE;
1179    ULONG status;
1180
1181    AfsClass_Enter();
1182    NOTIFYCALLBACK::SendNotificationToAll (evtChangeAddressBegin, lpiServer);
1183
1184    // Obtain hCell
1185    //
1186    PVOID hCell;
1187    LPCELL lpCell;
1188    if ((lpCell = lpiServer->OpenCell (&status)) == NULL)
1189       rc = FALSE;
1190    else
1191       {
1192       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
1193          rc = FALSE;
1194       lpCell->Close();
1195       }
1196
1197    if (rc)
1198       {
1199       AfsClass_Leave();
1200
1201       for (size_t iAddr = 0; rc && (iAddr < AFSCLASS_MAX_ADDRESSES_PER_SITE); ++iAddr)
1202          {
1203          int oldAddress;
1204          int newAddress;
1205          AfsClass_AddressToInt (&oldAddress, &pStatusOld->aAddresses[ iAddr ]);
1206          AfsClass_AddressToInt (&newAddress, &pStatusNew->aAddresses[ iAddr ]);
1207
1208          if (oldAddress && newAddress && (oldAddress != newAddress))
1209             {
1210             WORKERPACKET wp;
1211             wp.wpVosFileServerAddressChange.hCell = hCell;
1212             wp.wpVosFileServerAddressChange.addrOld = pStatusOld->aAddresses[ iAddr ];
1213             wp.wpVosFileServerAddressChange.addrNew = pStatusNew->aAddresses[ iAddr ];
1214
1215             rc = Worker_DoTask (wtaskVosFileServerAddressChange, &wp, &status);
1216             }
1217          else if (oldAddress && !newAddress)
1218             {
1219             WORKERPACKET wp;
1220             wp.wpVosFileServerAddressRemove.hCell = hCell;
1221             wp.wpVosFileServerAddressRemove.addr = pStatusOld->aAddresses[ iAddr ];
1222
1223             rc = Worker_DoTask (wtaskVosFileServerAddressRemove, &wp, &status);
1224             }
1225          }
1226
1227       AfsClass_Enter();
1228       }
1229
1230    if (rc)
1231       {
1232       LPSERVER lpServer;
1233       if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
1234          {
1235          lpServer->InvalidateStatus();
1236          lpServer->Close();
1237          }
1238
1239       LPCELL lpCell;
1240       if ((lpCell = lpiServer->OpenCell (&status)) == NULL)
1241          rc = FALSE;
1242       else
1243          {
1244          lpCell->InvalidateServers ();
1245          rc = lpCell->RefreshServers (TRUE, &status);
1246          lpCell->Close();
1247          }
1248       }
1249
1250    NOTIFYCALLBACK::SendNotificationToAll (evtChangeAddressEnd, lpiServer, status);
1251    AfsClass_Leave();
1252
1253    if (pStatus && !rc)
1254       *pStatus = status;
1255    return rc;
1256 }
1257
1258
1259 BOOL AfsClass_LockFileset (LPIDENT lpiFileset, ULONG *pStatus)
1260 {
1261    BOOL rc = TRUE;
1262    ULONG status;
1263
1264    AfsClass_Enter();
1265    NOTIFYCALLBACK::SendNotificationToAll (evtLockFilesetBegin, lpiFileset);
1266
1267    // Obtain hCell
1268    //
1269    PVOID hCell;
1270    LPCELL lpCell;
1271    if ((lpCell = lpiFileset->OpenCell (&status)) == NULL)
1272       rc = FALSE;
1273    else
1274       {
1275       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
1276          rc = FALSE;
1277       lpCell->Close();
1278       }
1279
1280    // Obtain the fileset's read-write identifier
1281    //
1282    LPIDENT lpiRW = NULL;
1283    LPFILESET lpFileset;
1284    if ((lpFileset = lpiFileset->OpenFileset (&status)) == NULL)
1285       rc = FALSE;
1286    else
1287       {
1288       if ((lpiRW = lpFileset->GetReadWriteIdentifier()) == NULL)
1289          rc = FALSE;
1290       lpFileset->Close();
1291       }
1292
1293    // Perform the lock operation
1294    //
1295    if (rc)
1296       {
1297       WORKERPACKET wp;
1298       wp.wpVosVLDBEntryLock.hCell = hCell;
1299       lpiRW->GetFilesetID (&wp.wpVosVLDBEntryLock.idVolume);
1300
1301       AfsClass_Leave();
1302       rc = Worker_DoTask (wtaskVosVLDBEntryLock, &wp, &status);
1303       AfsClass_Enter();
1304       }
1305
1306    if (rc)
1307       {
1308       LPCELL lpCell;
1309       if ((lpCell = lpiFileset->OpenCell (&status)) == NULL)
1310          rc = FALSE;
1311       else
1312          {
1313          if (lpiRW)
1314             lpCell->RefreshVLDB (lpiRW, TRUE, NULL, TRUE);
1315          else
1316             lpCell->RefreshVLDB (lpiFileset->GetCell());
1317          lpCell->Close();
1318          }
1319       }
1320
1321    NOTIFYCALLBACK::SendNotificationToAll (evtLockFilesetEnd, lpiFileset, status);
1322    AfsClass_Leave();
1323
1324    if (pStatus && !rc)
1325       *pStatus = status;
1326    return rc;
1327 }
1328
1329
1330 BOOL AfsClass_UnlockFileset (LPIDENT lpiFileset, ULONG *pStatus)
1331 {
1332    BOOL rc = TRUE;
1333    ULONG status;
1334
1335    AfsClass_Enter();
1336    NOTIFYCALLBACK::SendNotificationToAll (evtUnlockFilesetBegin, lpiFileset);
1337
1338    // Obtain hCell
1339    //
1340    PVOID hCell;
1341    LPCELL lpCell;
1342    if ((lpCell = lpiFileset->OpenCell (&status)) == NULL)
1343       rc = FALSE;
1344    else
1345       {
1346       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
1347          rc = FALSE;
1348       lpCell->Close();
1349       }
1350
1351    // Obtain the fileset's read-write identifier
1352    //
1353    LPIDENT lpiRW = NULL;
1354    LPFILESET lpFileset;
1355    if ((lpFileset = lpiFileset->OpenFileset (&status)) == NULL)
1356       rc = FALSE;
1357    else
1358       {
1359       if ((lpiRW = lpFileset->GetReadWriteIdentifier()) == NULL)
1360          rc = FALSE;
1361       lpFileset->Close();
1362       }
1363
1364    // Perform the unlock operation
1365    //
1366    if (rc)
1367       {
1368       WORKERPACKET wp;
1369       wp.wpVosVLDBEntryUnlock.hCell = hCell;
1370       wp.wpVosVLDBEntryUnlock.hServer = NULL;
1371       wp.wpVosVLDBEntryUnlock.idPartition = NO_PARTITION;
1372       lpiRW->GetFilesetID (&wp.wpVosVLDBEntryUnlock.idVolume);
1373
1374       AfsClass_Leave();
1375       rc = Worker_DoTask (wtaskVosVLDBEntryUnlock, &wp, &status);
1376       AfsClass_Enter();
1377       }
1378
1379    if (rc)
1380       {
1381       LPCELL lpCell;
1382       if ((lpCell = lpiFileset->OpenCell (&status)) == NULL)
1383          rc = FALSE;
1384       else
1385          {
1386          if (lpiRW)
1387             lpCell->RefreshVLDB (lpiRW, TRUE, NULL, TRUE);
1388          else
1389             lpCell->RefreshVLDB (lpiFileset->GetCell());
1390          lpCell->Close();
1391          }
1392       }
1393
1394    NOTIFYCALLBACK::SendNotificationToAll (evtUnlockFilesetEnd, lpiFileset, status);
1395    AfsClass_Leave();
1396
1397    if (pStatus && !rc)
1398       *pStatus = status;
1399    return rc;
1400 }
1401
1402
1403 BOOL AfsClass_UnlockAllFilesets (LPIDENT lpi, ULONG *pStatus)
1404 {
1405    BOOL rc = TRUE;
1406    ULONG status;
1407
1408    AfsClass_Enter();
1409    NOTIFYCALLBACK::SendNotificationToAll (evtUnlockAllFilesetsBegin, lpi);
1410
1411    // Obtain hCell
1412    //
1413    PVOID hCell;
1414    LPCELL lpCell;
1415    if ((lpCell = lpi->OpenCell (&status)) == NULL)
1416       rc = FALSE;
1417    else
1418       {
1419       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
1420          rc = FALSE;
1421       lpCell->Close();
1422       }
1423
1424    // Obtain hServer if appropriate
1425    //
1426    PVOID hVOS = NULL;
1427    if (lpi && (!lpi->fIsCell()))
1428       {
1429       LPSERVER lpServer;
1430       if ((lpServer = lpi->OpenServer (&status)) == NULL)
1431          rc = FALSE;
1432       else
1433          {
1434          if ((hVOS = lpServer->OpenVosObject (NULL, &status)) == NULL)
1435             rc = FALSE;
1436          lpServer->Close();
1437          }
1438       }
1439
1440    // Obtain the ID of the scope aggregate.
1441    //
1442    int idPartition = NO_PARTITION;
1443    if (rc && (lpi->fIsFileset() || (lpi->fIsAggregate())))
1444       {
1445       LPAGGREGATE lpAggregate;
1446       if ((lpAggregate = lpi->OpenAggregate (&status)) == NULL)
1447          rc = FALSE;
1448       else
1449          {
1450          if ((idPartition = lpAggregate->GetID()) == NO_PARTITION)
1451             rc = FALSE;
1452          lpAggregate->Close();
1453          }
1454       }
1455
1456    // Perform the unlock operation
1457    //
1458    if (rc)
1459       {
1460       WORKERPACKET wp;
1461       wp.wpVosVLDBEntryUnlock.hCell = hCell;
1462       wp.wpVosVLDBEntryUnlock.hServer = hVOS;
1463       wp.wpVosVLDBEntryUnlock.idPartition = idPartition;
1464       wp.wpVosVLDBEntryUnlock.idVolume = NO_VOLUME;
1465
1466       AfsClass_Leave();
1467       rc = Worker_DoTask (wtaskVosVLDBEntryUnlock, &wp, &status);
1468       AfsClass_Enter();
1469       }
1470
1471    if (rc)
1472       {
1473       LPCELL lpCell;
1474       if ((lpCell = lpi->OpenCell (&status)) == NULL)
1475          rc = FALSE;
1476       else
1477          {
1478          lpCell->RefreshVLDB (lpi);
1479          lpCell->Close();
1480          }
1481       }
1482
1483    if (hVOS)
1484       {
1485       LPSERVER lpServer;
1486       if ((lpServer = lpi->OpenServer (&status)) != NULL)
1487          {
1488          lpServer->CloseVosObject();
1489          lpServer->Close();
1490          }
1491       }
1492
1493    NOTIFYCALLBACK::SendNotificationToAll (evtUnlockAllFilesetsEnd, lpi);
1494    AfsClass_Leave();
1495
1496    if (pStatus && !rc)
1497       *pStatus = status;
1498    return rc;
1499 }
1500
1501
1502 LPIDENT AfsClass_CreateReplica (LPIDENT lpiFileset, LPIDENT lpiAggregate, ULONG *pStatus)
1503 {
1504    BOOL rc = TRUE;
1505    ULONG status;
1506    LPIDENT lpiReplica = NULL;
1507
1508    AfsClass_Enter();
1509    NOTIFYCALLBACK::SendNotificationToAll (evtCreateReplicaBegin, lpiFileset, lpiAggregate, NULL, NULL, 0, 0);
1510
1511    // Obtain hCell and hVOS for the target server
1512    //
1513    PVOID hCell;
1514    PVOID hVOS = NULL;
1515    LPSERVER lpServer;
1516    if ((lpServer = lpiAggregate->OpenServer (&status)) == NULL)
1517       rc = FALSE;
1518    else
1519       {
1520       if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
1521          rc = FALSE;
1522       lpServer->Close();
1523       }
1524
1525    // Obtain idPartition
1526    //
1527    int idPartition;
1528    LPAGGREGATE lpAggregate;
1529    if ((lpAggregate = lpiAggregate->OpenAggregate (&status)) == NULL)
1530       rc = FALSE;
1531    else
1532       {
1533       idPartition = lpAggregate->GetID();
1534       lpAggregate->Close();
1535       }
1536
1537    // Modify VLDB to create mention of a new replica
1538    //
1539    if (rc)
1540       {
1541       WORKERPACKET wp;
1542       wp.wpVosVLDBReadOnlySiteCreate.hCell = hCell;
1543       wp.wpVosVLDBReadOnlySiteCreate.hServer = hVOS;
1544       wp.wpVosVLDBReadOnlySiteCreate.idPartition = idPartition;
1545       lpiFileset->GetFilesetID (&wp.wpVosVLDBReadOnlySiteCreate.idVolume);
1546
1547       AfsClass_Leave();
1548       rc = Worker_DoTask (wtaskVosVLDBReadOnlySiteCreate, &wp, &status);
1549       AfsClass_Enter();
1550       }
1551
1552    // Clean up
1553    //
1554    if (rc)
1555       {
1556       LPAGGREGATE lpAggregate;
1557       if ((lpAggregate = lpiAggregate->OpenAggregate (&status)) == NULL)
1558          rc = FALSE;
1559       else
1560          {
1561          lpAggregate->Invalidate();
1562          lpAggregate->RefreshFilesets (TRUE, &status);
1563          lpAggregate->Close();
1564          }
1565       }
1566
1567    if (rc)
1568       {
1569       LPCELL lpCell;
1570       if ((lpCell = lpiAggregate->OpenCell()) == NULL)
1571          rc = FALSE;
1572       else
1573          {
1574          lpCell->RefreshVLDB (lpiAggregate);
1575          lpCell->Close();
1576          }
1577       }
1578
1579    if (rc)
1580       {
1581       LPFILESET lpFileset;
1582       if ((lpFileset = lpiFileset->OpenFileset (&status)) == NULL)
1583          rc = FALSE;
1584       else
1585          {
1586          if ((lpiReplica = lpFileset->GetReadOnlyIdentifier (lpiAggregate, &status)) == NULL)
1587             rc = FALSE;
1588          lpFileset->Close();
1589          }
1590       }
1591
1592    if (hVOS)
1593       {
1594       if ((lpServer = lpiAggregate->OpenServer (&status)) != NULL)
1595          {
1596          lpServer->CloseVosObject();
1597          lpServer->Close();
1598          }
1599       }
1600
1601    NOTIFYCALLBACK::SendNotificationToAll (evtCreateReplicaEnd, lpiFileset, lpiAggregate, NULL, NULL, 0, status);
1602    AfsClass_Leave();
1603
1604    if (pStatus && !rc)
1605       *pStatus = status;
1606    return (rc) ? lpiReplica : FALSE;
1607 }
1608
1609
1610 BOOL AfsClass_DeleteReplica (LPIDENT lpiReplica, ULONG *pStatus)
1611 {
1612    BOOL rc = TRUE;
1613    ULONG status;
1614
1615    AfsClass_Enter();
1616    NOTIFYCALLBACK::SendNotificationToAll (evtDeleteFilesetBegin, lpiReplica);
1617
1618    // Obtain hCell and hVOS for the server
1619    //
1620    PVOID hCell;
1621    PVOID hVOS = NULL;
1622    LPSERVER lpServer;
1623    if ((lpServer = lpiReplica->OpenServer (&status)) == NULL)
1624       rc = FALSE;
1625    else
1626       {
1627       if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
1628          rc = FALSE;
1629       lpServer->Close();
1630       }
1631
1632    // Get the read/write fileset identifier and Ghost status
1633    //
1634    LPIDENT lpiRW = NULL;
1635    int wFilesetGhost = 0;
1636    LPFILESET lpFileset;
1637    if ((lpFileset = lpiReplica->OpenFileset (&status)) == NULL)
1638       rc = FALSE;
1639    else
1640       {
1641       wFilesetGhost = lpFileset->GetGhostStatus();
1642       if ((lpiRW = lpFileset->GetReadWriteIdentifier()) == NULL)
1643          rc = FALSE;
1644       lpFileset->Close();
1645       }
1646
1647    TCHAR szAggregateName[ cchNAME ];
1648    lpiReplica->GetAggregateName (szAggregateName);
1649
1650    // Obtain the ID of the replica's partition
1651    //
1652    int idPartition;
1653    LPAGGREGATE lpAggregate;
1654    if ((lpAggregate = lpiReplica->OpenAggregate (&status)) == NULL)
1655       rc = FALSE;
1656    else
1657       {
1658       idPartition = lpAggregate->GetID();
1659       lpAggregate->Close();
1660       }
1661
1662    // If the volume exists in both VLDB and on the server, just delete it
1663    //
1664    if (rc && (wFilesetGhost & GHOST_HAS_VLDB_ENTRY) && (wFilesetGhost & GHOST_HAS_SERVER_ENTRY))
1665       {
1666       WORKERPACKET wp;
1667       wp.wpVosVolumeDelete.hCell = hCell;
1668       wp.wpVosVolumeDelete.hServer = hVOS;
1669       wp.wpVosVolumeDelete.idPartition = idPartition;
1670       lpiReplica->GetFilesetID (&wp.wpVosVolumeDelete.idVolume);
1671
1672       AfsClass_Leave();
1673       rc = Worker_DoTask (wtaskVosVolumeDelete, &wp, &status);
1674       AfsClass_Enter();
1675       }
1676    else
1677       {
1678       // If necessary, modify VLDB to remove mention of this replica
1679       //
1680       if (rc && (wFilesetGhost & GHOST_HAS_VLDB_ENTRY))
1681          {
1682          WORKERPACKET wp;
1683          wp.wpVosVLDBReadOnlySiteDelete.hCell = hCell;
1684          wp.wpVosVLDBReadOnlySiteDelete.hServer = hVOS;
1685          wp.wpVosVLDBReadOnlySiteDelete.idPartition = idPartition;
1686          lpiRW->GetFilesetID (&wp.wpVosVLDBReadOnlySiteDelete.idVolume);
1687
1688          AfsClass_Leave();
1689          rc = Worker_DoTask (wtaskVosVLDBReadOnlySiteDelete, &wp, &status);
1690          AfsClass_Enter();
1691          }
1692
1693       // If necessary, zap the volume
1694       //
1695       if (rc && (wFilesetGhost & GHOST_HAS_SERVER_ENTRY))
1696          {
1697          WORKERPACKET wp;
1698          wp.wpVosVolumeZap.hCell = hCell;
1699          wp.wpVosVolumeZap.hServer = hVOS;
1700          wp.wpVosVolumeZap.idPartition = idPartition;
1701          lpiReplica->GetFilesetID (&wp.wpVosVolumeZap.idVolume);
1702          wp.wpVosVolumeZap.fForce = TRUE;
1703
1704          AfsClass_Leave();
1705          rc = Worker_DoTask (wtaskVosVolumeZap, &wp, &status);
1706          AfsClass_Enter();
1707          }
1708       }
1709
1710    // Clean up
1711    //
1712    if (rc)
1713       {
1714       LPAGGREGATE lpAggregate;
1715       if ((lpAggregate = lpiReplica->OpenAggregate (&status)) == NULL)
1716          rc = FALSE;
1717       else
1718          {
1719          lpAggregate->Invalidate();
1720          lpAggregate->RefreshFilesets (TRUE, &status);
1721          lpAggregate->Close();
1722          }
1723       }
1724
1725    if (rc)
1726       {
1727       LPCELL lpCell;
1728       if ((lpCell = lpiReplica->OpenCell()) == NULL)
1729          rc = FALSE;
1730       else
1731          {
1732          lpCell->RefreshVLDB (lpiReplica->GetAggregate());
1733          lpCell->Close();
1734          }
1735       }
1736
1737    if (hVOS)
1738       {
1739       if ((lpServer = lpiReplica->OpenServer (&status)) != NULL)
1740          {
1741          lpServer->CloseVosObject();
1742          lpServer->Close();
1743          }
1744       }
1745
1746    NOTIFYCALLBACK::SendNotificationToAll (evtDeleteFilesetEnd, lpiReplica, status);
1747    AfsClass_Leave();
1748
1749    if (pStatus && !rc)
1750       *pStatus = status;
1751    return rc;
1752 }
1753
1754
1755 BOOL AfsClass_DeleteClone (LPIDENT lpiClone, ULONG *pStatus)
1756 {
1757    return AfsClass_DeleteFileset (lpiClone, TRUE, TRUE, pStatus);
1758 }
1759
1760
1761 BOOL AfsClass_InstallFile (LPIDENT lpiServer, LPTSTR pszTarget, LPTSTR pszSource, ULONG *pStatus)
1762 {
1763    BOOL rc = TRUE;
1764    ULONG status;
1765
1766    AfsClass_Enter();
1767    NOTIFYCALLBACK::SendNotificationToAll (evtInstallFileBegin, lpiServer, pszSource, 0);
1768
1769    PVOID hCell;
1770    PVOID hBOS;
1771    LPSERVER lpServer;
1772    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
1773       rc = FALSE;
1774    else
1775       {
1776       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
1777          rc = FALSE;
1778       lpServer->Close();
1779       }
1780
1781    if (rc)
1782       {
1783       WORKERPACKET wp;
1784       wp.wpBosExecutableCreate.hServer = hBOS;
1785       wp.wpBosExecutableCreate.pszLocal = pszSource;
1786       wp.wpBosExecutableCreate.pszRemoteDir = pszTarget;
1787
1788       AfsClass_Leave();
1789       rc = Worker_DoTask (wtaskBosExecutableCreate, &wp, &status);
1790       AfsClass_Enter();
1791       }
1792
1793    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
1794       {
1795       lpServer->CloseBosObject();
1796       lpServer->Close();
1797       }
1798
1799    NOTIFYCALLBACK::SendNotificationToAll (evtInstallFileEnd, lpiServer, pszSource, status);
1800    AfsClass_Leave();
1801
1802    if (pStatus && !rc)
1803       *pStatus = status;
1804    return rc;
1805 }
1806
1807
1808 BOOL AfsClass_UninstallFile (LPIDENT lpiServer, LPTSTR pszUninstall, ULONG *pStatus)
1809 {
1810    BOOL rc = TRUE;
1811    ULONG status;
1812
1813    AfsClass_Enter();
1814    NOTIFYCALLBACK::SendNotificationToAll (evtUninstallFileBegin, lpiServer, pszUninstall, 0);
1815
1816    PVOID hCell;
1817    PVOID hBOS;
1818    LPSERVER lpServer;
1819    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
1820       rc = FALSE;
1821    else
1822       {
1823       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
1824          rc = FALSE;
1825       lpServer->Close();
1826       }
1827
1828    if (rc)
1829       {
1830       WORKERPACKET wp;
1831       wp.wpBosExecutableRevert.hServer = hBOS;
1832       wp.wpBosExecutableRevert.pszFilename = pszUninstall;
1833
1834       AfsClass_Leave();
1835       rc = Worker_DoTask (wtaskBosExecutableRevert, &wp, &status);
1836       AfsClass_Enter();
1837       }
1838
1839    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
1840       {
1841       lpServer->CloseBosObject();
1842       lpServer->Close();
1843       }
1844
1845    NOTIFYCALLBACK::SendNotificationToAll (evtUninstallFileEnd, lpiServer, pszUninstall, status);
1846    AfsClass_Leave();
1847
1848    if (pStatus && !rc)
1849       *pStatus = status;
1850    return rc;
1851 }
1852
1853
1854 BOOL AfsClass_PruneOldFiles (LPIDENT lpiServer, BOOL fBAK, BOOL fOLD, BOOL fCore, ULONG *pStatus)
1855 {
1856    BOOL rc = TRUE;
1857    ULONG status;
1858
1859    AfsClass_Enter();
1860    NOTIFYCALLBACK::SendNotificationToAll (evtPruneFilesBegin, lpiServer);
1861
1862    PVOID hCell;
1863    PVOID hBOS;
1864    LPSERVER lpServer;
1865    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
1866       rc = FALSE;
1867    else
1868       {
1869       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
1870          rc = FALSE;
1871       lpServer->Close();
1872       }
1873
1874    if (rc)
1875       {
1876       WORKERPACKET wp;
1877       wp.wpBosExecutablePrune.hServer = hBOS;
1878       wp.wpBosExecutablePrune.fPruneBak = fBAK;
1879       wp.wpBosExecutablePrune.fPruneOld = fOLD;
1880       wp.wpBosExecutablePrune.fPruneCore = fCore;
1881
1882       AfsClass_Leave();
1883       rc = Worker_DoTask (wtaskBosExecutablePrune, &wp, &status);
1884       AfsClass_Enter();
1885       }
1886
1887    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
1888       {
1889       lpServer->CloseBosObject();
1890       lpServer->Close();
1891       }
1892
1893    NOTIFYCALLBACK::SendNotificationToAll (evtPruneFilesEnd, lpiServer, status);
1894    AfsClass_Leave();
1895
1896    if (pStatus && !rc)
1897       *pStatus = status;
1898    return rc;
1899 }
1900
1901
1902 BOOL AfsClass_RenameFileset (LPIDENT lpiFileset, LPTSTR pszNewName, ULONG *pStatus)
1903 {
1904    BOOL rc = TRUE;
1905    ULONG status;
1906
1907    AfsClass_Enter();
1908    NOTIFYCALLBACK::SendNotificationToAll (evtRenameFilesetBegin, lpiFileset, pszNewName, 0);
1909
1910    PVOID hCell;
1911    LPCELL lpCell;
1912    if ((lpCell = lpiFileset->OpenCell (&status)) == NULL)
1913       rc = FALSE;
1914    else
1915       {
1916       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
1917          rc = FALSE;
1918       lpCell->Close();
1919       }
1920
1921    if (rc)
1922       {
1923       WORKERPACKET wp;
1924       wp.wpVosVolumeRename.hCell = hCell;
1925       lpiFileset->GetFilesetID (&wp.wpVosVolumeRename.idVolume);
1926       wp.wpVosVolumeRename.pszVolume = pszNewName;
1927
1928       AfsClass_Leave();
1929       rc = Worker_DoTask (wtaskVosVolumeRename, &wp, &status);
1930       AfsClass_Enter();
1931       }
1932
1933    if (rc)
1934       {
1935       LPCELL lpCell;
1936       if ((lpCell = lpiFileset->OpenCell (&status)) == NULL)
1937          rc = FALSE;
1938       else
1939          {
1940          lpCell->Invalidate();
1941          rc = lpCell->RefreshAll (&status);
1942          lpCell->Close();
1943          }
1944       }
1945
1946
1947    NOTIFYCALLBACK::SendNotificationToAll (evtRenameFilesetEnd, lpiFileset, pszNewName, status);
1948    AfsClass_Leave();
1949
1950    if (pStatus && !rc)
1951       *pStatus = status;
1952    return rc;
1953 }
1954
1955
1956 #define iswhite(_ch) ((_ch)==TEXT(' ') || (_ch)==TEXT('\t'))
1957
1958 LPIDENT AfsClass_CreateService (LPIDENT lpiServer, LPTSTR pszService, LPTSTR pszCommand, LPTSTR pszParams, LPTSTR pszNotifier, AFSSERVICETYPE type, SYSTEMTIME *pstIfCron, ULONG *pStatus)
1959 {
1960    BOOL rc = TRUE;
1961    ULONG status;
1962    LPIDENT lpiService = NULL;
1963
1964    AfsClass_Enter();
1965    NOTIFYCALLBACK::SendNotificationToAll (evtCreateServiceBegin, lpiServer, pszService, 0);
1966
1967    PVOID hCell;
1968    PVOID hBOS;
1969    LPSERVER lpServer;
1970    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
1971       rc = FALSE;
1972    else
1973       {
1974       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
1975          rc = FALSE;
1976       lpServer->Close();
1977       }
1978
1979    if (rc)
1980       {
1981       WORKERPACKET wp;
1982       wp.wpBosProcessCreate.hServer = hBOS;
1983       wp.wpBosProcessCreate.pszService = pszService;
1984       wp.wpBosProcessCreate.type = type;
1985       wp.wpBosProcessCreate.pszNotifier = pszNotifier;
1986
1987       TCHAR szFullCommand[ MAX_PATH + MAX_PATH ];
1988       wsprintf (szFullCommand, TEXT("%s %s"), pszCommand, pszParams);
1989       wp.wpBosProcessCreate.pszCommand = szFullCommand;
1990
1991       TCHAR szCronTime[ 256 ] = TEXT("");
1992       wp.wpBosProcessCreate.pszTimeCron = szCronTime;
1993
1994       if (type == SERVICETYPE_CRON)
1995          AfsClass_FormatRecurringTime (szCronTime, pstIfCron);
1996       else
1997          wp.wpBosProcessCreate.pszTimeCron = NULL;
1998
1999       AfsClass_Leave();
2000       rc = Worker_DoTask (wtaskBosProcessCreate, &wp, &status);
2001       AfsClass_Enter();
2002       }
2003
2004    if (rc)
2005       {
2006       if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
2007          rc = FALSE;
2008       else
2009          {
2010          lpServer->InvalidateServices();
2011          if (!lpServer->RefreshServices (TRUE, &status))
2012             rc = FALSE;
2013          else
2014             {
2015             LPSERVICE lpService;
2016             if ((lpService = lpServer->OpenService (pszService, &status)) == NULL)
2017                rc = FALSE;
2018             else
2019                {
2020                lpiService = lpService->GetIdentifier();
2021                lpService->Close();
2022                }
2023             }
2024          lpServer->Close();
2025          }
2026       }
2027
2028    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
2029       {
2030       lpServer->CloseBosObject();
2031       lpServer->Close();
2032       }
2033
2034    NOTIFYCALLBACK::SendNotificationToAll (evtCreateServiceEnd, lpiServer, pszService, status);
2035    AfsClass_Leave();
2036
2037    if (pStatus && !rc)
2038       *pStatus = status;
2039    return (rc) ? lpiService : NULL;
2040 }
2041
2042
2043 BOOL AfsClass_DeleteService (LPIDENT lpiService, ULONG *pStatus)
2044 {
2045    BOOL rc = TRUE;
2046    ULONG status;
2047
2048    AfsClass_Enter();
2049    NOTIFYCALLBACK::SendNotificationToAll (evtDeleteServiceBegin, lpiService);
2050
2051    PVOID hCell;
2052    PVOID hBOS;
2053    LPSERVER lpServer;
2054    if ((lpServer = lpiService->OpenServer (&status)) == NULL)
2055       rc = FALSE;
2056    else
2057       {
2058       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
2059          rc = FALSE;
2060       lpServer->Close();
2061       }
2062
2063    // Before a service can be deleted, it must be stopped (otherwise, on NT,
2064    // the Delete operation won't block for the required Stop to complete--
2065    // so our wtaskDeleteBosProcess would return before the service really
2066    // was deleted).
2067    //
2068    if (rc)
2069       {
2070       TCHAR szService[ cchNAME ];
2071       lpiService->GetServiceName (szService);
2072
2073       WORKERPACKET wp;
2074       wp.wpBosProcessExecutionStateSet.hServer = hBOS;
2075       wp.wpBosProcessExecutionStateSet.pszService = szService;
2076       wp.wpBosProcessExecutionStateSet.state = SERVICESTATE_STOPPED;
2077       // TODO: wp.wpStopBosProcess.fWait = TRUE;
2078
2079       AfsClass_Leave();
2080       rc = Worker_DoTask (wtaskBosProcessExecutionStateSet, &wp, &status);
2081       AfsClass_Enter();
2082       }
2083
2084    // Delete the service
2085    //
2086    if (rc)
2087       {
2088       TCHAR szService[ cchNAME ];
2089       lpiService->GetServiceName (szService);
2090
2091       WORKERPACKET wp;
2092       wp.wpBosProcessDelete.hServer = hBOS;
2093       wp.wpBosProcessDelete.pszService = szService;
2094
2095       AfsClass_Leave();
2096       rc = Worker_DoTask (wtaskBosProcessDelete, &wp, &status);
2097       AfsClass_Enter();
2098       }
2099
2100    if (rc)
2101       {
2102       if ((lpServer = lpiService->OpenServer (&status)) == NULL)
2103          rc = FALSE;
2104       else
2105          {
2106          lpServer->InvalidateServices();
2107          if (!lpServer->RefreshServices (TRUE, &status))
2108             rc = FALSE;
2109          lpServer->Close();
2110          }
2111       }
2112
2113    if ((lpServer = lpiService->OpenServer (&status)) != NULL)
2114       {
2115       lpServer->CloseBosObject();
2116       lpServer->Close();
2117       }
2118
2119    NOTIFYCALLBACK::SendNotificationToAll (evtDeleteServiceEnd, lpiService, status);
2120    AfsClass_Leave();
2121
2122    if (pStatus && !rc)
2123       *pStatus = status;
2124    return rc;
2125 }
2126
2127
2128 BOOL AfsClass_ReleaseFileset (LPIDENT lpiFilesetRW, BOOL fForce, ULONG *pStatus)
2129 {
2130    BOOL rc = TRUE;
2131    ULONG status;
2132
2133    AfsClass_Enter();
2134    NOTIFYCALLBACK::SendNotificationToAll (evtReleaseFilesetBegin, lpiFilesetRW);
2135
2136    // Obtain hCell and hVOS
2137    //
2138    PVOID hCell;
2139    PVOID hVOS = NULL;
2140    LPSERVER lpServer;
2141    if ((lpServer = lpiFilesetRW->OpenServer (&status)) == NULL)
2142       rc = FALSE;
2143    else
2144       {
2145       if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
2146          rc = FALSE;
2147       lpServer->Close();
2148       }
2149
2150    // Perform the actual operation
2151    //
2152    if (rc)
2153       {
2154       WORKERPACKET wp;
2155       wp.wpVosVolumeRelease.hCell = hCell;
2156       wp.wpVosVolumeRelease.fForce = fForce;
2157       lpiFilesetRW->GetFilesetID (&wp.wpVosVolumeRelease.idVolume);
2158
2159       AfsClass_Leave();
2160       rc = Worker_DoTask (wtaskVosVolumeRelease, &wp, &status);
2161       AfsClass_Enter();
2162       }
2163
2164    // Clean up
2165    //
2166    if (rc)
2167       {
2168       LPCELL lpCell;
2169       if ((lpCell = lpiFilesetRW->OpenCell (&status)) == NULL)
2170          rc = FALSE;
2171       else
2172          {
2173          lpCell->Invalidate();
2174          rc = lpCell->RefreshAll (&status);
2175          lpCell->Close();
2176          }
2177       }
2178
2179    if (hVOS)
2180       {
2181       if ((lpServer = lpiFilesetRW->OpenServer (&status)) != NULL)
2182          {
2183          lpServer->CloseVosObject();
2184          lpServer->Close();
2185          }
2186       }
2187
2188    NOTIFYCALLBACK::SendNotificationToAll (evtReleaseFilesetEnd, lpiFilesetRW, status);
2189    AfsClass_Leave();
2190
2191    if (pStatus && !rc)
2192       *pStatus = status;
2193    return rc;
2194 }
2195
2196
2197 BOOL AfsClass_GetFileDates (LPIDENT lpiServer, LPTSTR pszFilename, SYSTEMTIME *pstFile, SYSTEMTIME *pstBAK, SYSTEMTIME *pstOLD, ULONG *pStatus)
2198 {
2199    BOOL rc = TRUE;
2200    ULONG status;
2201
2202    AfsClass_Enter();
2203    NOTIFYCALLBACK::SendNotificationToAll (evtGetFileDatesBegin, lpiServer, pszFilename, 0);
2204
2205    PVOID hCell;
2206    PVOID hBOS;
2207    LPSERVER lpServer;
2208    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
2209       rc = FALSE;
2210    else
2211       {
2212       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
2213          rc = FALSE;
2214       lpServer->Close();
2215       }
2216
2217    if (rc)
2218       {
2219       WORKERPACKET wp;
2220       wp.wpBosExecutableTimestampGet.hServer = hBOS;
2221       wp.wpBosExecutableTimestampGet.pszFilename = pszFilename;
2222
2223       AfsClass_Leave();
2224       if ((rc = Worker_DoTask (wtaskBosExecutableTimestampGet, &wp, &status)) == TRUE)
2225          {
2226          *pstFile = wp.wpBosExecutableTimestampGet.timeNew;
2227          *pstBAK = wp.wpBosExecutableTimestampGet.timeBak;
2228          *pstOLD = wp.wpBosExecutableTimestampGet.timeOld;
2229          }
2230
2231       AfsClass_Enter();
2232       }
2233
2234    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
2235       {
2236       lpServer->CloseBosObject();
2237       lpServer->Close();
2238       }
2239
2240    NOTIFYCALLBACK::SendNotificationToAll (evtGetFileDatesEnd, lpiServer, pszFilename, status);
2241    AfsClass_Leave();
2242
2243    if (pStatus && !rc)
2244       *pStatus = status;
2245    return rc;
2246 }
2247
2248
2249 BOOL AfsClass_ExecuteCommand (LPIDENT lpiServer, LPTSTR pszCommand, ULONG *pStatus)
2250 {
2251    BOOL rc = TRUE;
2252    ULONG status;
2253
2254    AfsClass_Enter();
2255    NOTIFYCALLBACK::SendNotificationToAll (evtExecuteCommandBegin, lpiServer, pszCommand, 0);
2256
2257    PVOID hCell;
2258    PVOID hBOS;
2259    LPSERVER lpServer;
2260    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
2261       rc = FALSE;
2262    else
2263       {
2264       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
2265          rc = FALSE;
2266       lpServer->Close();
2267       }
2268
2269    if (rc)
2270       {
2271       WORKERPACKET wp;
2272       wp.wpBosCommandExecute.hServer = hBOS;
2273       wp.wpBosCommandExecute.pszCommand = pszCommand;
2274
2275       AfsClass_Leave();
2276       rc = Worker_DoTask (wtaskBosCommandExecute, &wp, &status);
2277       AfsClass_Enter();
2278       }
2279
2280    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
2281       {
2282       lpServer->CloseBosObject();
2283       lpServer->Close();
2284       }
2285
2286    NOTIFYCALLBACK::SendNotificationToAll (evtExecuteCommandEnd, lpiServer, pszCommand, status);
2287    AfsClass_Leave();
2288
2289    if (pStatus && !rc)
2290       *pStatus = status;
2291    return rc;
2292 }
2293
2294
2295 LPADMINLIST AfsClass_AdminList_Load (LPIDENT lpiServer, ULONG *pStatus)
2296 {
2297    BOOL rc = TRUE;
2298    ULONG status;
2299    LPADMINLIST lpList = NULL;
2300
2301    AfsClass_Enter();
2302    NOTIFYCALLBACK::SendNotificationToAll (evtAdminListLoadBegin, lpiServer);
2303
2304    PVOID hCell;
2305    PVOID hBOS;
2306    LPSERVER lpServer;
2307    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
2308       rc = FALSE;
2309    else
2310       {
2311       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
2312          rc = FALSE;
2313       lpServer->Close();
2314       }
2315
2316    if (rc)
2317       {
2318       lpList = New(ADMINLIST);
2319       memset (lpList, 0x00, sizeof(ADMINLIST));
2320       lpList->cRef = 1;
2321       lpList->lpiServer = lpiServer;
2322
2323       WORKERPACKET wpBegin;
2324       wpBegin.wpBosAdminGetBegin.hServer = hBOS;
2325       if (!Worker_DoTask (wtaskBosAdminGetBegin, &wpBegin, &status))
2326          rc = FALSE;
2327       else
2328          {
2329          for (;;)
2330             {
2331             TCHAR szAdmin[ cchNAME ];
2332
2333             WORKERPACKET wpNext;
2334             wpNext.wpBosAdminGetNext.hEnum = wpBegin.wpBosAdminGetBegin.hEnum;
2335             wpNext.wpBosAdminGetNext.pszAdmin = szAdmin;
2336
2337             if (!Worker_DoTask (wtaskBosAdminGetNext, &wpNext, &status))
2338                {
2339                if (status == ADMITERATORDONE)
2340                   status = 0;
2341                else
2342                   rc = FALSE;
2343                break;
2344                }
2345
2346             size_t iAdded;
2347             if ((iAdded = AfsClass_AdminList_AddEntry (lpList, szAdmin)) != (size_t)-1)
2348                {
2349                lpList->aEntries[ iAdded ].fAdded = FALSE;
2350                }
2351             }
2352
2353          WORKERPACKET wpDone;
2354          wpDone.wpBosAdminGetDone.hEnum = wpBegin.wpBosAdminGetBegin.hEnum;
2355          Worker_DoTask (wtaskBosAdminGetDone, &wpDone);
2356          }
2357       }
2358
2359    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
2360       {
2361       lpServer->CloseBosObject();
2362       lpServer->Close();
2363       }
2364
2365    NOTIFYCALLBACK::SendNotificationToAll (evtAdminListLoadEnd, lpiServer, status);
2366    AfsClass_Leave();
2367
2368    if (pStatus && !rc)
2369       *pStatus = status;
2370    return (rc) ? lpList : NULL;
2371 }
2372
2373
2374 LPADMINLIST AfsClass_AdminList_Copy (LPADMINLIST lpOld)
2375 {
2376    LPADMINLIST lpNew = NULL;
2377
2378    if (lpOld)
2379       {
2380       lpNew = New(ADMINLIST);
2381       memcpy (lpNew, lpOld, sizeof(ADMINLIST));
2382
2383       lpNew->cRef = 1;
2384       lpNew->aEntries = 0;
2385       lpNew->cEntries = 0;
2386
2387       if (REALLOC (lpNew->aEntries, lpNew->cEntries, lpOld->cEntries, cREALLOC_ADMINLISTENTRIES))
2388          {
2389          size_t cb = lpOld->cEntries * sizeof(ADMINLISTENTRY);
2390          memcpy (lpNew->aEntries, lpOld->aEntries, cb);
2391          }
2392       }
2393
2394    return lpNew;
2395 }
2396
2397
2398 BOOL AfsClass_AdminList_Save (LPADMINLIST lpList, ULONG *pStatus)
2399 {
2400    BOOL rc = TRUE;
2401    ULONG status;
2402
2403    AfsClass_Enter();
2404    NOTIFYCALLBACK::SendNotificationToAll (evtAdminListSaveBegin, lpList->lpiServer);
2405
2406    PVOID hCell;
2407    PVOID hBOS;
2408    LPSERVER lpServer;
2409    if ((lpServer = lpList->lpiServer->OpenServer (&status)) == NULL)
2410       rc = FALSE;
2411    else
2412       {
2413       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
2414          rc = FALSE;
2415       lpServer->Close();
2416       }
2417
2418    if (rc)
2419       {
2420       for (size_t iEntry = 0; iEntry < lpList->cEntries; ++iEntry)
2421          {
2422          if (!lpList->aEntries[ iEntry ].szAdmin[0])
2423             continue;
2424
2425          // are we supposed to add this entry?
2426          //
2427          if (lpList->aEntries[ iEntry ].fAdded && !lpList->aEntries[ iEntry ].fDeleted)
2428             {
2429             WORKERPACKET wp;
2430             wp.wpBosAdminCreate.hServer = hBOS;
2431             wp.wpBosAdminCreate.pszAdmin = lpList->aEntries[ iEntry ].szAdmin;
2432
2433             ULONG thisstatus;
2434             if (!Worker_DoTask (wtaskBosAdminCreate, &wp, &thisstatus))
2435                {
2436                rc = FALSE;
2437                status = thisstatus;
2438                }
2439             else
2440                {
2441                lpList->aEntries[ iEntry ].fAdded = FALSE;
2442                }
2443             }
2444
2445          // are we supposed to delete this entry?
2446          //
2447          if (!lpList->aEntries[ iEntry ].fAdded && lpList->aEntries[ iEntry ].fDeleted)
2448             {
2449             WORKERPACKET wp;
2450             wp.wpBosAdminDelete.hServer = hBOS;
2451             wp.wpBosAdminDelete.pszAdmin = lpList->aEntries[ iEntry ].szAdmin;
2452
2453             ULONG thisstatus;
2454             if (!Worker_DoTask (wtaskBosAdminDelete, &wp, &thisstatus))
2455                {
2456                rc = FALSE;
2457                status = thisstatus;
2458                }
2459             else
2460                {
2461                lpList->aEntries[ iEntry ].szAdmin[0] = TEXT('\0');
2462                lpList->aEntries[ iEntry ].fDeleted = FALSE;
2463                }
2464             }
2465          }
2466       }
2467
2468    if ((lpServer = lpList->lpiServer->OpenServer (&status)) != NULL)
2469       {
2470       lpServer->CloseBosObject();
2471       lpServer->Close();
2472       }
2473
2474    NOTIFYCALLBACK::SendNotificationToAll (evtAdminListSaveEnd, lpList->lpiServer, status);
2475    AfsClass_Leave();
2476
2477    if (pStatus && !rc)
2478       *pStatus = status;
2479    return rc;
2480 }
2481
2482
2483 void AfsClass_AdminList_Free (LPADMINLIST lpList)
2484 {
2485    if (lpList && !InterlockedDecrement (&lpList->cRef))
2486       {
2487       if (lpList->aEntries)
2488          Free (lpList->aEntries);
2489       memset (lpList, 0x00, sizeof(ADMINLIST));
2490       Delete (lpList);
2491       }
2492 }
2493
2494
2495 size_t AfsClass_AdminList_AddEntry (LPADMINLIST lpList, LPTSTR pszAdmin)
2496 {
2497    size_t iAdded = (size_t)-1;
2498
2499    if (lpList)
2500       {
2501       size_t iEntry;
2502       for (iEntry = 0; iEntry < lpList->cEntries; ++iEntry)
2503          {
2504          if (!lpList->aEntries[ iEntry ].szAdmin[0])
2505             break;
2506          }
2507       if (iEntry >= lpList->cEntries)
2508          {
2509          (void)REALLOC (lpList->aEntries, lpList->cEntries, 1+iEntry, cREALLOC_ADMINLISTENTRIES);
2510          }
2511       if (iEntry < lpList->cEntries)
2512          {
2513          iAdded = iEntry;
2514          lstrcpy (lpList->aEntries[ iAdded ].szAdmin, pszAdmin);
2515          lpList->aEntries[ iAdded ].fAdded = TRUE;
2516          lpList->aEntries[ iAdded ].fDeleted = FALSE;
2517          }
2518       }
2519
2520    return iAdded;
2521 }
2522
2523
2524 BOOL AfsClass_AdminList_DelEntry (LPADMINLIST lpList, size_t iIndex)
2525 {
2526    BOOL rc = FALSE;
2527
2528    if ( lpList &&
2529         (iIndex < lpList->cEntries) &&
2530         (lpList->aEntries[ iIndex ].szAdmin[0]) &&
2531         (!lpList->aEntries[ iIndex ].fDeleted) )
2532       {
2533       if (lpList->aEntries[ iIndex ].fAdded)
2534          lpList->aEntries[ iIndex ].szAdmin[0] = TEXT('\0');
2535       else
2536          lpList->aEntries[ iIndex ].fDeleted = TRUE;
2537
2538       rc = TRUE;
2539       }
2540
2541    return rc;
2542 }
2543
2544
2545 LPKEYLIST AfsClass_KeyList_Load (LPIDENT lpiServer, ULONG *pStatus)
2546 {
2547    BOOL rc = TRUE;
2548    ULONG status;
2549    LPKEYLIST lpList = NULL;
2550
2551    AfsClass_Enter();
2552    NOTIFYCALLBACK::SendNotificationToAll (evtKeyListLoadBegin, lpiServer);
2553
2554    PVOID hCell;
2555    PVOID hBOS;
2556    LPSERVER lpServer;
2557    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
2558       rc = FALSE;
2559    else
2560       {
2561       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
2562          rc = FALSE;
2563       lpServer->Close();
2564       }
2565
2566    if (rc)
2567       {
2568       lpList = New(KEYLIST);
2569       memset (lpList, 0x00, sizeof(KEYLIST));
2570       lpList->lpiServer = lpiServer;
2571
2572       WORKERPACKET wpBegin;
2573       wpBegin.wpBosKeyGetBegin.hServer = hBOS;
2574       if (!Worker_DoTask (wtaskBosKeyGetBegin, &wpBegin, &status))
2575          rc = FALSE;
2576       else
2577          {
2578          for (size_t iEnum = 0; ; ++iEnum)
2579             {
2580             WORKERPACKET wpNext;
2581             wpNext.wpBosKeyGetNext.hEnum = wpBegin.wpBosKeyGetBegin.hEnum;
2582
2583             if (!Worker_DoTask (wtaskBosKeyGetNext, &wpNext, &status))
2584                {
2585                if (status == ADMITERATORDONE)
2586                   status = 0;
2587                else
2588                   rc = FALSE;
2589                break;
2590                }
2591
2592             if (REALLOC (lpList->aKeys, lpList->cKeys, 1+iEnum, cREALLOC_SERVERKEYS))
2593                {
2594                lpList->aKeys[ iEnum ].keyVersion = wpNext.wpBosKeyGetNext.keyVersion;
2595                memcpy (&lpList->aKeys[ iEnum ].keyData, &wpNext.wpBosKeyGetNext.keyData, sizeof(ENCRYPTIONKEY));
2596                memcpy (&lpList->aKeys[ iEnum ].keyInfo, &wpNext.wpBosKeyGetNext.keyInfo, sizeof(ENCRYPTIONKEYINFO));
2597                }
2598             }
2599
2600          WORKERPACKET wpDone;
2601          wpDone.wpBosKeyGetDone.hEnum = wpBegin.wpBosKeyGetBegin.hEnum;
2602          Worker_DoTask (wtaskBosKeyGetDone, &wpDone);
2603          }
2604       }
2605
2606    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
2607       {
2608       lpServer->CloseBosObject();
2609       lpServer->Close();
2610       }
2611
2612    NOTIFYCALLBACK::SendNotificationToAll (evtKeyListLoadEnd, lpiServer, status);
2613    AfsClass_Leave();
2614
2615    if (pStatus && !rc)
2616       *pStatus = status;
2617    return (rc) ? lpList : NULL;
2618 }
2619
2620
2621 void AfsClass_KeyList_Free (LPKEYLIST lpList)
2622 {
2623    if (lpList)
2624       {
2625       if (lpList->aKeys)
2626          Free (lpList->aKeys);
2627       memset (lpList, 0x00, sizeof(KEYLIST));
2628       Delete (lpList);
2629       }
2630 }
2631
2632
2633 BOOL AfsClass_AddKey (LPIDENT lpiServer, int keyVersion, LPTSTR pszString, ULONG *pStatus)
2634 {
2635    BOOL rc = TRUE;
2636    ULONG status = 0;
2637
2638    TCHAR szCell[ cchNAME ];
2639    lpiServer->GetCellName (szCell);
2640
2641    WORKERPACKET wp;
2642    wp.wpKasStringToKey.pszCell = szCell;
2643    wp.wpKasStringToKey.pszString = pszString;
2644    if (!Worker_DoTask (wtaskKasStringToKey, &wp, &status))
2645       {
2646       rc = FALSE;
2647       }
2648    else if (!AfsClass_AddKey (lpiServer, keyVersion, &wp.wpKasStringToKey.key, &status))
2649       {
2650       rc = FALSE;
2651       }
2652
2653    if (pStatus && !rc)
2654       *pStatus = status;
2655    return rc;
2656 }
2657
2658
2659 BOOL AfsClass_AddKey (LPIDENT lpiServer, int keyVersion, LPENCRYPTIONKEY pKey, ULONG *pStatus)
2660 {
2661    BOOL rc = TRUE;
2662    ULONG status = 0;
2663
2664    PVOID hCell;
2665    PVOID hBOS;
2666    LPSERVER lpServer;
2667    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
2668       rc = FALSE;
2669    else
2670       {
2671       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
2672          rc = FALSE;
2673       lpServer->Close();
2674       }
2675
2676    if (rc)
2677       {
2678       WORKERPACKET wp;
2679       wp.wpBosKeyCreate.hServer = hBOS;
2680       wp.wpBosKeyCreate.keyVersion = keyVersion;
2681       memcpy (&wp.wpBosKeyCreate.key, pKey, sizeof(ENCRYPTIONKEY));
2682       rc = Worker_DoTask (wtaskBosKeyCreate, &wp, &status);
2683       }
2684
2685    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
2686       {
2687       lpServer->CloseBosObject();
2688       lpServer->Close();
2689       }
2690
2691    if (pStatus && !rc)
2692       *pStatus = status;
2693    return rc;
2694 }
2695
2696
2697 BOOL AfsClass_DeleteKey (LPIDENT lpiServer, int keyVersion, ULONG *pStatus)
2698 {
2699    BOOL rc = TRUE;
2700    ULONG status = 0;
2701
2702    PVOID hCell;
2703    PVOID hBOS;
2704    LPSERVER lpServer;
2705    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
2706       rc = FALSE;
2707    else
2708       {
2709       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
2710          rc = FALSE;
2711       lpServer->Close();
2712       }
2713
2714    if (rc)
2715       {
2716       WORKERPACKET wp;
2717       wp.wpBosKeyDelete.hServer = hBOS;
2718       wp.wpBosKeyDelete.keyVersion = keyVersion;
2719       rc = Worker_DoTask (wtaskBosKeyDelete, &wp, &status);
2720       }
2721
2722    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
2723       {
2724       lpServer->CloseBosObject();
2725       lpServer->Close();
2726       }
2727
2728    if (pStatus && !rc)
2729       *pStatus = status;
2730    return rc;
2731 }
2732
2733
2734 BOOL AfsClass_GetRandomKey (LPIDENT lpi, LPENCRYPTIONKEY pKey, ULONG *pStatus)
2735 {
2736    BOOL rc = TRUE;
2737    ULONG status = 0;
2738
2739    PVOID hCell;
2740    PVOID hKAS;
2741    LPCELL lpCell;
2742    if ((lpCell = lpi->OpenCell (&status)) == NULL)
2743       rc = FALSE;
2744    else
2745       {
2746       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
2747          rc = FALSE;
2748       else
2749          hKAS = lpCell->GetKasObject (&status);
2750       lpCell->Close();
2751       }
2752
2753    if (rc)
2754       {
2755       WORKERPACKET wp;
2756       wp.wpKasServerRandomKeyGet.hCell = hCell;
2757       wp.wpKasServerRandomKeyGet.hServer = hKAS;
2758       rc = Worker_DoTask (wtaskKasServerRandomKeyGet, &wp, &status);
2759
2760       if (rc)
2761          memcpy (pKey, &wp.wpKasServerRandomKeyGet.key, sizeof(ENCRYPTIONKEY));
2762       }
2763
2764    if (pStatus && !rc)
2765       *pStatus = status;
2766    return rc;
2767 }
2768
2769
2770 BOOL AfsClass_Clone (LPIDENT lpiRW, ULONG *pStatus)
2771 {
2772    BOOL rc = TRUE;
2773    ULONG status;
2774
2775    AfsClass_Enter();
2776    NOTIFYCALLBACK::SendNotificationToAll (evtCloneBegin, lpiRW, 0);
2777
2778    // Obtain hCell
2779    //
2780    PVOID hCell;
2781    LPCELL lpCell;
2782    if ((lpCell = lpiRW->OpenCell (&status)) == NULL)
2783       rc = FALSE;
2784    else
2785       {
2786       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
2787          rc = FALSE;
2788       lpCell->Close();
2789       }
2790
2791    // Perform the actual operation
2792    //
2793    if (rc)
2794       {
2795       WORKERPACKET wp;
2796       wp.wpVosBackupVolumeCreate.hCell = hCell;
2797       lpiRW->GetFilesetID (&wp.wpVosBackupVolumeCreate.idVolume);
2798
2799       AfsClass_Leave();
2800       rc = Worker_DoTask (wtaskVosBackupVolumeCreate, &wp, &status);
2801       AfsClass_Enter();
2802       }
2803
2804    // Clean up
2805    //
2806    if (rc)
2807       {
2808       LPSERVER lpServer;
2809       if ((lpServer = lpiRW->OpenServer (&status)) == NULL)
2810          rc = FALSE;
2811       else
2812          {
2813          lpServer->Invalidate();
2814          rc = lpServer->RefreshAll (&status);
2815          lpServer->Close();
2816          }
2817       }
2818
2819    NOTIFYCALLBACK::SendNotificationToAll (evtCloneEnd, lpiRW, status);
2820    AfsClass_Leave();
2821
2822    if (pStatus && !rc)
2823       *pStatus = status;
2824    return rc;
2825 }
2826
2827
2828 BOOL AfsClass_CloneMultiple (LPIDENT lpi, LPTSTR pszPrefix, BOOL fExclude, ULONG *pStatus)
2829 {
2830    BOOL rc = TRUE;
2831    ULONG status;
2832
2833    AfsClass_Enter();
2834    NOTIFYCALLBACK::SendNotificationToAll (evtCloneMultipleBegin, lpi);
2835
2836    // Obtain hCell
2837    //
2838    PVOID hCell;
2839    LPCELL lpCell;
2840    if ((lpCell = lpi->OpenCell (&status)) == NULL)
2841       rc = FALSE;
2842    else
2843       {
2844       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
2845          rc = FALSE;
2846       lpCell->Close();
2847       }
2848
2849    // Obtain hServer if appropriate
2850    //
2851    PVOID hVOS = NULL;
2852    if (!lpi->fIsCell())
2853       {
2854       LPSERVER lpServer;
2855       if ((lpServer = lpi->OpenServer (&status)) == NULL)
2856          rc = FALSE;
2857       else
2858          {
2859          if ((hVOS = lpServer->OpenVosObject (NULL, &status)) == NULL)
2860             rc = FALSE;
2861          lpServer->Close();
2862          }
2863       }
2864
2865    // If requested, obtain the appropriate aggregate ID
2866    //
2867    int idPartition = NO_PARTITION;
2868    if (rc && (lpi->fIsFileset() || lpi->fIsAggregate()))
2869       {
2870       LPAGGREGATE lpAggregate;
2871       if ((lpAggregate = lpi->OpenAggregate (&status)) == NULL)
2872          rc = FALSE;
2873       else
2874          {
2875          if ((idPartition = lpAggregate->GetID()) == NO_PARTITION)
2876             rc = FALSE;
2877          lpAggregate->Close();
2878          }
2879       }
2880
2881    // Perform the actual operation
2882    //
2883    if (rc)
2884       {
2885       WORKERPACKET wp;
2886       wp.wpVosBackupVolumeCreateMultiple.hCell = hCell;
2887       wp.wpVosBackupVolumeCreateMultiple.hServer = hVOS;
2888       wp.wpVosBackupVolumeCreateMultiple.idPartition = idPartition;
2889       wp.wpVosBackupVolumeCreateMultiple.pszPrefix = pszPrefix;
2890       wp.wpVosBackupVolumeCreateMultiple.fExclude = fExclude;
2891
2892       AfsClass_Leave();
2893       rc = Worker_DoTask (wtaskVosBackupVolumeCreateMultiple, &wp, &status);
2894       AfsClass_Enter();
2895       }
2896
2897    // Clean up
2898    //
2899    if (rc)
2900       {
2901       if (lpi->fIsCell())
2902          {
2903          LPCELL lpCell;
2904          if ((lpCell = lpi->OpenCell (&status)) == NULL)
2905             rc = FALSE;
2906          else
2907             {
2908             lpCell->Invalidate();
2909             rc = lpCell->RefreshAll (&status);
2910             lpCell->Close();
2911             }
2912          }
2913       else
2914          {
2915          LPSERVER lpServer;
2916          if ((lpServer = lpi->OpenServer (&status)) == NULL)
2917             rc = FALSE;
2918          else
2919             {
2920             lpServer->Invalidate();
2921             rc = lpServer->RefreshAll (&status);
2922             lpServer->Close();
2923             }
2924          }
2925       }
2926
2927    if (hVOS)
2928       {
2929       LPSERVER lpServer;
2930       if ((lpServer = lpi->OpenServer (&status)) != NULL)
2931          {
2932          lpServer->CloseVosObject();
2933          lpServer->Close();
2934          }
2935       }
2936
2937    NOTIFYCALLBACK::SendNotificationToAll (evtCloneMultipleEnd, lpi, status);
2938    AfsClass_Leave();
2939
2940    if (pStatus && !rc)
2941       *pStatus = status;
2942    return rc;
2943 }
2944
2945
2946 BOOL AfsClass_DumpFileset (LPIDENT lpi, LPTSTR pszFilename, LPSYSTEMTIME pstDate, ULONG *pStatus)
2947 {
2948    BOOL rc = TRUE;
2949    ULONG status;
2950
2951    AfsClass_Enter();
2952    NOTIFYCALLBACK::SendNotificationToAll (evtDumpFilesetBegin, lpi, pszFilename, 0);
2953
2954    // Obtain hCell and hVOS
2955    //
2956    PVOID hCell;
2957    PVOID hVOS = NULL;
2958    LPSERVER lpServer;
2959    if ((lpServer = lpi->OpenServer (&status)) == NULL)
2960       rc = FALSE;
2961    else
2962       {
2963       if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
2964          rc = FALSE;
2965       lpServer->Close();
2966       }
2967
2968    // Obtain idPartition
2969    //
2970    int idPartition;
2971    LPAGGREGATE lpAggregate;
2972    if ((lpAggregate = lpi->OpenAggregate (&status)) == NULL)
2973       rc = FALSE;
2974    else
2975       {
2976       idPartition = lpAggregate->GetID();
2977       lpAggregate->Close();
2978       }
2979
2980    // Perform the actual operation
2981    //
2982    if (rc)
2983       {
2984       WORKERPACKET wp;
2985       wp.wpVosVolumeDump.hCell = hCell;
2986       wp.wpVosVolumeDump.hServer = hVOS;
2987       wp.wpVosVolumeDump.pszFilename = pszFilename;
2988       wp.wpVosVolumeDump.idPartition = idPartition;
2989       lpi->GetFilesetID (&wp.wpVosVolumeDump.idVolume);
2990
2991       if (pstDate)
2992          memcpy (&wp.wpVosVolumeDump.stStart, pstDate, sizeof(SYSTEMTIME));
2993       else
2994          memset (&wp.wpVosVolumeDump.stStart, 0x00, sizeof(SYSTEMTIME));
2995
2996       AfsClass_Leave();
2997       rc = Worker_DoTask (wtaskVosVolumeDump, &wp, &status);
2998       AfsClass_Enter();
2999       }
3000
3001    NOTIFYCALLBACK::SendNotificationToAll (evtDumpFilesetEnd, lpi, pszFilename, status);
3002    AfsClass_Leave();
3003
3004    if (hVOS)
3005       {
3006       LPSERVER lpServer;
3007       if ((lpServer = lpi->OpenServer (&status)) != NULL)
3008          {
3009          lpServer->CloseVosObject();
3010          lpServer->Close();
3011          }
3012       }
3013
3014    if (pStatus && !rc)
3015       *pStatus = status;
3016    return rc;
3017 }
3018
3019
3020 BOOL AfsClass_RestoreFileset (LPIDENT lpi, LPTSTR pszFileset, LPTSTR pszFilename, BOOL fIncremental, ULONG *pStatus)
3021 {
3022    BOOL rc = TRUE;
3023    ULONG status;
3024
3025    AfsClass_Enter();
3026    NOTIFYCALLBACK::SendNotificationToAll (evtRestoreFilesetBegin, lpi, NULL, pszFileset, pszFilename, 0, 0);
3027
3028    // Obtain hCell and hVOS
3029    //
3030    PVOID hCell;
3031    PVOID hVOS = NULL;
3032    LPSERVER lpServer;
3033    if ((lpServer = lpi->OpenServer (&status)) == NULL)
3034       rc = FALSE;
3035    else
3036       {
3037       if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
3038          rc = FALSE;
3039       lpServer->Close();
3040       }
3041
3042    // Obtain idPartition
3043    //
3044    int idPartition;
3045    LPAGGREGATE lpAggregate;
3046    if ((lpAggregate = lpi->OpenAggregate (&status)) == NULL)
3047       rc = FALSE;
3048    else
3049       {
3050       idPartition = lpAggregate->GetID();
3051       lpAggregate->Close();
3052       }
3053
3054    // Perform the actual operation
3055    //
3056    if (rc)
3057       {
3058       WORKERPACKET wp;
3059       wp.wpVosVolumeRestore.hCell = hCell;
3060       wp.wpVosVolumeRestore.hServer = hVOS;
3061       wp.wpVosVolumeRestore.idPartition = idPartition;
3062       wp.wpVosVolumeRestore.pszVolume = pszFileset;
3063       wp.wpVosVolumeRestore.pszFilename = pszFilename;
3064       wp.wpVosVolumeRestore.fIncremental = fIncremental;
3065
3066       if (lpi->fIsFileset())
3067          lpi->GetFilesetID (&wp.wpVosVolumeRestore.idVolume);
3068       else
3069          wp.wpVosVolumeRestore.idVolume = NO_VOLUME;
3070
3071       AfsClass_Leave();
3072       rc = Worker_DoTask (wtaskVosVolumeRestore, &wp, &status);
3073       AfsClass_Enter();
3074       }
3075
3076    // Clean up
3077    //
3078    if (rc)
3079       {
3080       if ((lpServer = lpi->OpenServer (&status)) == NULL)
3081          rc = FALSE;
3082       else
3083          {
3084          lpServer->Invalidate();
3085          rc = lpServer->RefreshAll (&status);
3086          lpServer->Close();
3087          }
3088       }
3089
3090    if (hVOS)
3091       {
3092       if ((lpServer = lpi->OpenServer (&status)) != NULL)
3093          {
3094          lpServer->CloseVosObject();
3095          lpServer->Close();
3096          }
3097       }
3098
3099    NOTIFYCALLBACK::SendNotificationToAll (evtRestoreFilesetEnd, lpi, NULL, pszFileset, pszFilename, 0, status);
3100    AfsClass_Leave();
3101
3102    if (pStatus && !rc)
3103       *pStatus = status;
3104    return rc;
3105 }
3106
3107
3108 BOOL AfsClass_GetRestartTimes (LPIDENT lpiServer, BOOL *pfWeekly, LPSYSTEMTIME pstWeekly, BOOL *pfDaily, LPSYSTEMTIME pstDaily, ULONG *pStatus)
3109 {
3110    BOOL rc = TRUE;
3111    ULONG status;
3112
3113    AfsClass_Enter();
3114    NOTIFYCALLBACK::SendNotificationToAll (evtGetRestartTimesBegin, lpiServer);
3115
3116    PVOID hCell;
3117    PVOID hBOS;
3118    LPSERVER lpServer;
3119    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
3120       rc = FALSE;
3121    else
3122       {
3123       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
3124          rc = FALSE;
3125       lpServer->Close();
3126       }
3127
3128    if (rc)
3129       {
3130       WORKERPACKET wp;
3131       wp.wpBosExecutableRestartTimeGet.hServer = hBOS;
3132
3133       AfsClass_Leave();
3134       rc = Worker_DoTask (wtaskBosExecutableRestartTimeGet, &wp, &status);
3135       AfsClass_Enter();
3136
3137       if (rc)
3138          {
3139          *pfWeekly = wp.wpBosExecutableRestartTimeGet.fWeeklyRestart;
3140          *pstWeekly = wp.wpBosExecutableRestartTimeGet.timeWeekly;
3141          *pfDaily = wp.wpBosExecutableRestartTimeGet.fDailyRestart;
3142          *pstDaily = wp.wpBosExecutableRestartTimeGet.timeDaily;
3143          }
3144       }
3145
3146    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
3147       {
3148       lpServer->CloseBosObject();
3149       lpServer->Close();
3150       }
3151
3152    NOTIFYCALLBACK::SendNotificationToAll (evtGetRestartTimesEnd, lpiServer, status);
3153    AfsClass_Leave();
3154
3155    if (pStatus && !rc)
3156       *pStatus = status;
3157    return rc;
3158 }
3159
3160
3161 BOOL AfsClass_SetRestartTimes (LPIDENT lpiServer, LPSYSTEMTIME pstWeekly, LPSYSTEMTIME pstDaily, ULONG *pStatus)
3162 {
3163    BOOL rc = TRUE;
3164    ULONG status;
3165
3166    AfsClass_Enter();
3167    NOTIFYCALLBACK::SendNotificationToAll (evtSetRestartTimesBegin, lpiServer);
3168
3169    PVOID hCell;
3170    PVOID hBOS;
3171    LPSERVER lpServer;
3172    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
3173       rc = FALSE;
3174    else
3175       {
3176       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
3177          rc = FALSE;
3178       lpServer->Close();
3179       }
3180
3181    if (rc)
3182       {
3183       SYSTEMTIME timeNever;
3184       memset (&timeNever, 0x00, sizeof(SYSTEMTIME));
3185
3186       WORKERPACKET wp;
3187       wp.wpBosExecutableRestartTimeSet.hServer = hBOS;
3188       wp.wpBosExecutableRestartTimeSet.fWeeklyRestart = (pstWeekly != NULL) ? TRUE : FALSE;
3189       wp.wpBosExecutableRestartTimeSet.timeWeekly = (pstWeekly != NULL) ? *pstWeekly : timeNever;
3190       wp.wpBosExecutableRestartTimeSet.fDailyRestart = (pstDaily != NULL) ? TRUE : FALSE;
3191       wp.wpBosExecutableRestartTimeSet.timeDaily = (pstDaily != NULL) ? *pstDaily : timeNever;
3192
3193       AfsClass_Leave();
3194       rc = Worker_DoTask (wtaskBosExecutableRestartTimeSet, &wp, &status);
3195       AfsClass_Enter();
3196       }
3197
3198    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
3199       {
3200       lpServer->CloseBosObject();
3201       lpServer->Close();
3202       }
3203
3204    NOTIFYCALLBACK::SendNotificationToAll (evtSetRestartTimesEnd, lpiServer, status);
3205    AfsClass_Leave();
3206
3207    if (pStatus && !rc)
3208       *pStatus = status;
3209    return rc;
3210 }
3211
3212
3213 BOOL AfsClass_MoveReplica (LPIDENT lpiReplica, LPIDENT lpiAggregateTarget, ULONG *pStatus)
3214 {
3215    BOOL rc = TRUE;
3216
3217    // Find the identifier for this replica's read/write fileset.
3218    //
3219    LPIDENT lpiFilesetRW = NULL;
3220    LPFILESET lpFileset;
3221    if ((lpFileset = lpiReplica->OpenFileset (pStatus)) == NULL)
3222       rc = FALSE;
3223    else
3224       {
3225       if ((lpiFilesetRW = lpFileset->GetReadWriteIdentifier (pStatus)) == NULL)
3226          rc = FALSE;
3227       lpFileset->Close();
3228       }
3229
3230    // If the fileset replica currently resides on the same server
3231    // as the target aggregate, we'll follow the following steps:
3232    //
3233    // 1. Delete the old fileset replica -> on error, quit
3234    // 2. Create the new fileset replica -> on error, recreate old replica, quit
3235    //
3236    // If the fileset replica instead currently resides on a different
3237    // server, we can follow the preferred steps:
3238    //
3239    // 1. Create the new fileset replica -> on error, quit
3240    // 2. Delete the old fileset replica -> on error, delete the new replica, quit
3241    //
3242    if (rc)
3243       {
3244       LPIDENT lpiReplicaNew;
3245
3246       if (lpiReplica->GetServer() == lpiAggregateTarget->GetServer())
3247          {
3248          LPIDENT lpiAggregateOriginal = lpiReplica->GetAggregate();
3249
3250          if (!AfsClass_DeleteReplica (lpiReplica, pStatus))
3251             {
3252             rc = FALSE;
3253             }
3254          else if ((lpiReplicaNew = AfsClass_CreateReplica (lpiFilesetRW, lpiAggregateTarget, pStatus)) == NULL)
3255             {
3256             (void)AfsClass_CreateReplica (lpiFilesetRW, lpiAggregateOriginal);
3257             rc = FALSE;
3258             }
3259          }
3260       else // different server?
3261          {
3262          if ((lpiReplicaNew = AfsClass_CreateReplica (lpiFilesetRW, lpiAggregateTarget, pStatus)) == NULL)
3263             {
3264             rc = FALSE;
3265             }
3266          else if (!AfsClass_DeleteReplica (lpiReplica, pStatus))
3267             {
3268             (void)AfsClass_DeleteReplica (lpiReplicaNew, pStatus);
3269             rc = FALSE;
3270             }
3271          }
3272       }
3273
3274    return rc;
3275 }
3276
3277
3278 BOOL AfsClass_Salvage (LPIDENT lpiSalvage, LPTSTR *ppszLogData, int nProcesses, LPTSTR pszTempDir, LPTSTR pszLogFile, BOOL fForce, BOOL fReadonly, BOOL fLogInodes, BOOL fLogRootInodes, BOOL fRebuildDirs, BOOL fReadBlocks, ULONG *pStatus)
3279 {
3280    BOOL rc = TRUE;
3281    ULONG status;
3282
3283    AfsClass_Enter();
3284    NOTIFYCALLBACK::SendNotificationToAll (evtSalvageBegin, lpiSalvage);
3285
3286    PVOID hCell;
3287    PVOID hBOS;
3288    LPSERVER lpServer;
3289    if ((lpServer = lpiSalvage->OpenServer (&status)) == NULL)
3290       rc = FALSE;
3291    else
3292       {
3293       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
3294          rc = FALSE;
3295       lpServer->Close();
3296       }
3297
3298    if (ppszLogData)
3299       *ppszLogData = NULL;
3300
3301    // Step one: perform the actual salvage. This will dump a log file onto
3302    // the target computer.
3303    //
3304    if (rc)
3305       {
3306       LPTSTR pszAggregate = NULL;
3307       TCHAR szAggregate[ cchNAME ];
3308       if (lpiSalvage->fIsAggregate() || lpiSalvage->fIsFileset())
3309          {
3310          lpiSalvage->GetAggregateName (szAggregate);
3311          pszAggregate = szAggregate;
3312          }
3313
3314       LPTSTR pszFileset = NULL;
3315       TCHAR szFileset[ cchNAME ];
3316       if (lpiSalvage->fIsFileset())
3317          {
3318          VOLUMEID vid;
3319          lpiSalvage->GetFilesetID (&vid);
3320          wsprintf (szFileset, TEXT("%lu"), vid);
3321          pszFileset = szFileset;
3322          }
3323
3324       if (pszLogFile == NULL)
3325          pszLogFile = TEXT("SalvageLog");
3326
3327       WORKERPACKET wp;
3328       wp.wpBosSalvage.hCell = hCell;
3329       wp.wpBosSalvage.hServer = hBOS;
3330       wp.wpBosSalvage.pszAggregate = pszAggregate;
3331       wp.wpBosSalvage.pszFileset = pszFileset;
3332       wp.wpBosSalvage.nProcesses = nProcesses;
3333       wp.wpBosSalvage.pszTempDir = pszTempDir;
3334       wp.wpBosSalvage.pszLogFile = pszLogFile;
3335       wp.wpBosSalvage.fForce = fForce;
3336       wp.wpBosSalvage.fReadonly = fReadonly;
3337       wp.wpBosSalvage.fLogInodes = fLogInodes;
3338       wp.wpBosSalvage.fLogRootInodes = fLogRootInodes;
3339       wp.wpBosSalvage.fRebuildDirs = fRebuildDirs;
3340       wp.wpBosSalvage.fReadBlocks = fReadBlocks;
3341
3342       AfsClass_Leave();
3343       rc = Worker_DoTask (wtaskBosSalvage, &wp, &status);
3344       AfsClass_Enter();
3345       }
3346
3347    // Step two: retrieve the log file from that salvage operation.
3348    // If we can't get the log file back, that's not fatal--just return
3349    // a NULL pointer for the log data.
3350    //
3351    if (rc && ppszLogData)
3352       {
3353       WORKERPACKET wp;
3354       wp.wpBosLogGet.hServer = hBOS;
3355       wp.wpBosLogGet.pszLogName = pszLogFile;
3356       wp.wpBosLogGet.pszLogData = NULL;
3357
3358       AfsClass_Leave();
3359       if ((rc = Worker_DoTask (wtaskBosLogGet, &wp, &status)) == TRUE)
3360          {
3361          // Okay, well, we have the log in memory now. Problem is,
3362          // it has UNIX-style CR's... and so is missing the LF which
3363          // PCs expect before each CR.  Wow--look at all the
3364          // acronyms!  Count the CRs, alloc a larger buffer, and stuff
3365          // in the LFs before each CR.
3366          //
3367          size_t cchRequired = 1;
3368          for (LPTSTR pchIn = wp.wpBosLogGet.pszLogData; *pchIn; ++pchIn)
3369             {
3370             cchRequired += (*pchIn == TEXT('\r')) ? 0 : (*pchIn == TEXT('\n')) ? 2 : 1;
3371             }
3372
3373          if ((*ppszLogData = AllocateString (cchRequired)) != NULL)
3374             {
3375             LPTSTR pszOut = *ppszLogData;
3376             for (LPTSTR pchIn = wp.wpBosLogGet.pszLogData; *pchIn; ++pchIn)
3377                {
3378                if (*pchIn == TEXT('\n'))
3379                   *pszOut++ = TEXT('\r');
3380                if (*pchIn != TEXT('\r'))
3381                   *pszOut++ = *pchIn;
3382                }
3383             *pszOut++ = TEXT('\0');
3384             }
3385          }
3386       AfsClass_Enter();
3387       }
3388
3389    if ((lpServer = lpiSalvage->OpenServer (&status)) != NULL)
3390       {
3391       lpServer->CloseBosObject();
3392       lpServer->Close();
3393       }
3394
3395    NOTIFYCALLBACK::SendNotificationToAll (evtSalvageEnd, lpiSalvage, status);
3396    AfsClass_Leave();
3397
3398    if (pStatus && !rc)
3399       *pStatus = status;
3400    return rc;
3401 }
3402
3403
3404 void AfsClass_FreeSalvageLog (LPTSTR pszLogData)
3405 {
3406    if (pszLogData)
3407       Free (pszLogData);
3408 }
3409
3410
3411 LPHOSTLIST AfsClass_HostList_Load (LPIDENT lpiServer, ULONG *pStatus)
3412 {
3413    BOOL rc = TRUE;
3414    ULONG status;
3415    LPHOSTLIST lpList = NULL;
3416
3417    AfsClass_Enter();
3418    NOTIFYCALLBACK::SendNotificationToAll (evtHostListLoadBegin, lpiServer);
3419
3420    PVOID hCell;
3421    PVOID hBOS;
3422    LPSERVER lpServer;
3423    if ((lpServer = lpiServer->OpenServer (&status)) == NULL)
3424       rc = FALSE;
3425    else
3426       {
3427       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
3428          rc = FALSE;
3429       lpServer->Close();
3430       }
3431
3432    if (rc)
3433       {
3434       lpList = New(HOSTLIST);
3435       memset (lpList, 0x00, sizeof(HOSTLIST));
3436       lpList->cRef = 1;
3437       lpList->lpiServer = lpiServer;
3438
3439       WORKERPACKET wpBegin;
3440       wpBegin.wpBosHostGetBegin.hServer = hBOS;
3441       if (!Worker_DoTask (wtaskBosHostGetBegin, &wpBegin, &status))
3442          rc = FALSE;
3443       else
3444          {
3445          for (;;)
3446             {
3447             TCHAR szHost[ cchNAME ];
3448
3449             WORKERPACKET wpNext;
3450             wpNext.wpBosHostGetNext.hEnum = wpBegin.wpBosHostGetBegin.hEnum;
3451             wpNext.wpBosHostGetNext.pszServer = szHost;
3452
3453             if (!Worker_DoTask (wtaskBosHostGetNext, &wpNext, &status))
3454                {
3455                if (status == ADMITERATORDONE)
3456                   status = 0;
3457                else
3458                   rc = FALSE;
3459                break;
3460                }
3461
3462             size_t iAdded;
3463             if ((iAdded = AfsClass_HostList_AddEntry (lpList, szHost)) != (size_t)-1)
3464                {
3465                lpList->aEntries[ iAdded ].fAdded = FALSE;
3466                }
3467             }
3468
3469          WORKERPACKET wpDone;
3470          wpDone.wpBosHostGetDone.hEnum = wpBegin.wpBosHostGetBegin.hEnum;
3471          Worker_DoTask (wtaskBosHostGetDone, &wpDone);
3472          }
3473       }
3474
3475    if ((lpServer = lpiServer->OpenServer (&status)) != NULL)
3476       {
3477       lpServer->CloseBosObject();
3478       lpServer->Close();
3479       }
3480
3481    NOTIFYCALLBACK::SendNotificationToAll (evtHostListLoadEnd, lpiServer, status);
3482    AfsClass_Leave();
3483
3484    if (pStatus && !rc)
3485       *pStatus = status;
3486    return (rc) ? lpList : NULL;
3487 }
3488
3489
3490 LPHOSTLIST AfsClass_HostList_Copy (LPHOSTLIST lpOld)
3491 {
3492    LPHOSTLIST lpNew = NULL;
3493
3494    if (lpOld)
3495       {
3496       lpNew = New(HOSTLIST);
3497       memcpy (lpNew, lpOld, sizeof(HOSTLIST));
3498
3499       lpNew->cRef = 1;
3500       lpNew->aEntries = 0;
3501       lpNew->cEntries = 0;
3502
3503       if (REALLOC (lpNew->aEntries, lpNew->cEntries, lpOld->cEntries, cREALLOC_HOSTLISTENTRIES))
3504          {
3505          size_t cb = lpOld->cEntries * sizeof(HOSTLISTENTRY);
3506          memcpy (lpNew->aEntries, lpOld->aEntries, cb);
3507          }
3508       }
3509
3510    return lpNew;
3511 }
3512
3513
3514 BOOL AfsClass_HostList_Save (LPHOSTLIST lpList, ULONG *pStatus)
3515 {
3516    BOOL rc = TRUE;
3517    ULONG status;
3518
3519    AfsClass_Enter();
3520    NOTIFYCALLBACK::SendNotificationToAll (evtHostListSaveBegin, lpList->lpiServer);
3521
3522    PVOID hCell;
3523    PVOID hBOS;
3524    LPSERVER lpServer;
3525    if ((lpServer = lpList->lpiServer->OpenServer (&status)) == NULL)
3526       rc = FALSE;
3527    else
3528       {
3529       if ((hBOS = lpServer->OpenBosObject (&hCell, &status)) == NULL)
3530          rc = FALSE;
3531       lpServer->Close();
3532       }
3533
3534    if (rc)
3535       {
3536       for (size_t iEntry = 0; iEntry < lpList->cEntries; ++iEntry)
3537          {
3538          if (!lpList->aEntries[ iEntry ].szHost[0])
3539             continue;
3540
3541          // are we supposed to add this entry?
3542          //
3543          if (lpList->aEntries[ iEntry ].fAdded && !lpList->aEntries[ iEntry ].fDeleted)
3544             {
3545             WORKERPACKET wp;
3546             wp.wpBosHostCreate.hServer = hBOS;
3547             wp.wpBosHostCreate.pszServer = lpList->aEntries[ iEntry ].szHost;
3548
3549             ULONG thisstatus;
3550             if (!Worker_DoTask (wtaskBosHostCreate, &wp, &thisstatus))
3551                {
3552                rc = FALSE;
3553                status = thisstatus;
3554                }
3555             else
3556                {
3557                lpList->aEntries[ iEntry ].fAdded = FALSE;
3558                }
3559             }
3560
3561          // are we supposed to delete this entry?
3562          //
3563          if (!lpList->aEntries[ iEntry ].fAdded && lpList->aEntries[ iEntry ].fDeleted)
3564             {
3565             WORKERPACKET wp;
3566             wp.wpBosHostDelete.hServer = hBOS;
3567             wp.wpBosHostDelete.pszServer = lpList->aEntries[ iEntry ].szHost;
3568
3569             ULONG thisstatus;
3570             if (!Worker_DoTask (wtaskBosHostDelete, &wp, &thisstatus))
3571                {
3572                rc = FALSE;
3573                status = thisstatus;
3574                }
3575             else
3576                {
3577                lpList->aEntries[ iEntry ].szHost[0] = TEXT('\0');
3578                lpList->aEntries[ iEntry ].fDeleted = FALSE;
3579                }
3580             }
3581          }
3582       }
3583
3584    if ((lpServer = lpList->lpiServer->OpenServer (&status)) != NULL)
3585       {
3586       lpServer->CloseBosObject();
3587       lpServer->Close();
3588       }
3589
3590    NOTIFYCALLBACK::SendNotificationToAll (evtHostListSaveEnd, lpList->lpiServer, status);
3591    AfsClass_Leave();
3592
3593    if (pStatus && !rc)
3594       *pStatus = status;
3595    return rc;
3596 }
3597
3598
3599 void AfsClass_HostList_Free (LPHOSTLIST lpList)
3600 {
3601    if (lpList && !InterlockedDecrement (&lpList->cRef))
3602       {
3603       if (lpList->aEntries)
3604          Free (lpList->aEntries);
3605       memset (lpList, 0x00, sizeof(HOSTLIST));
3606       Delete (lpList);
3607       }
3608 }
3609
3610
3611 size_t AfsClass_HostList_AddEntry (LPHOSTLIST lpList, LPTSTR pszHost)
3612 {
3613    size_t iAdded = (size_t)-1;
3614
3615    if (lpList)
3616       {
3617       size_t iEntry;
3618       for (iEntry = 0; iEntry < lpList->cEntries; ++iEntry)
3619          {
3620          if (!lpList->aEntries[ iEntry ].szHost[0])
3621             break;
3622          }
3623       if (iEntry >= lpList->cEntries)
3624          {
3625          (void)REALLOC (lpList->aEntries, lpList->cEntries, 1+iEntry, cREALLOC_HOSTLISTENTRIES);
3626          }
3627       if (iEntry < lpList->cEntries)
3628          {
3629          iAdded = iEntry;
3630          lstrcpy (lpList->aEntries[ iAdded ].szHost, pszHost);
3631          lpList->aEntries[ iAdded ].fAdded = TRUE;
3632          lpList->aEntries[ iAdded ].fDeleted = FALSE;
3633          }
3634       }
3635
3636    return iAdded;
3637 }
3638
3639
3640 BOOL AfsClass_HostList_DelEntry (LPHOSTLIST lpList, size_t iIndex)
3641 {
3642    BOOL rc = FALSE;
3643
3644    if ( lpList &&
3645         (iIndex < lpList->cEntries) &&
3646         (lpList->aEntries[ iIndex ].szHost[0]) &&
3647         (!lpList->aEntries[ iIndex ].fDeleted) )
3648       {
3649       if (lpList->aEntries[ iIndex ].fAdded)
3650          lpList->aEntries[ iIndex ].szHost[0] = TEXT('\0');
3651       else
3652          lpList->aEntries[ iIndex ].fDeleted = TRUE;
3653
3654       rc = TRUE;
3655       }
3656
3657    return rc;
3658 }
3659
3660
3661 BOOL AfsClass_GetPtsProperties (LPIDENT lpiCell, LPPTSPROPERTIES pProperties, ULONG *pStatus)
3662 {
3663    BOOL rc = TRUE;
3664    ULONG status;
3665
3666    memset (pProperties, 0x00, sizeof(PTSPROPERTIES));
3667
3668    // Obtain hCell
3669    //
3670    PVOID hCell;
3671    LPCELL lpCell;
3672    if ((lpCell = lpiCell->OpenCell (&status)) == NULL)
3673       rc = FALSE;
3674    else
3675       {
3676       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
3677          rc = FALSE;
3678       lpCell->Close();
3679       }
3680
3681    // Go get the necessary properties
3682    //
3683    if (rc)
3684       {
3685       WORKERPACKET wp;
3686       wp.wpPtsUserMaxGet.hCell = hCell;
3687
3688       if ((rc = Worker_DoTask (wtaskPtsUserMaxGet, &wp, &status)) == TRUE)
3689          pProperties->idUserMax = wp.wpPtsUserMaxGet.idUserMax;
3690       }
3691
3692    if (rc)
3693       {
3694       WORKERPACKET wp;
3695       wp.wpPtsGroupMaxGet.hCell = hCell;
3696
3697       if ((rc = Worker_DoTask (wtaskPtsGroupMaxGet, &wp, &status)) == TRUE)
3698          pProperties->idGroupMax = wp.wpPtsGroupMaxGet.idGroupMax;
3699       }
3700
3701    if (pStatus && !rc)
3702       *pStatus = status;
3703    return rc;
3704 }
3705
3706
3707 BOOL AfsClass_SetPtsProperties (LPIDENT lpiCell, LPPTSPROPERTIES pProperties, ULONG *pStatus)
3708 {
3709    BOOL rc = TRUE;
3710    ULONG status;
3711
3712    // Obtain hCell
3713    //
3714    PVOID hCell;
3715    LPCELL lpCell;
3716    if ((lpCell = lpiCell->OpenCell (&status)) == NULL)
3717       rc = FALSE;
3718    else
3719       {
3720       if ((hCell = lpCell->GetCellObject (&status)) == NULL)
3721          rc = FALSE;
3722       lpCell->Close();
3723       }
3724
3725    // Modify the specified properties
3726    //
3727    if (rc)
3728       {
3729       WORKERPACKET wp;
3730       wp.wpPtsUserMaxSet.hCell = hCell;
3731       wp.wpPtsUserMaxSet.idUserMax = pProperties->idUserMax;
3732       rc = Worker_DoTask (wtaskPtsUserMaxSet, &wp, &status);
3733       }
3734
3735    if (rc)
3736       {
3737       WORKERPACKET wp;
3738       wp.wpPtsGroupMaxSet.hCell = hCell;
3739       wp.wpPtsGroupMaxSet.idGroupMax = pProperties->idGroupMax;
3740       Worker_DoTask (wtaskPtsGroupMaxSet, &wp, &status);
3741       }
3742
3743    if (pStatus && !rc)