freelance-updates-20011031
[openafs.git] / src / WINNT / afsd / cm_ioctl.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afs/param.h>
11 #include <afs/stds.h>
12
13 #ifndef DJGPP
14 #include <windows.h>
15 #else
16 #include <sys/socket.h>
17 #endif /* !DJGPP */
18 #include <errno.h>
19 #include <stdlib.h>
20 #include <malloc.h>
21 #include <string.h>
22 #include <stdio.h>
23 #include <time.h>
24
25 #include <osi.h>
26
27 #include "afsd.h"
28 #include "afsd_init.h"
29
30 #include "smb.h"
31
32 #ifndef DJGPP
33 #include <rxkad.h>
34 #include "afsrpc.h"
35 #else
36 #include <rx/rxkad.h>
37 #include "afsrpc95.h"
38 #endif
39
40 #include "cm_rpc.h"
41
42 /* Copied from afs_tokens.h */
43 #define PIOCTL_LOGON    0x1
44 #define MAX_PATH 260
45
46 osi_mutex_t cm_Afsdsbmt_Lock;
47 #ifdef AFS_FREELANCE_CLIENT
48 extern osi_mutex_t cm_Freelance_Lock;
49 #endif
50
51 extern afs_int32 cryptall;
52
53 void cm_InitIoctl(void)
54 {
55         lock_InitializeMutex(&cm_Afsdsbmt_Lock, "AFSDSBMT.INI Access Lock");
56 }
57
58 long cm_FlushFile(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
59 {
60         long code;
61
62         lock_ObtainWrite(&scp->bufCreateLock);
63         code = buf_FlushCleanPages(scp, userp, reqp);
64         
65         lock_ObtainMutex(&scp->mx);
66         scp->cbServerp = NULL;
67         scp->cbExpires = 0;
68         lock_ReleaseMutex(&scp->mx);
69
70         lock_ReleaseWrite(&scp->bufCreateLock);
71         cm_dnlcPurgedp(scp);
72
73         return code;
74 }
75
76 /*
77  * cm_ResetACLCache -- invalidate ACL info for a user that has just
78  *                      obtained or lost tokens
79  */
80 void cm_ResetACLCache(cm_user_t *userp)
81 {
82         cm_scache_t *scp;
83         int hash;
84
85         lock_ObtainWrite(&cm_scacheLock);
86         for (hash=0; hash < cm_hashTableSize; hash++) {
87                 for (scp=cm_hashTablep[hash]; scp; scp=scp->nextp) {
88                         scp->refCount++;
89                         lock_ReleaseWrite(&cm_scacheLock);
90                         lock_ObtainMutex(&scp->mx);
91                         cm_InvalidateACLUser(scp, userp);
92                         lock_ReleaseMutex(&scp->mx);
93                         lock_ObtainWrite(&cm_scacheLock);
94                         scp->refCount--;
95                 }
96         }
97         lock_ReleaseWrite(&cm_scacheLock);
98 }
99
100 /*
101  *  TranslateExtendedChars - This is a fix for TR 54482.
102  *
103  *  If an extended character (80 - FF) is entered into a file
104  *  or directory name in Windows, the character is translated
105  *  into the OEM character map before being passed to us.  Why
106  *  this occurs is unknown.  Our pioctl functions must match
107  *  this translation for paths given via our own commands (like
108  *  fs).  If we do not do this, then we will try to perform an
109  *  operation on a non-translated path, which we will fail to 
110  *  find, since the path was created with the translated chars.
111  *  This function performs the required translation.
112  */
113 void TranslateExtendedChars(char *str)
114 {
115   char *p;
116   
117         if (!str || !*str)
118                 return;
119
120 #ifndef DJGPP
121         CharToOem(str, str);
122 #else
123         p = str;
124         while (*p) *p++ &= 0x7f;  /* turn off high bit; probably not right */
125 #endif
126 }
127         
128 /* parse the passed-in file name and do a namei on it.  If we fail,
129  * return an error code, otherwise return the vnode located in *scpp.
130  */
131 long cm_ParseIoctlPath(smb_ioctl_t *ioctlp, cm_user_t *userp, cm_req_t *reqp,
132         cm_scache_t **scpp)
133 {
134         long code;
135         cm_scache_t *substRootp;
136
137         /* This is usually the file name, but for StatMountPoint it is the path. */
138         TranslateExtendedChars(ioctlp->inDatap);
139
140         code = cm_NameI(cm_rootSCachep, ioctlp->prefix->data,
141                 CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
142                 userp, ioctlp->tidPathp, reqp, &substRootp);
143         if (code) return code;
144         
145         code = cm_NameI(substRootp, ioctlp->inDatap, CM_FLAG_FOLLOW,
146                 userp, NULL, reqp, scpp);
147         if (code) return code;
148         
149         /* # of bytes of path */
150         code = strlen(ioctlp->inDatap) + 1;
151         ioctlp->inDatap += code;
152
153         /* This is usually nothing, but for StatMountPoint it is the file name. */
154         TranslateExtendedChars(ioctlp->inDatap);
155
156         /* and return success */
157         return 0;
158 }
159
160 void cm_SkipIoctlPath(smb_ioctl_t *ioctlp)
161 {
162         long temp;
163         
164         temp = strlen(ioctlp->inDatap) + 1;
165         ioctlp->inDatap += temp;
166 }
167
168
169 /* format the specified path to look like "/afs/<cellname>/usr", by
170  * adding "/afs" (if necessary) in front, changing any \'s to /'s, and
171  * removing any trailing "/"'s. One weirdo caveat: "/afs" will be
172  * intentionally returned as "/afs/"--this makes submount manipulation
173  * easier (because we can always jump past the initial "/afs" to find
174  * the AFS path that should be written into afsdsbmt.ini).
175  */
176 void cm_NormalizeAfsPath (char *outpathp, char *inpathp)
177 {
178         char *cp;
179
180         if (!strnicmp (inpathp, "/afs", strlen("/afs")))
181                 lstrcpy (outpathp, inpathp);
182         else if (!strnicmp (inpathp, "\\afs", strlen("\\afs")))
183                 lstrcpy (outpathp, inpathp);
184         else if ((inpathp[0] == '/') || (inpathp[0] == '\\'))
185                 sprintf (outpathp, "/afs%s", inpathp);
186         else // inpathp looks like "<cell>/usr"
187                 sprintf (outpathp, "/afs/%s", inpathp);
188
189         for (cp = outpathp; *cp != 0; ++cp) {
190                 if (*cp == '\\')
191                         *cp = '/';
192         }
193
194         if (strlen(outpathp) && (outpathp[strlen(outpathp)-1] == '/')) {
195            outpathp[strlen(outpathp)-1] = 0;
196         }
197
198         if (!strcmpi (outpathp, "/afs")) {
199            strcpy (outpathp, "/afs/");
200         }
201 }
202
203 /* parse the passed-in file name and do a namei on its parent.  If we fail,
204  * return an error code, otherwise return the vnode located in *scpp.
205  */
206 long cm_ParseIoctlParent(smb_ioctl_t *ioctlp, cm_user_t *userp, cm_req_t *reqp,
207                          cm_scache_t **scpp, char *leafp)
208 {
209         long code;
210         char tbuffer[1024];
211         char *tp, *jp;
212         cm_scache_t *substRootp;
213
214         strcpy(tbuffer, ioctlp->inDatap);
215         tp = strrchr(tbuffer, '\\');
216         jp = strrchr(tbuffer, '/');
217         if (!tp)
218                 tp = jp;
219         else if (jp && (tp - tbuffer) < (jp - tbuffer))
220                 tp = jp;
221         if (!tp) {
222                 strcpy(tbuffer, "\\");
223                 if (leafp) strcpy(leafp, ioctlp->inDatap);
224         }
225         else {
226                 *tp = 0;
227                 if (leafp) strcpy(leafp, tp+1);
228         }
229
230         code = cm_NameI(cm_rootSCachep, ioctlp->prefix->data,
231                 CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
232                 userp, ioctlp->tidPathp, reqp, &substRootp);
233         if (code) return code;
234
235         code = cm_NameI(substRootp, tbuffer, CM_FLAG_FOLLOW,
236                 userp, NULL, reqp, scpp);
237         if (code) return code;
238         
239         /* # of bytes of path */
240         code = strlen(ioctlp->inDatap) + 1;
241         ioctlp->inDatap += code;
242
243         /* and return success */
244         return 0;
245 }
246
247 long cm_IoctlGetACL(smb_ioctl_t *ioctlp, cm_user_t *userp)
248 {
249         cm_conn_t *connp;
250         cm_scache_t *scp;
251         AFSOpaque acl;
252         AFSFetchStatus fileStatus;
253         AFSVolSync volSync;
254         long code;
255         AFSFid fid;
256         int tlen;
257         cm_req_t req;
258
259         cm_InitReq(&req);
260
261         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
262         if (code) return code;
263         
264         /* now make the get acl call */
265         fid.Volume = scp->fid.volume;
266         fid.Vnode = scp->fid.vnode;
267         fid.Unique = scp->fid.unique;
268         do {
269                 acl.AFSOpaque_val = ioctlp->outDatap;
270                 acl.AFSOpaque_len = 0;
271                 code = cm_Conn(&scp->fid, userp, &req, &connp);
272                 if (code) continue;
273                 
274                 code = RXAFS_FetchACL(connp->callp, &fid, &acl, &fileStatus, &volSync);
275         } while (cm_Analyze(connp, userp, &req, &scp->fid,
276                             &volSync, NULL, code));
277         code = cm_MapRPCError(code, &req);
278         cm_ReleaseSCache(scp);
279         
280         if (code) return code;
281         
282         /* skip over return data */
283         tlen = strlen(ioctlp->outDatap) + 1;
284         ioctlp->outDatap += tlen;
285
286         /* and return success */
287         return 0;
288 }
289
290 long cm_IoctlGetFileCellName(struct smb_ioctl *ioctlp, struct cm_user *userp)
291 {
292         long code;
293         cm_scache_t *scp;
294         cm_cell_t *cellp;
295         cm_req_t req;
296
297         cm_InitReq(&req);
298
299         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
300         if (code) return code;
301         
302         cellp = cm_FindCellByID(scp->fid.cell);
303         if (cellp) {
304                 strcpy(ioctlp->outDatap, cellp->namep);
305                 ioctlp->outDatap += strlen(ioctlp->outDatap) + 1;
306                 code = 0;
307         }
308         else code = CM_ERROR_NOSUCHCELL;
309         
310         cm_ReleaseSCache(scp);
311         return code;
312 }
313
314 long cm_IoctlSetACL(struct smb_ioctl *ioctlp, struct cm_user *userp)
315 {
316         cm_conn_t *connp;
317         cm_scache_t *scp;
318         AFSOpaque acl;
319         AFSFetchStatus fileStatus;
320         AFSVolSync volSync;
321         long code;
322         AFSFid fid;
323         cm_req_t req;
324
325         cm_InitReq(&req);
326
327         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
328         if (code) return code;
329         
330         /* now make the get acl call */
331         fid.Volume = scp->fid.volume;
332         fid.Vnode = scp->fid.vnode;
333         fid.Unique = scp->fid.unique;
334         do {
335                 acl.AFSOpaque_val = ioctlp->inDatap;
336                 acl.AFSOpaque_len = strlen(ioctlp->inDatap)+1;
337                 code = cm_Conn(&scp->fid, userp, &req, &connp);
338                 if (code) continue;
339                 
340                 code = RXAFS_StoreACL(connp->callp, &fid, &acl, &fileStatus, &volSync);
341         } while (cm_Analyze(connp, userp, &req, &scp->fid,
342                             &volSync, NULL, code));
343         code = cm_MapRPCError(code, &req);
344
345         /* invalidate cache info, since we just trashed the ACL cache */
346         lock_ObtainMutex(&scp->mx);
347         cm_DiscardSCache(scp);
348         lock_ReleaseMutex(&scp->mx);
349
350         cm_ReleaseSCache(scp);
351         
352         return code;
353 }
354
355 long cm_IoctlFlushVolume(struct smb_ioctl *ioctlp, struct cm_user *userp)
356 {
357         long code;
358         cm_scache_t *scp;
359         unsigned long volume;
360         int i;
361         cm_req_t req;
362
363         cm_InitReq(&req);
364
365         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
366         if (code) return code;
367         
368         volume = scp->fid.volume;
369         cm_ReleaseSCache(scp);
370
371         lock_ObtainWrite(&cm_scacheLock);
372         for(i=0; i<cm_hashTableSize; i++) {
373                 for(scp = cm_hashTablep[i]; scp; scp = scp->nextp) {
374                         if (scp->fid.volume == volume) {
375                                 scp->refCount++;
376                                 lock_ReleaseWrite(&cm_scacheLock);
377
378                                 /* now flush the file */
379                                 cm_FlushFile(scp, userp, &req);
380
381                                 lock_ObtainWrite(&cm_scacheLock);
382                                 scp->refCount--;
383                         }
384                 }
385         }
386         lock_ReleaseWrite(&cm_scacheLock);
387
388         return code;
389 }
390
391 long cm_IoctlFlushFile(struct smb_ioctl *ioctlp, struct cm_user *userp)
392 {
393         long code;
394         cm_scache_t *scp;
395         cm_req_t req;
396
397         cm_InitReq(&req);
398
399         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
400         if (code) return code;
401         
402         cm_FlushFile(scp, userp, &req);
403         cm_ReleaseSCache(scp);
404
405         return 0;
406 }
407
408 long cm_IoctlSetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
409 {
410         cm_scache_t *scp;
411         char volName[32];
412         char offLineMsg[256];
413         char motd[256];
414         cm_conn_t *tcp;
415         long code;
416         AFSFetchVolumeStatus volStat;
417         AFSStoreVolumeStatus storeStat;
418         cm_volume_t *tvp;
419         char *cp;
420         cm_cell_t *cellp;
421         cm_req_t req;
422
423         cm_InitReq(&req);
424
425         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
426         if (code) return code;
427
428         cellp = cm_FindCellByID(scp->fid.cell);
429         osi_assert(cellp);
430
431         if (scp->flags & CM_SCACHEFLAG_RO) {
432                 cm_ReleaseSCache(scp);
433                 return CM_ERROR_READONLY;
434         }
435
436         code = cm_GetVolumeByID(cellp, scp->fid.volume, userp, &req, &tvp);
437         if (code) {
438                 cm_ReleaseSCache(scp);
439                 return code;
440         }
441
442         /* Copy the junk out, using cp as a roving pointer. */
443         cp = ioctlp->inDatap;
444         memcpy((char *)&volStat, cp, sizeof(AFSFetchVolumeStatus));
445         cp += sizeof(AFSFetchVolumeStatus);
446         strcpy(volName, cp);
447         cp += strlen(volName)+1;
448         strcpy(offLineMsg, cp);
449         cp +=  strlen(offLineMsg)+1;
450         strcpy(motd, cp);
451         storeStat.Mask = 0;
452         if (volStat.MinQuota != -1) {
453                 storeStat.MinQuota = volStat.MinQuota;
454                 storeStat.Mask |= AFS_SETMINQUOTA;
455         }
456         if (volStat.MaxQuota != -1) {
457                 storeStat.MaxQuota = volStat.MaxQuota;
458                 storeStat.Mask |= AFS_SETMAXQUOTA;
459         }
460
461         do {
462                 code = cm_Conn(&scp->fid, userp, &req, &tcp);
463                 if (code) continue;
464
465                 code = RXAFS_SetVolumeStatus(tcp->callp, scp->fid.volume,
466                         &storeStat, volName, offLineMsg, motd);
467         } while (cm_Analyze(tcp, userp, &req, &scp->fid, NULL, NULL, code));
468         code = cm_MapRPCError(code, &req);
469
470         /* return on failure */
471         cm_ReleaseSCache(scp);
472         if (code) {
473                 return code;
474         }
475
476         /* we are sending parms back to make compat. with prev system.  should
477          * change interface later to not ask for current status, just set
478          * new status
479          */
480         cp = ioctlp->outDatap;
481         memcpy(cp, (char *)&volStat, sizeof(VolumeStatus));
482         cp += sizeof(VolumeStatus);
483         strcpy(cp, volName);
484         cp += strlen(volName)+1;
485         strcpy(cp, offLineMsg);
486         cp += strlen(offLineMsg)+1;
487         strcpy(cp, motd);
488         cp += strlen(motd)+1;
489
490         /* now return updated return data pointer */
491         ioctlp->outDatap = cp;
492
493         return 0;
494 }
495
496 long cm_IoctlGetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
497 {
498         char volName[32];
499         cm_scache_t *scp;
500         char offLineMsg[256];
501         char motd[256];
502         cm_conn_t *tcp;
503         register long code;
504         AFSFetchVolumeStatus volStat;
505         register char *cp;
506         char *Name;
507         char *OfflineMsg;
508         char *MOTD;
509         cm_req_t req;
510
511         cm_InitReq(&req);
512
513         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
514         if (code) return code;
515
516         Name = volName;
517         OfflineMsg = offLineMsg;
518         MOTD = motd;
519         do {
520                 code = cm_Conn(&scp->fid, userp, &req, &tcp);
521                 if (code) continue;
522
523                 code = RXAFS_GetVolumeStatus(tcp->callp, scp->fid.volume,
524                         &volStat, &Name, &OfflineMsg, &MOTD);
525         } while (cm_Analyze(tcp, userp, &req, &scp->fid, NULL, NULL, code));
526         code = cm_MapRPCError(code, &req);
527
528         cm_ReleaseSCache(scp);
529         if (code) return code;
530
531         /* Copy all this junk into msg->im_data, keeping track of the lengths. */
532         cp = ioctlp->outDatap;
533         memcpy(cp, (char *)&volStat, sizeof(AFSFetchVolumeStatus));
534         cp += sizeof(AFSFetchVolumeStatus);
535         strcpy(cp, volName);
536         cp += strlen(volName)+1;
537         strcpy(cp, offLineMsg);
538         cp += strlen(offLineMsg)+1;
539         strcpy(cp, motd);
540         cp += strlen(motd)+1;
541
542         /* return new size */
543         ioctlp->outDatap = cp;
544
545         return 0;
546 }
547
548 long cm_IoctlWhereIs(struct smb_ioctl *ioctlp, struct cm_user *userp)
549 {
550         long code;
551         cm_scache_t *scp;
552         cm_cell_t *cellp;
553         cm_volume_t *tvp;
554         cm_serverRef_t *tsrp;
555         cm_server_t *tsp;
556         unsigned long volume;
557         char *cp;
558         cm_req_t req;
559
560         cm_InitReq(&req);
561
562         code = cm_ParseIoctlPath(ioctlp, userp, &req, &scp);
563         if (code) return code;
564         
565         volume = scp->fid.volume;
566
567         cellp = cm_FindCellByID(scp->fid.cell);
568         osi_assert(cellp);
569
570         cm_ReleaseSCache(scp);
571
572         code = cm_GetVolumeByID(cellp, volume, userp, &req, &tvp);
573         if (code) return code;
574         
575         cp = ioctlp->outDatap;
576         
577         lock_ObtainMutex(&tvp->mx);
578         tsrp = cm_GetVolServers(tvp, volume);
579         lock_ObtainRead(&cm_serverLock);
580         while(tsrp) {
581                 tsp = tsrp->server;
582                 memcpy(cp, (char *)&tsp->addr.sin_addr.s_addr, sizeof(long));
583                 cp += sizeof(long);
584                 tsrp = tsrp->next;
585         }
586         lock_ReleaseRead(&cm_serverLock);
587         lock_ReleaseMutex(&tvp->mx);
588
589         /* still room for terminating NULL, add it on */
590         volume = 0;     /* reuse vbl */
591         memcpy(cp, (char *)&volume, sizeof(long));
592         cp += sizeof(long);
593
594         ioctlp->outDatap = cp;
595         cm_PutVolume(tvp);
596         return 0;
597 }
598
599 long cm_IoctlStatMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp)
600 {
601         long code;
602         cm_scache_t *dscp;
603         cm_scache_t *scp;
604         char *cp;
605         cm_req_t req;
606
607         cm_InitReq(&req);
608
609         code = cm_ParseIoctlPath(ioctlp, userp, &req, &dscp);
610         if (code) return code;
611         
612         cp = ioctlp->inDatap;
613
614         code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, &req, &scp);
615         cm_ReleaseSCache(dscp);
616         if (code) return code;
617         
618         lock_ObtainMutex(&scp->mx);
619
620         /* now check that this is a real mount point */
621         if (scp->fileType != CM_SCACHETYPE_MOUNTPOINT) {
622                 lock_ReleaseMutex(&scp->mx);
623                 cm_ReleaseSCache(scp);
624                 return CM_ERROR_INVAL;
625         }
626         
627         code = cm_ReadMountPoint(scp, userp, &req);
628         if (code == 0) {
629                 cp = ioctlp->outDatap;
630                 strcpy(cp, scp->mountPointStringp);
631                 cp += strlen(cp) + 1;
632                 ioctlp->outDatap = cp;
633         }
634         lock_ReleaseMutex(&scp->mx);
635         cm_ReleaseSCache(scp);
636
637         return code;
638 }
639
640 long cm_IoctlDeleteMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp)
641 {
642         long code;
643         cm_scache_t *dscp;
644         cm_scache_t *scp;
645         char *cp;
646         cm_req_t req;
647
648         cm_InitReq(&req);
649
650         code = cm_ParseIoctlPath(ioctlp, userp, &req, &dscp);
651         if (code) return code;
652         
653         cp = ioctlp->inDatap;
654
655         code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, &req, &scp);
656         
657         /* if something went wrong, bail out now */
658         if (code) {
659                 goto done;
660         }
661         
662         lock_ObtainMutex(&scp->mx);
663         code = cm_SyncOp(scp, NULL, userp, &req, 0,
664                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
665         if (code) {
666                 lock_ReleaseMutex(&scp->mx);
667                 cm_ReleaseSCache(scp);
668                 goto done;
669         }
670         
671         /* now check that this is a real mount point */
672         if (scp->fileType != CM_SCACHETYPE_MOUNTPOINT) {
673                 lock_ReleaseMutex(&scp->mx);
674                 cm_ReleaseSCache(scp);
675                 code = CM_ERROR_INVAL;
676                 goto done;
677         }
678         
679         /* time to make the RPC, so drop the lock */
680         lock_ReleaseMutex(&scp->mx);
681         cm_ReleaseSCache(scp);
682         
683         /* easier to do it this way */
684         code = cm_Unlink(dscp, cp, userp, &req);
685         if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
686                 smb_NotifyChange(FILE_ACTION_REMOVED,
687                                  FILE_NOTIFY_CHANGE_DIR_NAME,
688                                  dscp, cp, NULL, TRUE);
689
690 done:
691         cm_ReleaseSCache(dscp);
692         return code;
693 }
694
695 long cm_IoctlCheckServers(struct smb_ioctl *ioctlp, struct cm_user *userp)
696 {
697         cm_cell_t *cellp;
698         chservinfo_t csi;
699         char *tp;
700         char *cp;
701         long temp;
702         cm_server_t *tsp;
703         int haveCell;
704         
705         cm_SkipIoctlPath(ioctlp);       /* we don't care about the path */
706         tp = ioctlp->inDatap;
707         haveCell = 0;
708
709         memcpy(&temp, tp, sizeof(temp));
710         if (temp == 0x12345678) {       /* For afs3.3 version */
711                 memcpy(&csi, tp, sizeof(csi));
712                 if (csi.tinterval >= 0) {
713                         cp = ioctlp->outDatap;
714                         memcpy(cp, (char *)&cm_daemonCheckInterval, sizeof(long));
715                         ioctlp->outDatap += sizeof(long);
716                         if (csi.tinterval > 0) {
717                                 if (!smb_SUser(userp))
718                                         return CM_ERROR_NOACCESS;
719                                 cm_daemonCheckInterval = csi.tinterval;
720                         }
721                         return 0;
722                 }
723                 if (csi.tsize)
724                         haveCell = 1;
725                 temp = csi.tflags;
726                 cp = csi.tbuffer;
727         } else {        /* For pre afs3.3 versions */
728                 memcpy((char *)&temp, ioctlp->inDatap, sizeof(long));
729                 ioctlp->inDatap = cp = ioctlp->inDatap + sizeof(long);
730                 if (cp - ioctlp->inAllocp < ioctlp->inCopied)   /* still more data available */
731                         haveCell = 1;
732         }
733
734         /* 
735          * 1: fast check, don't contact servers.
736          * 2: local cell only.
737          */
738         if (haveCell) {
739                 /* have cell name, too */
740                 cellp = cm_GetCell(cp, 0);
741                 if (!cellp) return CM_ERROR_NOSUCHCELL;
742         }
743         else cellp = (cm_cell_t *) 0;
744         if (!cellp && (temp & 2)) {
745                 /* use local cell */
746                 cellp = cm_FindCellByID(1);
747         }
748         if (!(temp & 1)) {      /* if not fast, call server checker routine */
749                 /* check down servers */
750                 cm_CheckServers(CM_FLAG_CHECKDOWNSERVERS | CM_FLAG_CHECKUPSERVERS,
751                         cellp);
752         }
753
754         /* now return the current down server list */
755         cp = ioctlp->outDatap;
756         lock_ObtainRead(&cm_serverLock);
757         for(tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
758                 if (cellp && tsp->cellp != cellp) continue;     /* cell spec'd and wrong */
759                 if ((tsp->flags & CM_SERVERFLAG_DOWN)
760                         && tsp->type == CM_SERVER_FILE) {
761                         memcpy(cp, (char *)&tsp->addr.sin_addr.s_addr, sizeof(long));
762                         cp += sizeof(long);
763                 }
764         }
765         lock_ReleaseRead(&cm_serverLock);
766
767         ioctlp->outDatap = cp;
768         return 0;
769 }
770
771 long cm_IoctlGag(struct smb_ioctl *ioctlp, struct cm_user *userp)
772 {
773         /* we don't print anything superfluous, so we don't support the gag call */
774         return CM_ERROR_INVAL;
775 }
776
777 long cm_IoctlCheckVolumes(struct smb_ioctl *ioctlp, struct cm_user *userp)
778 {
779         cm_CheckVolumes();
780         return 0;
781 }
782
783 long cm_IoctlSetCacheSize(struct smb_ioctl *ioctlp, struct cm_user *userp)
784 {
785         long temp;
786         long code;
787         
788         cm_SkipIoctlPath(ioctlp);
789
790         memcpy(&temp, ioctlp->inDatap, sizeof(temp));
791         if (temp == 0) temp = buf_nOrigBuffers;
792         else {
793                 /* temp is in 1K units, convert to # of buffers */
794                 temp = temp / (buf_bufferSize / 1024);
795         }
796
797         /* now adjust the cache size */
798         code = buf_SetNBuffers(temp);
799
800         return code;
801 }
802
803 long cm_IoctlTraceControl(struct smb_ioctl *ioctlp, struct cm_user *userp)
804 {
805         long inValue;
806         
807         cm_SkipIoctlPath(ioctlp);
808         
809         memcpy(&inValue, ioctlp->inDatap, sizeof(long));
810
811         /* print trace */
812         if (inValue & 8) {
813                 afsd_ForceTrace(FALSE);
814         }
815         
816         if (inValue & 2) {
817                 /* set tracing value to low order bit */
818                 if ((inValue & 1) == 0) {
819                         /* disable tracing */
820                         osi_LogDisable(afsd_logp);
821                 }
822                 else {
823                         /* enable tracing */
824                         osi_LogEnable(afsd_logp);
825                 }
826         }
827
828         /* see if we're supposed to do a reset, too */
829         if (inValue & 4) {
830                 osi_LogReset(afsd_logp);
831         }
832
833         /* and copy out tracing flag */
834         inValue = afsd_logp->enabled;   /* use as a temp vbl */
835         memcpy(ioctlp->outDatap, &inValue, sizeof(long));
836         ioctlp->outDatap += sizeof(long);
837         return 0;
838 }
839
840 long cm_IoctlGetCacheParms(struct smb_ioctl *ioctlp, struct cm_user *userp)
841 {
842         cm_cacheParms_t parms;
843         
844         memset(&parms, 0, sizeof(parms));
845
846         /* first we get, in 1K units, the cache size */
847         parms.parms[0] = buf_nbuffers * (buf_bufferSize / 1024);
848         
849         /* and then the actual # of buffers in use (not in the free list, I guess,
850          * will be what we do).
851          */
852         parms.parms[1] = (buf_nbuffers - buf_CountFreeList()) * (buf_bufferSize / 1024);
853         
854         memcpy(ioctlp->outDatap, &parms, sizeof(parms));
855         ioctlp->outDatap += sizeof(parms);
856
857         return 0;
858 }
859
860 long cm_IoctlGetCell(struct smb_ioctl *ioctlp, struct cm_user *userp)
861 {
862         long whichCell;
863         long magic = 0;
864         cm_cell_t *tcellp;
865         cm_serverRef_t *serverRefp;
866         cm_server_t *serverp;
867         long i;
868         char *cp;
869         char *tp;
870         char *basep;
871
872         cm_SkipIoctlPath(ioctlp);
873
874         tp = ioctlp->inDatap;
875
876         memcpy((char *)&whichCell, tp, sizeof(long));
877         tp += sizeof(long);
878         
879         /* see if more than one long passed in, ignoring the null pathname (the -1) */
880         if (ioctlp->inCopied-1 > sizeof(long)) {
881                 memcpy((char *)&magic, tp, sizeof(long));
882         }
883
884         lock_ObtainRead(&cm_cellLock);
885         for(tcellp = cm_allCellsp; tcellp; tcellp = tcellp->nextp) {
886                 if (whichCell == 0) break;
887                 whichCell--;
888         }
889         lock_ReleaseRead(&cm_cellLock);
890         if (tcellp) {
891                 int max = 8;
892
893                 cp = ioctlp->outDatap;
894
895                 if (magic == 0x12345678) {
896                         memcpy(cp, (char *)&magic, sizeof(long));
897                         max = 13;
898                 }
899                 memset(cp, 0, max * sizeof(long));
900                 basep = cp;
901                 lock_ObtainRead(&cm_serverLock);        /* for going down server list */
902                 serverRefp = tcellp->vlServersp;
903                 for(i=0; i<max; i++) {
904                         if (!serverRefp) break;
905                         serverp = serverRefp->server;
906                         memcpy(cp, &serverp->addr.sin_addr.s_addr, sizeof(long));
907                         cp += sizeof(long);
908                         serverRefp = serverRefp->next;
909                 }
910                 lock_ReleaseRead(&cm_serverLock);
911                 cp = basep + max * sizeof(afs_int32);
912                 strcpy(cp, tcellp->namep);
913                 cp += strlen(tcellp->namep)+1;
914                 ioctlp->outDatap = cp;
915         }
916
917         if (tcellp) return 0;
918         else return CM_ERROR_NOMORETOKENS;      /* mapped to EDOM */
919 }
920
921 long cm_IoctlNewCell(struct smb_ioctl *ioctlp, struct cm_user *userp)
922 {
923         /* don't need to do, since NT cache manager will re-read afsdcell.ini
924          * on every access to a new cell.
925          */
926         return CM_ERROR_INVAL;
927 }
928
929 long cm_IoctlGetWsCell(smb_ioctl_t *ioctlp, cm_user_t *userp)
930 {
931         /* if we don't know our default cell, return failure */
932         if (cm_rootCellp == NULL) {
933                 return CM_ERROR_NOSUCHCELL;
934         }
935
936         /* return the default cellname to the caller */
937         strcpy(ioctlp->outDatap, cm_rootCellp->namep);
938         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
939         
940         /* done: success */
941         return 0;
942 }
943
944 long cm_IoctlSysName(struct smb_ioctl *ioctlp, struct cm_user *userp)
945 {
946         long setSysName;
947         char *cp;
948         
949         cm_SkipIoctlPath(ioctlp);
950
951         memcpy(&setSysName, ioctlp->inDatap, sizeof(long));
952         ioctlp->inDatap += sizeof(long);
953         
954         if (setSysName) {
955                 strcpy(cm_sysName, ioctlp->inDatap);
956         }
957         else {
958                 /* return the sysname to the caller */
959                 setSysName = 1; /* really means "found sys name */
960                 cp = ioctlp->outDatap;
961                 memcpy(cp, &setSysName, sizeof(long));
962                 cp += sizeof(long);     /* skip found flag */
963                 strcpy(cp, cm_sysName);
964                 cp += strlen(cp) + 1;   /* skip name and terminating null char */
965                 ioctlp->outDatap = cp;
966         }
967         
968         /* done: success */
969         return 0;
970 }
971
972 long cm_IoctlGetCellStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
973 {
974         long temp;
975         cm_cell_t *cellp;
976
977         cm_SkipIoctlPath(ioctlp);
978
979         cellp = cm_GetCell(ioctlp->inDatap, 0);
980         if (!cellp) return CM_ERROR_NOSUCHCELL;
981
982         temp = 0;
983         lock_ObtainMutex(&cellp->mx);
984         if (cellp->flags & CM_CELLFLAG_SUID)
985                 temp |= CM_SETCELLFLAG_SUID;
986         lock_ReleaseMutex(&cellp->mx);
987         
988         /* now copy out parm */
989         memcpy(ioctlp->outDatap, &temp, sizeof(long));
990         ioctlp->outDatap += sizeof(long);
991
992         return 0;
993 }
994
995 long cm_IoctlSetCellStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
996 {
997         long temp;
998         cm_cell_t *cellp;
999
1000         cm_SkipIoctlPath(ioctlp);
1001
1002         cellp = cm_GetCell(ioctlp->inDatap + 2*sizeof(long), 0);
1003         if (!cellp) return CM_ERROR_NOSUCHCELL;
1004
1005         memcpy((char *)&temp, ioctlp->inDatap, sizeof(long));
1006
1007         lock_ObtainMutex(&cellp->mx);
1008         if (temp & CM_SETCELLFLAG_SUID)
1009                 cellp->flags |= CM_CELLFLAG_SUID;
1010         else
1011                 cellp->flags &= ~CM_CELLFLAG_SUID;
1012         lock_ReleaseMutex(&cellp->mx);
1013
1014         return 0;
1015 }
1016
1017 long cm_IoctlSetSPrefs(struct smb_ioctl *ioctlp, struct cm_user *userp)
1018 {
1019         cm_SSetPref_t     *spin; /* input */
1020         cm_SPref_t        *srvin;   /* one input component */
1021         cm_server_t       *tsp;
1022         int               i, vlonly, noServers, type;
1023         struct sockaddr_in      tmp;
1024         unsigned short    rank;
1025
1026         cm_SkipIoctlPath(ioctlp);       /* we don't care about the path */
1027
1028         spin       = (cm_SSetPref_t *)ioctlp->inDatap;
1029         noServers  = spin->num_servers;
1030         vlonly     = spin->flags;
1031         if ( vlonly )
1032                 type = CM_SERVER_VLDB;
1033         else    type = CM_SERVER_FILE;
1034
1035         for ( i=0; i < noServers; i++) 
1036         {
1037                 srvin          = &(spin->servers[i]);
1038                 rank           = srvin->rank + (rand() & 0x000f);
1039                 tmp.sin_addr   = srvin->host;
1040                 tmp.sin_family = AF_INET;
1041
1042                 tsp = cm_FindServer(&tmp, type);
1043                 if ( tsp )              /* an existing server */
1044                 {
1045                         tsp->ipRank = rank; /* no need to protect by mutex*/
1046
1047                         if ( type == CM_SERVER_FILE) /* fileserver */
1048                         {
1049                             /* find volumes which might have RO copy 
1050                             /* on server and change the ordering of 
1051                             ** their RO list */
1052                             cm_ChangeRankVolume(tsp);
1053                         }
1054                         else    
1055                         {
1056                             /* set preferences for an existing vlserver */
1057                             cm_ChangeRankCellVLServer(tsp);
1058                         }
1059                 }
1060                 else                    /* add a new server without a cell*/
1061                 {
1062                         tsp = cm_NewServer(&tmp, type, NULL);
1063                         tsp->ipRank = rank;
1064                 }
1065                 cm_PutServer(tsp);
1066         }
1067         return 0;
1068 }
1069
1070 long cm_IoctlGetSPrefs(struct smb_ioctl *ioctlp, struct cm_user *userp)
1071 {
1072         cm_SPrefRequest_t *spin; /* input */
1073         cm_SPrefInfo_t    *spout;   /* output */
1074         cm_SPref_t        *srvout;   /* one output component */
1075         cm_server_t       *tsp;
1076         int               i, vlonly, noServers;
1077
1078         cm_SkipIoctlPath(ioctlp);       /* we don't care about the path */
1079
1080         spin      = (cm_SPrefRequest_t *)ioctlp->inDatap;
1081         spout     = (cm_SPrefInfo_t *) ioctlp->outDatap;
1082         srvout    = spout->servers;
1083         noServers = spin->num_servers; 
1084         vlonly    = spin->flags & CM_SPREF_VLONLY;
1085         spout->num_servers = 0;
1086
1087         lock_ObtainRead(&cm_serverLock); /* get server lock */
1088
1089         for(tsp=cm_allServersp, i=0; tsp && noServers; tsp=tsp->allNextp,i++){
1090                 if (spin->offset > i) {
1091                         continue;    /* catch up to where we left off */
1092                 }
1093
1094                 if ( vlonly && (tsp->type == CM_SERVER_FILE) )
1095                         continue;   /* ignore fileserver for -vlserver option*/
1096                 if ( !vlonly && (tsp->type == CM_SERVER_VLDB) )
1097                         continue;   /* ignore vlservers */
1098
1099                 srvout->host = tsp->addr.sin_addr;
1100                 srvout->rank = tsp->ipRank;
1101                 srvout++;       
1102                 spout->num_servers++;
1103                 noServers--;
1104         }
1105         lock_ReleaseRead(&cm_serverLock); /* release server lock */
1106
1107         if ( tsp )      /* we ran out of space in the output buffer */
1108                 spout->next_offset = i;
1109         else    
1110                 spout->next_offset = 0; 
1111         ioctlp->outDatap += sizeof(cm_SPrefInfo_t) + 
1112                         (spout->num_servers -1 ) * sizeof(cm_SPref_t) ;
1113         return 0;
1114 }
1115
1116 long cm_IoctlStoreBehind(struct smb_ioctl *ioctlp, struct cm_user *userp)
1117 {
1118         /* we ignore default asynchrony since we only have one way
1119          * of doing this today.
1120          */
1121         return 0;
1122 }
1123
1124 long cm_IoctlCreateMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp)
1125 {
1126         char leaf[256];
1127         long code;
1128         cm_scache_t *dscp;
1129         cm_attr_t tattr;
1130         char *cp;
1131         cm_req_t req;
1132         char mpInfo[256];
1133         char fullCell[256];
1134         char volume[256];
1135         char cell[256];
1136         int ttl;
1137
1138         cm_InitReq(&req);
1139         
1140         code = cm_ParseIoctlParent(ioctlp, userp, &req, &dscp, leaf);
1141         if (code) return code;
1142
1143         /* Translate chars for the mount point name */
1144         TranslateExtendedChars(leaf);
1145
1146         /* 
1147          * The fs command allows the user to specify partial cell names on NT.  These must
1148          * be expanded to the full cell name for mount points so that the mount points will
1149          * work on UNIX clients.
1150          */
1151
1152         /* Extract the possibly partial cell name */
1153         strcpy(cell, ioctlp->inDatap + 1);      /* Skip the mp type character */
1154         
1155         if (cp = strchr(cell, ':')) {
1156                 /* Extract the volume name */
1157                 *cp = 0;
1158                 strcpy(volume,  cp + 1);
1159         
1160                 /* Get the full name for this cell */
1161                 code = cm_SearchCellFile(cell, fullCell, 0, 0);
1162 #ifdef AFS_AFSDB_ENV
1163                 if (code && cm_dnsEnabled)
1164                   code = cm_SearchCellByDNS(cell, fullCell, &ttl, 0, 0);
1165 #endif
1166                   if (code)
1167                         return CM_ERROR_NOSUCHCELL;
1168         
1169                 sprintf(mpInfo, "%c%s:%s", *ioctlp->inDatap, fullCell, volume);
1170         } else {
1171                 /* No cell name specified */
1172                 strcpy(mpInfo, ioctlp->inDatap);
1173         }
1174
1175 #ifdef AFS_FREELANCE_CLIENT
1176         if (cm_freelanceEnabled && dscp == cm_rootSCachep) {
1177           /* we are adding the mount point to the root dir., so call
1178              the freelance code to do the add. */
1179           code = cm_FreelanceAddMount(leaf, fullCell, volume, NULL);
1180           return code;
1181         }
1182 #endif
1183         /* create the symlink with mode 644.  The lack of X bits tells
1184          * us that it is a mount point.
1185          */
1186         tattr.mask = CM_ATTRMASK_UNIXMODEBITS | CM_ATTRMASK_CLIENTMODTIME;
1187         tattr.unixModeBits = 0644;
1188         tattr.clientModTime = time(NULL);
1189
1190         code = cm_SymLink(dscp, leaf, mpInfo, 0, &tattr, userp, &req);
1191         if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
1192                 smb_NotifyChange(FILE_ACTION_ADDED,
1193                                  FILE_NOTIFY_CHANGE_DIR_NAME,
1194                                  dscp, leaf, NULL, TRUE);
1195
1196         cm_ReleaseSCache(dscp);
1197
1198         return code;
1199 }
1200
1201 long cm_IoctlSymlink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1202 {
1203         char leaf[256];
1204         long code;
1205         cm_scache_t *dscp;
1206         cm_attr_t tattr;
1207         char *cp;
1208         cm_req_t req;
1209
1210         cm_InitReq(&req);
1211
1212         code = cm_ParseIoctlParent(ioctlp, userp, &req, &dscp, leaf);
1213         if (code) return code;
1214
1215         /* Translate chars for the link name */
1216         TranslateExtendedChars(leaf);
1217
1218         /* Translate chars for the linked to name */
1219         TranslateExtendedChars(ioctlp->inDatap);
1220
1221         cp = ioctlp->inDatap;           /* contents of link */
1222
1223         /* Create symlink with mode 0755. */
1224         tattr.mask = CM_ATTRMASK_UNIXMODEBITS;
1225         tattr.unixModeBits = 0755;
1226
1227         code = cm_SymLink(dscp, leaf, cp, 0, &tattr, userp, &req);
1228         if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
1229                 smb_NotifyChange(FILE_ACTION_ADDED,
1230                                  FILE_NOTIFY_CHANGE_FILE_NAME
1231                                    | FILE_NOTIFY_CHANGE_DIR_NAME,
1232                                  dscp, leaf, NULL, TRUE);
1233
1234         cm_ReleaseSCache(dscp);
1235
1236         return code;
1237 }
1238
1239 extern long cm_AssembleLink(cm_scache_t *linkScp, char *pathSuffixp,
1240         cm_scache_t **newRootScpp, cm_space_t **newSpaceBufferp,
1241         cm_user_t *userp, cm_req_t *reqp);
1242
1243 long cm_IoctlListlink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1244 {
1245         long code;
1246         cm_scache_t *dscp;
1247         cm_scache_t *scp;
1248         char *cp;
1249         cm_space_t *spacep;
1250         cm_scache_t *newRootScp;
1251         cm_req_t req;
1252
1253         cm_InitReq(&req);
1254
1255         code = cm_ParseIoctlPath(ioctlp, userp, &req, &dscp);
1256         if (code) return code;
1257
1258         cp = ioctlp->inDatap;
1259
1260         code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, &req, &scp);
1261         cm_ReleaseSCache(dscp);
1262         if (code) return code;
1263
1264         /* Check that it's a real symlink */
1265         if (scp->fileType != CM_SCACHETYPE_SYMLINK){
1266                 cm_ReleaseSCache(scp);
1267                 return CM_ERROR_INVAL;
1268         }
1269
1270         code = cm_AssembleLink(scp, "", &newRootScp, &spacep, userp, &req);
1271         cm_ReleaseSCache(scp);
1272         if (code == 0) {
1273                 cp = ioctlp->outDatap;
1274                 if (newRootScp != NULL) {
1275                         strcpy(cp, "/afs/");
1276                         cp += strlen(cp);
1277                 }
1278                 strcpy(cp, spacep->data);
1279                 cp += strlen(cp) + 1;
1280                 ioctlp->outDatap = cp;
1281                 cm_FreeSpace(spacep);
1282                 if (newRootScp != NULL)
1283                         cm_ReleaseSCache(newRootScp);
1284         }
1285
1286         return code;
1287 }
1288
1289 long cm_IoctlDeletelink(struct smb_ioctl *ioctlp, struct cm_user *userp)
1290 {
1291         long code;
1292         cm_scache_t *dscp;
1293         cm_scache_t *scp;
1294         char *cp;
1295         cm_req_t req;
1296
1297         cm_InitReq(&req);
1298
1299         code = cm_ParseIoctlPath(ioctlp, userp, &req, &dscp);
1300         if (code) return code;
1301
1302         cp = ioctlp->inDatap;
1303
1304         code = cm_Lookup(dscp, cp, CM_FLAG_NOMOUNTCHASE, userp, &req, &scp);
1305         
1306         /* if something went wrong, bail out now */
1307         if (code) {
1308                 goto done;
1309         }
1310         
1311         lock_ObtainMutex(&scp->mx);
1312         code = cm_SyncOp(scp, NULL, userp, &req, 0,
1313                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1314         if (code) {
1315                 lock_ReleaseMutex(&scp->mx);
1316                 cm_ReleaseSCache(scp);
1317                 goto done;
1318         }
1319         
1320         /* now check that this is a real symlink */
1321         if (scp->fileType != CM_SCACHETYPE_SYMLINK) {
1322                 lock_ReleaseMutex(&scp->mx);
1323                 cm_ReleaseSCache(scp);
1324                 code = CM_ERROR_INVAL;
1325                 goto done;
1326         }
1327         
1328         /* time to make the RPC, so drop the lock */
1329         lock_ReleaseMutex(&scp->mx);
1330         cm_ReleaseSCache(scp);
1331         
1332         /* easier to do it this way */
1333         code = cm_Unlink(dscp, cp, userp, &req);
1334         if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
1335                 smb_NotifyChange(FILE_ACTION_REMOVED,
1336                                  FILE_NOTIFY_CHANGE_FILE_NAME
1337                                    | FILE_NOTIFY_CHANGE_DIR_NAME,
1338                                  dscp, cp, NULL, TRUE);
1339
1340 done:
1341         cm_ReleaseSCache(dscp);
1342         return code;
1343 }
1344
1345 long cm_IoctlSetToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1346 {
1347         char *saveDataPtr;
1348         char *tp;
1349         int ticketLen;
1350         char *ticket;
1351         int ctSize;
1352         struct ClearToken ct;
1353         cm_cell_t *cellp;
1354         cm_ucell_t *ucellp;
1355         char *uname = NULL;
1356         afs_uuid_t uuid;
1357         int flags;
1358         char sessionKey[8];
1359
1360         saveDataPtr = ioctlp->inDatap;
1361
1362         cm_SkipIoctlPath(ioctlp);
1363
1364         tp = ioctlp->inDatap;
1365
1366         /* ticket length */
1367         memcpy(&ticketLen, tp, sizeof(ticketLen));
1368         tp += sizeof(ticketLen);
1369         if (ticketLen < MINKTCTICKETLEN || ticketLen > MAXKTCTICKETLEN)
1370                 return CM_ERROR_INVAL;
1371
1372         /* remember ticket and skip over it for now */
1373         ticket = tp;
1374         tp += ticketLen;
1375
1376         /* clear token size */
1377         memcpy(&ctSize, tp, sizeof(ctSize));
1378         tp += sizeof(ctSize);
1379         if (ctSize != sizeof(struct ClearToken))
1380                 return CM_ERROR_INVAL;
1381
1382         /* clear token */
1383         memcpy(&ct, tp, ctSize);
1384         tp += ctSize;
1385         if (ct.AuthHandle == -1)
1386                 ct.AuthHandle = 999;    /* more rxvab compat stuff */
1387
1388         /* more stuff, if any */
1389         if (ioctlp->inCopied > tp - saveDataPtr) {
1390                 /* flags:  logon flag */
1391                 memcpy(&flags, tp, sizeof(int));
1392                 tp += sizeof(int);
1393
1394                 /* cell name */
1395                 cellp = cm_GetCell(tp, CM_FLAG_CREATE);
1396                 if (!cellp) return CM_ERROR_NOSUCHCELL;
1397                 tp += strlen(tp) + 1;
1398
1399                 /* user name */
1400                 uname = tp;
1401                 tp += strlen(tp) + 1;
1402
1403 #ifndef DJGPP   /* for win95, session key is back in pioctl */
1404                 /* uuid */
1405                 memcpy(&uuid, tp, sizeof(uuid));
1406                 if (!cm_FindTokenEvent(uuid, sessionKey))
1407                         return CM_ERROR_INVAL;
1408 #endif /* !DJGPP */
1409         } else
1410                 cellp = cm_rootCellp;
1411
1412         if (flags & PIOCTL_LOGON) {
1413           userp = smb_FindCMUserByName(/*ioctlp->fidp->vcp,*/ uname,
1414                                                               ioctlp->fidp->vcp->rname);
1415         }
1416         
1417         /* store the token */
1418         lock_ObtainMutex(&userp->mx);
1419         ucellp = cm_GetUCell(userp, cellp);
1420         ucellp->ticketLen = ticketLen;
1421         if (ucellp->ticketp)
1422                 free(ucellp->ticketp);  /* Discard old token if any */
1423         ucellp->ticketp = malloc(ticketLen);
1424         memcpy(ucellp->ticketp, ticket, ticketLen);
1425 #ifndef DJGPP
1426         /*
1427          * Get the session key from the RPC, rather than from the pioctl.
1428          */
1429         /*
1430         memcpy(&ucellp->sessionKey, ct.HandShakeKey, sizeof(ct.HandShakeKey));
1431          */
1432         memcpy(ucellp->sessionKey.data, sessionKey, sizeof(sessionKey));
1433 #else
1434         /* for win95, we are getting the session key from the pioctl */
1435         memcpy(&ucellp->sessionKey, ct.HandShakeKey, sizeof(ct.HandShakeKey));
1436 #endif /* !DJGPP */
1437         ucellp->kvno = ct.AuthHandle;
1438         ucellp->expirationTime = ct.EndTimestamp;
1439         ucellp->gen++;
1440         if (uname) strcpy(ucellp->userName, uname);
1441         ucellp->flags |= CM_UCELLFLAG_RXKAD;
1442         lock_ReleaseMutex(&userp->mx);
1443
1444         if (flags & PIOCTL_LOGON) {
1445                 ioctlp->flags |= SMB_IOCTLFLAG_LOGON;
1446         }
1447
1448         cm_ResetACLCache(userp);
1449
1450         return 0;
1451 }
1452
1453 long cm_IoctlGetTokenIter(struct smb_ioctl *ioctlp, struct cm_user *userp)
1454 {
1455         char *tp, *cp;
1456         int iterator;
1457         int temp;
1458         cm_ucell_t *ucellp;
1459         struct ClearToken ct;
1460
1461         cm_SkipIoctlPath(ioctlp);
1462
1463         tp = ioctlp->inDatap;
1464         cp = ioctlp->outDatap;
1465
1466         /* iterator */
1467         memcpy(&iterator, tp, sizeof(iterator));
1468         tp += sizeof(iterator);
1469
1470         lock_ObtainMutex(&userp->mx);
1471
1472         /* look for token */
1473         for (;;iterator++) {
1474                 ucellp = cm_FindUCell(userp, iterator);
1475                 if (!ucellp) {
1476                         lock_ReleaseMutex(&userp->mx);
1477                         return CM_ERROR_NOMORETOKENS;
1478                 }
1479                 if (ucellp->flags & CM_UCELLFLAG_RXKAD)
1480                         break;
1481         }
1482
1483         /* new iterator */
1484         temp = ucellp->iterator + 1;
1485         memcpy(cp, &temp, sizeof(temp));
1486         cp += sizeof(temp);
1487
1488         /* ticket length */
1489         memcpy(cp, &ucellp->ticketLen, sizeof(ucellp->ticketLen));
1490         cp += sizeof(ucellp->ticketLen);
1491
1492         /* ticket */
1493         memcpy(cp, ucellp->ticketp, ucellp->ticketLen);
1494         cp += ucellp->ticketLen;
1495
1496         /* clear token size */
1497         temp = sizeof(ct);
1498         memcpy(cp, &temp, sizeof(temp));
1499         cp += sizeof(temp);
1500
1501         /* clear token */
1502         ct.AuthHandle = ucellp->kvno;
1503 #ifndef DJGPP
1504         /*
1505          * Don't give out a real session key here
1506          */
1507         /*
1508         memcpy(ct.HandShakeKey, &ucellp->sessionKey, sizeof(ct.HandShakeKey));
1509          */
1510         memset(ct.HandShakeKey, 0, sizeof(ct.HandShakeKey));
1511 #else
1512         memcpy(ct.HandShakeKey, &ucellp->sessionKey, sizeof(ct.HandShakeKey));
1513 #endif /* !DJGPP */
1514         ct.ViceId = 37;                 /* XXX */
1515         ct.BeginTimestamp = 0;          /* XXX */
1516         ct.EndTimestamp = ucellp->expirationTime;
1517         memcpy(cp, &ct, sizeof(ct));
1518         cp += sizeof(ct);
1519
1520         /* Primary flag (unused) */
1521         temp = 0;
1522         memcpy(cp, &temp, sizeof(temp));
1523         cp += sizeof(temp);
1524
1525         /* cell name */
1526         strcpy(cp, ucellp->cellp->namep);
1527         cp += strlen(cp) + 1;
1528
1529         /* user name */
1530         strcpy(cp, ucellp->userName);
1531         cp += strlen(cp) + 1;
1532
1533         ioctlp->outDatap = cp;
1534
1535         lock_ReleaseMutex(&userp->mx);
1536
1537         return 0;
1538 }
1539
1540 long cm_IoctlGetToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1541 {
1542         char *cp;
1543         int temp;
1544         cm_cell_t *cellp;
1545         cm_ucell_t *ucellp;
1546         struct ClearToken ct;
1547         char *tp;
1548 #ifndef DJGPP
1549         afs_uuid_t uuid;
1550 #endif /* !DJGPP */
1551
1552         cm_SkipIoctlPath(ioctlp);
1553
1554         tp = ioctlp->inDatap;
1555
1556         cp = ioctlp->outDatap;
1557
1558         /* cell name is right here */
1559         cellp = cm_GetCell(tp, 0);
1560         if (!cellp) return CM_ERROR_NOSUCHCELL;
1561         tp += strlen(tp) + 1;
1562
1563 #ifndef DJGPP
1564         /* uuid */
1565         memcpy(&uuid, tp, sizeof(uuid));
1566 #endif /* !DJGPP */
1567
1568         lock_ObtainMutex(&userp->mx);
1569
1570         ucellp = cm_GetUCell(userp, cellp);
1571         if (!ucellp || !(ucellp->flags & CM_UCELLFLAG_RXKAD)) {
1572                 lock_ReleaseMutex(&userp->mx);
1573                 return CM_ERROR_NOMORETOKENS;
1574         }
1575
1576         /* ticket length */
1577         memcpy(cp, &ucellp->ticketLen, sizeof(ucellp->ticketLen));
1578         cp += sizeof(ucellp->ticketLen);
1579
1580         /* ticket */
1581         memcpy(cp, ucellp->ticketp, ucellp->ticketLen);
1582         cp += ucellp->ticketLen;
1583
1584         /* clear token size */
1585         temp = sizeof(ct);
1586         memcpy(cp, &temp, sizeof(temp));
1587         cp += sizeof(temp);
1588
1589         /* clear token */
1590         ct.AuthHandle = ucellp->kvno;
1591 #ifndef DJGPP
1592         /*
1593          * Don't give out a real session key here
1594          */
1595         /*
1596         memcpy(ct.HandShakeKey, &ucellp->sessionKey, sizeof(ct.HandShakeKey));
1597          */
1598         memset(ct.HandShakeKey, 0, sizeof(ct.HandShakeKey));
1599 #else
1600         memcpy(ct.HandShakeKey, &ucellp->sessionKey, sizeof(ct.HandShakeKey));
1601 #endif /* !DJGPP */
1602         ct.ViceId = 37;                 /* XXX */
1603         ct.BeginTimestamp = 0;          /* XXX */
1604         ct.EndTimestamp = ucellp->expirationTime;
1605         memcpy(cp, &ct, sizeof(ct));
1606         cp += sizeof(ct);
1607
1608         /* Primary flag (unused) */
1609         temp = 0;
1610         memcpy(cp, &temp, sizeof(temp));
1611         cp += sizeof(temp);
1612
1613         /* cell name */
1614         strcpy(cp, ucellp->cellp->namep);
1615         cp += strlen(cp) + 1;
1616
1617         /* user name */
1618         strcpy(cp, ucellp->userName);
1619         cp += strlen(cp) + 1;
1620
1621         ioctlp->outDatap = cp;
1622
1623         lock_ReleaseMutex(&userp->mx);
1624
1625 #ifndef DJGPP
1626         cm_RegisterNewTokenEvent(uuid, ucellp->sessionKey.data);
1627 #endif /* !DJGPP */
1628
1629         return 0;
1630 }
1631
1632 long cm_IoctlDelToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1633 {
1634         char *cp;
1635         cm_cell_t *cellp;
1636         cm_ucell_t *ucellp;
1637
1638         cm_SkipIoctlPath(ioctlp);
1639
1640         cp = ioctlp->outDatap;
1641
1642         /* cell name is right here */
1643         cellp = cm_GetCell(ioctlp->inDatap, 0);
1644         if (!cellp) return CM_ERROR_NOSUCHCELL;
1645
1646         lock_ObtainMutex(&userp->mx);
1647
1648         ucellp = cm_GetUCell(userp, cellp);
1649         if (!ucellp) {
1650                 lock_ReleaseMutex(&userp->mx);
1651                 return CM_ERROR_NOMORETOKENS;
1652         }
1653
1654         if (ucellp->ticketp) {
1655                 free(ucellp->ticketp);
1656                 ucellp->ticketp = NULL;
1657         }
1658         ucellp->flags &= ~CM_UCELLFLAG_RXKAD;
1659         ucellp->gen++;
1660
1661         lock_ReleaseMutex(&userp->mx);
1662
1663         cm_ResetACLCache(userp);
1664
1665         return 0;
1666 }
1667
1668 long cm_IoctlDelAllToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
1669 {
1670         cm_ucell_t *ucellp;
1671
1672         lock_ObtainMutex(&userp->mx);
1673
1674         for (ucellp = userp->cellInfop; ucellp; ucellp = ucellp->nextp) {
1675                 ucellp->flags &= ~CM_UCELLFLAG_RXKAD;
1676                 ucellp->gen++;
1677         }
1678
1679         lock_ReleaseMutex(&userp->mx);
1680
1681         cm_ResetACLCache(userp);
1682
1683         return 0;
1684 }
1685
1686 long cm_IoctlMakeSubmount(smb_ioctl_t *ioctlp, cm_user_t *userp)
1687 {
1688         char afspath[MAX_PATH];
1689         char *submountreqp;
1690         int iteration;
1691         int submountDataSize;
1692         char *submountData;
1693         char *submountName;
1694         int nextAutoSubmount;
1695
1696         cm_SkipIoctlPath(ioctlp);
1697
1698         /* Serialize this one, to prevent simultaneous mods
1699          * to afsdsbmt.ini
1700          */
1701         lock_ObtainMutex(&cm_Afsdsbmt_Lock);
1702
1703         /* Parse the input parameters--first the required afs path,
1704          * then the requested submount name (which may be "").
1705          */
1706         cm_NormalizeAfsPath (afspath, ioctlp->inDatap);
1707         submountreqp = ioctlp->inDatap + (strlen(ioctlp->inDatap)+1);
1708
1709         /* If the caller supplied a suggested submount name, see if
1710          * that submount name is in use... if so, the submount's path
1711          * has to match our path.
1712          */
1713         if (submountreqp && *submountreqp) {
1714                 char submountPathNormalized[MAX_PATH];
1715                 char submountPath[MAX_PATH];
1716                 int submountPathLen;
1717
1718                 submountPathLen = GetPrivateProfileString("AFS Submounts",
1719                                         submountreqp, "", submountPath,
1720                                         sizeof(submountPath), "afsdsbmt.ini");
1721
1722                 if ((submountPathLen == 0) ||
1723                     (submountPathLen == sizeof(submountPath) - 1)) {
1724
1725                         /* The suggested submount name isn't in use now--
1726                          * so we can safely map the requested submount name
1727                          * to the supplied path. Remember not to write the
1728                          * leading "/afs" when writing out the submount.
1729                          */
1730                         WritePrivateProfileString("AFS Submounts",
1731                                         submountreqp, &afspath[strlen("/afs")],
1732                                         "afsdsbmt.ini");
1733
1734                         strcpy(ioctlp->outDatap, submountreqp);
1735                         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
1736                         lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
1737                         return 0;
1738                 }
1739
1740                 /* The suggested submount name is already in use--if the
1741                  * supplied path matches the submount's path, we can still
1742                  * use the suggested submount name.
1743                  */
1744                 cm_NormalizeAfsPath (submountPathNormalized, submountPath);
1745                 if (!strcmp (submountPathNormalized, afspath)) {
1746                         strcpy(ioctlp->outDatap, submountreqp);
1747                         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
1748                         lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
1749                         return 0;
1750                 }
1751         }
1752
1753         /* At this point, the user either didn't request a particular
1754          * submount name, or that submount name couldn't be used.
1755          * Look through afsdsbmt.ini to see if there are any submounts
1756          * already associated with the specified path. The first
1757          * step in doing that search is to load the AFS Submounts
1758          * section of afsdsbmt.ini into memory.
1759          */
1760
1761         submountDataSize = 1024;
1762         submountData = malloc (submountDataSize);
1763
1764         for (iteration = 0; iteration < 5; ++iteration) {
1765
1766                 int sectionSize;
1767                 sectionSize = GetPrivateProfileString("AFS Submounts",
1768                                         NULL, "", submountData,
1769                                         submountDataSize, "afsdsbmt.ini");
1770                 if (sectionSize < submountDataSize-2)
1771                         break;
1772
1773                 free (submountData);
1774                 submountDataSize *= 2;
1775                 submountData = malloc (submountDataSize);
1776         }
1777
1778         /* Having obtained a list of all available submounts, start
1779          * searching that list for a path which matches the requested
1780          * AFS path. We'll also keep track of the highest "auto15"/"auto47"
1781          * submount, in case we need to add a new one later.
1782          */
1783
1784         nextAutoSubmount = 1;
1785
1786         for (submountName = submountData;
1787                 submountName && *submountName;
1788                 submountName += 1+strlen(submountName)) {
1789
1790                 char submountPathNormalized[MAX_PATH];
1791                 char submountPath[MAX_PATH] = "";
1792                 int submountPathLen;
1793
1794                 /* If this is an Auto### submount, remember its ### value */
1795
1796                 if ((!strnicmp (submountName, "auto", 4)) &&
1797                     (isdigit (submountName[strlen("auto")]))) {
1798                         int thisAutoSubmount;
1799                         thisAutoSubmount = atoi (&submountName[strlen("auto")]);
1800                         nextAutoSubmount = max (nextAutoSubmount,
1801                                                 thisAutoSubmount+1);
1802                 }
1803
1804                 /* We have the name of a submount in the AFS Submounts
1805                  * section; read that entry to find out what path it
1806                  * maps to.
1807                  */
1808                 submountPathLen = GetPrivateProfileString("AFS Submounts",
1809                                         submountName, "", submountPath,
1810                                         sizeof(submountPath), "afsdsbmt.ini");
1811
1812                 if ((submountPathLen == 0) ||
1813                     (submountPathLen == sizeof(submountPath) - 1)) {
1814                         continue;
1815                 }
1816
1817                 /* See if the path for this submount matches the path
1818                  * that our caller specified. If so, we can return
1819                  * this submount.
1820                  */
1821                 cm_NormalizeAfsPath (submountPathNormalized, submountPath);
1822                 if (!strcmp (submountPathNormalized, afspath)) {
1823
1824                         strcpy(ioctlp->outDatap, submountName);
1825                         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
1826                         free (submountData);
1827                         lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
1828                         return 0;
1829
1830                 }
1831         }
1832
1833         free (submountData);
1834
1835         /* We've been through the entire list of existing submounts, and
1836          * didn't find any which matched the specified path. So, we'll
1837          * just have to add one. Remember not to write the leading "/afs"
1838          * when writing out the submount.
1839          */
1840
1841         sprintf(ioctlp->outDatap, "auto%ld", nextAutoSubmount);
1842
1843         WritePrivateProfileString("AFS Submounts", ioctlp->outDatap,
1844                                         &afspath[lstrlen("/afs")],
1845                                         "afsdsbmt.ini");
1846
1847         ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
1848         lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
1849         return 0;
1850 }
1851
1852 long cm_IoctlGetRxkcrypt(smb_ioctl_t *ioctlp, cm_user_t *userp)
1853 {
1854         memcpy(ioctlp->outDatap, &cryptall, sizeof(cryptall));
1855         ioctlp->outDatap += sizeof(cryptall);
1856
1857         return 0;
1858 }
1859
1860 long cm_IoctlSetRxkcrypt(smb_ioctl_t *ioctlp, cm_user_t *userp)
1861 {
1862         cm_SkipIoctlPath(ioctlp);
1863
1864         memcpy(&cryptall, ioctlp->inDatap, sizeof(cryptall));
1865
1866         return 0;
1867 }
1868
1869 #ifdef DJGPP
1870 extern int afsd_shutdown(int);
1871 extern int afs_shutdown;
1872
1873 long cm_IoctlShutdown(smb_ioctl_t *ioctlp, cm_user_t *userp) {
1874   afs_shutdown = 1;   /* flag to shut down */
1875   return 0;
1876 }
1877 #endif /* DJGPP */
1878