csc_policy_logon_updates-20040503
[openafs.git] / src / WINNT / afsd / smb3.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 #endif /* !DJGPP */
16 #include <stdlib.h>
17 #include <malloc.h>
18 #include <string.h>
19 #include <stdio.h>
20 #include <time.h>
21
22 #include <osi.h>
23
24 #include "afsd.h"
25
26 #include "smb.h"
27
28 extern osi_hyper_t hzero;
29
30 smb_packet_t *smb_Directory_Watches = NULL;
31 osi_mutex_t smb_Dir_Watch_Lock;
32
33 smb_tran2Dispatch_t smb_tran2DispatchTable[SMB_TRAN2_NOPCODES];
34
35 /* protected by the smb_globalLock */
36 smb_tran2Packet_t *smb_tran2AssemblyQueuep;
37
38 /* retrieve a held reference to a user structure corresponding to an incoming
39  * request */
40 cm_user_t *smb_GetTran2User(smb_vc_t *vcp, smb_tran2Packet_t *inp)
41 {
42         smb_user_t *uidp;
43     cm_user_t *up = NULL;
44         
45     uidp = smb_FindUID(vcp, inp->uid, 0);
46     if (!uidp) return NULL;
47         
48         lock_ObtainMutex(&uidp->mx);
49     if (uidp->unp) {
50         up = uidp->unp->userp;
51         cm_HoldUser(up);
52     }
53         lock_ReleaseMutex(&uidp->mx);
54
55     smb_ReleaseUID(uidp);
56
57     return up;
58 }
59
60 /*
61  * Return extended attributes.
62  * Right now, we aren't using any of the "new" bits, so this looks exactly
63  * like smb_Attributes() (see smb.c).
64  */
65 unsigned long smb_ExtAttributes(cm_scache_t *scp)
66 {
67         unsigned long attrs;
68
69         if (scp->fileType == CM_SCACHETYPE_DIRECTORY
70             || scp->fileType == CM_SCACHETYPE_MOUNTPOINT)
71                 attrs = SMB_ATTR_DIRECTORY;
72         else
73                 attrs = 0;
74         /*
75          * We used to mark a file RO if it was in an RO volume, but that
76          * turns out to be impolitic in NT.  See defect 10007.
77          */
78 #ifdef notdef
79         if ((scp->unixModeBits & 0222) == 0 || (scp->flags & CM_SCACHEFLAG_RO))
80 #endif
81         if ((scp->unixModeBits & 0222) == 0)
82                 attrs |= SMB_ATTR_READONLY;             /* Read-only */
83
84         if (attrs == 0)
85                 attrs = SMB_ATTR_NORMAL;                /* FILE_ATTRIBUTE_NORMAL */
86
87         return attrs;
88 }
89
90 int smb_V3IsStarMask(char *maskp)
91 {
92     char tc;
93
94         while (tc = *maskp++)
95         if (tc == '?' || tc == '*') 
96             return 1;
97         return 0;
98 }
99
100 unsigned char *smb_ParseString(unsigned char *inp, char **chainpp)
101 {
102     if (chainpp) {
103                 /* skip over null-terminated string */
104                 *chainpp = inp + strlen(inp) + 1;
105     }
106     return inp;
107 }   
108
109 long smb_ReceiveV3SessionSetupX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
110 {
111     char *tp;
112     char *usern, *pwd, *pwdx;
113     smb_user_t *uidp;
114     unsigned short newUid;
115     unsigned long caps;
116     cm_user_t *userp;
117     smb_username_t *unp;
118     char *s1 = " ";
119
120     /* Check for bad conns */
121     if (vcp->flags & SMB_VCFLAG_REMOTECONN)
122         return CM_ERROR_REMOTECONN;
123
124     /* For NT LM 0.12 and up, get capabilities */
125     if (vcp->flags & SMB_VCFLAG_USENT) {
126         caps = smb_GetSMBParm(inp, 11);
127         if (caps & 0x40)
128             vcp->flags |= SMB_VCFLAG_STATUS32;
129         /* for now, ignore other capability bits */
130     }
131
132     /* Parse the data */
133     tp = smb_GetSMBData(inp, NULL);
134     if (vcp->flags & SMB_VCFLAG_USENT)
135         pwdx = smb_ParseString(tp, &tp);
136     pwd = smb_ParseString(tp, &tp);
137     usern = smb_ParseString(tp, &tp);
138
139     /* On Windows 2000, this function appears to be called more often than
140        it is expected to be called. This resulted in multiple smb_user_t
141        records existing all for the same user session which results in all
142        of the users tokens disappearing.
143
144        To avoid this problem, we look for an existing smb_user_t record
145        based on the users name, and use that one if we find it.
146     */
147
148     uidp = smb_FindUserByNameThisSession(vcp, usern);
149     if (uidp) {   /* already there, so don't create a new one */
150         unp = uidp->unp;
151         userp = unp->userp;
152         newUid = (unsigned short)uidp->userID;  /* For some reason these are different types!*/
153                 osi_LogEvent("AFS smb_ReceiveV3SessionSetupX",NULL,"FindUserByName:Lana[%d],lsn[%d],userid[%d],name[%s]",vcp->lana,vcp->lsn,newUid,usern);
154                 osi_Log3(smb_logp,"smb_ReceiveV3SessionSetupX FindUserByName:Lana[%d],lsn[%d],userid[%d]",vcp->lana,vcp->lsn,newUid);
155         smb_ReleaseUID(uidp);
156     }
157     else {
158       /* do a global search for the username/machine name pair */
159         unp = smb_FindUserByName(usern, vcp->rname, SMB_FLAG_CREATE);
160
161         /* Create a new UID and cm_user_t structure */
162         userp = unp->userp;
163         if (!userp)
164             userp = cm_NewUser();
165         lock_ObtainMutex(&vcp->mx);
166         if (!vcp->uidCounter)
167             vcp->uidCounter++; /* handle unlikely wraparounds */
168         newUid = (strlen(usern)==0)?0:vcp->uidCounter++;
169         lock_ReleaseMutex(&vcp->mx);
170
171         /* Create a new smb_user_t structure and connect them up */
172         lock_ObtainMutex(&unp->mx);
173         unp->userp = userp;
174         lock_ReleaseMutex(&unp->mx);
175
176         uidp = smb_FindUID(vcp, newUid, SMB_FLAG_CREATE);
177         lock_ObtainMutex(&uidp->mx);
178         uidp->unp = unp;
179                 osi_LogEvent("AFS smb_ReceiveV3SessionSetupX",NULL,"MakeNewUser:VCP[%x],Lana[%d],lsn[%d],userid[%d],TicketKTCName[%s]",(int)vcp,vcp->lana,vcp->lsn,newUid,usern);
180                 osi_Log4(smb_logp,"smb_ReceiveV3SessionSetupX MakeNewUser:VCP[%x],Lana[%d],lsn[%d],userid[%d]",vcp,vcp->lana,vcp->lsn,newUid);
181         lock_ReleaseMutex(&uidp->mx);
182         smb_ReleaseUID(uidp);
183     }
184
185     /* Return UID to the client */
186     ((smb_t *)outp)->uid = newUid;
187     /* Also to the next chained message */
188     ((smb_t *)inp)->uid = newUid;
189
190     osi_Log3(smb_logp, "SMB3 session setup name %s creating ID %d%s",
191              osi_LogSaveString(smb_logp, usern), newUid, osi_LogSaveString(smb_logp, s1));
192     smb_SetSMBParm(outp, 2, 0);
193     smb_SetSMBDataLength(outp, 0);
194     return 0;
195 }
196
197 long smb_ReceiveV3UserLogoffX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
198 {
199         smb_user_t *uidp;
200
201         /* don't get tokens from this VC */
202         vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
203
204         inp->flags |= SMB_PACKETFLAG_PROFILE_UPDATE_OK;
205
206         /* find the tree and free it */
207     uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
208     /* TODO: smb_ReleaseUID() ? */
209     if (uidp) {
210                 char *s1 = NULL, *s2 = NULL;
211
212                 if (s2 == NULL) s2 = " ";
213                 if (s1 == NULL) {s1 = s2; s2 = " ";}
214
215                 osi_Log4(smb_logp, "SMB3 user logoffX uid %d name %s%s%s",
216                   uidp->userID,
217                   osi_LogSaveString(smb_logp,
218                                     (uidp->unp) ? uidp->unp->name: " "), s1, s2);
219
220                 lock_ObtainMutex(&uidp->mx);
221                 uidp->flags |= SMB_USERFLAG_DELETE;
222                 /*
223                  * it doesn't get deleted right away
224                  * because the vcp points to it
225                  */
226         lock_ReleaseMutex(&uidp->mx);
227     }
228         else    
229                 osi_Log0(smb_logp, "SMB3 user logoffX");
230
231     smb_SetSMBDataLength(outp, 0);
232     return 0;
233 }
234
235 #define SMB_SUPPORT_SEARCH_BITS        0x0001
236
237 long smb_ReceiveV3TreeConnectX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
238 {
239     smb_tid_t *tidp;
240     unsigned short newTid;
241     char shareName[256];
242         char *sharePath;
243         int shareFound;
244     char *tp;
245     char *pathp;
246     char *passwordp;
247         char *servicep;
248     cm_user_t *userp;
249         
250         osi_Log0(smb_logp, "SMB3 receive tree connect");
251
252         /* parse input parameters */
253         tp = smb_GetSMBData(inp, NULL);
254     passwordp = smb_ParseString(tp, &tp);
255         pathp = smb_ParseString(tp, &tp);
256         servicep = smb_ParseString(tp, &tp);
257
258         tp = strrchr(pathp, '\\');
259     if (!tp) {
260         return CM_ERROR_BADSMB;
261     }
262     strcpy(shareName, tp+1);
263
264         if (strcmp(servicep, "IPC") == 0 || strcmp(shareName, "IPC$") == 0)
265                 return CM_ERROR_NOIPC;
266
267     userp = smb_GetUser(vcp, inp);
268
269         lock_ObtainMutex(&vcp->mx);
270     newTid = vcp->tidCounter++;
271         lock_ReleaseMutex(&vcp->mx);
272         
273         tidp = smb_FindTID(vcp, newTid, SMB_FLAG_CREATE);
274         shareFound = smb_FindShare(vcp, inp, shareName, &sharePath);
275         if (!shareFound) {
276                 smb_ReleaseTID(tidp);
277                 return CM_ERROR_BADSHARENAME;
278         }
279     lock_ObtainMutex(&tidp->mx);
280     tidp->userp = userp;
281         tidp->pathname = sharePath;
282     lock_ReleaseMutex(&tidp->mx);
283     smb_ReleaseTID(tidp);
284
285         if (vcp->flags & SMB_VCFLAG_USENT)
286     {
287         int policy = smb_FindShareCSCPolicy(shareName);
288         smb_SetSMBParm(outp, 2, SMB_SUPPORT_SEARCH_BITS | (policy << 2));
289     }
290
291         ((smb_t *)outp)->tid = newTid;
292         ((smb_t *)inp)->tid = newTid;
293         tp = smb_GetSMBData(outp, NULL);
294     *tp++ = 'A';
295     *tp++ = ':';
296     *tp++ = 0;
297     smb_SetSMBDataLength(outp, 3);
298
299     osi_Log1(smb_logp, "SMB3 tree connect created ID %d", newTid);
300     return 0;
301 }
302
303 /* must be called with global tran lock held */
304 smb_tran2Packet_t *smb_FindTran2Packet(smb_vc_t *vcp, smb_packet_t *inp)
305 {
306         smb_tran2Packet_t *tp;
307     smb_t *smbp;
308         
309     smbp = (smb_t *) inp->data;
310         for(tp = smb_tran2AssemblyQueuep; tp; tp = (smb_tran2Packet_t *) osi_QNext(&tp->q)) {
311                 if (tp->vcp == vcp && tp->mid == smbp->mid && tp->tid == smbp->tid)
312             return tp;
313     }
314     return NULL;
315 }
316
317 smb_tran2Packet_t *smb_NewTran2Packet(smb_vc_t *vcp, smb_packet_t *inp,
318         int totalParms, int totalData)
319 {
320         smb_tran2Packet_t *tp;
321     smb_t *smbp;
322         
323     smbp = (smb_t *) inp->data;
324         tp = malloc(sizeof(*tp));
325     memset(tp, 0, sizeof(*tp));
326     tp->vcp = vcp;
327     smb_HoldVC(vcp);
328     tp->curData = tp->curParms = 0;
329     tp->totalData = totalData;
330     tp->totalParms = totalParms;
331     tp->tid = smbp->tid;
332     tp->mid = smbp->mid;
333     tp->uid = smbp->uid;
334     tp->pid = smbp->pid;
335         tp->res[0] = smbp->res[0];
336         osi_QAdd((osi_queue_t **)&smb_tran2AssemblyQueuep, &tp->q);
337     tp->opcode = smb_GetSMBParm(inp, 14);
338         if (totalParms != 0)
339         tp->parmsp = malloc(totalParms);
340         if (totalData != 0)
341         tp->datap = malloc(totalData);
342         tp->flags |= SMB_TRAN2PFLAG_ALLOC;
343     return tp;
344 }
345
346 smb_tran2Packet_t *smb_GetTran2ResponsePacket(smb_vc_t *vcp,
347         smb_tran2Packet_t *inp, smb_packet_t *outp,
348         int totalParms, int totalData)
349 {
350         smb_tran2Packet_t *tp;
351         unsigned short parmOffset;
352         unsigned short dataOffset;
353         unsigned short dataAlign;
354         
355         tp = malloc(sizeof(*tp));
356     memset(tp, 0, sizeof(*tp));
357     tp->vcp = NULL;
358     tp->curData = tp->curParms = 0;
359     tp->totalData = totalData;
360     tp->totalParms = totalParms;
361         tp->oldTotalParms = totalParms;
362     tp->tid = inp->tid;
363     tp->mid = inp->mid;
364     tp->uid = inp->uid;
365     tp->pid = inp->pid;
366         tp->res[0] = inp->res[0];
367     tp->opcode = inp->opcode;
368
369         /*
370          * We calculate where the parameters and data will start.
371          * This calculation must parallel the calculation in
372          * smb_SendTran2Packet.
373          */
374
375         parmOffset = 10*2 + 35;
376         parmOffset++;                   /* round to even */
377         tp->parmsp = (unsigned short *) (outp->data + parmOffset);
378
379         dataOffset = parmOffset + totalParms;
380         dataAlign = dataOffset & 2;     /* quad-align */
381         dataOffset += dataAlign;
382         tp->datap = outp->data + dataOffset;
383
384     return tp;
385 }
386
387 /* free a tran2 packet; must be called with smb_globalLock held */
388 void smb_FreeTran2Packet(smb_tran2Packet_t *t2p)
389 {
390     if (t2p->vcp) smb_ReleaseVC(t2p->vcp);
391         if (t2p->flags & SMB_TRAN2PFLAG_ALLOC) {
392                 if (t2p->parmsp)
393                         free(t2p->parmsp);
394                 if (t2p->datap)
395                         free(t2p->datap);
396         }
397     free(t2p);
398 }
399
400 /* called with a VC, an input packet to respond to, and an error code.
401  * sends an error response.
402  */
403 void smb_SendTran2Error(smb_vc_t *vcp, smb_tran2Packet_t *t2p,
404         smb_packet_t *tp, long code)
405 {
406     smb_t *smbp;
407     unsigned short errCode;
408     unsigned char errClass;
409         unsigned long NTStatus;
410
411     if (vcp->flags & SMB_VCFLAG_STATUS32)
412                 smb_MapNTError(code, &NTStatus);
413         else
414                 smb_MapCoreError(code, vcp, &errCode, &errClass);
415
416     smb_FormatResponsePacket(vcp, NULL, tp);
417     smbp = (smb_t *) tp;
418
419         /* We can handle long names */
420         if (vcp->flags & SMB_VCFLAG_USENT)
421                 smbp->flg2 |= 0x40;     /* IS_LONG_NAME */
422         
423     /* now copy important fields from the tran 2 packet */
424     smbp->com = 0x32;           /* tran 2 response */
425     smbp->tid = t2p->tid;
426     smbp->mid = t2p->mid;
427     smbp->pid = t2p->pid;
428     smbp->uid = t2p->uid;
429         smbp->res[0] = t2p->res[0];
430         if (vcp->flags & SMB_VCFLAG_STATUS32) {
431                 smbp->rcls = (unsigned char) (NTStatus & 0xff);
432                 smbp->reh = (unsigned char) ((NTStatus >> 8) & 0xff);
433                 smbp->errLow = (unsigned char) ((NTStatus >> 16) & 0xff);
434                 smbp->errHigh = (unsigned char) ((NTStatus >> 24) & 0xff);
435                 smbp->flg2 |= 0x4000;
436         }
437         else {
438         smbp->rcls = errClass;
439                 smbp->errLow = (unsigned char) (errCode & 0xff);
440                 smbp->errHigh = (unsigned char) ((errCode >> 8) & 0xff);
441         }
442         
443     /* send packet */
444     smb_SendPacket(vcp, tp);
445 }        
446
447 void smb_SendTran2Packet(smb_vc_t *vcp, smb_tran2Packet_t *t2p, smb_packet_t *tp)
448 {
449     smb_t *smbp;
450     unsigned short parmOffset;
451         unsigned short dataOffset;
452         unsigned short totalLength;
453         unsigned short dataAlign;
454     char *datap;
455         
456     smb_FormatResponsePacket(vcp, NULL, tp);
457     smbp = (smb_t *) tp;
458
459         /* We can handle long names */
460         if (vcp->flags & SMB_VCFLAG_USENT)
461                 smbp->flg2 |= 0x40;     /* IS_LONG_NAME */
462
463     /* now copy important fields from the tran 2 packet */
464     smbp->com = 0x32;           /* tran 2 response */
465     smbp->tid = t2p->tid;
466     smbp->mid = t2p->mid;
467     smbp->pid = t2p->pid;
468     smbp->uid = t2p->uid;
469         smbp->res[0] = t2p->res[0];
470
471     totalLength = 1 + t2p->totalData + t2p->totalParms;
472
473     /* now add the core parameters (tran2 info) to the packet */
474     smb_SetSMBParm(tp, 0, t2p->totalParms);     /* parm bytes */
475     smb_SetSMBParm(tp, 1, t2p->totalData);      /* data bytes */
476     smb_SetSMBParm(tp, 2, 0);           /* reserved */
477     smb_SetSMBParm(tp, 3, t2p->totalParms);     /* parm bytes in this packet */
478         parmOffset = 10*2 + 35;                 /* parm offset in packet */
479         parmOffset++;                           /* round to even */
480     smb_SetSMBParm(tp, 4, parmOffset);  /* 11 parm words plus *
481     * hdr, bcc and wct */
482     smb_SetSMBParm(tp, 5, 0);           /* parm displacement */
483     smb_SetSMBParm(tp, 6, t2p->totalData);      /* data in this packet */
484         dataOffset = parmOffset + t2p->oldTotalParms;
485         dataAlign = dataOffset & 2;             /* quad-align */
486         dataOffset += dataAlign;
487     smb_SetSMBParm(tp, 7, dataOffset);  /* offset of data */
488     smb_SetSMBParm(tp, 8, 0);           /* data displacement */
489     smb_SetSMBParm(tp, 9, 0);           /* low: setup word count *
490     * high: resvd */
491
492     datap = smb_GetSMBData(tp, NULL);
493         *datap++ = 0;                           /* we rounded to even */
494
495         totalLength += dataAlign;
496     smb_SetSMBDataLength(tp, totalLength);
497         
498     /* next, send the datagram */
499     smb_SendPacket(vcp, tp);
500 }   
501
502 long smb_ReceiveV3Tran2A(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
503 {
504     smb_tran2Packet_t *asp;
505     int totalParms;
506     int totalData;
507     int parmDisp;
508     int dataDisp;
509     int parmOffset;
510     int dataOffset;
511     int parmCount;
512     int dataCount;
513     int firstPacket;
514     long code = 0;
515
516         /* We sometimes see 0 word count.  What to do? */
517         if (*inp->wctp == 0) {
518 #ifndef DJGPP
519                 HANDLE h;
520                 char *ptbuf[1];
521
522                 osi_Log0(smb_logp, "TRANSACTION2 word count = 0"); 
523
524                 h = RegisterEventSource(NULL, AFS_DAEMON_EVENT_NAME);
525                 ptbuf[0] = "Transaction2 word count = 0";
526                 ReportEvent(h, EVENTLOG_WARNING_TYPE, 0, 1003, NULL,
527                             1, inp->ncb_length, ptbuf, inp);
528                 DeregisterEventSource(h);
529 #else /* DJGPP */
530                 osi_Log0(smb_logp, "TRANSACTION2 word count = 0"); 
531 #endif /* !DJGPP */
532
533         smb_SetSMBDataLength(outp, 0);
534         smb_SendPacket(vcp, outp);
535                 return 0;
536         }
537
538     totalParms = smb_GetSMBParm(inp, 0);
539     totalData = smb_GetSMBParm(inp, 1);
540         
541     firstPacket = (inp->inCom == 0x32);
542         
543         /* find the packet we're reassembling */
544         lock_ObtainWrite(&smb_globalLock);
545     asp = smb_FindTran2Packet(vcp, inp);
546     if (!asp) {
547         asp = smb_NewTran2Packet(vcp, inp, totalParms, totalData);
548         }
549     lock_ReleaseWrite(&smb_globalLock);
550         
551     /* now merge in this latest packet; start by looking up offsets */
552         if (firstPacket) {
553                 parmDisp = dataDisp = 0;
554         parmOffset = smb_GetSMBParm(inp, 10);
555         dataOffset = smb_GetSMBParm(inp, 12);
556         parmCount = smb_GetSMBParm(inp, 9);
557         dataCount = smb_GetSMBParm(inp, 11);
558                 asp->maxReturnParms = smb_GetSMBParm(inp, 2);
559         asp->maxReturnData = smb_GetSMBParm(inp, 3);
560
561                 osi_Log3(smb_logp, "SMB3 received T2 init packet total data %d, cur data %d, max return data %d",
562                  totalData, dataCount, asp->maxReturnData);
563     }
564     else {
565         parmDisp = smb_GetSMBParm(inp, 4);
566         parmOffset = smb_GetSMBParm(inp, 3);
567         dataDisp = smb_GetSMBParm(inp, 7);
568         dataOffset = smb_GetSMBParm(inp, 6);
569         parmCount = smb_GetSMBParm(inp, 2);
570         dataCount = smb_GetSMBParm(inp, 5);
571
572         osi_Log2(smb_logp, "SMB3 received T2 aux packet parms %d, data %d",
573                  parmCount, dataCount);
574     }   
575
576     /* now copy the parms and data */
577     if ( parmCount != 0 )
578     {
579         memcpy(((char *)asp->parmsp) + parmDisp, inp->data + parmOffset, parmCount);
580     }
581     if ( dataCount != 0 ) {
582         memcpy(asp->datap + dataDisp, inp->data + dataOffset, dataCount);
583     }
584
585     /* account for new bytes */
586     asp->curData += dataCount;
587     asp->curParms += parmCount;
588
589     /* finally, if we're done, remove the packet from the queue and dispatch it */
590     if (asp->totalData <= asp->curData && asp->totalParms <= asp->curParms) {
591                 /* we've received it all */
592         lock_ObtainWrite(&smb_globalLock);
593                 osi_QRemove((osi_queue_t **) &smb_tran2AssemblyQueuep, &asp->q);
594         lock_ReleaseWrite(&smb_globalLock);
595
596         /* now dispatch it */
597         if ( asp->opcode >= 0 && asp->opcode < 20 && smb_tran2DispatchTable[asp->opcode].procp) {
598             osi_LogEvent("AFS-Dispatch-2[%s]",myCrt_2Dispatch(asp->opcode),"vcp[%x] lana[%d] lsn[%d]",(int)vcp,vcp->lana,vcp->lsn);
599             osi_Log4(smb_logp,"AFS Server - Dispatch-2 %s vcp[%x] lana[%d] lsn[%d]",myCrt_2Dispatch(asp->opcode),vcp,vcp->lana,vcp->lsn);
600             code = (*smb_tran2DispatchTable[asp->opcode].procp)(vcp, asp, outp);
601         }
602         else {
603             osi_LogEvent("AFS-Dispatch-2 [invalid]", NULL, "op[%x] vcp[%x] lana[%d] lsn[%d]", asp->opcode, vcp, vcp->lana, vcp->lsn);
604             osi_Log4(smb_logp,"AFS Server - Dispatch-2 [INVALID] op[%x] vcp[%x] lana[%d] lsn[%d]", asp->opcode, vcp, vcp->lana, vcp->lsn);
605             code = CM_ERROR_BADOP;
606         }
607
608                 /* if an error is returned, we're supposed to send an error packet,
609          * otherwise the dispatched function already did the data sending.
610          * We give dispatched proc the responsibility since it knows how much
611          * space to allocate.
612          */
613         if (code != 0) {
614             smb_SendTran2Error(vcp, asp, outp, code);
615         }
616
617                 /* free the input tran 2 packet */
618                 lock_ObtainWrite(&smb_globalLock);
619         smb_FreeTran2Packet(asp);
620                 lock_ReleaseWrite(&smb_globalLock);
621     }
622     else if (firstPacket) {
623                 /* the first packet in a multi-packet request, we need to send an
624          * ack to get more data.
625          */
626         smb_SetSMBDataLength(outp, 0);
627         smb_SendPacket(vcp, outp);
628     }
629
630         return 0;
631 }
632
633 long smb_ReceiveTran2Open(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op)
634 {
635         char *pathp;
636     smb_tran2Packet_t *outp;
637     long code = 0;
638         cm_space_t *spacep;
639     int excl;
640     cm_user_t *userp;
641     cm_scache_t *dscp;          /* dir we're dealing with */
642     cm_scache_t *scp;           /* file we're creating */
643     cm_attr_t setAttr;
644     int initialModeBits;
645     smb_fid_t *fidp;
646     int attributes;
647     char *lastNamep;
648     long dosTime;
649     int openFun;
650     int trunc;
651     int openMode;
652     int extraInfo;
653     int openAction;
654     int parmSlot;                       /* which parm we're dealing with */
655     long returnEALength;
656         char *tidPathp;
657         cm_req_t req;
658
659         cm_InitReq(&req);
660
661     scp = NULL;
662         
663         extraInfo = (p->parmsp[0] & 1); /* return extra info */
664     returnEALength = (p->parmsp[0] & 8);        /* return extended attr length */
665
666         openFun = p->parmsp[6];         /* open function */
667     excl = ((openFun & 3) == 0);
668     trunc = ((openFun & 3) == 2);       /* truncate it */
669         openMode = (p->parmsp[1] & 0x7);
670     openAction = 0;                     /* tracks what we did */
671
672     attributes = p->parmsp[3];
673     dosTime = p->parmsp[4] | (p->parmsp[5] << 16);
674         
675         /* compute initial mode bits based on read-only flag in attributes */
676     initialModeBits = 0666;
677     if (attributes & 1) initialModeBits &= ~0222;
678         
679     pathp = (char *) (&p->parmsp[14]);
680         
681     outp = smb_GetTran2ResponsePacket(vcp, p, op, 40, 0);
682
683         spacep = cm_GetSpace();
684     smb_StripLastComponent(spacep->data, &lastNamep, pathp);
685
686         if (lastNamep && strcmp(lastNamep, SMB_IOCTL_FILENAME) == 0) {
687                 /* special case magic file name for receiving IOCTL requests
688          * (since IOCTL calls themselves aren't getting through).
689          */
690         fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
691         smb_SetupIoctlFid(fidp, spacep);
692
693         /* copy out remainder of the parms */
694                 parmSlot = 0;
695                 outp->parmsp[parmSlot] = fidp->fid; parmSlot++;
696                 if (extraInfo) {
697             outp->parmsp[parmSlot] = /* attrs */ 0; parmSlot++;
698             outp->parmsp[parmSlot] = 0; parmSlot++;     /* mod time */
699             outp->parmsp[parmSlot] = 0; parmSlot++;
700             outp->parmsp[parmSlot] = 0; parmSlot++;     /* len */
701             outp->parmsp[parmSlot] = 0x7fff; parmSlot++;
702             outp->parmsp[parmSlot] = openMode; parmSlot++;
703             outp->parmsp[parmSlot] = 0; parmSlot++; /* file type 0 ==> normal file or dir */
704             outp->parmsp[parmSlot] = 0; parmSlot++; /* IPC junk */
705                 }   
706                 /* and the final "always present" stuff */
707         outp->parmsp[parmSlot] = /* openAction found existing file */ 1; parmSlot++;
708                 /* next write out the "unique" ID */
709                 outp->parmsp[parmSlot] = 0x1234; parmSlot++;
710                 outp->parmsp[parmSlot] = 0x5678; parmSlot++;
711         outp->parmsp[parmSlot] = 0; parmSlot++;
712                 if (returnEALength) {
713                         outp->parmsp[parmSlot] = 0; parmSlot++;
714                         outp->parmsp[parmSlot] = 0; parmSlot++;
715         }
716                 
717         outp->totalData = 0;
718         outp->totalParms = parmSlot * 2;
719                 
720         smb_SendTran2Packet(vcp, outp, op);
721                 
722         smb_FreeTran2Packet(outp);
723
724                 /* and clean up fid reference */
725         smb_ReleaseFID(fidp);
726         return 0;
727     }
728
729 #ifdef DEBUG_VERBOSE
730         {
731                 char *hexp, *asciip;
732                 asciip = (lastNamep ? lastNamep : pathp);
733                 hexp = osi_HexifyString( asciip );
734                 DEBUG_EVENT2("AFS","T2Open H[%s] A[%s]", hexp, asciip);
735                 free(hexp);
736         }
737 #endif
738
739         userp = smb_GetTran2User(vcp, p);
740     /* In the off chance that userp is NULL, we log and abandon */
741     if(!userp) {
742         osi_Log1(smb_logp, "ReceiveTran2Open user [%d] not resolvable", p->uid);
743         smb_FreeTran2Packet(outp);
744         return CM_ERROR_BADSMB;
745     }
746
747         tidPathp = smb_GetTIDPath(vcp, p->tid);
748
749         dscp = NULL;
750         code = cm_NameI(cm_rootSCachep, pathp,
751                     CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
752                     userp, tidPathp, &req, &scp);
753         if (code != 0) {
754                 code = cm_NameI(cm_rootSCachep, spacep->data,
755                         CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
756                         userp, tidPathp, &req, &dscp);
757                 cm_FreeSpace(spacep);
758
759         if (code) {
760             cm_ReleaseUser(userp);
761                         smb_FreeTran2Packet(outp);
762             return code;
763         }
764         
765         /* otherwise, scp points to the parent directory.  Do a lookup,
766                  * and truncate the file if we find it, otherwise we create the
767                  * file.
768          */
769         if (!lastNamep) lastNamep = pathp;
770         else lastNamep++;
771         code = cm_Lookup(dscp, lastNamep, CM_FLAG_CASEFOLD, userp,
772                          &req, &scp);
773         if (code && code != CM_ERROR_NOSUCHFILE) {
774                         cm_ReleaseSCache(dscp);
775             cm_ReleaseUser(userp);
776                         smb_FreeTran2Packet(outp);
777             return code;
778         }
779         }
780     else {
781         cm_FreeSpace(spacep);
782         }
783         
784     /* if we get here, if code is 0, the file exists and is represented by
785      * scp.  Otherwise, we have to create it.
786      */
787         if (code == 0) {
788         code = cm_CheckOpen(scp, openMode, trunc, userp, &req);
789         if (code) {
790             if (dscp) cm_ReleaseSCache(dscp);
791             cm_ReleaseSCache(scp);
792             cm_ReleaseUser(userp);
793                         smb_FreeTran2Packet(outp);
794             return code;
795         }
796
797                 if (excl) {
798                         /* oops, file shouldn't be there */
799             if (dscp) cm_ReleaseSCache(dscp);
800             cm_ReleaseSCache(scp);
801             cm_ReleaseUser(userp);
802                         smb_FreeTran2Packet(outp);
803             return CM_ERROR_EXISTS;
804         }
805
806                 if (trunc) {
807                         setAttr.mask = CM_ATTRMASK_LENGTH;
808             setAttr.length.LowPart = 0;
809             setAttr.length.HighPart = 0;
810                         code = cm_SetAttr(scp, &setAttr, userp, &req);
811             openAction = 3;     /* truncated existing file */
812                 }   
813         else openAction = 1;    /* found existing file */
814     }
815         else if (!(openFun & SMB_ATTR_DIRECTORY)) {
816                 /* don't create if not found */
817         if (dscp) cm_ReleaseSCache(dscp);
818         osi_assert(scp == NULL);
819         cm_ReleaseUser(userp);
820                 smb_FreeTran2Packet(outp);
821         return CM_ERROR_NOSUCHFILE;
822     }
823     else {
824                 osi_assert(dscp != NULL && scp == NULL);
825                 openAction = 2; /* created file */
826                 setAttr.mask = CM_ATTRMASK_CLIENTMODTIME;
827                 smb_UnixTimeFromSearchTime(&setAttr.clientModTime, dosTime);
828         code = cm_Create(dscp, lastNamep, 0, &setAttr, &scp, userp,
829                          &req);
830                 if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
831                         smb_NotifyChange(FILE_ACTION_ADDED,
832                              FILE_NOTIFY_CHANGE_FILE_NAME,  
833                              dscp, lastNamep, NULL, TRUE);
834         if (!excl && code == CM_ERROR_EXISTS) {
835                         /* not an exclusive create, and someone else tried
836                          * creating it already, then we open it anyway.  We
837                          * don't bother retrying after this, since if this next
838                          * fails, that means that the file was deleted after we
839                          * started this call.
840              */
841             code = cm_Lookup(dscp, lastNamep, CM_FLAG_CASEFOLD,
842                              userp, &req, &scp);
843             if (code == 0) {
844                 if (trunc) {
845                                         setAttr.mask = CM_ATTRMASK_LENGTH;
846                     setAttr.length.LowPart = 0;
847                     setAttr.length.HighPart = 0;
848                     code = cm_SetAttr(scp, &setAttr, userp,
849                                       &req);
850                 }   
851                         }       /* lookup succeeded */
852         }
853     }
854         
855         /* we don't need this any longer */
856         if (dscp) cm_ReleaseSCache(dscp);
857
858     if (code) {
859                 /* something went wrong creating or truncating the file */
860         if (scp) cm_ReleaseSCache(scp);
861         cm_ReleaseUser(userp);
862                 smb_FreeTran2Packet(outp);
863         return code;
864     }
865         
866         /* make sure we're about to open a file */
867         if (scp->fileType != CM_SCACHETYPE_FILE) {
868                 cm_ReleaseSCache(scp);
869                 cm_ReleaseUser(userp);
870                 smb_FreeTran2Packet(outp);
871                 return CM_ERROR_ISDIR;
872         }
873
874     /* now all we have to do is open the file itself */
875     fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
876     osi_assert(fidp);
877         
878         /* save a pointer to the vnode */
879     fidp->scp = scp;
880         
881         /* compute open mode */
882     if (openMode != 1) fidp->flags |= SMB_FID_OPENREAD;
883     if (openMode == 1 || openMode == 2)
884         fidp->flags |= SMB_FID_OPENWRITE;
885
886         smb_ReleaseFID(fidp);
887         
888         cm_Open(scp, 0, userp);
889
890     /* copy out remainder of the parms */
891         parmSlot = 0;
892         outp->parmsp[parmSlot] = fidp->fid; parmSlot++;
893         lock_ObtainMutex(&scp->mx);
894         if (extraInfo) {
895         outp->parmsp[parmSlot] = smb_Attributes(scp); parmSlot++;
896                 smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
897         outp->parmsp[parmSlot] = (unsigned short)(dosTime & 0xffff); parmSlot++;
898         outp->parmsp[parmSlot] = (unsigned short)((dosTime>>16) & 0xffff); parmSlot++;
899         outp->parmsp[parmSlot] = (unsigned short) (scp->length.LowPart & 0xffff);
900         parmSlot++;
901         outp->parmsp[parmSlot] = (unsigned short) ((scp->length.LowPart >> 16) & 0xffff);
902         parmSlot++;
903         outp->parmsp[parmSlot] = openMode; parmSlot++;
904         outp->parmsp[parmSlot] = 0; parmSlot++; /* file type 0 ==> normal file or dir */
905         outp->parmsp[parmSlot] = 0; parmSlot++; /* IPC junk */
906         }   
907         /* and the final "always present" stuff */
908     outp->parmsp[parmSlot] = openAction; parmSlot++;
909         /* next write out the "unique" ID */
910         outp->parmsp[parmSlot] = (unsigned short) (scp->fid.vnode & 0xffff); parmSlot++;
911         outp->parmsp[parmSlot] = (unsigned short) (scp->fid.volume & 0xffff); parmSlot++;
912     outp->parmsp[parmSlot] = 0; parmSlot++;
913     if (returnEALength) {
914                 outp->parmsp[parmSlot] = 0; parmSlot++;
915                 outp->parmsp[parmSlot] = 0; parmSlot++;
916     }
917         lock_ReleaseMutex(&scp->mx);
918         outp->totalData = 0;            /* total # of data bytes */
919     outp->totalParms = parmSlot * 2;    /* shorts are two bytes */
920
921         smb_SendTran2Packet(vcp, outp, op);
922         
923     smb_FreeTran2Packet(outp);
924
925     cm_ReleaseUser(userp);
926     /* leave scp held since we put it in fidp->scp */
927     return 0;
928 }   
929
930 long smb_ReceiveTran2FindFirst(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
931 {
932     return CM_ERROR_BADOP;
933 }
934
935 long smb_ReceiveTran2FindNext(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
936 {
937     return CM_ERROR_BADOP;
938 }
939
940 long smb_ReceiveTran2QFSInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op)
941 {
942         smb_tran2Packet_t *outp;
943     smb_tran2QFSInfo_t qi;
944         int responseSize;
945         osi_hyper_t temp;
946         static char FSname[6] = {'A', 0, 'F', 0, 'S', 0};
947         
948         osi_Log1(smb_logp, "T2 QFSInfo type 0x%x", p->parmsp[0]);
949
950         switch (p->parmsp[0]) {
951         case 1: responseSize = sizeof(qi.u.allocInfo); break;
952         case 2: responseSize = sizeof(qi.u.volumeInfo); break;
953         case 0x102: responseSize = sizeof(qi.u.FSvolumeInfo); break;
954         case 0x103: responseSize = sizeof(qi.u.FSsizeInfo); break;
955         case 0x104: responseSize = sizeof(qi.u.FSdeviceInfo); break;
956         case 0x105: responseSize = sizeof(qi.u.FSattributeInfo); break;
957         default: return CM_ERROR_INVAL;
958         }
959
960     outp = smb_GetTran2ResponsePacket(vcp, p, op, 0, responseSize);
961         switch (p->parmsp[0]) {
962         case 1:
963                 /* alloc info */
964         qi.u.allocInfo.FSID = 0;
965         qi.u.allocInfo.sectorsPerAllocUnit = 1;
966         qi.u.allocInfo.totalAllocUnits = 0x7fffffff;
967         qi.u.allocInfo.availAllocUnits = 0x3fffffff;
968         qi.u.allocInfo.bytesPerSector = 1024;
969                 break;
970
971     case 2:
972                 /* volume info */
973         qi.u.volumeInfo.vsn = 1234;
974         qi.u.volumeInfo.vnCount = 4;
975                 /* we're supposed to pad it out with zeroes to the end */
976                 memset(&qi.u.volumeInfo.label, 0, sizeof(qi.u.volumeInfo.label));
977         memcpy(qi.u.volumeInfo.label, "AFS", 4);
978                 break;
979
980         case 0x102:
981                 /* FS volume info */
982                 memset((char *)&qi.u.FSvolumeInfo.vct, 0, sizeof(FILETIME));
983                 qi.u.FSvolumeInfo.vsn = 1234;
984                 qi.u.FSvolumeInfo.vnCount = 8;
985                 memcpy(qi.u.FSvolumeInfo.label, "A\0F\0S\0\0", 8);
986                 break;
987
988         case 0x103:
989                 /* FS size info */
990                 temp.HighPart = 0;
991                 temp.LowPart = 0x7fffffff;
992                 qi.u.FSsizeInfo.totalAllocUnits = temp;
993                 temp.LowPart = 0x3fffffff;
994                 qi.u.FSsizeInfo.availAllocUnits = temp;
995                 qi.u.FSsizeInfo.sectorsPerAllocUnit = 1;
996                 qi.u.FSsizeInfo.bytesPerSector = 1024;
997                 break;
998
999         case 0x104:
1000                 /* FS device info */
1001                 qi.u.FSdeviceInfo.devType = 0;  /* don't have a number */
1002                 qi.u.FSdeviceInfo.characteristics = 0x50; /* remote, virtual */
1003                 break;
1004
1005         case 0x105:
1006                 /* FS attribute info */
1007                 /* attributes, defined in WINNT.H:
1008                  *      FILE_CASE_SENSITIVE_SEARCH      0x1
1009                  *      FILE_CASE_PRESERVED_NAMES       0x2
1010                  *      <no name defined>               0x4000
1011                  *         If bit 0x4000 is not set, Windows 95 thinks
1012                  *         we can't handle long (non-8.3) names,
1013                  *         despite our protestations to the contrary.
1014                  */
1015                 qi.u.FSattributeInfo.attributes = 0x4003;
1016                 qi.u.FSattributeInfo.maxCompLength = 255;
1017                 qi.u.FSattributeInfo.FSnameLength = 6;
1018                 memcpy(qi.u.FSattributeInfo.FSname, FSname, 6);
1019                 break;
1020     }
1021         
1022         /* copy out return data, and set corresponding sizes */
1023         outp->totalParms = 0;
1024     outp->totalData = responseSize;
1025     memcpy(outp->datap, &qi, responseSize);
1026
1027         /* send and free the packets */
1028         smb_SendTran2Packet(vcp, outp, op);
1029     smb_FreeTran2Packet(outp);
1030
1031     return 0;
1032 }
1033
1034 long smb_ReceiveTran2SetFSInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1035 {
1036     return CM_ERROR_BADOP;
1037 }
1038
1039 struct smb_ShortNameRock {
1040         char *maskp;
1041         unsigned int vnode;
1042         char *shortName;
1043         size_t shortNameLen;
1044 };
1045
1046 int cm_GetShortNameProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *vrockp,
1047         osi_hyper_t *offp)
1048 {
1049         struct smb_ShortNameRock *rockp;
1050         char *shortNameEnd;
1051
1052         rockp = vrockp;
1053         /* compare both names and vnodes, though probably just comparing vnodes
1054          * would be safe enough.
1055          */
1056         if (stricmp(dep->name, rockp->maskp) != 0)
1057                 return 0;
1058         if (ntohl(dep->fid.vnode) != rockp->vnode)
1059                 return 0;
1060         /* This is the entry */
1061         cm_Gen8Dot3Name(dep, rockp->shortName, &shortNameEnd);
1062         rockp->shortNameLen = shortNameEnd - rockp->shortName;
1063         return CM_ERROR_STOPNOW;
1064 }
1065
1066 long cm_GetShortName(char *pathp, cm_user_t *userp, cm_req_t *reqp,
1067         char *tidPathp, int vnode, char *shortName, size_t *shortNameLenp)
1068 {
1069         struct smb_ShortNameRock rock;
1070         char *lastNamep;
1071         cm_space_t *spacep;
1072         cm_scache_t *dscp;
1073         int caseFold = CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD;
1074         long code = 0;
1075         osi_hyper_t thyper;
1076
1077         spacep = cm_GetSpace();
1078         smb_StripLastComponent(spacep->data, &lastNamep, pathp);
1079
1080         code = cm_NameI(cm_rootSCachep, spacep->data, caseFold, userp, tidPathp,
1081                      reqp, &dscp);
1082         cm_FreeSpace(spacep);
1083         if (code) return code;
1084
1085         if (!lastNamep) lastNamep = pathp;
1086         else lastNamep++;
1087         thyper.LowPart = 0;
1088         thyper.HighPart = 0;
1089         rock.shortName = shortName;
1090         rock.vnode = vnode;
1091         rock.maskp = lastNamep;
1092         code = cm_ApplyDir(dscp, cm_GetShortNameProc, &rock, &thyper, userp,
1093                         reqp, NULL);
1094
1095         cm_ReleaseSCache(dscp);
1096
1097         if (code == 0)
1098                 return CM_ERROR_NOSUCHFILE;
1099         if (code == CM_ERROR_STOPNOW) {
1100                 *shortNameLenp = rock.shortNameLen;
1101                 return 0;
1102         }
1103         return code;
1104 }
1105
1106 long smb_ReceiveTran2QPathInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *opx)
1107 {
1108         smb_tran2Packet_t *outp;
1109     unsigned long dosTime;
1110         FILETIME ft;
1111     unsigned short infoLevel;
1112     int nbytesRequired;
1113     unsigned short attributes;
1114         unsigned long extAttributes;
1115         char shortName[13];
1116         unsigned int len;
1117     cm_user_t *userp;
1118         cm_space_t *spacep;
1119     cm_scache_t *scp, *dscp;
1120     long code = 0;
1121     char *op;
1122         char *tidPathp;
1123         char *lastComp;
1124         cm_req_t req;
1125
1126         cm_InitReq(&req);
1127
1128         infoLevel = p->parmsp[0];
1129     if (infoLevel == 6) nbytesRequired = 0;
1130     else if (infoLevel == 1) nbytesRequired = 22;
1131     else if (infoLevel == 2) nbytesRequired = 26;
1132         else if (infoLevel == 0x101) nbytesRequired = 40;
1133         else if (infoLevel == 0x102) nbytesRequired = 24;
1134         else if (infoLevel == 0x103) nbytesRequired = 4;
1135         else if (infoLevel == 0x108) nbytesRequired = 30;
1136     else {
1137                 osi_Log2(smb_logp, "Bad Tran2 op 0x%x infolevel 0x%x",
1138                   p->opcode, infoLevel);
1139                 smb_SendTran2Error(vcp, p, opx, CM_ERROR_INVAL);
1140         return 0;
1141     }
1142         osi_Log2(smb_logp, "T2 QPathInfo type 0x%x path %s", infoLevel,
1143              osi_LogSaveString(smb_logp, (char *)(&p->parmsp[3])));
1144
1145     outp = smb_GetTran2ResponsePacket(vcp, p, opx, 2, nbytesRequired);
1146
1147         if (infoLevel > 0x100)
1148                 outp->totalParms = 2;
1149         else
1150                 outp->totalParms = 0;
1151         outp->totalData = nbytesRequired;
1152         
1153     /* now, if we're at infoLevel 6, we're only being asked to check
1154      * the syntax, so we just OK things now.  In particular, we're *not*
1155      * being asked to verify anything about the state of any parent dirs.
1156      */
1157         if (infoLevel == 6) {
1158                 smb_SendTran2Packet(vcp, outp, opx);
1159         smb_FreeTran2Packet(outp);
1160                 return 0;
1161     }
1162         
1163     userp = smb_GetTran2User(vcp, p);
1164     if(!userp) {
1165         osi_Log1(smb_logp, "ReceiveTran2QPathInfo unable to resolve user [%d]", p->uid);
1166         smb_FreeTran2Packet(outp);
1167         return CM_ERROR_BADSMB;
1168     }
1169
1170         tidPathp = smb_GetTIDPath(vcp, p->tid);
1171
1172         /*
1173          * XXX Strange hack XXX
1174          *
1175          * As of Patch 7 (13 January 98), we are having the following problem:
1176          * In NT Explorer 4.0, whenever we click on a directory, AFS gets
1177          * requests to look up "desktop.ini" in all the subdirectories.
1178          * This can cause zillions of timeouts looking up non-existent cells
1179          * and volumes, especially in the top-level directory.
1180          *
1181          * We have not found any way to avoid this or work around it except
1182          * to explicitly ignore the requests for mount points that haven't
1183          * yet been evaluated and for directories that haven't yet been
1184          * fetched.
1185          */
1186         if (infoLevel == 0x101) {
1187                 spacep = cm_GetSpace();
1188                 smb_StripLastComponent(spacep->data, &lastComp,
1189                                         (char *)(&p->parmsp[3]));
1190                 /* Make sure that lastComp is not NULL */
1191                 if (lastComp) {
1192                     if (strcmp(lastComp, "\\desktop.ini") == 0) {
1193                 code = cm_NameI(cm_rootSCachep, spacep->data,
1194                                 CM_FLAG_CASEFOLD
1195                                 | CM_FLAG_DIRSEARCH
1196                                 | CM_FLAG_FOLLOW,
1197                                 userp, tidPathp, &req, &dscp);
1198                 if (code == 0) {
1199                     if (dscp->fileType == CM_SCACHETYPE_MOUNTPOINT
1200                          && !dscp->mountRootFidp)
1201                         code = CM_ERROR_NOSUCHFILE;
1202                     else if (dscp->fileType == CM_SCACHETYPE_DIRECTORY) {
1203                         cm_buf_t *bp = buf_Find(dscp, &hzero);
1204                         if (bp)
1205                             buf_Release(bp);
1206                         else
1207                             code = CM_ERROR_NOSUCHFILE;
1208                     }
1209                     cm_ReleaseSCache(dscp);
1210                     if (code) {
1211                         cm_FreeSpace(spacep);
1212                         cm_ReleaseUser(userp);
1213                         smb_SendTran2Error(vcp, p, opx, code);
1214                         smb_FreeTran2Packet(outp);
1215                         return 0;
1216                     }
1217                 }
1218             }
1219         }
1220                 cm_FreeSpace(spacep);
1221         }
1222
1223         /* now do namei and stat, and copy out the info */
1224     code = cm_NameI(cm_rootSCachep, (char *)(&p->parmsp[3]),
1225                     CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD, userp, tidPathp, &req, &scp);
1226
1227         if (code) {
1228                 cm_ReleaseUser(userp);
1229         smb_SendTran2Error(vcp, p, opx, code);
1230         smb_FreeTran2Packet(outp);
1231         return 0;
1232     }
1233
1234     lock_ObtainMutex(&scp->mx);
1235         code = cm_SyncOp(scp, NULL, userp, &req, 0,
1236                          CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1237         if (code) goto done;
1238         
1239     /* now we have the status in the cache entry, and everything is locked.
1240          * Marshall the output data.
1241      */
1242         op = outp->datap;
1243         /* for info level 108, figure out short name */
1244         if (infoLevel == 0x108) {
1245                 code = cm_GetShortName((char *)(&p->parmsp[3]), userp, &req,
1246                                 tidPathp, scp->fid.vnode, shortName,
1247                                 (size_t *) &len);
1248                 if (code) {
1249                         goto done;
1250                 }
1251
1252                 op = outp->datap;
1253                 *((u_long *)op) = len * 2; op += 4;
1254                 mbstowcs((unsigned short *)op, shortName, len);
1255                 op += (len * 2);
1256
1257                 goto done;
1258         }
1259         if (infoLevel == 1 || infoLevel == 2) {
1260                 smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
1261         *((u_long *)op) = dosTime; op += 4;     /* creation time */
1262         *((u_long *)op) = dosTime; op += 4;     /* access time */
1263         *((u_long *)op) = dosTime; op += 4;     /* write time */
1264         *((u_long *)op) = scp->length.LowPart; op += 4; /* length */
1265         *((u_long *)op) = scp->length.LowPart; op += 4; /* alloc size */
1266                 attributes = smb_Attributes(scp);
1267                 *((u_short *)op) = attributes; op += 2; /* attributes */
1268         }
1269         else if (infoLevel == 0x101) {
1270                 smb_LargeSearchTimeFromUnixTime(&ft, scp->clientModTime);
1271                 *((FILETIME *)op) = ft; op += 8;        /* creation time */
1272                 *((FILETIME *)op) = ft; op += 8;        /* last access time */
1273                 *((FILETIME *)op) = ft; op += 8;        /* last write time */
1274                 *((FILETIME *)op) = ft; op += 8;        /* last change time */
1275                 extAttributes = smb_ExtAttributes(scp);
1276                 *((u_long *)op) = extAttributes; op += 4; /* extended attribs */
1277                 *((u_long *)op) = 0; op += 4;   /* don't know what this is */
1278         }
1279         else if (infoLevel == 0x102) {
1280                 *((LARGE_INTEGER *)op) = scp->length; op += 8;  /* alloc size */
1281                 *((LARGE_INTEGER *)op) = scp->length; op += 8;  /* EOF */
1282                 *((u_long *)op) = scp->linkCount; op += 4;
1283                 *op++ = 0;
1284                 *op++ = 0;
1285                 *op++ = (scp->fileType == CM_SCACHETYPE_DIRECTORY ? 1 : 0);
1286                 *op++ = 0;
1287         }
1288         else if (infoLevel == 0x103) {
1289                 memset(op, 0, 4); op += 4;      /* EA size */
1290         }
1291
1292         /* now, if we are being asked about extended attrs, return a 0 size */
1293         if (infoLevel == 2) {
1294                 *((u_long *)op) = 0; op += 4;
1295         }
1296         
1297
1298         /* send and free the packets */
1299   done:
1300         lock_ReleaseMutex(&scp->mx);
1301     cm_ReleaseSCache(scp);
1302     cm_ReleaseUser(userp);
1303         if (code == 0) 
1304         smb_SendTran2Packet(vcp, outp, opx);
1305     else 
1306         smb_SendTran2Error(vcp, p, opx, code);
1307     smb_FreeTran2Packet(outp);
1308
1309     return 0;
1310 }
1311
1312 long smb_ReceiveTran2SetPathInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1313 {
1314     return CM_ERROR_BADOP;
1315 }
1316
1317 long smb_ReceiveTran2QFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *opx)
1318 {
1319         smb_tran2Packet_t *outp;
1320         FILETIME ft;
1321         unsigned long attributes;
1322         unsigned short infoLevel;
1323         int nbytesRequired;
1324         unsigned short fid;
1325         cm_user_t *userp;
1326     smb_fid_t *fidp;
1327         cm_scache_t *scp;
1328         char *op;
1329         long code = 0;
1330         cm_req_t req;
1331
1332         cm_InitReq(&req);
1333
1334     fid = p->parmsp[0];
1335     fidp = smb_FindFID(vcp, fid, 0);
1336
1337         if (fidp == NULL) {
1338                 smb_SendTran2Error(vcp, p, opx, CM_ERROR_BADFD);
1339                 return 0;
1340         }
1341
1342         infoLevel = p->parmsp[1];
1343         if (infoLevel == 0x101) nbytesRequired = 40;
1344         else if (infoLevel == 0x102) nbytesRequired = 24;
1345         else if (infoLevel == 0x103) nbytesRequired = 4;
1346         else if (infoLevel == 0x104) nbytesRequired = 6;
1347         else {
1348                 osi_Log2(smb_logp, "Bad Tran2 op 0x%x infolevel 0x%x",
1349                  p->opcode, infoLevel);
1350                 smb_SendTran2Error(vcp, p, opx, CM_ERROR_INVAL);
1351         smb_ReleaseFID(fidp);
1352                 return 0;
1353         }
1354         osi_Log2(smb_logp, "T2 QFileInfo type 0x%x fid %d", infoLevel, fid);
1355
1356         outp = smb_GetTran2ResponsePacket(vcp, p, opx, 2, nbytesRequired);
1357
1358         if (infoLevel > 0x100)
1359                 outp->totalParms = 2;
1360         else
1361                 outp->totalParms = 0;
1362         outp->totalData = nbytesRequired;
1363
1364         userp = smb_GetTran2User(vcp, p);
1365     if(!userp) {
1366         osi_Log1(smb_logp, "ReceiveTran2QFileInfo unable to resolve user [%d]", p->uid);
1367         code = CM_ERROR_BADSMB;
1368         goto done;
1369     }
1370
1371         scp = fidp->scp;
1372         lock_ObtainMutex(&scp->mx);
1373         code = cm_SyncOp(scp, NULL, userp, &req, 0,
1374                      CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1375         if (code) goto done;
1376
1377         /* now we have the status in the cache entry, and everything is locked.
1378          * Marshall the output data.
1379          */
1380         op = outp->datap;
1381         if (infoLevel == 0x101) {
1382                 smb_LargeSearchTimeFromUnixTime(&ft, scp->clientModTime);
1383                 *((FILETIME *)op) = ft; op += 8;        /* creation time */
1384                 *((FILETIME *)op) = ft; op += 8;        /* last access time */
1385                 *((FILETIME *)op) = ft; op += 8;        /* last write time */
1386                 *((FILETIME *)op) = ft; op += 8;        /* last change time */
1387                 attributes = smb_ExtAttributes(scp);
1388                 *((u_long *)op) = attributes; op += 4;
1389                 *((u_long *)op) = 0; op += 4;
1390         }
1391         else if (infoLevel == 0x102) {
1392                 *((LARGE_INTEGER *)op) = scp->length; op += 8;  /* alloc size */
1393                 *((LARGE_INTEGER *)op) = scp->length; op += 8;  /* EOF */
1394                 *((u_long *)op) = scp->linkCount; op += 4;
1395                 *op++ = ((fidp->flags & SMB_FID_DELONCLOSE) ? 1 : 0);
1396                 *op++ = (scp->fileType == CM_SCACHETYPE_DIRECTORY ? 1 : 0);
1397                 *op++ = 0;
1398                 *op++ = 0;
1399         }
1400         else if (infoLevel == 0x103) {
1401                 *((u_long *)op) = 0; op += 4;
1402         }
1403         else if (infoLevel == 0x104) {
1404                 unsigned long len;
1405                 char *name;
1406
1407                 if (fidp->NTopen_wholepathp)
1408                         name = fidp->NTopen_wholepathp;
1409                 else
1410                         name = "\\";    /* probably can't happen */
1411                 len = strlen(name);
1412                 outp->totalData = (len*2) + 4;  /* this is actually what we want to return */
1413                 *((u_long *)op) = len * 2; op += 4;
1414                 mbstowcs((unsigned short *)op, name, len); op += (len * 2);
1415         }
1416
1417         /* send and free the packets */
1418   done:
1419         lock_ReleaseMutex(&scp->mx);
1420         cm_ReleaseUser(userp);
1421         smb_ReleaseFID(fidp);
1422         if (code == 0) smb_SendTran2Packet(vcp, outp, opx);
1423         else smb_SendTran2Error(vcp, p, opx, code);
1424         smb_FreeTran2Packet(outp);
1425
1426         return 0;
1427 }
1428
1429 long smb_ReceiveTran2SetFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op)
1430 {
1431         long code = 0;
1432         unsigned short fid;
1433         smb_fid_t *fidp;
1434         unsigned short infoLevel;
1435         smb_tran2Packet_t *outp;
1436         cm_user_t *userp;
1437         cm_scache_t *scp;
1438         cm_req_t req;
1439
1440         cm_InitReq(&req);
1441
1442     fid = p->parmsp[0];
1443         fidp = smb_FindFID(vcp, fid, 0);
1444
1445         if (fidp == NULL) {
1446                 smb_SendTran2Error(vcp, p, op, CM_ERROR_BADFD);
1447                 return 0;
1448         }
1449
1450         infoLevel = p->parmsp[1];
1451         if (infoLevel > 0x104 || infoLevel < 0x101) {
1452                 osi_Log2(smb_logp, "Bad Tran2 op 0x%x infolevel 0x%x",
1453                          p->opcode, infoLevel);
1454                 smb_SendTran2Error(vcp, p, op, CM_ERROR_INVAL);
1455         smb_ReleaseFID(fidp);
1456                 return 0;
1457         }
1458
1459         if (infoLevel == 0x102 && !(fidp->flags & SMB_FID_OPENDELETE)) {
1460                 smb_SendTran2Error(vcp, p, op, CM_ERROR_NOACCESS);
1461         smb_ReleaseFID(fidp);
1462                 return 0;
1463         }
1464         if ((infoLevel == 0x103 || infoLevel == 0x104)
1465             && !(fidp->flags & SMB_FID_OPENWRITE)) {
1466                 smb_SendTran2Error(vcp, p, op, CM_ERROR_NOACCESS);
1467         smb_ReleaseFID(fidp);
1468                 return 0;
1469         }
1470
1471         osi_Log1(smb_logp, "T2 SFileInfo type 0x%x", infoLevel);
1472
1473         outp = smb_GetTran2ResponsePacket(vcp, p, op, 2, 0);
1474
1475         outp->totalParms = 2;
1476         outp->totalData = 0;
1477
1478         userp = smb_GetTran2User(vcp, p);
1479     if(!userp) {
1480         osi_Log1(smb_logp,"ReceiveTran2SetFileInfo unable to resolve user [%d]", p->uid);
1481         code = CM_ERROR_BADSMB;
1482         goto done;
1483     }
1484
1485         scp = fidp->scp;
1486
1487         if (infoLevel == 0x101) {
1488                 FILETIME lastMod;
1489                 unsigned int attribute;
1490                 cm_attr_t attr;
1491
1492                 /* lock the vnode with a callback; we need the current status
1493                  * to determine what the new status is, in some cases.
1494                  */
1495                 lock_ObtainMutex(&scp->mx);
1496                 code = cm_SyncOp(scp, NULL, userp, &req, 0,
1497                          CM_SCACHESYNC_GETSTATUS
1498                          | CM_SCACHESYNC_NEEDCALLBACK);
1499                 if (code) {
1500                         lock_ReleaseMutex(&scp->mx);
1501                         goto done;
1502                 }
1503
1504                 /* prepare for setattr call */
1505                 attr.mask = 0;
1506                 
1507                 lastMod = *((FILETIME *)(p->datap + 16));
1508                 /* when called as result of move a b, lastMod is (-1, -1). 
1509          * If the check for -1 is not present, timestamp
1510                  * of the resulting file will be 1969 (-1)
1511                  */
1512                 if (LargeIntegerNotEqualToZero(*((LARGE_INTEGER *)&lastMod)) && 
1513             lastMod.dwLowDateTime != -1 && lastMod.dwHighDateTime != -1) {
1514                         attr.mask |= CM_ATTRMASK_CLIENTMODTIME;
1515                         smb_UnixTimeFromLargeSearchTime(&attr.clientModTime,
1516                                                         &lastMod);
1517                         fidp->flags |= SMB_FID_MTIMESETDONE;
1518                 }
1519                 
1520                 attribute = *((u_long *)(p->datap + 32));
1521                 if (attribute != 0) {
1522                         if ((scp->unixModeBits & 0222)
1523                             && (attribute & 1) != 0) {
1524                                 /* make a writable file read-only */
1525                                 attr.mask |= CM_ATTRMASK_UNIXMODEBITS;
1526                                 attr.unixModeBits = scp->unixModeBits & ~0222;
1527                         }
1528                         else if ((scp->unixModeBits & 0222) == 0
1529                                  && (attribute & 1) == 0) {
1530                                 /* make a read-only file writable */
1531                                 attr.mask |= CM_ATTRMASK_UNIXMODEBITS;
1532                                 attr.unixModeBits = scp->unixModeBits | 0222;
1533                         }
1534                 }
1535                 lock_ReleaseMutex(&scp->mx);
1536
1537                 /* call setattr */
1538                 if (attr.mask)
1539                         code = cm_SetAttr(scp, &attr, userp, &req);
1540                 else
1541                         code = 0;
1542         }
1543         else if (infoLevel == 0x103 || infoLevel == 0x104) {
1544                 LARGE_INTEGER size = *((LARGE_INTEGER *)(p->datap));
1545                 cm_attr_t attr;
1546
1547                 attr.mask = CM_ATTRMASK_LENGTH;
1548                 attr.length.LowPart = size.LowPart;
1549                 attr.length.HighPart = size.HighPart;
1550                 code = cm_SetAttr(scp, &attr, userp, &req);
1551         }
1552         else if (infoLevel == 0x102) {
1553                 if (*((char *)(p->datap))) {
1554                         code = cm_CheckNTDelete(fidp->NTopen_dscp, scp, userp,
1555                                                 &req);
1556                         if (code == 0)
1557                                 fidp->flags |= SMB_FID_DELONCLOSE;
1558                 }
1559                 else {
1560                         code = 0;
1561                         fidp->flags &= ~SMB_FID_DELONCLOSE;
1562                 }
1563         }
1564   done:
1565         cm_ReleaseUser(userp);
1566         smb_ReleaseFID(fidp);
1567         if (code == 0) smb_SendTran2Packet(vcp, outp, op);
1568         else smb_SendTran2Error(vcp, p, op, code);
1569         smb_FreeTran2Packet(outp);
1570
1571         return 0;
1572 }
1573
1574 long smb_ReceiveTran2FSCTL(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1575 {
1576     return CM_ERROR_BADOP;
1577 }
1578
1579 long smb_ReceiveTran2IOCTL(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1580 {
1581     return CM_ERROR_BADOP;
1582 }
1583
1584 long smb_ReceiveTran2FindNotifyFirst(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1585 {
1586     return CM_ERROR_BADOP;
1587 }
1588
1589 long smb_ReceiveTran2FindNotifyNext(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1590 {
1591     return CM_ERROR_BADOP;
1592 }
1593
1594 long smb_ReceiveTran2MKDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *outp)
1595 {
1596     return CM_ERROR_BADOP;
1597 }
1598
1599 long smb_ApplyV3DirListPatches(cm_scache_t *dscp,
1600         smb_dirListPatch_t **dirPatchespp, int infoLevel, cm_user_t *userp,
1601         cm_req_t *reqp)
1602 {
1603         long code = 0;
1604     cm_scache_t *scp;
1605     cm_scache_t *targetScp;                     /* target if scp is a symlink */
1606     char *dptr;
1607     long dosTime;
1608         FILETIME ft;
1609     int shortTemp;
1610     unsigned short attr;
1611         unsigned long lattr;
1612     smb_dirListPatch_t *patchp;
1613     smb_dirListPatch_t *npatchp;
1614         
1615     for(patchp = *dirPatchespp; patchp; patchp =
1616          (smb_dirListPatch_t *) osi_QNext(&patchp->q)) {
1617                 code = cm_GetSCache(&patchp->fid, &scp, userp, reqp);
1618         if (code) continue;
1619         lock_ObtainMutex(&scp->mx);
1620         code = cm_SyncOp(scp, NULL, userp, reqp, 0,
1621                           CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1622                 if (code) { 
1623                         lock_ReleaseMutex(&scp->mx);
1624                         cm_ReleaseSCache(scp);
1625                         continue;
1626         }
1627                 
1628         /* now watch for a symlink */
1629         if (scp->fileType == CM_SCACHETYPE_SYMLINK) {
1630                         lock_ReleaseMutex(&scp->mx);
1631             code = cm_EvaluateSymLink(dscp, scp, &targetScp, userp, reqp);
1632             if (code == 0) {
1633                                 /* we have a more accurate file to use (the
1634                                  * target of the symbolic link).  Otherwise,
1635                                  * we'll just use the symlink anyway.
1636                  */
1637                                 osi_Log2(smb_logp, "symlink vp %x to vp %x",
1638                          scp, targetScp);
1639                                 cm_ReleaseSCache(scp);
1640                 scp = targetScp;
1641             }
1642             lock_ObtainMutex(&scp->mx);
1643         }
1644
1645                 dptr = patchp->dptr;
1646
1647                 if (infoLevel >= 0x101) {
1648                         /* get filetime */
1649                         smb_LargeSearchTimeFromUnixTime(&ft, scp->clientModTime);
1650
1651                         /* copy to Creation Time */
1652                         *((FILETIME *)dptr) = ft;
1653                         dptr += 8;
1654
1655                         /* copy to Last Access Time */
1656                         *((FILETIME *)dptr) = ft;
1657                         dptr += 8;
1658
1659                         /* copy to Last Write Time */
1660                         *((FILETIME *)dptr) = ft;
1661                         dptr += 8;
1662
1663                         /* copy to Change Time */
1664                         *((FILETIME *)dptr) = ft;
1665                         dptr += 8;
1666
1667                         /* Use length for both file length and alloc length */
1668                         *((LARGE_INTEGER *)dptr) = scp->length;
1669                         dptr += 8;
1670                         *((LARGE_INTEGER *)dptr) = scp->length;
1671                         dptr += 8;
1672
1673                         /* Copy attributes */
1674                         lattr = smb_ExtAttributes(scp);
1675             /* merge in hidden (dot file) attribute */
1676                         if( patchp->flags & SMB_DIRLISTPATCH_DOTFILE )
1677                                 lattr |= SMB_ATTR_HIDDEN;
1678                         *((u_long *)dptr) = lattr;
1679                         dptr += 4;
1680                 }
1681                 else {
1682                         /* get dos time */
1683                         smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
1684
1685                         /* and copy out date */
1686                         shortTemp = (dosTime>>16) & 0xffff;
1687                         *((u_short *)dptr) = shortTemp;
1688                         dptr += 2;
1689
1690                         /* copy out creation time */
1691                         shortTemp = dosTime & 0xffff;
1692                         *((u_short *)dptr) = shortTemp;
1693                         dptr += 2;
1694
1695                         /* and copy out date */
1696                         shortTemp = (dosTime>>16) & 0xffff;
1697                         *((u_short *)dptr) = shortTemp;
1698                         dptr += 2;
1699                         
1700                         /* copy out access time */
1701                         shortTemp = dosTime & 0xffff;
1702                         *((u_short *)dptr) = shortTemp;
1703                         dptr += 2;
1704
1705                         /* and copy out date */
1706                         shortTemp = (dosTime>>16) & 0xffff;
1707                         *((u_short *)dptr) = shortTemp;
1708                         dptr += 2;
1709                         
1710                         /* copy out mod time */
1711                         shortTemp = dosTime & 0xffff;
1712                         *((u_short *)dptr) = shortTemp;
1713                         dptr += 2;
1714
1715                         /* copy out file length and alloc length,
1716                          * using the same for both
1717                          */
1718                         *((u_long *)dptr) = scp->length.LowPart;
1719                         dptr += 4;
1720                         *((u_long *)dptr) = scp->length.LowPart;
1721                         dptr += 4;
1722
1723                         /* finally copy out attributes as short */
1724                         attr = smb_Attributes(scp);
1725             /* merge in hidden (dot file) attribute */
1726             if( patchp->flags & SMB_DIRLISTPATCH_DOTFILE )
1727                 attr |= SMB_ATTR_HIDDEN;
1728                         *dptr++ = attr & 0xff;
1729                         *dptr++ = (attr >> 8) & 0xff;
1730                 }
1731
1732         lock_ReleaseMutex(&scp->mx);
1733         cm_ReleaseSCache(scp);
1734         }
1735         
1736     /* now free the patches */
1737     for(patchp = *dirPatchespp; patchp; patchp = npatchp) {
1738                 npatchp = (smb_dirListPatch_t *) osi_QNext(&patchp->q);
1739         free(patchp);
1740         }
1741         
1742     /* and mark the list as empty */
1743     *dirPatchespp = NULL;
1744
1745     return code;
1746 }
1747
1748 /* do a case-folding search of the star name mask with the name in namep.
1749  * Return 1 if we match, otherwise 0.
1750  */
1751 int smb_V3MatchMask(char *namep, char *maskp, int flags)
1752 {
1753         unsigned char tcp1, tcp2;       /* Pattern characters */
1754     unsigned char tcn1;         /* Name characters */
1755         int sawDot = 0, sawStar = 0, req8dot3 = 0;
1756         char *starNamep, *starMaskp;
1757         static char nullCharp[] = {0};
1758
1759         /* make sure we only match 8.3 names, if requested */
1760     req8dot3 = (flags & CM_FLAG_8DOT3);
1761         if (req8dot3 && !cm_Is8Dot3(namep)) 
1762         return 0;
1763
1764         /* loop */
1765         while (1) {
1766                 /* Next pattern character */
1767                 tcp1 = *maskp++;
1768
1769                 /* Next name character */
1770                 tcn1 = *namep;
1771
1772                 if (tcp1 == 0) {
1773                         /* 0 - end of pattern */
1774                         if (tcn1 == 0)
1775                                 return 1;
1776                         else
1777                                 return 0;
1778                 }
1779                 else if (tcp1 == '.' || tcp1 == '"') {
1780                         if (sawDot) {
1781                                 if (tcn1 == '.') {
1782                                         namep++;
1783                                         continue;
1784                                 } else
1785                                         return 0;
1786                         }
1787                         else {
1788                                 /*
1789                                  * first dot in pattern;
1790                                  * must match dot or end of name
1791                                  */
1792                                 sawDot = 1;
1793                                 if (tcn1 == 0)
1794                                         continue;
1795                                 else if (tcn1 == '.') {
1796                                         sawStar = 0;
1797                                         namep++;
1798                                         continue;
1799                                 }
1800                                 else
1801                                         return 0;
1802                         }
1803                 }
1804                 else if (tcp1 == '?') {
1805                         if (tcn1 == 0 || tcn1 == '.')
1806                                 return 0;
1807                         namep++;
1808                         continue;
1809                 }
1810                 else if (tcp1 == '>') {
1811                         if (tcn1 != 0 && tcn1 != '.')
1812                                 namep++;
1813                         continue;
1814                 }
1815                 else if (tcp1 == '*' || tcp1 == '<') {
1816                         tcp2 = *maskp++;
1817                         if (tcp2 == 0)
1818                                 return 1;
1819                         else if ((req8dot3 && tcp2 == '.') || tcp2 == '"') {
1820                                 while (req8dot3 && tcn1 != '.' && tcn1 != 0)
1821                                         tcn1 = *++namep;
1822                                 if (tcn1 == 0) {
1823                                         if (sawDot)
1824                                                 return 0;
1825                                         else
1826                                                 continue;
1827                                 }
1828                                 else {
1829                                         namep++;
1830                                         continue;
1831                                 }
1832                         }
1833                         else {
1834                                 /*
1835                                  * pattern character after '*' is not null or
1836                                  * period.  If it is '?' or '>', we are not
1837                                  * going to understand it.  If it is '*' or
1838                                  * '<', we are going to skip over it.  None of
1839                                  * these are likely, I hope.
1840                                  */
1841                                 /* skip over '*' and '<' */
1842                                 while (tcp2 == '*' || tcp2 == '<')
1843                                         tcp2 = *maskp++;
1844
1845                                 /* skip over characters that don't match tcp2 */
1846                                 while (req8dot3 && tcn1 != '.' && tcn1 != 0
1847                                         && cm_foldUpper[tcn1] != cm_foldUpper[tcp2])
1848                                         tcn1 = *++namep;
1849
1850                                 /* No match */
1851                                 if ((req8dot3 && tcn1 == '.') || tcn1 == 0)
1852                                         return 0;
1853
1854                                 /* Remember where we are */
1855                                 sawStar = 1;
1856                                 starMaskp = maskp;
1857                                 starNamep = namep;
1858
1859                                 namep++;
1860                                 continue;
1861                         }
1862                 }
1863                 else {
1864                         /* tcp1 is not a wildcard */
1865                         if (cm_foldUpper[tcn1] == cm_foldUpper[tcp1]) {
1866                                 /* they match */
1867                                 namep++;
1868                                 continue;
1869                         }
1870                         /* if trying to match a star pattern, go back */
1871                         if (sawStar) {
1872                                 maskp = starMaskp - 2;
1873                                 namep = starNamep + 1;
1874                                 sawStar = 0;
1875                                 continue;
1876                         }
1877                         /* that's all */
1878                         return 0;
1879                 }
1880         }
1881 }
1882
1883 long smb_ReceiveTran2SearchDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *opx)
1884 {
1885         int attribute;
1886     long nextCookie;
1887     char *tp;
1888     long code = 0;
1889     char *pathp;
1890     cm_dirEntry_t *dep;
1891     int maxCount;
1892     smb_dirListPatch_t *dirListPatchesp;
1893     smb_dirListPatch_t *curPatchp;
1894     cm_buf_t *bufferp;
1895     long temp;
1896     long orbytes;                       /* # of bytes in this output record */
1897     long ohbytes;                       /* # of bytes, except file name */
1898     long onbytes;                       /* # of bytes in name, incl. term. null */
1899     osi_hyper_t dirLength;
1900     osi_hyper_t bufferOffset;
1901     osi_hyper_t curOffset;
1902     osi_hyper_t thyper;
1903     smb_dirSearch_t *dsp;
1904     cm_scache_t *scp;
1905     long entryInDir;
1906     long entryInBuffer;
1907         cm_pageHeader_t *pageHeaderp;
1908     cm_user_t *userp = NULL;
1909     int slotInPage;
1910     int returnedNames;
1911     long nextEntryCookie;
1912     int numDirChunks;           /* # of 32 byte dir chunks in this entry */
1913     char *op;                   /* output data ptr */
1914         char *origOp;                   /* original value of op */
1915     cm_space_t *spacep;         /* for pathname buffer */
1916     long maxReturnData;         /* max # of return data */
1917     long maxReturnParms;                /* max # of return parms */
1918     long bytesInBuffer;         /* # data bytes in the output buffer */
1919     int starPattern;
1920     char *maskp;                        /* mask part of path */
1921     int infoLevel;
1922     int searchFlags;
1923     int eos;
1924     smb_tran2Packet_t *outp;    /* response packet */
1925         char *tidPathp;
1926         int align;
1927         char shortName[13];             /* 8.3 name if needed */
1928         int NeedShortName;
1929         char *shortNameEnd;
1930     int fileType;
1931     cm_fid_t fid;
1932
1933     cm_req_t req;
1934
1935         cm_InitReq(&req);
1936
1937         eos = 0;
1938         if (p->opcode == 1) {
1939                 /* find first; obtain basic parameters from request */
1940         attribute = p->parmsp[0];
1941         maxCount = p->parmsp[1];
1942         infoLevel = p->parmsp[3];
1943         searchFlags = p->parmsp[2];
1944         dsp = smb_NewDirSearch(1);
1945         dsp->attribute = attribute;
1946         pathp = ((char *) p->parmsp) + 12;      /* points to path */
1947         nextCookie = 0;
1948         maskp = strrchr(pathp, '\\');
1949         if (maskp == NULL) maskp = pathp;
1950                 else maskp++;   /* skip over backslash */
1951         strcpy(dsp->mask, maskp);       /* and save mask */
1952                 /* track if this is likely to match a lot of entries */
1953         starPattern = smb_V3IsStarMask(maskp);
1954         }
1955     else {
1956                 osi_assert(p->opcode == 2);
1957         /* find next; obtain basic parameters from request or open dir file */
1958         dsp = smb_FindDirSearch(p->parmsp[0]);
1959         if (!dsp) return CM_ERROR_BADFD;
1960         attribute = dsp->attribute;
1961         maxCount = p->parmsp[1];
1962         infoLevel = p->parmsp[2];
1963         searchFlags = p->parmsp[5];
1964         pathp = NULL;
1965         nextCookie = p->parmsp[3] | (p->parmsp[4] << 16);
1966         maskp = dsp->mask;
1967                 starPattern = 1;        /* assume, since required a Find Next */
1968     }
1969
1970         osi_Log4(smb_logp,
1971               "T2 search dir attr 0x%x, info level %d, max count %d, flags 0x%x",
1972               attribute, infoLevel, maxCount, searchFlags);
1973
1974         osi_Log2(smb_logp, "...T2 search op %d, nextCookie 0x%x",
1975               p->opcode, nextCookie);
1976
1977         if (infoLevel >= 0x101)
1978                 searchFlags &= ~4;      /* no resume keys */
1979
1980     dirListPatchesp = NULL;
1981
1982         maxReturnData = p->maxReturnData;
1983     if (p->opcode == 1) /* find first */
1984         maxReturnParms = 10;    /* bytes */
1985         else    
1986         maxReturnParms = 8;     /* bytes */
1987
1988 #ifndef CM_CONFIG_MULTITRAN2RESPONSES
1989     if (maxReturnData > 6000) 
1990         maxReturnData = 6000;
1991 #endif /* CM_CONFIG_MULTITRAN2RESPONSES */
1992
1993         outp = smb_GetTran2ResponsePacket(vcp, p, opx, maxReturnParms,
1994                                       maxReturnData);
1995
1996     osi_Log1(smb_logp, "T2 receive search dir %s",
1997              osi_LogSaveString(smb_logp, pathp));
1998         
1999     /* bail out if request looks bad */
2000     if (p->opcode == 1 && !pathp) {
2001         smb_ReleaseDirSearch(dsp);
2002         smb_FreeTran2Packet(outp);
2003         return CM_ERROR_BADSMB;
2004     }
2005         
2006         osi_Log2(smb_logp, "T2 dir search cookie 0x%x, connection %d",
2007              nextCookie, dsp->cookie);
2008
2009         userp = smb_GetTran2User(vcp, p);
2010     if (!userp) {
2011         osi_Log1(smb_logp, "T2 dir search unable to resolve user [%d]", p->uid);
2012         smb_ReleaseDirSearch(dsp);
2013         smb_FreeTran2Packet(outp);
2014         return CM_ERROR_BADSMB;
2015     }
2016
2017         /* try to get the vnode for the path name next */
2018         lock_ObtainMutex(&dsp->mx);
2019         if (dsp->scp) {
2020                 scp = dsp->scp;
2021         cm_HoldSCache(scp);
2022         code = 0;
2023     }
2024     else {
2025                 spacep = cm_GetSpace();
2026         smb_StripLastComponent(spacep->data, NULL, pathp);
2027         lock_ReleaseMutex(&dsp->mx);
2028
2029                 tidPathp = smb_GetTIDPath(vcp, p->tid);
2030         code = cm_NameI(cm_rootSCachep, spacep->data,
2031                         CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
2032                         userp, tidPathp, &req, &scp);
2033         cm_FreeSpace(spacep);
2034
2035         lock_ObtainMutex(&dsp->mx);
2036                 if (code == 0) {
2037             if (dsp->scp != 0) cm_ReleaseSCache(dsp->scp);
2038                         dsp->scp = scp;
2039                         /* we need one hold for the entry we just stored into,
2040              * and one for our own processing.  When we're done
2041                          * with this function, we'll drop the one for our own
2042                          * processing.  We held it once from the namei call,
2043                          * and so we do another hold now.
2044              */
2045             cm_HoldSCache(scp);
2046                         lock_ObtainMutex(&scp->mx);
2047                         if ((scp->flags & CM_SCACHEFLAG_BULKSTATTING) == 0
2048                             && LargeIntegerGreaterOrEqualToZero(scp->bulkStatProgress)) {
2049                 scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
2050                                 dsp->flags |= SMB_DIRSEARCH_BULKST;
2051                         }
2052                         lock_ReleaseMutex(&scp->mx);
2053         }
2054     }
2055         lock_ReleaseMutex(&dsp->mx);
2056     if (code) {
2057                 cm_ReleaseUser(userp);
2058         smb_FreeTran2Packet(outp);
2059                 smb_DeleteDirSearch(dsp);
2060                 smb_ReleaseDirSearch(dsp);
2061         return code;
2062         }
2063
2064     /* get the directory size */
2065         lock_ObtainMutex(&scp->mx);
2066     code = cm_SyncOp(scp, NULL, userp, &req, 0,
2067                      CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
2068         if (code) {
2069                 lock_ReleaseMutex(&scp->mx);
2070         cm_ReleaseSCache(scp);
2071         cm_ReleaseUser(userp);
2072         smb_FreeTran2Packet(outp);
2073                 smb_DeleteDirSearch(dsp);
2074                 smb_ReleaseDirSearch(dsp);
2075         return code;
2076     }
2077
2078     dirLength = scp->length;
2079     bufferp = NULL;
2080     bufferOffset.LowPart = bufferOffset.HighPart = 0;
2081     curOffset.HighPart = 0;
2082     curOffset.LowPart = nextCookie;
2083         origOp = outp->datap;
2084
2085     code = 0;
2086     returnedNames = 0;
2087     bytesInBuffer = 0;
2088     while (1) {
2089                 op = origOp;
2090                 if (searchFlags & 4)
2091                         /* skip over resume key */
2092                         op += 4;
2093
2094                 /* make sure that curOffset.LowPart doesn't point to the first
2095          * 32 bytes in the 2nd through last dir page, and that it doesn't
2096          * point at the first 13 32-byte chunks in the first dir page,
2097          * since those are dir and page headers, and don't contain useful
2098          * information.
2099          */
2100                 temp = curOffset.LowPart & (2048-1);
2101         if (curOffset.HighPart == 0 && curOffset.LowPart < 2048) {
2102                         /* we're in the first page */
2103             if (temp < 13*32) temp = 13*32;
2104                 }
2105                 else {
2106                         /* we're in a later dir page */
2107             if (temp < 32) temp = 32;
2108         }
2109                 
2110         /* make sure the low order 5 bits are zero */
2111         temp &= ~(32-1);
2112                 
2113         /* now put temp bits back ito curOffset.LowPart */
2114         curOffset.LowPart &= ~(2048-1);
2115         curOffset.LowPart |= temp;
2116
2117         /* check if we've passed the dir's EOF */
2118         if (LargeIntegerGreaterThanOrEqualTo(curOffset, dirLength)) {
2119             eos = 1;
2120             break;
2121         }
2122
2123         /* check if we've returned all the names that will fit in the
2124          * response packet; we check return count as well as the number
2125          * of bytes requested.  We check the # of bytes after we find
2126          * the dir entry, since we'll need to check its size.
2127          */
2128         if (returnedNames >= maxCount) {
2129             break;
2130         }
2131
2132         /* see if we can use the bufferp we have now; compute in which
2133          * page the current offset would be, and check whether that's
2134          * the offset of the buffer we have.  If not, get the buffer.
2135          */
2136         thyper.HighPart = curOffset.HighPart;
2137         thyper.LowPart = curOffset.LowPart & ~(buf_bufferSize-1);
2138         if (!bufferp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
2139                         /* wrong buffer */
2140             if (bufferp) {
2141                 buf_Release(bufferp);
2142                 bufferp = NULL;
2143                         }       
2144                         lock_ReleaseMutex(&scp->mx);
2145                         lock_ObtainRead(&scp->bufCreateLock);
2146             code = buf_Get(scp, &thyper, &bufferp);
2147                         lock_ReleaseRead(&scp->bufCreateLock);
2148
2149                         /* now, if we're doing a star match, do bulk fetching
2150                          * of all of the status info for files in the dir.
2151              */
2152             if (starPattern) {
2153                                 smb_ApplyV3DirListPatches(scp, &dirListPatchesp,
2154                                           infoLevel, userp,
2155                                           &req);
2156                                 if ((dsp->flags & SMB_DIRSEARCH_BULKST)
2157                     && LargeIntegerGreaterThanOrEqualTo(thyper, scp->bulkStatProgress)) {
2158                                         /* Don't bulk stat if risking timeout */
2159                                         int now = GetCurrentTime();
2160                                         if (now - req.startTime > 5000) {
2161                                                 scp->bulkStatProgress = thyper;
2162                                                 scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
2163                                                 dsp->flags &= ~SMB_DIRSEARCH_BULKST;
2164                                         } else
2165                         cm_TryBulkStat(scp, &thyper, userp, &req);
2166                                 }
2167                         }
2168
2169             lock_ObtainMutex(&scp->mx);
2170             if (code) break;
2171             bufferOffset = thyper;
2172
2173             /* now get the data in the cache */
2174             while (1) {
2175                                 code = cm_SyncOp(scp, bufferp, userp, &req,
2176                                  PRSFS_LOOKUP,
2177                                  CM_SCACHESYNC_NEEDCALLBACK
2178                                  | CM_SCACHESYNC_READ);
2179                                 if (code) break;
2180                                 
2181                 if (cm_HaveBuffer(scp, bufferp, 0)) break;
2182
2183                 /* otherwise, load the buffer and try again */
2184                 code = cm_GetBuffer(scp, bufferp, NULL, userp,
2185                                     &req);
2186                 if (code) break;
2187             }
2188             if (code) {
2189                                 buf_Release(bufferp);
2190                 bufferp = NULL;
2191                 break;
2192                         }
2193         }       /* if (wrong buffer) ... */
2194                 
2195         /* now we have the buffer containing the entry we're interested
2196          * in; copy it out if it represents a non-deleted entry.
2197          */
2198                 entryInDir = curOffset.LowPart & (2048-1);
2199         entryInBuffer = curOffset.LowPart & (buf_bufferSize - 1);
2200
2201                 /* page header will help tell us which entries are free.  Page
2202                  * header can change more often than once per buffer, since
2203                  * AFS 3 dir page size may be less than (but not more than)
2204                  * a buffer package buffer.
2205          */
2206                 /* only look intra-buffer */
2207                 temp = curOffset.LowPart & (buf_bufferSize - 1);
2208         temp &= ~(2048 - 1);    /* turn off intra-page bits */
2209                 pageHeaderp = (cm_pageHeader_t *) (bufferp->datap + temp);
2210
2211                 /* now determine which entry we're looking at in the page.
2212                  * If it is free (there's a free bitmap at the start of the
2213                  * dir), we should skip these 32 bytes.
2214          */
2215         slotInPage = (entryInDir & 0x7e0) >> 5;
2216         if (!(pageHeaderp->freeBitmap[slotInPage>>3]
2217                & (1 << (slotInPage & 0x7)))) {
2218                         /* this entry is free */
2219             numDirChunks = 1;   /* only skip this guy */
2220             goto nextEntry;
2221         }
2222
2223                 tp = bufferp->datap + entryInBuffer;
2224         dep = (cm_dirEntry_t *) tp;     /* now points to AFS3 dir entry */
2225
2226         /* while we're here, compute the next entry's location, too,
2227                  * since we'll need it when writing out the cookie into the dir
2228                  * listing stream.
2229          *
2230          * XXXX Probably should do more sanity checking.
2231          */
2232                 numDirChunks = cm_NameEntries(dep->name, &onbytes);
2233                 
2234         /* compute offset of cookie representing next entry */
2235         nextEntryCookie = curOffset.LowPart + (CM_DIR_CHUNKSIZE * numDirChunks);
2236
2237                 /* Need 8.3 name? */
2238                 NeedShortName = 0;
2239                 if (infoLevel == 0x104
2240                     && dep->fid.vnode != 0
2241                     && !cm_Is8Dot3(dep->name)) {
2242                         cm_Gen8Dot3Name(dep, shortName, &shortNameEnd);
2243                         NeedShortName = 1;
2244                 }
2245
2246         if (dep->fid.vnode != 0
2247              && (smb_V3MatchMask(dep->name, maskp, CM_FLAG_CASEFOLD)
2248                  || (NeedShortName
2249                       && smb_V3MatchMask(shortName, maskp,
2250                                           CM_FLAG_CASEFOLD)))) {
2251
2252             /* Eliminate entries that don't match requested attributes */
2253             if (smb_hideDotFiles && !(dsp->attribute & SMB_ATTR_HIDDEN) && 
2254                  smb_IsDotFile(dep->name))
2255                 goto nextEntry; /* no hidden files */
2256                     
2257             if (!(dsp->attribute & SMB_ATTR_DIRECTORY))  /* no directories */
2258             {
2259                 /* We have already done the cm_TryBulkStat above */
2260                 fid.cell = scp->fid.cell;
2261                 fid.volume = scp->fid.volume;
2262                 fid.vnode = ntohl(dep->fid.vnode);
2263                 fid.unique = ntohl(dep->fid.unique);
2264                 fileType = cm_FindFileType(&fid);
2265                 /*osi_Log2(smb_logp, "smb_ReceiveTran2SearchDir: file %s "
2266                  "has filetype %d", dep->name,
2267                  fileType);*/
2268                 if (fileType == CM_SCACHETYPE_DIRECTORY)
2269                     goto nextEntry;
2270             }
2271
2272                         /* finally check if this name will fit */
2273
2274                         /* standard dir entry stuff */
2275                         if (infoLevel < 0x101)
2276                                 ohbytes = 23;   /* pre-NT */
2277                         else if (infoLevel == 0x103)
2278                                 ohbytes = 12;   /* NT names only */
2279                         else
2280                                 ohbytes = 64;   /* NT */
2281
2282                         if (infoLevel == 0x104)
2283                                 ohbytes += 26;  /* Short name & length */
2284
2285             if (searchFlags & 4) {
2286                 ohbytes += 4;   /* if resume key required */
2287                         }   
2288
2289             if (infoLevel != 1
2290                  && infoLevel != 0x101
2291                  && infoLevel != 0x103)
2292                                 ohbytes += 4;   /* EASIZE */
2293
2294                         /* add header to name & term. null */
2295                         orbytes = onbytes + ohbytes + 1;
2296
2297                         /* now, we round up the record to a 4 byte alignment,
2298                          * and we make sure that we have enough room here for
2299                          * even the aligned version (so we don't have to worry
2300                          * about an * overflow when we pad things out below).
2301                          * That's the reason for the alignment arithmetic below.
2302              */
2303                         if (infoLevel >= 0x101)
2304                                 align = (4 - (orbytes & 3)) & 3;
2305                         else
2306                                 align = 0;
2307                         if (orbytes + bytesInBuffer + align > maxReturnData)
2308                 break;
2309
2310                         /* this is one of the entries to use: it is not deleted
2311                          * and it matches the star pattern we're looking for.
2312                          * Put out the name, preceded by its length.
2313              */
2314                         /* First zero everything else */
2315                         memset(origOp, 0, ohbytes);
2316
2317                         if (infoLevel <= 0x101)
2318                 *(origOp + ohbytes - 1) = (unsigned char) onbytes;
2319                         else if (infoLevel == 0x103)
2320                                 *((u_long *)(op + 8)) = onbytes;
2321                         else
2322                                 *((u_long *)(op + 60)) = onbytes;
2323             strcpy(origOp+ohbytes, dep->name);
2324
2325                         /* Short name if requested and needed */
2326             if (infoLevel == 0x104) {
2327                                 if (NeedShortName) {
2328                                         strcpy(op + 70, shortName);
2329                                         *(op + 68) = shortNameEnd - shortName;
2330                                 }
2331                         }
2332
2333             /* now, adjust the # of entries copied */
2334             returnedNames++;
2335
2336                         /* NextEntryOffset and FileIndex */
2337                         if (infoLevel >= 101) {
2338                                 int entryOffset = orbytes + align;
2339                                 *((u_long *)op) = entryOffset;
2340                                 *((u_long *)(op+4)) = nextEntryCookie;
2341                         }
2342
2343             /* now we emit the attribute.  This is tricky, since
2344              * we need to really stat the file to find out what
2345                          * type of entry we've got.  Right now, we're copying
2346                          * out data from * a buffer, while holding the scp
2347                          * locked, so it isn't really convenient to stat
2348                          * something now.  We'll put in a place holder
2349              * now, and make a second pass before returning this
2350                          * to get the real attributes.  So, we just skip the
2351                          * data for now, and adjust it later.  We allocate a
2352                          * patch record to make it easy to find this point
2353                          * later.  The replay will happen at a time when it is
2354                          * safe to unlock the directory.
2355              */
2356                         if (infoLevel != 0x103) {
2357                                 curPatchp = malloc(sizeof(*curPatchp));
2358                 osi_QAdd((osi_queue_t **) &dirListPatchesp,
2359                           &curPatchp->q);
2360                                 curPatchp->dptr = op;
2361                                 if (infoLevel >= 0x101)
2362                                         curPatchp->dptr += 8;
2363
2364                 if (smb_hideDotFiles && smb_IsDotFile(dep->name)) {
2365                     curPatchp->flags = SMB_DIRLISTPATCH_DOTFILE;
2366                 }
2367                 else
2368                     curPatchp->flags = 0;
2369
2370                                 curPatchp->fid.cell = scp->fid.cell;
2371                                 curPatchp->fid.volume = scp->fid.volume;
2372                                 curPatchp->fid.vnode = ntohl(dep->fid.vnode);
2373                                 curPatchp->fid.unique = ntohl(dep->fid.unique);
2374
2375                 /* temp */
2376                 curPatchp->dep = dep;
2377                         }   
2378
2379                         if (searchFlags & 4)
2380                                 /* put out resume key */
2381                                 *((u_long *)origOp) = nextEntryCookie;
2382
2383                         /* Adjust byte ptr and count */
2384                         origOp += orbytes;      /* skip entire record */
2385             bytesInBuffer += orbytes;
2386
2387                         /* and pad the record out */
2388             while (--align >= 0) {
2389                                 *origOp++ = 0;
2390                 bytesInBuffer++;
2391             }
2392
2393                 }       /* if we're including this name */
2394                 
2395       nextEntry:
2396         /* and adjust curOffset to be where the new cookie is */
2397                 thyper.HighPart = 0;
2398         thyper.LowPart = CM_DIR_CHUNKSIZE * numDirChunks;
2399         curOffset = LargeIntegerAdd(thyper, curOffset);
2400     }           /* while copying data for dir listing */
2401
2402         /* release the mutex */
2403         lock_ReleaseMutex(&scp->mx);
2404     if (bufferp) buf_Release(bufferp);
2405
2406         /* apply and free last set of patches; if not doing a star match, this
2407          * will be empty, but better safe (and freeing everything) than sorry.
2408      */
2409     smb_ApplyV3DirListPatches(scp, &dirListPatchesp, infoLevel, userp,
2410                               &req);
2411         
2412     /* now put out the final parameters */
2413         if (returnedNames == 0) eos = 1;
2414     if (p->opcode == 1) {
2415                 /* find first */
2416         outp->parmsp[0] = (unsigned short) dsp->cookie;
2417         outp->parmsp[1] = returnedNames;
2418         outp->parmsp[2] = eos;
2419         outp->parmsp[3] = 0;            /* nothing wrong with EAS */
2420         outp->parmsp[4] = 0;    
2421         /* don't need last name to continue
2422          * search, cookie is enough.  Normally,
2423          * this is the offset of the file name
2424          * of the last entry returned.
2425          */
2426         outp->totalParms = 10;  /* in bytes */
2427     }
2428     else {
2429         /* find next */
2430         outp->parmsp[0] = returnedNames;
2431         outp->parmsp[1] = eos;
2432         outp->parmsp[2] = 0;    /* EAS error */
2433         outp->parmsp[3] = 0;    /* last name, as above */
2434         outp->totalParms = 8;   /* in bytes */
2435     }   
2436
2437         /* return # of bytes in the buffer */
2438     outp->totalData = bytesInBuffer;
2439
2440         osi_Log2(smb_logp, "T2 search dir done, %d names, code %d",
2441               returnedNames, code);
2442
2443         /* Return error code if unsuccessful on first request */
2444         if (code == 0 && p->opcode == 1 && returnedNames == 0)
2445                 code = CM_ERROR_NOSUCHFILE;
2446
2447         /* if we're supposed to close the search after this request, or if
2448      * we're supposed to close the search if we're done, and we're done,
2449      * or if something went wrong, close the search.
2450      */
2451     /* ((searchFlags & 1) || ((searchFlags & 2) && eos) */
2452         if ((searchFlags & 1) || (returnedNames == 0) || 
2453          ((searchFlags & 2) && eos) || code != 0)
2454             smb_DeleteDirSearch(dsp);
2455         if (code)
2456         smb_SendTran2Error(vcp, p, opx, code);
2457         else {
2458         smb_SendTran2Packet(vcp, outp, opx);
2459         }
2460         smb_FreeTran2Packet(outp);
2461     smb_ReleaseDirSearch(dsp);
2462     cm_ReleaseSCache(scp);
2463     cm_ReleaseUser(userp);
2464     return 0;
2465 }
2466
2467 long smb_ReceiveV3FindClose(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2468 {
2469     int dirHandle;
2470     smb_dirSearch_t *dsp;
2471
2472     dirHandle = smb_GetSMBParm(inp, 0);
2473         
2474     osi_Log1(smb_logp, "SMB3 find close handle %d", dirHandle);
2475
2476     dsp = smb_FindDirSearch(dirHandle);
2477         
2478     if (!dsp)
2479                 return CM_ERROR_BADFD;
2480         
2481     /* otherwise, we have an FD to destroy */
2482     smb_DeleteDirSearch(dsp);
2483     smb_ReleaseDirSearch(dsp);
2484         
2485         /* and return results */
2486         smb_SetSMBDataLength(outp, 0);
2487
2488     return 0;
2489 }
2490
2491 long smb_ReceiveV3FindNotifyClose(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2492 {
2493         smb_SetSMBDataLength(outp, 0);
2494     return 0;
2495 }
2496
2497 long smb_ReceiveV3OpenX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2498 {
2499         char *pathp;
2500     long code = 0;
2501         cm_space_t *spacep;
2502     int excl;
2503     cm_user_t *userp;
2504     cm_scache_t *dscp;          /* dir we're dealing with */
2505     cm_scache_t *scp;           /* file we're creating */
2506     cm_attr_t setAttr;
2507     int initialModeBits;
2508     smb_fid_t *fidp;
2509     int attributes;
2510     char *lastNamep;
2511     long dosTime;
2512     int openFun;
2513     int trunc;
2514     int openMode;
2515     int extraInfo;
2516     int openAction;
2517     int parmSlot;                       /* which parm we're dealing with */
2518         char *tidPathp;
2519         cm_req_t req;
2520
2521         cm_InitReq(&req);
2522
2523     scp = NULL;
2524         
2525         extraInfo = (smb_GetSMBParm(inp, 2) & 1);       /* return extra info */
2526         openFun = smb_GetSMBParm(inp, 8);       /* open function */
2527     excl = ((openFun & 3) == 0);
2528     trunc = ((openFun & 3) == 2);               /* truncate it */
2529         openMode = (smb_GetSMBParm(inp, 3) & 0x7);
2530     openAction = 0;                     /* tracks what we did */
2531
2532     attributes = smb_GetSMBParm(inp, 5);
2533     dosTime = smb_GetSMBParm(inp, 6) | (smb_GetSMBParm(inp, 7) << 16);
2534
2535         /* compute initial mode bits based on read-only flag in attributes */
2536     initialModeBits = 0666;
2537     if (attributes & 1) initialModeBits &= ~0222;
2538         
2539     pathp = smb_GetSMBData(inp, NULL);
2540
2541         spacep = inp->spacep;
2542     smb_StripLastComponent(spacep->data, &lastNamep, pathp);
2543
2544         if (lastNamep && strcmp(lastNamep, SMB_IOCTL_FILENAME) == 0) {
2545                 /* special case magic file name for receiving IOCTL requests
2546          * (since IOCTL calls themselves aren't getting through).
2547          */
2548 #ifdef NOTSERVICE
2549         osi_Log0(smb_logp, "IOCTL Open");
2550 #endif
2551
2552         fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
2553         smb_SetupIoctlFid(fidp, spacep);
2554
2555                 /* set inp->fid so that later read calls in same msg can find fid */
2556         inp->fid = fidp->fid;
2557         
2558         /* copy out remainder of the parms */
2559                 parmSlot = 2;
2560                 smb_SetSMBParm(outp, parmSlot, fidp->fid); parmSlot++;
2561                 if (extraInfo) {
2562             smb_SetSMBParm(outp, parmSlot, /* attrs */ 0); parmSlot++;
2563             smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;      /* mod time */
2564             smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;
2565             smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;      /* len */
2566             smb_SetSMBParm(outp, parmSlot, 0x7fff); parmSlot++;
2567             smb_SetSMBParm(outp, parmSlot, openMode); parmSlot++;
2568             smb_SetSMBParm(outp, parmSlot, 0); parmSlot++; /* file type 0 ==> normal file or dir */
2569             smb_SetSMBParm(outp, parmSlot, 0); parmSlot++; /* IPC junk */
2570                 }   
2571                 /* and the final "always present" stuff */
2572         smb_SetSMBParm(outp, parmSlot, /* openAction found existing file */ 1); parmSlot++;
2573                 /* next write out the "unique" ID */
2574                 smb_SetSMBParm(outp, parmSlot, 0x1234); parmSlot++;
2575                 smb_SetSMBParm(outp, parmSlot, 0x5678); parmSlot++;
2576         smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;
2577         smb_SetSMBDataLength(outp, 0);
2578
2579                 /* and clean up fid reference */
2580         smb_ReleaseFID(fidp);
2581         return 0;
2582     }
2583
2584 #ifdef DEBUG_VERBOSE
2585     {
2586         char *hexp, *asciip;
2587         asciip = (lastNamep ? lastNamep : pathp );
2588         hexp = osi_HexifyString(asciip);
2589         DEBUG_EVENT2("AFS", "V3Open H[%s] A[%s]", hexp, asciip );
2590         free(hexp);
2591     }
2592 #endif
2593     userp = smb_GetUser(vcp, inp);
2594
2595         dscp = NULL;
2596         tidPathp = smb_GetTIDPath(vcp, ((smb_t *)inp)->tid);
2597         code = cm_NameI(cm_rootSCachep, pathp,
2598                     CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
2599                     userp, tidPathp, &req, &scp);
2600         if (code != 0) {
2601                 code = cm_NameI(cm_rootSCachep, spacep->data,
2602                         CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
2603                         userp, tidPathp, &req, &dscp);
2604
2605         if (code) {
2606             cm_ReleaseUser(userp);
2607             return code;
2608         }
2609         
2610         /* otherwise, scp points to the parent directory.  Do a lookup,
2611          * and truncate the file if we find it, otherwise we create the
2612          * file.
2613          */
2614         if (!lastNamep) lastNamep = pathp;
2615         else lastNamep++;
2616         code = cm_Lookup(dscp, lastNamep, CM_FLAG_CASEFOLD, userp,
2617                           &req, &scp);
2618         if (code && code != CM_ERROR_NOSUCHFILE) {
2619                         cm_ReleaseSCache(dscp);
2620             cm_ReleaseUser(userp);
2621             return code;
2622         }
2623         }
2624         
2625     /* if we get here, if code is 0, the file exists and is represented by
2626      * scp.  Otherwise, we have to create it.  The dir may be represented
2627      * by dscp, or we may have found the file directly.  If code is non-zero,
2628      * scp is NULL.
2629      */
2630         if (code == 0) {
2631         code = cm_CheckOpen(scp, openMode, trunc, userp, &req);
2632         if (code) {
2633             if (dscp) cm_ReleaseSCache(dscp);
2634             cm_ReleaseSCache(scp);
2635             cm_ReleaseUser(userp);
2636             return code;
2637         }
2638
2639                 if (excl) {
2640                         /* oops, file shouldn't be there */
2641             if (dscp) cm_ReleaseSCache(dscp);
2642             cm_ReleaseSCache(scp);
2643             cm_ReleaseUser(userp);
2644             return CM_ERROR_EXISTS;
2645         }
2646
2647                 if (trunc) {
2648                         setAttr.mask = CM_ATTRMASK_LENGTH;
2649             setAttr.length.LowPart = 0;
2650             setAttr.length.HighPart = 0;
2651                         code = cm_SetAttr(scp, &setAttr, userp, &req);
2652             openAction = 3;     /* truncated existing file */
2653                 }
2654         else openAction = 1;    /* found existing file */
2655     }
2656         else if (!(openFun & 0x10)) {
2657                 /* don't create if not found */
2658         if (dscp) cm_ReleaseSCache(dscp);
2659         cm_ReleaseUser(userp);
2660         return CM_ERROR_NOSUCHFILE;
2661     }
2662     else {
2663                 osi_assert(dscp != NULL);
2664                 osi_Log1(smb_logp, "smb_ReceiveV3OpenX creating file %s",
2665                  osi_LogSaveString(smb_logp, lastNamep));
2666                 openAction = 2; /* created file */
2667                 setAttr.mask = CM_ATTRMASK_CLIENTMODTIME;
2668                 smb_UnixTimeFromDosUTime(&setAttr.clientModTime, dosTime);
2669         code = cm_Create(dscp, lastNamep, 0, &setAttr, &scp, userp,
2670                          &req);
2671                 if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
2672                         smb_NotifyChange(FILE_ACTION_ADDED,
2673                              FILE_NOTIFY_CHANGE_FILE_NAME,
2674                              dscp, lastNamep, NULL, TRUE);
2675         if (!excl && code == CM_ERROR_EXISTS) {
2676                         /* not an exclusive create, and someone else tried
2677                          * creating it already, then we open it anyway.  We
2678                          * don't bother retrying after this, since if this next
2679                          * fails, that means that the file was deleted after we
2680                          * started this call.
2681              */
2682             code = cm_Lookup(dscp, lastNamep, CM_FLAG_CASEFOLD,
2683                              userp, &req, &scp);
2684             if (code == 0) {
2685                 if (trunc) {
2686                                         setAttr.mask = CM_ATTRMASK_LENGTH;
2687                     setAttr.length.LowPart = 0;
2688                     setAttr.length.HighPart = 0;
2689                     code = cm_SetAttr(scp, &setAttr, userp, &req);
2690                 }   
2691                         }       /* lookup succeeded */
2692         }
2693     }
2694         
2695         /* we don't need this any longer */
2696         if (dscp) cm_ReleaseSCache(dscp);
2697
2698     if (code) {
2699                 /* something went wrong creating or truncating the file */
2700         if (scp) cm_ReleaseSCache(scp);
2701         cm_ReleaseUser(userp);
2702         return code;
2703     }
2704         
2705         /* make sure we're about to open a file */
2706         if (scp->fileType != CM_SCACHETYPE_FILE) {
2707                 cm_ReleaseSCache(scp);
2708                 cm_ReleaseUser(userp);
2709                 return CM_ERROR_ISDIR;
2710         }
2711
2712     /* now all we have to do is open the file itself */
2713     fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
2714     osi_assert(fidp);
2715         
2716         /* save a pointer to the vnode */
2717     fidp->scp = scp;
2718         
2719         /* compute open mode */
2720     if (openMode != 1) fidp->flags |= SMB_FID_OPENREAD;
2721     if (openMode == 1 || openMode == 2)
2722         fidp->flags |= SMB_FID_OPENWRITE;
2723
2724         smb_ReleaseFID(fidp);
2725         
2726         cm_Open(scp, 0, userp);
2727
2728         /* set inp->fid so that later read calls in same msg can find fid */
2729     inp->fid = fidp->fid;
2730         
2731     /* copy out remainder of the parms */
2732         parmSlot = 2;
2733         smb_SetSMBParm(outp, parmSlot, fidp->fid); parmSlot++;
2734         lock_ObtainMutex(&scp->mx);
2735         if (extraInfo) {
2736         smb_SetSMBParm(outp, parmSlot, smb_Attributes(scp)); parmSlot++;
2737                 smb_DosUTimeFromUnixTime(&dosTime, scp->clientModTime);
2738         smb_SetSMBParm(outp, parmSlot, dosTime & 0xffff); parmSlot++;
2739         smb_SetSMBParm(outp, parmSlot, (dosTime>>16) & 0xffff); parmSlot++;
2740         smb_SetSMBParm(outp, parmSlot, scp->length.LowPart & 0xffff); parmSlot++;
2741         smb_SetSMBParm(outp, parmSlot, (scp->length.LowPart >> 16) & 0xffff); parmSlot++;
2742         smb_SetSMBParm(outp, parmSlot, openMode); parmSlot++;
2743         smb_SetSMBParm(outp, parmSlot, 0); parmSlot++; /* file type 0 ==> normal file or dir */
2744         smb_SetSMBParm(outp, parmSlot, 0); parmSlot++; /* IPC junk */
2745         }
2746         /* and the final "always present" stuff */
2747     smb_SetSMBParm(outp, parmSlot, openAction); parmSlot++;
2748         /* next write out the "unique" ID */
2749         smb_SetSMBParm(outp, parmSlot, scp->fid.vnode & 0xffff); parmSlot++;
2750         smb_SetSMBParm(outp, parmSlot, scp->fid.volume & 0xffff); parmSlot++;
2751     smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;
2752         lock_ReleaseMutex(&scp->mx);
2753     smb_SetSMBDataLength(outp, 0);
2754
2755         osi_Log1(smb_logp, "SMB OpenX opening fid %d", fidp->fid);
2756
2757     cm_ReleaseUser(userp);
2758     /* leave scp held since we put it in fidp->scp */
2759     return 0;
2760 }   
2761
2762 long smb_ReceiveV3LockingX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2763 {
2764         cm_req_t req;
2765         cm_user_t *userp;
2766         unsigned short fid;
2767         smb_fid_t *fidp;
2768         cm_scache_t *scp;
2769         unsigned char LockType;
2770         unsigned short NumberOfUnlocks, NumberOfLocks;
2771         unsigned long Timeout;
2772         char *op;
2773         LARGE_INTEGER LOffset, LLength;
2774         smb_waitingLock_t *waitingLock;
2775         void *lockp;
2776         long code = 0;
2777         int i;
2778
2779         cm_InitReq(&req);
2780
2781         fid = smb_GetSMBParm(inp, 2);
2782         fid = smb_ChainFID(fid, inp);
2783
2784         fidp = smb_FindFID(vcp, fid, 0);
2785         if (!fidp || (fidp->flags & SMB_FID_IOCTL)) {
2786                 return CM_ERROR_BADFD;
2787         }
2788         /* set inp->fid so that later read calls in same msg can find fid */
2789     inp->fid = fid;
2790
2791         userp = smb_GetUser(vcp, inp);
2792
2793         scp = fidp->scp;
2794
2795         lock_ObtainMutex(&scp->mx);
2796         code = cm_SyncOp(scp, NULL, userp, &req, 0,
2797                          CM_SCACHESYNC_NEEDCALLBACK
2798                          | CM_SCACHESYNC_GETSTATUS
2799                          | CM_SCACHESYNC_LOCK);
2800         if (code) goto doneSync;
2801
2802         LockType = smb_GetSMBParm(inp, 3) & 0xff;
2803         Timeout = (smb_GetSMBParm(inp, 5) << 16) + smb_GetSMBParm(inp, 4);
2804         NumberOfUnlocks = smb_GetSMBParm(inp, 6);
2805         NumberOfLocks = smb_GetSMBParm(inp, 7);
2806
2807         op = smb_GetSMBData(inp, NULL);
2808
2809         for (i=0; i<NumberOfUnlocks; i++) {
2810                 if (LockType & 0x10) {
2811                         /* Large Files */
2812                         LOffset.HighPart = *((LONG *)(op + 4));
2813                         LOffset.LowPart = *((DWORD *)(op + 8));
2814                         LLength.HighPart = *((LONG *)(op + 12));
2815                         LLength.LowPart = *((DWORD *)(op + 16));
2816                         op += 20;
2817                 }
2818                 else {
2819                         /* Not Large Files */
2820                         LOffset.HighPart = 0;
2821                         LOffset.LowPart = *((DWORD *)(op + 2));
2822                         LLength.HighPart = 0;
2823                         LLength.LowPart = *((DWORD *)(op + 6));
2824                         op += 10;
2825                 }
2826                 if (LargeIntegerNotEqualToZero(LOffset))
2827                         continue;
2828                 /* Do not check length -- length check done in cm_Unlock */
2829
2830                 code = cm_Unlock(scp, LockType, LOffset, LLength, userp, &req);
2831                 if (code) goto done;
2832         }
2833
2834         for (i=0; i<NumberOfLocks; i++) {
2835                 if (LockType & 0x10) {
2836                         /* Large Files */
2837                         LOffset.HighPart = *((LONG *)(op + 4));
2838                         LOffset.LowPart = *((DWORD *)(op + 8));
2839                         LLength.HighPart = *((LONG *)(op + 12));
2840                         LLength.LowPart = *((DWORD *)(op + 16));
2841                         op += 20;
2842                 }
2843                 else {
2844                         /* Not Large Files */
2845                         LOffset.HighPart = 0;
2846                         LOffset.LowPart = *((DWORD *)(op + 2));
2847                         LLength.HighPart = 0;
2848                         LLength.LowPart = *((DWORD *)(op + 6));
2849                         op += 10;
2850                 }
2851                 if (LargeIntegerNotEqualToZero(LOffset))
2852                         continue;
2853                 if (LargeIntegerLessThan(LOffset, scp->length))
2854                         continue;
2855
2856                 code = cm_Lock(scp, LockType, LOffset, LLength, Timeout,
2857                                 userp, &req, &lockp);
2858                 if (code == CM_ERROR_WOULDBLOCK && Timeout != 0) {
2859                         /* Put on waiting list */
2860                         waitingLock = malloc(sizeof(smb_waitingLock_t));
2861                         waitingLock->vcp = vcp;
2862                         waitingLock->inp = smb_CopyPacket(inp);
2863                         waitingLock->outp = smb_CopyPacket(outp);
2864                         waitingLock->timeRemaining = Timeout;
2865                         waitingLock->lockp = lockp;
2866                         lock_ObtainWrite(&smb_globalLock);
2867                         osi_QAdd((osi_queue_t **)&smb_allWaitingLocks,
2868                                  &waitingLock->q);
2869                         osi_Wakeup((long) &smb_allWaitingLocks);
2870                         lock_ReleaseWrite(&smb_globalLock);
2871                         /* don't send reply immediately */
2872                         outp->flags |= SMB_PACKETFLAG_NOSEND;
2873                 }
2874                 if (code) break;
2875         }
2876
2877         if (code) {
2878                 /* release any locks acquired before the failure */
2879         }
2880         else
2881                 smb_SetSMBDataLength(outp, 0);
2882 done:
2883         cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
2884 doneSync:
2885         lock_ReleaseMutex(&scp->mx);
2886         cm_ReleaseUser(userp);
2887         smb_ReleaseFID(fidp);
2888
2889         return code;
2890 }
2891
2892 long smb_ReceiveV3GetAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2893 {
2894         unsigned short fid;
2895     smb_fid_t *fidp;
2896     cm_scache_t *scp;
2897     long code = 0;
2898     long searchTime;
2899     cm_user_t *userp;
2900         cm_req_t req;
2901
2902         cm_InitReq(&req);
2903
2904     fid = smb_GetSMBParm(inp, 0);
2905     fid = smb_ChainFID(fid, inp);
2906         
2907     fidp = smb_FindFID(vcp, fid, 0);
2908     if (!fidp || (fidp->flags & SMB_FID_IOCTL)) {
2909                 return CM_ERROR_BADFD;
2910     }
2911         
2912     userp = smb_GetUser(vcp, inp);
2913         
2914     scp = fidp->scp;
2915         
2916     /* otherwise, stat the file */
2917         lock_ObtainMutex(&scp->mx);
2918     code = cm_SyncOp(scp, NULL, userp, &req, 0,
2919                      CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
2920         if (code) goto done;
2921
2922         /* decode times.  We need a search time, but the response to this
2923      * call provides the date first, not the time, as returned in the
2924      * searchTime variable.  So we take the high-order bits first.
2925      */
2926         smb_SearchTimeFromUnixTime(&searchTime, scp->clientModTime);
2927     smb_SetSMBParm(outp, 0, (searchTime >> 16) & 0xffff);       /* ctime */
2928     smb_SetSMBParm(outp, 1, searchTime & 0xffff);
2929     smb_SetSMBParm(outp, 2, (searchTime >> 16) & 0xffff);       /* atime */
2930     smb_SetSMBParm(outp, 3, searchTime & 0xffff);
2931     smb_SetSMBParm(outp, 4, (searchTime >> 16) & 0xffff);       /* mtime */
2932     smb_SetSMBParm(outp, 5, searchTime & 0xffff);
2933
2934     /* now handle file size and allocation size */
2935     smb_SetSMBParm(outp, 6, scp->length.LowPart & 0xffff);              /* file size */
2936     smb_SetSMBParm(outp, 7, (scp->length.LowPart >> 16) & 0xffff);
2937     smb_SetSMBParm(outp, 8, scp->length.LowPart & 0xffff);              /* alloc size */
2938     smb_SetSMBParm(outp, 9, (scp->length.LowPart >> 16) & 0xffff);
2939
2940         /* file attribute */
2941     smb_SetSMBParm(outp, 10, smb_Attributes(scp));
2942         
2943     /* and finalize stuff */
2944     smb_SetSMBDataLength(outp, 0);
2945     code = 0;
2946
2947   done:
2948         lock_ReleaseMutex(&scp->mx);
2949         cm_ReleaseUser(userp);
2950         smb_ReleaseFID(fidp);
2951         return code;
2952 }
2953
2954 long smb_ReceiveV3SetAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2955 {
2956         unsigned short fid;
2957     smb_fid_t *fidp;
2958     cm_scache_t *scp;
2959     long code = 0;
2960         long searchTime;
2961     long unixTime;
2962     cm_user_t *userp;
2963     cm_attr_t attrs;
2964         cm_req_t req;
2965
2966         cm_InitReq(&req);
2967
2968     fid = smb_GetSMBParm(inp, 0);
2969     fid = smb_ChainFID(fid, inp);
2970         
2971     fidp = smb_FindFID(vcp, fid, 0);
2972     if (!fidp || (fidp->flags & SMB_FID_IOCTL)) {
2973                 return CM_ERROR_BADFD;
2974     }
2975         
2976     userp = smb_GetUser(vcp, inp);
2977         
2978     scp = fidp->scp;
2979         
2980         /* now prepare to call cm_setattr.  This message only sets various times,
2981      * and AFS only implements mtime, and we'll set the mtime if that's
2982      * requested.  The others we'll ignore.
2983      */
2984         searchTime = smb_GetSMBParm(inp, 5) | (smb_GetSMBParm(inp, 6) << 16);
2985         
2986     if (searchTime != 0) {
2987                 smb_UnixTimeFromSearchTime(&unixTime, searchTime);
2988
2989         if ( unixTime != -1 ) {
2990             attrs.mask = CM_ATTRMASK_CLIENTMODTIME;
2991             attrs.clientModTime = unixTime;
2992             code = cm_SetAttr(scp, &attrs, userp, &req);
2993
2994             osi_Log1(smb_logp, "SMB receive V3SetAttributes [fid=%ld]", fid);
2995         } else {
2996             osi_Log1(smb_logp, "**smb_UnixTimeFromSearchTime failed searchTime=%ld", searchTime);
2997         }
2998     }
2999     else code = 0;
3000
3001         cm_ReleaseUser(userp);
3002         smb_ReleaseFID(fidp);
3003         return code;
3004 }
3005
3006
3007 long smb_ReceiveV3ReadX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3008 {
3009         osi_hyper_t offset;
3010     long count, finalCount;
3011     unsigned short fd;
3012     smb_fid_t *fidp;
3013     long code = 0;
3014     cm_user_t *userp;
3015     char *op;
3016         
3017     fd = smb_GetSMBParm(inp, 2);
3018     count = smb_GetSMBParm(inp, 5);
3019     offset.HighPart = 0;        /* too bad */
3020     offset.LowPart = smb_GetSMBParm(inp, 3) | (smb_GetSMBParm(inp, 4) << 16);
3021
3022     osi_Log3(smb_logp, "smb_ReceiveV3Read fd %d, off 0x%x, size 0x%x",
3023              fd, offset.LowPart, count);
3024         
3025         fd = smb_ChainFID(fd, inp);
3026     fidp = smb_FindFID(vcp, fd, 0);
3027     if (!fidp) {
3028                 return CM_ERROR_BADFD;
3029     }
3030         /* set inp->fid so that later read calls in same msg can find fid */
3031     inp->fid = fd;
3032
3033     if (fidp->flags & SMB_FID_IOCTL) {
3034                 return smb_IoctlV3Read(fidp, vcp, inp, outp);
3035     }
3036         
3037         userp = smb_GetUser(vcp, inp);
3038
3039         /* 0 and 1 are reserved for request chaining, were setup by our caller,
3040      * and will be further filled in after we return.
3041      */
3042     smb_SetSMBParm(outp, 2, 0); /* remaining bytes, for pipes */
3043     smb_SetSMBParm(outp, 3, 0); /* resvd */
3044     smb_SetSMBParm(outp, 4, 0); /* resvd */
3045         smb_SetSMBParm(outp, 5, count); /* # of bytes we're going to read */
3046     /* fill in #6 when we have all the parameters' space reserved */
3047     smb_SetSMBParm(outp, 7, 0); /* resv'd */
3048     smb_SetSMBParm(outp, 8, 0); /* resv'd */
3049     smb_SetSMBParm(outp, 9, 0); /* resv'd */
3050     smb_SetSMBParm(outp, 10, 0);        /* resv'd */
3051         smb_SetSMBParm(outp, 11, 0);    /* reserved */
3052
3053         /* get op ptr after putting in the parms, since otherwise we don't
3054      * know where the data really is.
3055      */
3056     op = smb_GetSMBData(outp, NULL);
3057         
3058     /* now fill in offset from start of SMB header to first data byte (to op) */
3059     smb_SetSMBParm(outp, 6, ((int) (op - outp->data)));
3060
3061         /* set the packet data length the count of the # of bytes */
3062     smb_SetSMBDataLength(outp, count);
3063
3064 #ifndef DJGPP
3065         code = smb_ReadData(fidp, &offset, count, op, userp, &finalCount);
3066 #else /* DJGPP */
3067         code = smb_ReadData(fidp, &offset, count, op, userp, &finalCount, FALSE);
3068 #endif /* !DJGPP */
3069
3070         /* fix some things up */
3071         smb_SetSMBParm(outp, 5, finalCount);
3072         smb_SetSMBDataLength(outp, finalCount);
3073
3074     smb_ReleaseFID(fidp);
3075
3076     cm_ReleaseUser(userp);
3077     return code;
3078 }   
3079         
3080 /*
3081  * Values for createDisp, copied from NTDDK.H
3082  *
3083  *  FILE_SUPERSEDE      0       (???)
3084  *  FILE_OPEN           1       (open)
3085  *  FILE_CREATE         2       (exclusive)
3086  *  FILE_OPEN_IF        3       (non-exclusive)
3087  *  FILE_OVERWRITE      4       (open & truncate, but do not create)
3088  *  FILE_OVERWRITE_IF   5       (open & truncate, or create)
3089  */
3090
3091 long smb_ReceiveNTCreateX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3092 {
3093         char *pathp, *realPathp;
3094         long code = 0;
3095         cm_space_t *spacep;
3096         cm_user_t *userp;
3097         cm_scache_t *dscp;              /* parent dir */
3098         cm_scache_t *scp;               /* file to create or open */
3099         cm_attr_t setAttr;
3100         char *lastNamep;
3101     char *treeStartp;
3102         unsigned short nameLength;
3103         unsigned int flags;
3104         unsigned int requestOpLock;
3105         unsigned int requestBatchOpLock;
3106         unsigned int mustBeDir;
3107     unsigned int treeCreate;
3108         int realDirFlag;
3109         unsigned int desiredAccess;
3110         unsigned int extAttributes;
3111         unsigned int createDisp;
3112         unsigned int createOptions;
3113         int initialModeBits;
3114         unsigned short baseFid;
3115         smb_fid_t *baseFidp;
3116         smb_fid_t *fidp;
3117         cm_scache_t *baseDirp;
3118         unsigned short openAction;
3119         int parmSlot;
3120         long fidflags;
3121         FILETIME ft;
3122         LARGE_INTEGER sz;
3123         char *tidPathp;
3124         BOOL foundscp;
3125         cm_req_t req;
3126
3127         cm_InitReq(&req);
3128
3129     treeCreate = FALSE;
3130         foundscp = FALSE;
3131         scp = NULL;
3132
3133         nameLength = smb_GetSMBOffsetParm(inp, 2, 1);
3134         flags = smb_GetSMBOffsetParm(inp, 3, 1)
3135                   | (smb_GetSMBOffsetParm(inp, 4, 1) << 16);
3136         requestOpLock = flags & 0x02;
3137         requestBatchOpLock = flags & 0x04;
3138         mustBeDir = flags & 0x08;
3139
3140         /*
3141          * Why all of a sudden 32-bit FID?
3142          * We will reject all bits higher than 16.
3143          */
3144         if (smb_GetSMBOffsetParm(inp, 6, 1) != 0)
3145                 return CM_ERROR_INVAL;
3146         baseFid = smb_GetSMBOffsetParm(inp, 5, 1);
3147         desiredAccess = smb_GetSMBOffsetParm(inp, 7, 1)
3148                           | (smb_GetSMBOffsetParm(inp, 8, 1) << 16);
3149         extAttributes = smb_GetSMBOffsetParm(inp, 13, 1)
3150                           | (smb_GetSMBOffsetParm(inp, 14, 1) << 16);
3151         createDisp = smb_GetSMBOffsetParm(inp, 17, 1)
3152                         | (smb_GetSMBOffsetParm(inp, 18, 1) << 16);
3153         createOptions = smb_GetSMBOffsetParm(inp, 19, 1)
3154                           | (smb_GetSMBOffsetParm(inp, 20, 1) << 16);
3155
3156         /* mustBeDir is never set; createOptions directory bit seems to be
3157          * more important
3158          */
3159         if (createOptions & 1)
3160                 realDirFlag = 1;
3161         else if (createOptions & 0x40)
3162                 realDirFlag = 0;
3163         else
3164                 realDirFlag = -1;
3165
3166         /*
3167          * compute initial mode bits based on read-only flag in
3168          * extended attributes
3169          */
3170         initialModeBits = 0666;
3171         if (extAttributes & 1) initialModeBits &= ~0222;
3172
3173         pathp = smb_GetSMBData(inp, NULL);
3174         /* Sometimes path is not null-terminated, so we make a copy. */
3175         realPathp = malloc(nameLength+1);
3176         memcpy(realPathp, pathp, nameLength);
3177         realPathp[nameLength] = 0;
3178
3179         spacep = inp->spacep;
3180         smb_StripLastComponent(spacep->data, &lastNamep, realPathp);
3181
3182     osi_Log1(smb_logp,"NTCreateX for [%s]",osi_LogSaveString(smb_logp,realPathp));
3183     osi_Log4(smb_logp,"NTCreateX da=[%x] ea=[%x] cd=[%x] co=[%x]", desiredAccess, extAttributes, createDisp, createOptions);
3184
3185         if (lastNamep && strcmp(lastNamep, SMB_IOCTL_FILENAME) == 0) {
3186                 /* special case magic file name for receiving IOCTL requests
3187                  * (since IOCTL calls themselves aren't getting through).
3188                  */
3189                 fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
3190                 smb_SetupIoctlFid(fidp, spacep);
3191
3192                 /* set inp->fid so that later read calls in same msg can find fid */
3193                 inp->fid = fidp->fid;
3194
3195                 /* out parms */
3196                 parmSlot = 2;
3197                 smb_SetSMBParmByte(outp, parmSlot, 0);  /* oplock */
3198                 smb_SetSMBParm(outp, parmSlot, fidp->fid); parmSlot++;
3199                 smb_SetSMBParmLong(outp, parmSlot, 1); parmSlot += 2; /* Action */
3200                 /* times */
3201                 memset(&ft, 0, sizeof(ft));
3202                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&ft); parmSlot += 4;
3203                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&ft); parmSlot += 4;
3204                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&ft); parmSlot += 4;
3205                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&ft); parmSlot += 4;
3206                 smb_SetSMBParmLong(outp, parmSlot, 0); parmSlot += 2; /* attr */
3207                 sz.HighPart = 0x7fff; sz.LowPart = 0;
3208                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&sz); parmSlot += 4; /* alen */
3209                 smb_SetSMBParmDouble(outp, parmSlot, (char *)&sz); parmSlot += 4; /* len */
3210                 smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;  /* filetype */
3211                 smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;  /* dev state */
3212                 smb_SetSMBParmByte(outp, parmSlot, 0);  /* is a dir? */
3213                 smb_SetSMBDataLength(outp, 0);
3214
3215                 /* clean up fid reference */
3216                 smb_ReleaseFID(fidp);
3217                 free(realPathp);
3218                 return 0;
3219         }
3220
3221 #ifdef DEBUG_VERBOSE
3222     {
3223         char *hexp, *asciip;
3224         asciip = (lastNamep? lastNamep : realPathp);
3225         hexp = osi_HexifyString( asciip );
3226         DEBUG_EVENT2("AFS", "NTCreateX H[%s] A[%s]", hexp, asciip);
3227         free(hexp);
3228     }
3229 #endif
3230     userp = smb_GetUser(vcp, inp);
3231     if (!userp) {
3232         osi_Log1(smb_logp, "NTCreateX Invalid user [%d]", ((smb_t *) inp)->uid);
3233         free(realPathp);
3234         return CM_ERROR_INVAL;
3235     }
3236
3237         if (baseFid == 0) {
3238                 baseDirp = cm_rootSCachep;
3239                 tidPathp = smb_GetTIDPath(vcp, ((smb_t *)inp)->tid);
3240         }
3241         else {
3242         baseFidp = smb_FindFID(vcp, baseFid, 0);
3243         if (!baseFidp) {
3244                 osi_Log1(smb_logp, "NTCreateX Invalid base fid [%d]", baseFid);
3245                 free(realPathp);
3246                 cm_ReleaseUser(userp);
3247                 return CM_ERROR_INVAL;
3248         }
3249                 baseDirp = baseFidp->scp;
3250                 tidPathp = NULL;
3251         }
3252
3253     osi_Log1(smb_logp, "NTCreateX tidPathp=[%s]", (tidPathp==NULL)?"null": osi_LogSaveString(smb_logp,tidPathp));
3254         
3255     /* compute open mode */
3256         fidflags = 0;
3257         if (desiredAccess & DELETE)
3258                 fidflags |= SMB_FID_OPENDELETE;
3259         if (desiredAccess & AFS_ACCESS_READ)
3260                 fidflags |= SMB_FID_OPENREAD;
3261         if (desiredAccess & AFS_ACCESS_WRITE)
3262                 fidflags |= SMB_FID_OPENWRITE;
3263
3264         dscp = NULL;
3265         code = 0;
3266         code = cm_NameI(baseDirp, realPathp, CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
3267                         userp, tidPathp, &req, &scp);
3268         if (code == 0) foundscp = TRUE;
3269         if (code != 0
3270             || (fidflags & (SMB_FID_OPENDELETE | SMB_FID_OPENWRITE))) {
3271                 /* look up parent directory */
3272         /* If we are trying to create a path (i.e. multiple nested directories), then we don't *need*
3273         the immediate parent.  We have to work our way up realPathp until we hit something that we
3274         recognize.
3275         */
3276
3277         while(1) {
3278             char *tp;
3279
3280             code = cm_NameI(baseDirp, spacep->data,
3281                              CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
3282                              userp, tidPathp, &req, &dscp);
3283
3284             if (code && 
3285                 (tp = strrchr(spacep->data,'\\')) &&
3286                 (createDisp == 2) &&
3287                 (realDirFlag == 1)) {
3288                 *tp++ = 0;
3289                 treeCreate = TRUE;
3290                 treeStartp = realPathp + (tp - spacep->data);
3291
3292                 if (*tp && !smb_IsLegalFilename(tp)) {
3293                     if(baseFid != 0) smb_ReleaseFID(baseFidp);
3294                     cm_ReleaseUser(userp);
3295                     free(realPathp);
3296                     return CM_ERROR_BADNTFILENAME;
3297                 }
3298             }
3299             else
3300                 break;
3301         }
3302
3303         if (baseFid != 0) smb_ReleaseFID(baseFidp);
3304
3305         if (code) {
3306             osi_Log0(smb_logp,"NTCreateX parent not found");
3307             cm_ReleaseUser(userp);
3308             free(realPathp);
3309             return code;
3310         }
3311
3312         if(treeCreate && dscp->fileType == CM_SCACHETYPE_FILE) {
3313             /* A file exists where we want a directory. */
3314             cm_ReleaseSCache(dscp);
3315             cm_ReleaseUser(userp);
3316             free(realPathp);
3317             return CM_ERROR_EXISTS;
3318         }
3319
3320         if (!lastNamep) lastNamep = realPathp;
3321         else lastNamep++;
3322
3323         if (!smb_IsLegalFilename(lastNamep)) {
3324             cm_ReleaseSCache(dscp);
3325             cm_ReleaseUser(userp);
3326             free(realPathp);
3327             return CM_ERROR_BADNTFILENAME;
3328         }
3329
3330         if (!foundscp && !treeCreate) {
3331                         code = cm_Lookup(dscp, lastNamep,
3332                                          CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD,
3333                                          userp, &req, &scp);
3334                         if (code && code != CM_ERROR_NOSUCHFILE) {
3335                                 cm_ReleaseSCache(dscp);
3336                                 cm_ReleaseUser(userp);
3337                                 free(realPathp);
3338                                 return code;
3339                         }
3340                 }
3341         }
3342         else {
3343                 if (baseFid != 0) smb_ReleaseFID(baseFidp);
3344         }
3345