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