windows-winlogon-logon-event-20050414
[openafs.git] / src / WINNT / client_exp / gui2fs.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 "stdafx.h"
16 #include <errno.h>
17 #include <time.h>
18
19 #include "gui2fs.h"
20 #include "msgs.h"
21 #include "results_dlg.h"
22 #include "volume_inf.h"
23 #include "mount_points_dlg.h"
24 #include "hourglass.h"
25 #include "down_servers_dlg.h"
26
27 extern "C" {
28 #include <afs/param.h>
29 #include <osi.h>
30 #include "fs.h"
31 #include "fs_utils.h"
32 #include <afsint.h>
33 #include <afs/auth.h>
34 }
35
36
37 #define PCCHAR(str)             ((char *)(const char *)(str))
38
39
40 #define MAXHOSTS 13
41 #define OMAXHOSTS 8
42 #define MAXNAME 100
43 #define MAXSIZE 2048
44 #define MAXINSIZE 1300    /* pioctl complains if data is larger than this */
45 #define VMSGSIZE 128      /* size of msg buf in volume hdr */
46
47 #define MAXCELLCHARS            64
48 #define MAXHOSTCHARS            64
49 #define MAXHOSTSPERCELL         8
50
51 struct afsconf_cell {
52         char name[MAXCELLCHARS];
53     short numServers;
54     short flags;
55     struct sockaddr_in hostAddr[MAXHOSTSPERCELL];
56     char hostName[MAXHOSTSPERCELL][MAXHOSTCHARS];
57     char *linkedCell;
58 };
59
60 static char space[MAXSIZE];
61 static char tspace[1024];
62
63 // #define      LOGGING_ON              // Enable this to log certain pioctl calls
64
65 #ifdef  LOGGING_ON
66 static char *szLogFileName = "afsguilog.txt";
67 #endif
68
69
70 FILE *OpenFile(char *file, char *rwp)
71 {
72     char wdir[256];
73     long code;
74     long tlen;
75     FILE *fp;
76
77     code = GetWindowsDirectory(wdir, sizeof(wdir));
78     if (code == 0 || code > sizeof(wdir)) 
79         return FALSE;
80
81     /* add trailing backslash, if required */
82     tlen = strlen(wdir);
83     if (wdir[tlen - 1] != '\\')
84         strcat(wdir, "\\");
85
86     strcat(wdir, file);
87
88     fp = fopen(wdir, rwp);
89
90     return fp;
91 }       
92
93 CString StripPath(CString& strPath)
94 {
95     int nIndex = strPath.ReverseFind('\\');
96
97     CString strFile = strPath.Mid(nIndex + 1);
98     if (strFile.IsEmpty())
99         return strPath;
100
101     return strFile;
102 }
103
104 CStringArray& StripPath(CStringArray& files)
105 {
106     for (int i = 0; i < files.GetSize(); i++)
107         files[i] = StripPath(files[i]);
108
109     return files;
110 }
111
112 void Flush(const CStringArray& files)
113 {
114     register LONG code;
115     struct ViceIoctl blob;
116     int error = 0;
117
118     HOURGLASS hourglass;
119
120     for (int i = 0; i < files.GetSize(); i++) {
121         blob.in_size = blob.out_size = 0;
122
123         code = pioctl(PCCHAR(files[i]), VIOCFLUSH, &blob, 0);
124         if (code) {
125             error = 1;
126             if (errno == EMFILE)
127                 ShowMessageBox(IDS_FLUSH_FAILED, MB_ICONEXCLAMATION, IDS_FLUSH_FAILED, files[i]);
128             else 
129                 ShowMessageBox(IDS_FLUSH_ERROR, MB_ICONEXCLAMATION, IDS_FLUSH_ERROR, files[i], strerror(errno));
130         }
131     }   
132
133     if (!error)
134         ShowMessageBox(IDS_FLUSH_OK, MB_ICONEXCLAMATION, IDS_FLUSH_OK);
135 }       
136
137 void FlushVolume(const CStringArray& files)
138 {
139     register LONG code;
140     struct ViceIoctl blob;
141     int error = 0;
142
143     HOURGLASS hourglass;
144
145     for (int i = 0; i < files.GetSize(); i++) {
146         blob.in_size = blob.out_size = 0;
147
148         code = pioctl(PCCHAR(files[i]), VIOC_FLUSHVOLUME, &blob, 0);
149         if (code) {
150             error = 1;
151             ShowMessageBox(IDS_FLUSH_VOLUME_ERROR, MB_ICONEXCLAMATION, IDS_FLUSH_VOLUME_ERROR, files[i], strerror(errno));
152         }
153     }   
154
155     if (!code)
156         ShowMessageBox(IDS_FLUSH_VOLUME_OK, MB_ICONEXCLAMATION, IDS_FLUSH_VOLUME_OK);
157 }       
158
159 void WhichCell(CStringArray& files)
160 {
161     register LONG code;
162     struct ViceIoctl blob;
163     int error;
164     CString str;
165     CString str2;
166
167     CStringArray results;
168
169     error = 0;
170
171     HOURGLASS hourglass;
172
173     for (int i = 0; i < files.GetSize(); i++) {
174         blob.in_size = 0;
175         blob.out_size = MAXSIZE;
176         blob.out = space;
177
178         code = pioctl(PCCHAR(files[i]), VIOC_FILE_CELL_NAME, &blob, 1);
179         if (code) {
180             if (code == ENOENT) {
181                 LoadString (str, IDS_CANT_GET_CELL);
182                 results.Add(str);
183             } else
184                 results.Add(GetAfsError(errno));
185         } else
186             results.Add(space);
187     }       
188
189     LoadString (str, IDS_SHOW_CELL);
190     LoadString (str2, IDS_SHOW_CELL_COLUMN);
191     CResultsDlg dlg(SHOW_CELL_HELP_ID);
192     dlg.SetContents(str, str2, StripPath(files), results);
193     dlg.DoModal();
194 }
195
196 void WSCellCmd()
197 {
198     register LONG code;
199     struct ViceIoctl blob;
200     
201     HOURGLASS hourglass;
202
203     blob.in_size = 0;
204     blob.in = (char *) 0;
205     blob.out_size = MAXSIZE;
206     blob.out = space;
207
208     code = pioctl((char *) 0, VIOC_GET_WS_CELL, &blob, 1);
209
210     if (code) {
211         //Die(errno, (char *) 0);
212     }
213     //else
214     //printf("This workstation belongs to cell '%s'\n", space);
215 }
216
217 BOOL CheckVolumes()
218 {
219     register LONG code;
220     struct ViceIoctl blob;
221     
222     blob.in_size = 0;
223     blob.out_size = 0;
224     code = pioctl(0, VIOCCKBACK, &blob, 1);
225     if (code) {
226         ShowMessageBox(IDS_CHECK_VOLUMES_ERROR, MB_ICONEXCLAMATION, IDS_CHECK_VOLUMES_ERROR, GetAfsError(errno, CString()));
227         return FALSE;
228     }
229
230     ShowMessageBox(IDS_CHECK_VOLUMES_OK, MB_OK, IDS_CHECK_VOLUMES_OK);
231
232     return TRUE;
233 }
234
235 void SetCacheSizeCmd(LONG nNewCacheSize)
236 {
237     register LONG code;
238     struct ViceIoctl blob;
239     
240     HOURGLASS hourglass;
241
242     blob.in = (char *) &nNewCacheSize;
243     blob.in_size = sizeof(LONG);
244     blob.out_size = 0;
245
246     code = pioctl(0, VIOCSETCACHESIZE, &blob, 1);
247     //if (code)
248     //  Die(errno, (char *) 0);
249     //else
250     //  printf("New cache size set.\n");
251 }
252
253 void WhereIs(CStringArray& files)
254 {
255     register LONG code;
256     struct ViceIoctl blob;
257     CStringArray servers;
258     CStringArray resultFiles;
259     CString str;
260     CString str2;
261
262     HOURGLASS hourglass;
263
264     for (int i = 0; i < files.GetSize(); i++) {
265         blob.out_size = MAXSIZE;
266         blob.in_size = 0;
267         blob.out = space;
268         memset(space, 0, sizeof(space));
269
270         code = pioctl(PCCHAR(files[i]), VIOCWHEREIS, &blob, 1);
271         if (code) {
272             resultFiles.Add(StripPath(files[i]));
273             servers.Add(GetAfsError(errno));
274             continue;
275         }
276
277         LONG *hosts = (LONG *)space;
278         BOOL bFirst = TRUE;
279         str = "";
280
281         for (int j = 0; j < MAXHOSTS; j++) {
282             if (hosts[j] == 0)
283                 break;
284             char *hostName = hostutil_GetNameByINet(hosts[j]);
285             if (bFirst) {
286                 resultFiles.Add(StripPath(files[i]));
287                 bFirst = FALSE;
288             } else
289                 resultFiles.Add(" ");
290             servers.Add(hostName);
291         }
292     }
293
294     LoadString (str, IDS_SHOW_FS);
295     LoadString (str2, IDS_SHOW_FS_COLUMN);
296     CResultsDlg dlg(SHOW_FILE_SERVERS_HELP_ID);
297     dlg.SetContents(str, str2, resultFiles, servers);
298     dlg.DoModal();
299 }       
300
301 CString GetAfsError(int code, const char *filename)
302 {
303     CString strMsg;
304
305     if (code == EINVAL) {
306         if (filename)
307             strMsg.Format("Invalid argument; it is possible that the file is not in AFS");
308         else 
309             strMsg.Format("Invalid argument");
310     } else if (code == ENOENT) {
311         if (filename) 
312             strMsg.Format("The file does not exist");
313         else 
314             strMsg.Format("No such file returned");
315     } else if (code == EROFS)  {
316         strMsg.Format("You can not change a backup or readonly volume");
317     } else if (code == EACCES || code == EPERM) {
318         strMsg.Format("You do not have the required rights to do this operation");
319     } else if (code == ENODEV) {
320         strMsg.Format("AFS service may not have started");
321     } else if (code == ESRCH) {
322         strMsg.Format("Cell name not recognized");
323     } else if (code == ETIMEDOUT) {
324         strMsg.Format("Connection timed out");
325     } else if (code == EPIPE) {
326         strMsg.Format("Volume name or ID not recognized");
327     } else {
328         strMsg.Format("Error 0x%x occurred", code);
329     }
330
331     return strMsg;
332 }
333
334
335 /************************************************************************
336 ************************** ACL Code *************************************
337 ************************************************************************/
338
339 typedef char sec_rgy_name_t[1025];      /* A DCE definition */
340
341 struct AclEntry {
342     struct AclEntry *next;
343     char name[MAXNAME];
344     LONG rights;
345 };
346
347 struct Acl {
348     int dfs;                    //      Originally true if a dfs acl; now also the type
349                                 //      of the acl (1, 2, or 3, corresponding to object,
350                                 //      initial dir, or initial object).
351     sec_rgy_name_t cell;        //      DFS cell name
352     int nplus;
353     int nminus;
354     struct AclEntry *pluslist;
355     struct AclEntry *minuslist;
356 };
357
358 int foldcmp (register char *a, register char *b)
359 {
360     register char t, u;
361     while (1) {
362         t = *a++;
363         u = *b++;
364         if (t >= 'A' && t <= 'Z') t += 0x20;
365         if (u >= 'A' && u <= 'Z') u += 0x20;
366         if (t != u) return 1;
367         if (t == 0) return 0;
368     }
369 }
370
371 extern "C" void ZapList(struct AclEntry *alist)
372 {
373     register struct AclEntry *tp, *np;
374
375     for (tp = alist; tp; tp = np) {
376         np = tp->next;
377         free(tp);
378     }
379 }
380
381 extern "C" void ZapAcl (struct Acl *acl)
382 {
383     ZapList(acl->pluslist);
384     ZapList(acl->minuslist);
385     free(acl);
386 }
387
388 extern "C" int PruneList (struct AclEntry **ae, int dfs)
389 {
390     struct AclEntry **lp = ae;
391     struct AclEntry *te, *ne;
392     LONG ctr = 0;
393     
394     for (te = *ae; te; te = ne) {
395         if ((!dfs && te->rights == 0) || te->rights == -1) {
396             *lp = te->next;
397             ne = te->next;
398             free(te);
399             ctr++;
400         }
401         else {
402             ne = te->next;
403             lp = &te->next;
404         }
405     }
406     
407     return ctr;
408 }
409
410 char *SkipLine (register char *astr)
411 {
412     while (*astr != '\n') 
413         astr++;
414     
415     astr++;
416     
417     return astr;
418 }
419
420 /* tell if a name is 23 or -45 (digits or minus digits), which are bad names we must prune */
421 static BadName(register char *aname)
422 {
423     register int tc;
424
425     /* all must be '-' or digit to be bad */
426     while (tc = *aname++) {
427         if ((tc != '-') && (tc < '0' || tc > '9')) 
428             return 0;
429     }
430
431     return 1;
432 }
433
434 CString GetRightsString(register LONG arights, int dfs)
435 {
436     CString str;
437
438     if (!dfs) {
439         if (arights & PRSFS_READ) str += "r";
440         if (arights & PRSFS_LOOKUP) str += "l";
441         if (arights & PRSFS_INSERT) str += "i";
442         if (arights & PRSFS_DELETE) str += "d";
443         if (arights & PRSFS_WRITE) str += "w";
444         if (arights & PRSFS_LOCK) str += "k";
445         if (arights & PRSFS_ADMINISTER) str += "a";
446     } else {
447         ASSERT(FALSE);
448 /*
449                 if (arights & DFS_READ) str += "r"; else str += "-";
450                 if (arights & DFS_WRITE) str += "w"; else printf("-");
451                 if (arights & DFS_EXECUTE) str += "x"; else printf("-");
452                 if (arights & DFS_CONTROL) str += "c"; else printf("-");
453                 if (arights & DFS_INSERT) str += "i"; else printf("-");
454                 if (arights & DFS_DELETE) str += "d"; else printf("-");
455                 if (arights & (DFS_USRALL)) str += "+";
456 */
457     }   
458
459     return str;
460 }
461
462 char *AclToString(struct Acl *acl)
463 {
464     static char mydata[MAXSIZE];
465     char tstring[MAXSIZE];
466     char dfsstring[30];
467     struct AclEntry *tp;
468     
469     if (acl->dfs)
470         sprintf(dfsstring, " dfs:%d %s", acl->dfs, acl->cell);
471     else
472         dfsstring[0] = '\0';
473     sprintf(mydata, "%d%s\n%d\n", acl->nplus, dfsstring, acl->nminus);
474     
475     for(tp = acl->pluslist; tp; tp = tp->next) {
476         sprintf(tstring, "%s %d\n", tp->name, tp->rights);
477         strcat(mydata, tstring);
478     }
479     
480     for(tp = acl->minuslist; tp; tp = tp->next) {
481         sprintf(tstring, "%s %d\n", tp->name, tp->rights);
482         strcat(mydata, tstring);
483     }
484     
485     return mydata;
486 }
487
488 struct Acl *EmptyAcl(const CString& strCellName)
489 {
490     register struct Acl *tp;
491     
492     tp = (struct Acl *)malloc(sizeof (struct Acl));
493     tp->nplus = tp->nminus = 0;
494     tp->pluslist = tp->minuslist = 0;
495     tp->dfs = 0;
496     strcpy(tp->cell, strCellName);
497
498     return tp;
499 }
500
501 struct Acl *ParseAcl(char *astr)
502 {
503     int nplus, nminus, i, trights;
504     char tname[MAXNAME];
505     struct AclEntry *first, *last, *tl;
506     struct Acl *ta;
507
508     ta = (struct Acl *) malloc (sizeof (struct Acl));
509     ta->dfs = 0;
510     sscanf(astr, "%d dfs:%d %s", &ta->nplus, &ta->dfs, ta->cell);
511     astr = SkipLine(astr);
512     sscanf(astr, "%d", &ta->nminus);
513     astr = SkipLine(astr);
514
515     nplus = ta->nplus;
516     nminus = ta->nminus;
517
518     last = 0;
519     first = 0;
520     for(i = 0; i < nplus; i++) {
521         sscanf(astr, "%100s %d", tname, &trights);
522         astr = SkipLine(astr);
523         tl = (struct AclEntry *) malloc(sizeof (struct AclEntry));
524         if (!first)
525                         first = tl;
526         strcpy(tl->name, tname);
527         tl->rights = trights;
528         tl->next = 0;
529         if (last)
530                         last->next = tl;
531         last = tl;
532     }
533     ta->pluslist = first;
534
535     last = 0;
536     first = 0;
537     for(i=0; i < nminus; i++) {
538         sscanf(astr, "%100s %d", tname, &trights);
539         astr = SkipLine(astr);
540         tl = (struct AclEntry *) malloc(sizeof (struct AclEntry));
541         if (!first) 
542                         first = tl;
543         strcpy(tl->name, tname);
544         tl->rights = trights;
545         tl->next = 0;
546         if (last) 
547                         last->next = tl;
548         last = tl;
549     }
550     ta->minuslist = first;
551
552     return ta;
553 }
554
555 /* clean up an access control list of its bad entries; return 1 if we made
556    any changes to the list, and 0 otherwise */
557 extern "C" int CleanAcl(struct Acl *aa)
558 {
559     register struct AclEntry *te, **le, *ne;
560     int changes;
561
562     HOURGLASS hourglass;
563
564     /* Don't correct DFS ACL's for now */
565     if (aa->dfs)
566         return 0;
567
568     /* prune out bad entries */
569     changes = 0;            /* count deleted entries */
570     le = &aa->pluslist;
571     for(te = aa->pluslist; te; te = ne) {
572         ne = te->next;
573         if (BadName(te->name)) {
574             /* zap this dude */
575             *le = te->next;
576             aa->nplus--;
577             free(te);
578             changes++;
579         }
580         else
581             le = &te->next;
582     }
583
584     le = &aa->minuslist;
585     
586     for(te = aa->minuslist; te; te = ne) {
587         ne = te->next;
588         if (BadName(te->name)) {
589             /* zap this dude */
590             *le = te->next;
591             aa->nminus--;
592             free(te);
593             changes++;
594         }
595         else
596             le = &te->next;
597     }   
598
599     return changes;
600 }
601
602 void CleanACL(CStringArray& names)
603 {
604     register LONG code;
605     register struct Acl *ta;
606     struct ViceIoctl blob;
607     int changes;
608
609     ShowMessageBox(IDS_CLEANACL_MSG, MB_OK, IDS_CLEANACL_MSG);
610
611     HOURGLASS hourglass;
612
613     for (int i = 0; i < names.GetSize(); i++) {
614         blob.out_size = MAXSIZE;
615         blob.in_size = 0;
616         blob.out = space;
617
618         code = pioctl(PCCHAR(names[i]), VIOCGETAL, &blob, 1);
619         if (code) {
620             ShowMessageBox(IDS_CLEANACL_ERROR, MB_ICONEXCLAMATION, 0, names[i], GetAfsError(errno));
621             continue;
622         }
623
624         ta = ParseAcl(space);
625         if (ta->dfs) {
626             ShowMessageBox(IDS_CLEANACL_NOT_SUPPORTED, MB_ICONEXCLAMATION, IDS_CLEANACL_NOT_SUPPORTED, names[i]);
627             continue;
628         }
629
630         changes = CleanAcl(ta);
631         if (!changes)
632             continue;
633
634         /* now set the acl */
635         blob.in = AclToString(ta);
636         blob.in_size = strlen((char *)blob.in) + 1;
637         blob.out_size = 0;
638                 
639         code = pioctl(PCCHAR(names[i]), VIOCSETAL, &blob, 1);
640         if (code) {
641             if (errno == EINVAL) {
642                 ShowMessageBox(IDS_CLEANACL_INVALID_ARG, MB_ICONEXCLAMATION, IDS_CLEANACL_INVALID_ARG, names[i]);
643                 continue;
644             }
645             else {
646                 ShowMessageBox(IDS_CLEANACL_ERROR, MB_ICONEXCLAMATION, 0, names[i], GetAfsError(errno));
647                 continue;
648             }
649         }
650     }
651 }       
652
653 // Derived from fs.c's ListAclCmd
654 BOOL GetRights(const CString& strDir, CStringArray& strNormal, CStringArray& strNegative)
655 {
656     register LONG code;
657     register struct Acl *ta;
658     struct ViceIoctl blob;
659     struct AclEntry *te;
660     int idf = 0; //getidf(as, parm_listacl_id);
661
662     HOURGLASS hourglass;
663
664     blob.out_size = MAXSIZE;
665     blob.in_size = idf;
666     blob.in = blob.out = space;
667         
668     code = pioctl(PCCHAR(strDir), VIOCGETAL, &blob, 1);
669     if (code) {
670         ShowMessageBox(IDS_GETRIGHTS_ERROR, MB_ICONEXCLAMATION, IDS_GETRIGHTS_ERROR, strDir, GetAfsError(errno));
671         return FALSE;
672     }
673
674     ta = ParseAcl(space);
675     if (ta->dfs) {
676         ShowMessageBox(IDS_DFSACL_ERROR, MB_ICONEXCLAMATION, IDS_DFSACL_ERROR);
677         return FALSE;
678     }
679
680 //      if (ta->dfs)
681 //              printf("  Default cell = %s\n", ta->cell);
682
683     CString strRight;
684
685     if (ta->nplus > 0) {
686         for (te = ta->pluslist; te; te = te->next) {
687             strNormal.Add(te->name);
688             strNormal.Add(GetRightsString(te->rights, ta->dfs));
689         }
690     }
691
692     if (ta->nminus > 0) {
693         for (te = ta->minuslist; te; te = te->next) {
694             strNegative.Add(te->name);
695             strNegative.Add(GetRightsString(te->rights, ta->dfs));
696         }
697     }
698
699     return TRUE;
700 }
701
702 struct AclEntry *FindList(register struct AclEntry *pCurEntry, const char *entryName)
703 {
704     while (pCurEntry) {
705         if (!foldcmp(pCurEntry->name, PCCHAR(entryName)))
706             return pCurEntry;
707         pCurEntry = pCurEntry->next;
708     }
709     
710     return 0;
711 }
712
713 void ChangeList (struct Acl *pAcl, BYTE bNormalRights, const char *entryName, LONG nEntryRights)
714 {
715     ASSERT(pAcl);
716     ASSERT(entryName);
717     
718     struct AclEntry *pEntry;
719
720     HOURGLASS hourglass;
721
722     pEntry = (bNormalRights ? pAcl->pluslist : pAcl->minuslist);
723     pEntry = FindList(pEntry, entryName);
724
725     /* Found the item already in the list. */
726     if (pEntry) {
727         pEntry->rights = nEntryRights;
728         if (bNormalRights)
729             pAcl->nplus -= PruneList(&pAcl->pluslist, pAcl->dfs);
730         else
731             pAcl->nminus -= PruneList(&pAcl->minuslist, pAcl->dfs);
732         return;
733     }
734
735     /* Otherwise we make a new item and plug in the new data. */
736     pEntry = (struct AclEntry *) malloc(sizeof (struct AclEntry));
737     ASSERT(pEntry);
738         
739     strcpy(pEntry->name, entryName);
740     pEntry->rights = nEntryRights;
741     
742     if (bNormalRights) {
743         pEntry->next = pAcl->pluslist;
744         pAcl->pluslist = pEntry;
745         pAcl->nplus++;
746         if (nEntryRights == 0 || nEntryRights == -1)
747             pAcl->nplus -= PruneList(&pAcl->pluslist, pAcl->dfs);
748     }
749     else {
750         pEntry->next = pAcl->minuslist;
751         pAcl->minuslist = pEntry;
752         pAcl->nminus++;
753         if (nEntryRights == 0)
754             pAcl->nminus -= PruneList(&pAcl->minuslist, pAcl->dfs);
755     }
756 }
757
758 enum rtype {add, destroy, deny};
759
760 LONG Convert(const register char *arights, int dfs, enum rtype *rtypep)
761 {
762     register int i, len;
763     LONG mode;
764     register char tc;
765
766     *rtypep = add;      /* add rights, by default */
767
768     if (!strcmp(arights,"read")) 
769         return PRSFS_READ | PRSFS_LOOKUP;
770     if (!strcmp(arights, "write")) 
771         return PRSFS_READ | PRSFS_LOOKUP | PRSFS_INSERT | PRSFS_DELETE | PRSFS_WRITE | PRSFS_LOCK;
772     if (!strcmp(arights, "mail")) 
773         return PRSFS_INSERT | PRSFS_LOCK | PRSFS_LOOKUP;
774     if (!strcmp(arights, "all")) 
775         return PRSFS_READ | PRSFS_LOOKUP | PRSFS_INSERT | PRSFS_DELETE | PRSFS_WRITE | PRSFS_LOCK | PRSFS_ADMINISTER;
776     
777     if (!strcmp(arights, "none")) {
778         *rtypep = destroy; /* Remove entire entry */
779         return 0;
780     }
781
782     len = strlen(arights);
783     mode = 0;
784
785     for (i = 0; i < len; i++) {
786         tc = *arights++;
787         if (tc == 'r') mode |= PRSFS_READ;
788         else if (tc == 'l') mode |= PRSFS_LOOKUP;
789         else if (tc == 'i') mode |= PRSFS_INSERT;
790         else if (tc == 'd') mode |= PRSFS_DELETE;
791         else if (tc == 'w') mode |= PRSFS_WRITE;
792         else if (tc == 'k') mode |= PRSFS_LOCK;
793         else if (tc == 'a') mode |= PRSFS_ADMINISTER;
794         else {
795             fprintf(stderr, "illegal rights character '%c'.\n", tc);
796             exit(1);
797         }
798     }   
799     return mode;
800 }
801
802 BOOL SaveACL(const CString& strCellName, const CString& strDir, const CStringArray& normal, const CStringArray& negative)
803 {
804     register LONG code;
805     struct ViceIoctl blob;
806     struct Acl *pAcl;
807     LONG rights;
808     enum rtype rtype;
809
810     HOURGLASS hourglass;
811
812     // Create a new ACL
813     pAcl = EmptyAcl(strCellName);
814
815     // Set its normal rights
816     for (int i = 0; i < normal.GetSize(); i += 2) {
817         rights = Convert(normal[i + 1], 0, &rtype);
818         ChangeList(pAcl, TRUE, normal[i], rights);
819     }
820
821     // Set its negative rights
822     for (i = 0; i < negative.GetSize(); i += 2) {
823         rights = Convert(negative[i + 1], 0, &rtype);
824         ChangeList(pAcl, FALSE, negative[i], rights);
825     }
826
827     // Write the ACL
828     blob.in = AclToString(pAcl);
829     blob.out_size = 0;
830     blob.in_size = 1 + strlen((const char *)blob.in);
831
832     code = pioctl(PCCHAR(strDir), VIOCSETAL, &blob, 1);
833     if (code) {
834         if (errno == EINVAL)
835             ShowMessageBox(IDS_SAVE_ACL_EINVAL_ERROR, MB_ICONEXCLAMATION, IDS_SAVE_ACL_EINVAL_ERROR, strDir);
836         else
837             ShowMessageBox(IDS_SAVE_ACL_ERROR, MB_ICONEXCLAMATION, IDS_SAVE_ACL_ERROR, strDir, GetAfsError(errno, strDir));
838     }       
839
840     ZapAcl(pAcl);
841
842     return (code == 0);
843 }
844
845 BOOL CopyACL(const CString& strToDir, const CStringArray& normal, const CStringArray& negative, BOOL bClear)
846 {
847     register LONG code;
848     struct ViceIoctl blob;
849     struct Acl *pToAcl;
850     int idf = 0; // getidf(as, parm_copyacl_id);
851
852     HOURGLASS hourglass;
853
854     // Get ACL to copy to
855     blob.out_size = MAXSIZE;
856     blob.in_size = idf;
857     blob.in = blob.out = space;
858         
859     code = pioctl(PCCHAR(strToDir), VIOCGETAL, &blob, 1);
860     if (code) {
861         ShowMessageBox(IDS_ACL_READ_ERROR, MB_ICONEXCLAMATION, IDS_ACL_READ_ERROR, strToDir, GetAfsError(errno, strToDir));
862         return FALSE;
863     }
864         
865     if (bClear) 
866         pToAcl = EmptyAcl(space);
867     else 
868         pToAcl = ParseAcl(space);
869
870     CleanAcl(pToAcl);
871
872     if (pToAcl->dfs) {
873         ShowMessageBox(IDS_NO_DFS_COPY_ACL, MB_ICONEXCLAMATION, IDS_NO_DFS_COPY_ACL, strToDir);
874         ZapAcl(pToAcl);
875         return FALSE;
876     }
877
878     enum rtype rtype;
879
880     // Set normal rights
881     for (int i = 0; i < normal.GetSize(); i += 2) {
882         LONG rights = Convert(normal[i + 1], 0, &rtype);
883         ChangeList(pToAcl, TRUE, normal[i], rights);
884     }
885
886     // Set negative rights
887     for (i = 0; i < negative.GetSize(); i += 2) {
888         LONG rights = Convert(negative[i + 1], 0, &rtype);
889         ChangeList(pToAcl, FALSE, normal[i], rights);
890     }
891
892     // Save modified ACL
893     blob.in = AclToString(pToAcl);
894     blob.out_size = 0;
895     blob.in_size = 1 + strlen((char *)blob.in);
896
897     code = pioctl(PCCHAR(strToDir), VIOCSETAL, &blob, 1);
898     if (code) {
899         ZapAcl(pToAcl);
900         if (errno == EINVAL)
901             ShowMessageBox(IDS_COPY_ACL_EINVAL_ERROR, MB_ICONEXCLAMATION, IDS_COPY_ACL_EINVAL_ERROR, strToDir);
902         else 
903             ShowMessageBox(IDS_COPY_ACL_ERROR, MB_ICONEXCLAMATION, IDS_COPY_ACL_ERROR, strToDir, GetAfsError(errno, strToDir));
904         return FALSE;
905     }
906
907     ZapAcl(pToAcl);
908
909     ShowMessageBox(IDS_COPY_ACL_OK, MB_OK, IDS_COPY_ACL_OK);
910
911     return TRUE;
912 }
913
914 CString ParseMountPoint(const CString strFile, CString strMountPoint)
915 {
916     CString strType;
917     CString strVolume;
918     CString strCell;
919     CString strMountPointInfo;
920
921     if (strMountPoint[0] == '#')
922         strType = "Regular";
923     else if (strMountPoint[0] == '%')
924         strType = "Read/Write";
925
926     int nColon = strMountPoint.Find(':');
927     if (nColon >= 0) {
928         strCell = strMountPoint.Mid(1, nColon - 1);
929         strVolume = strMountPoint.Mid(nColon + 1);
930     } else
931         strVolume = strMountPoint.Mid(1);
932
933     strMountPointInfo = strFile + "\t" + strVolume + "\t" + strCell + "\t" + strType;
934
935     return strMountPointInfo;
936 }       
937
938 BOOL ListMount(CStringArray& files)
939 {
940     register LONG code;
941     struct ViceIoctl blob;
942     int error;
943     char orig_name[1024];                       /* Original name, may be modified */
944     char true_name[1024];                       /* ``True'' dirname (e.g., symlink target) */
945     char parent_dir[1024];                      /* Parent directory of true name */
946     register char *last_component;      /* Last component of true name */
947     CStringArray mountPoints;
948     
949     HOURGLASS hourglass;
950
951     error = 0;
952
953     for (int i = 0; i < files.GetSize(); i++) {
954         strcpy(orig_name, files[i]);
955         strcpy(true_name, orig_name);
956
957         /*
958          * Find rightmost slash, if any.
959          */
960         last_component = (char *)strrchr(true_name, '\\');
961         if (last_component) {
962             /*
963              * Found it.  Designate everything before it as the parent directory,
964              * everything after it as the final component.
965              */
966             strncpy(parent_dir, true_name, last_component - true_name + 1);
967             parent_dir[last_component - true_name + 1] = 0;
968             last_component++;   /* Skip the slash */
969         }
970         else {
971             /*
972              * No slash appears in the given file name.  Set parent_dir to the current
973              * directory, and the last component as the given name.
974              */
975             fs_ExtractDriveLetter(true_name, parent_dir);
976             strcat(parent_dir, ".");
977             last_component = true_name;
978             fs_StripDriveLetter(true_name, true_name, sizeof(true_name));
979         }
980
981         blob.in = last_component;
982         blob.in_size = strlen(last_component) + 1;
983         blob.out_size = MAXSIZE;
984         blob.out = space;
985         memset(space, 0, MAXSIZE);
986
987         code = pioctl(parent_dir, VIOC_AFS_STAT_MT_PT, &blob, 1);
988         if (code == 0) {
989             int nPos = strlen(space) - 1;
990             if (space[nPos] == '.')
991                 space[nPos] = 0;
992             mountPoints.Add(ParseMountPoint(StripPath(files[i]), space));
993         } else {
994             error = 1;
995             if (errno == EINVAL)
996                 mountPoints.Add(GetMessageString(IDS_NOT_MOUNT_POINT_ERROR, StripPath(files[i])));
997             else
998                 mountPoints.Add(GetMessageString(IDS_LIST_MOUNT_POINT_ERROR, GetAfsError(errno, StripPath(files[i]))));
999         }
1000     }
1001
1002     CMountPointsDlg dlg;
1003     dlg.SetMountPoints(mountPoints);
1004     dlg.DoModal();
1005
1006     return !error;
1007 }
1008
1009 BOOL IsPathInAfs(const CHAR *strPath)
1010 {
1011     struct ViceIoctl blob;
1012     int code;
1013
1014     HOURGLASS hourglass;
1015
1016     blob.in_size = 0;
1017     blob.out_size = MAXSIZE;
1018     blob.out = space;
1019
1020     code = pioctl((LPTSTR)((LPCTSTR)strPath), VIOC_FILE_CELL_NAME, &blob, 1);
1021     if (code)
1022         return FALSE;
1023     return TRUE;
1024 }
1025
1026 /* return a static pointer to a buffer */
1027 static char *Parent(char *apath)
1028 {
1029     register char *tp;
1030
1031     strcpy(tspace, apath);
1032     tp = strrchr(tspace, '\\');
1033     if (tp) {
1034         *(tp+1) = 0;    /* lv trailing slash so Parent("k:\foo") is "k:\" not "k:" */
1035     }
1036     else {
1037         fs_ExtractDriveLetter(apath, tspace);
1038         strcat(tspace, ".");
1039     }
1040     
1041     return tspace;
1042 }
1043
1044 BOOL MakeMount(const CString& strDir, const CString& strVolName, const CString& strCellName, BOOL bRW)
1045 {
1046     register LONG code;
1047     register char *cellName;
1048     char localCellName[1000];
1049     struct ViceIoctl blob;
1050
1051     HOURGLASS hourglass;
1052
1053     ASSERT(strVolName.GetLength() < 64);
1054
1055     /*
1056
1057     defect #3069
1058
1059     if (as->parms[5].items && !as->parms[2].items) {
1060         fprintf(stderr,"fs: must provide cell when creating cellular mount point.\n");
1061         return FALSE;
1062     }
1063     */
1064
1065     if (strCellName.GetLength() > 0)    /* cell name specified */
1066         cellName = PCCHAR(strCellName);
1067     else
1068         cellName = (char *) 0;
1069
1070     if (!IsPathInAfs(Parent(PCCHAR(strDir)))) {
1071         ShowMessageBox(IDS_MAKE_MP_NOT_AFS_ERROR, MB_ICONEXCLAMATION, IDS_MAKE_MP_NOT_AFS_ERROR);
1072         return FALSE;
1073     }
1074
1075     if (cellName) {
1076         blob.in_size = 0;
1077         blob.out_size = MAXSIZE;
1078         blob.out = space;
1079         code = pioctl(Parent(PCCHAR(strDir)), VIOC_FILE_CELL_NAME, &blob, 1);
1080     }   
1081
1082     strcpy(localCellName, (cellName? cellName : space));
1083
1084     if (bRW)    /* if -rw specified */
1085         strcpy(space, "%");
1086     else
1087         strcpy(space, "#");
1088
1089     /* If cellular mount point, prepend cell prefix */
1090     if (cellName) {
1091         strcat(space, localCellName);
1092         strcat(space, ":");
1093     }   
1094
1095     strcat(space, strVolName);  /* append volume name */
1096     strcat(space, ".");         /* stupid convention; these end with a period */
1097
1098     /* create symlink with a special pioctl for Windows NT, since it doesn't
1099      * have a symlink system call.
1100      */
1101     blob.out_size = 0;
1102     blob.in_size = 1 + strlen(space);
1103     blob.in = space;
1104     blob.out = NULL;
1105     code = pioctl(PCCHAR(strDir), VIOC_AFS_CREATE_MT_PT, &blob, 0);
1106
1107     if (code) {
1108         ShowMessageBox(IDS_MOUNT_POINT_ERROR, MB_ICONEXCLAMATION, IDS_MOUNT_POINT_ERROR, GetAfsError(errno, strDir));
1109         return FALSE;
1110     }
1111     
1112     return TRUE;
1113 }
1114
1115 /*
1116 */
1117 long fs_ExtractDriveLetter(const char *inPathp, char *outPathp)
1118 {
1119     if (inPathp[0] != 0 && inPathp[1] == ':') {
1120         /* there is a drive letter */
1121         *outPathp++ = *inPathp++;
1122         *outPathp++ = *inPathp++;
1123         *outPathp++ = 0;
1124     }
1125     else *outPathp = 0;
1126
1127     return 0;
1128 }       
1129
1130 /* strip the drive letter from a component */
1131 long fs_StripDriveLetter(const char *inPathp, char *outPathp, long outSize)
1132 {
1133     char tempBuffer[1000];
1134     strcpy(tempBuffer, inPathp);
1135     if (tempBuffer[0] != 0 && tempBuffer[1] == ':') {
1136         /* drive letter present */
1137         strcpy(outPathp, tempBuffer+2);
1138     }
1139     else {
1140         /* no drive letter present */
1141         strcpy(outPathp, tempBuffer);
1142     }
1143     return 0;
1144 }       
1145
1146
1147 BOOL RemoveSymlink(const char * linkName)
1148 {
1149     BOOL error = FALSE;
1150     INT code=0;
1151     struct ViceIoctl blob;
1152     char tbuffer[1024];
1153     char lsbuffer[1024];
1154     char tpbuffer[1024];
1155     char *tp;
1156     
1157     HOURGLASS hourglass;
1158
1159     tp = (char *) strrchr(linkName, '\\');
1160     if (!tp)
1161         tp = (char *) strrchr(linkName, '/');
1162     if (tp) {
1163         strncpy(tbuffer, linkName, code=tp-linkName+1);  /* the dir name */
1164         tbuffer[code] = 0;
1165         tp++;   /* skip the slash */
1166     }
1167     else {
1168         fs_ExtractDriveLetter(linkName, tbuffer);
1169         strcat(tbuffer, ".");
1170         fs_StripDriveLetter(tp, tpbuffer, 0);
1171         tp=tpbuffer;
1172     }
1173     blob.in = tp;
1174     blob.in_size = strlen(tp)+1;
1175     blob.out = lsbuffer;
1176     blob.out_size = sizeof(lsbuffer);
1177     code = pioctl(tbuffer, VIOC_LISTSYMLINK, &blob, 0);
1178     if (code)
1179         return FALSE;
1180     blob.out_size = 0;
1181     blob.in = tp;
1182     blob.in_size = strlen(tp)+1;
1183     return (pioctl(tbuffer, VIOC_DELSYMLINK, &blob, 0)==0);
1184 }       
1185
1186 BOOL IsSymlink(const char * true_name)
1187 {
1188     char parent_dir[MAXSIZE];           /*Parent directory of true name*/
1189     char strip_name[MAXSIZE];
1190     struct ViceIoctl blob;
1191     char *last_component;
1192     int code;
1193
1194     HOURGLASS hourglass;
1195
1196     last_component = (char *) strrchr(true_name, '\\');
1197     if (!last_component)
1198         last_component = (char *) strrchr(true_name, '/');
1199     if (last_component) {
1200         /*
1201          * Found it.  Designate everything before it as the parent directory,
1202          * everything after it as the final component.
1203          */
1204         strncpy(parent_dir, true_name, last_component - true_name + 1);
1205         parent_dir[last_component - true_name + 1] = 0;
1206         last_component++;   /*Skip the slash*/
1207     }
1208     else {
1209         /*
1210          * No slash appears in the given file name.  Set parent_dir to the current
1211          * directory, and the last component as the given name.
1212          */
1213         fs_ExtractDriveLetter(true_name, parent_dir);
1214         strcat(parent_dir, ".");
1215         last_component = strip_name;
1216         fs_StripDriveLetter(true_name, strip_name, sizeof(strip_name));
1217     }
1218
1219     blob.in = last_component;
1220     blob.in_size = strlen(last_component)+1;
1221     blob.out_size = MAXSIZE;
1222     blob.out = space;
1223     memset(space, 0, MAXSIZE);
1224     code = pioctl(parent_dir, VIOC_LISTSYMLINK, &blob, 1);
1225     return (code==0);
1226 }       
1227
1228
1229 /*
1230  * Delete AFS mount points.  Variables are used as follows:
1231  *       tbuffer: Set to point to the null-terminated directory name of the mount point
1232  *          (or ``.'' if none is provided)
1233  *      tp: Set to point to the actual name of the mount point to nuke.
1234  */
1235 BOOL RemoveMount(CStringArray& files)
1236 {
1237     register LONG code = 0;
1238     struct ViceIoctl blob;
1239     char tbuffer[1024];
1240     char lsbuffer[1024];
1241     register char *tp;
1242     BOOL error = FALSE;
1243     CStringArray results;
1244     CString str;
1245     CString str2;
1246
1247     HOURGLASS hourglass;
1248
1249     for (int i = 0; i < files.GetSize(); i++) {
1250         char szCurItem[1024];
1251         strcpy(szCurItem, files[i]);
1252         
1253         tp = (char *)strrchr(szCurItem, '\\');
1254         if (tp) {
1255             strncpy(tbuffer, szCurItem, code = tp - szCurItem + 1);  /* the dir name */
1256             tbuffer[code] = 0;
1257             tp++;   /* skip the slash */
1258         } else {
1259             fs_ExtractDriveLetter(szCurItem, tbuffer);
1260             strcat(tbuffer, ".");
1261             tp = szCurItem;
1262             fs_StripDriveLetter(tp, tp, 0);
1263         }
1264
1265         blob.in = tp;
1266         blob.in_size = strlen(tp)+1;
1267         blob.out = lsbuffer;
1268         blob.out_size = sizeof(lsbuffer);
1269
1270         code = pioctl(tbuffer, VIOC_AFS_STAT_MT_PT, &blob, 0);
1271         if (code) {
1272             error = TRUE;
1273             if (errno == EINVAL)
1274                 results.Add(GetMessageString(IDS_NOT_MOUNT_POINT_ERROR, StripPath(files[i])));
1275             else
1276                 results.Add(GetMessageString(IDS_ERROR, GetAfsError(errno, StripPath(files[i]))));
1277             continue;   // don't bother trying
1278         }
1279
1280         blob.out_size = 0;
1281         blob.in = tp;
1282         blob.in_size = strlen(tp)+1;
1283
1284         code = pioctl(tbuffer, VIOC_AFS_DELETE_MT_PT, &blob, 0);
1285         if (code) {
1286             error = TRUE;
1287             results.Add(GetMessageString(IDS_ERROR, GetAfsError(errno, StripPath(files[i]))));
1288         } else
1289             results.Add(GetMessageString(IDS_DELETED));
1290     }   
1291
1292     LoadString (str, IDS_REMOVE_MP);
1293     LoadString (str2, IDS_REMOVE_MP_COLUMN);
1294     CResultsDlg dlg(REMOVE_MOUNT_POINTS_HELP_ID);
1295     dlg.SetContents(str, str2, StripPath(files), results);
1296     dlg.DoModal();
1297
1298     return !error;
1299 }
1300
1301 BOOL GetVolumeInfo(CString strFile, CVolInfo& volInfo)
1302 {
1303     register LONG code;
1304     struct ViceIoctl blob;
1305     struct VolumeStatus *status;
1306     char *name;
1307
1308     HOURGLASS hourglass;
1309
1310     volInfo.m_strFilePath = strFile;
1311     volInfo.m_strFileName = StripPath(strFile);
1312
1313     /*
1314         volInfo.m_strName = "VolumeName";
1315         volInfo.m_nID = 10;
1316         volInfo.m_nQuota = 20 * 1024 * 1024;
1317         volInfo.m_nNewQuota = volInfo.m_nQuota;
1318         volInfo.m_nUsed = volInfo.m_nQuota / 2;
1319         volInfo.m_nPartSize = 50 * 1024 * 1024;
1320         volInfo.m_nPartFree = 30 * 1024 * 1024;
1321         volInfo.m_nDup = -1;
1322         return TRUE;
1323      */
1324
1325     blob.out_size = MAXSIZE;
1326     blob.in_size = 0;
1327     blob.out = space;
1328
1329     code = pioctl(PCCHAR(strFile), VIOCGETVOLSTAT, &blob, 1);
1330     if (code) {
1331         volInfo.m_strErrorMsg = GetAfsError(errno, strFile);
1332         return FALSE;
1333     }
1334
1335     status = (VolumeStatus *)space;
1336     name = (char *)status + sizeof(*status);
1337
1338     volInfo.m_strName = name;
1339     volInfo.m_nID = status->Vid;
1340     volInfo.m_nQuota = status->MaxQuota;
1341     volInfo.m_nNewQuota = status->MaxQuota;
1342     volInfo.m_nUsed = status->BlocksInUse;
1343     volInfo.m_nPartSize = status->PartMaxBlocks;
1344     volInfo.m_nPartFree = status->PartBlocksAvail;
1345     volInfo.m_nDup = -1;
1346
1347     return TRUE;
1348 }
1349         
1350 BOOL SetVolInfo(CVolInfo& volInfo)
1351 {
1352     register LONG code;
1353     struct ViceIoctl blob;
1354     struct VolumeStatus *status;
1355     char *input;
1356
1357     HOURGLASS hourglass;
1358
1359     blob.out_size = MAXSIZE;
1360     blob.in_size = sizeof(*status) + 3; /* for the three terminating nulls */
1361     blob.out = space;
1362     blob.in = space;
1363
1364     status = (VolumeStatus *)space;
1365     status->MinQuota = -1;
1366     status->MaxQuota = volInfo.m_nNewQuota;
1367         
1368     input = (char *)status + sizeof(*status);
1369     *(input++) = '\0';  /* never set name: this call doesn't change vldb */
1370     *(input++) = '\0';  // No offmsg
1371     *(input++) = '\0';  // No motd
1372
1373 #ifdef LOGGING_ON
1374     FILE *fp = OpenFile(szLogFileName, "a");
1375     if (fp) {
1376         fprintf(fp, "\nSetVolInfo() pioctl parms:\n");
1377         fprintf(fp, "\tpathp = %s\n\topcode = VIOCSETVOLSTAT (%d)\n\tblobp = %ld\n", PCCHAR(volInfo.m_strFilePath), VIOCSETVOLSTAT, &blob);
1378         fprintf(fp, "\t\tblobp.in = %ld (VolumeStatus *status)\n\t\tblobp.in_size = %ld\n\t\tblobp.out = %ld ((VolumeStatus *status))\n\t\tblobp.out_size = %ld\n", blob.in, blob.in_size, blob.out, blob.out_size);
1379         fprintf(fp, "\t\t\tstatus->MinQuota = %ld\n", status->MinQuota);
1380         fprintf(fp, "\t\t\tstatus->MaxQuota = %ld\n", status->MaxQuota);
1381         fprintf(fp, "\t\t\tOther status fields aren't set\n");
1382         fprintf(fp, "\t\t\t3 nulls follow the VolumeStatus structure.\n");
1383         fprintf(fp, "\tfollow = 1\n");
1384         fclose(fp);             
1385     }
1386 #endif
1387
1388     code = pioctl(PCCHAR(volInfo.m_strFilePath), VIOCSETVOLSTAT, &blob, 1);
1389     if (code) {
1390         ShowMessageBox(IDS_SET_QUOTA_ERROR, MB_ICONEXCLAMATION, IDS_SET_QUOTA_ERROR, GetAfsError(errno, volInfo.m_strName));
1391         return FALSE;
1392     }
1393
1394     return TRUE;
1395 }
1396
1397 int GetCellName(char *cellNamep, struct afsconf_cell *infop)
1398 {
1399     strcpy(infop->name, cellNamep);
1400     return 0;
1401 }
1402
1403 BOOL CheckServers(const CString& strCellName, WHICH_CELLS nCellsToCheck, BOOL bFast)
1404 {
1405     register LONG code;
1406     struct ViceIoctl blob;
1407     register LONG j;
1408     LONG temp = 0;
1409     struct afsconf_cell info;
1410     struct chservinfo checkserv;
1411
1412     HOURGLASS hourglass;
1413
1414     memset(&checkserv, 0, sizeof(struct chservinfo));
1415     blob.in_size = sizeof(struct chservinfo);
1416     blob.in = (caddr_t)&checkserv;
1417
1418     blob.out_size = MAXSIZE;
1419     blob.out = space;
1420     memset(space, 0, sizeof(LONG));     /* so we assure zero when nothing is copied back */
1421
1422     /* prepare flags for checkservers command */
1423     if (nCellsToCheck == LOCAL_CELL)
1424         temp = 2;       /* default to checking local cell only */
1425     else if (nCellsToCheck == ALL_CELLS)
1426         temp &= ~2;     /* turn off local cell check */
1427
1428     if (bFast)
1429         temp |= 1;      /* set fast flag */
1430     
1431     checkserv.magic = 0x12345678;       /* XXX */
1432     checkserv.tflags = temp;
1433
1434     /* now copy in optional cell name, if specified */
1435     if (nCellsToCheck == SPECIFIC_CELL) {
1436         GetCellName(PCCHAR(strCellName), &info);
1437         strcpy(checkserv.tbuffer,info.name);
1438         checkserv.tsize = strlen(info.name) + 1;
1439     } else {
1440         strcpy(checkserv.tbuffer, "\0");
1441         checkserv.tsize = 0;
1442     }
1443
1444     checkserv.tinterval = -1;   /* don't change current interval */
1445
1446     code = pioctl(0, VIOCCKSERV, &blob, 1);
1447     if (code) {
1448         ShowMessageBox(IDS_CHECK_SERVERS_ERROR, MB_ICONEXCLAMATION, IDS_CHECK_SERVERS_ERROR, GetAfsError(errno, CString()));
1449         return FALSE;
1450     }
1451
1452     memcpy(&temp, space, sizeof(LONG));
1453
1454     if (temp == 0) {
1455         ShowMessageBox(IDS_ALL_SERVERS_RUNNING, MB_OK, IDS_ALL_SERVERS_RUNNING);
1456         return TRUE;
1457     }
1458
1459     CStringArray servers;
1460     for (j = 0; j < MAXHOSTS; j++) {
1461         memcpy(&temp, space + j * sizeof(LONG), sizeof(LONG));
1462         if (temp == 0)
1463             break;
1464
1465         char *name = hostutil_GetNameByINet(temp);
1466         servers.Add(name);
1467     }
1468
1469     CDownServersDlg dlg;
1470     dlg.SetServerNames(servers);
1471     dlg.DoModal();
1472
1473     return TRUE;
1474 }       
1475
1476 BOOL GetTokenInfo(CStringArray& tokenInfo)
1477 {
1478     int cellNum;
1479     int rc;
1480     time_t current_time;
1481     time_t tokenExpireTime;
1482     char *expireString;
1483     char userName[100];
1484 //      char s[100];
1485     struct ktc_principal serviceName, clientName;
1486     struct ktc_token token;
1487
1488     CString strTokenInfo;
1489     CString strUserName;
1490     CString strCellName;
1491     CString strExpir;
1492
1493 //      tokenInfo.Add("");
1494 //      return TRUE;
1495
1496
1497     HOURGLASS hourglass;
1498
1499 //      printf("\nTokens held by the Cache Manager:\n\n");
1500     cellNum = 0;
1501     current_time = time(0);
1502
1503     while (1) {
1504         rc = ktc_ListTokens(cellNum, &cellNum, &serviceName);
1505         if (rc == KTC_NOENT) {
1506             /* end of list */
1507 //          printf("   --End of list --\n");
1508             break;
1509         }
1510         else if (rc == KTC_NOCM) {
1511             ShowMessageBox(IDS_GET_TOKENS_NO_AFS_SERVICE);
1512 //          printf("AFS service may not have started\n");
1513             break;
1514         }
1515         else if (rc) {
1516             ShowMessageBox(IDS_GET_TOKENS_UNEXPECTED_ERROR, MB_ICONEXCLAMATION, IDS_GET_TOKENS_UNEXPECTED_ERROR, rc);
1517             return FALSE;
1518 //          printf("Unexpected error, code %d\n", rc);
1519 //          exit(1);
1520         }
1521         else {
1522             rc = ktc_GetToken(&serviceName, &token, sizeof(token), &clientName);
1523             if (rc) {
1524                 ShowMessageBox(IDS_GET_TOKENS_UNEXPECTED_ERROR2, MB_ICONEXCLAMATION, IDS_GET_TOKENS_UNEXPECTED_ERROR2, 
1525                                 serviceName.name, serviceName.instance, serviceName.cell, rc);
1526                 continue;
1527             }
1528
1529             tokenExpireTime = token.endTime;
1530
1531             strcpy(userName, clientName.name);
1532             if (clientName.instance[0] != 0) {
1533                 strcat(userName, ".");
1534                 strcat(userName, clientName.instance);
1535             }
1536
1537             BOOL bShowName = FALSE;
1538
1539             if (userName[0] == '\0')
1540                 ; //printf("Tokens");
1541 // AFS ID is not returned at this time.
1542 //          else if (strncmp(userName, "AFS ID", 6) == 0)
1543 //              printf("User's (%s) tokens", userName);
1544 //              sscanf(userName, "(AFS ID %s)", szAfsID);
1545             else if (strncmp(userName, "Unix UID", 8) == 0)
1546                 ; //printf("Tokens");
1547             else
1548                 strUserName = userName;
1549 //              printf("User %s's tokens", userName);
1550                         
1551 //              printf(" for %s%s%s@%s ", serviceName.name, serviceName.instance[0] ? "." : "", serviceName.instance, serviceName.cell);
1552             strCellName = serviceName.cell;
1553                         
1554             if (tokenExpireTime <= current_time)
1555                 strExpir = "[>> Expired <<]";
1556 //              printf("[>> Expired <<]\n");
1557             else {
1558                 expireString = ctime(&tokenExpireTime);
1559                 expireString += 4;       /* Skip day of week */
1560                 expireString[12] = '\0'; /* Omit secs & year */
1561 //              printf("[Expires %s]\n", expireString);
1562                 strExpir.Format("%s", expireString);
1563             }
1564
1565             strTokenInfo = strUserName + "\t" + strCellName + "\t" + strExpir + "\t" + strCellName;
1566             tokenInfo.Add(strTokenInfo);
1567         }
1568     }
1569
1570 //      printf("Press <Enter> or <Return> when finished: ");
1571 //      gets(s);
1572     return TRUE;
1573 }
1574
1575 UINT MakeSymbolicLink(const char *strName ,const char *strDir)
1576 {
1577     struct ViceIoctl blob;
1578     char space[MAXSIZE];
1579     UINT code;
1580
1581     HOURGLASS hourglass;
1582
1583     /*lets confirm its a good symlink*/
1584     if (!IsPathInAfs(strDir))
1585         return 1;
1586     LPTSTR lpsz = new TCHAR[strlen(strDir)+1];
1587     _tcscpy(lpsz, strName);
1588     strcpy(space, strDir);
1589     blob.out_size = 0;
1590     blob.in_size = 1 + strlen(space);
1591     blob.in = space;
1592     blob.out = NULL;
1593     if ((code=pioctl(lpsz, VIOC_SYMLINK, &blob, 0))!=0)
1594         return code;
1595     return 0;
1596 }
1597
1598 void ListSymbolicLinkPath(const char *strName,char *strPath,UINT nlenPath)
1599 {
1600     ASSERT(nlenPath<MAX_PATH);
1601     struct ViceIoctl blob;
1602     char orig_name[MAX_PATH+1];         /*Original name, may be modified*/
1603     char true_name[MAX_PATH+1];         /*``True'' dirname (e.g., symlink target)*/
1604     char parent_dir[MAX_PATH+1];                /*Parent directory of true name*/
1605     char *last_component;       /*Last component of true name*/
1606     UINT code;    
1607
1608     HOURGLASS hourglass;
1609
1610     strcpy(orig_name, strName);
1611     strcpy(true_name, orig_name);
1612         /*
1613          * Find rightmost slash, if any.
1614          */
1615     last_component = (char *) strrchr(true_name, '\\');
1616     if (!last_component)
1617         last_component = (char *) strrchr(true_name, '/');
1618     if (last_component) {
1619             /*
1620              * Found it.  Designate everything before it as the parent directory,
1621              * everything after it as the final component.
1622              */
1623         strncpy(parent_dir, true_name, last_component - true_name + 1);
1624         parent_dir[last_component - true_name + 1] = 0;
1625         last_component++;   /*Skip the slash*/
1626     }
1627     else {
1628         /*
1629          * No slash appears in the given file name.  Set parent_dir to the current
1630          * directory, and the last component as the given name.
1631          */
1632         fs_ExtractDriveLetter(true_name, parent_dir);
1633         strcat(parent_dir, ".");
1634         last_component = true_name;
1635         fs_StripDriveLetter(true_name, true_name, sizeof(true_name));
1636     }
1637     blob.in = last_component;
1638     blob.in_size = strlen(last_component)+1;
1639     blob.out_size = MAXSIZE;
1640     blob.out = space;
1641     memset(space, 0, MAXSIZE);
1642     if ((code = pioctl(parent_dir, VIOC_LISTSYMLINK, &blob, 1)))
1643         strcpy(space,"???");
1644     ASSERT(strlen(space)<MAX_PATH);
1645     strncpy(strPath,space,nlenPath);
1646 }