netbiosName-cellname-20040306
[openafs.git] / src / WINNT / afsd / smb.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 //#define NOSERVICE 1
11
12 #define NOMOREFILESFIX 1
13
14 #include <afs/param.h>
15 #include <afs/stds.h>
16
17 #ifndef DJGPP
18 #include <windows.h>
19 #else
20 #include <sys/timeb.h>
21 #include <tzfile.h>
22 #endif /* !DJGPP */
23 #include <stddef.h>
24 #include <stdlib.h>
25 #include <malloc.h>
26 #include <string.h>
27 #include <stdio.h>
28 #include <time.h>
29
30 #include <osi.h>
31
32 #include "afsd.h"
33
34 #include "smb.h"
35 #include "lanahelper.h"
36
37 /* These characters are illegal in Windows filenames */
38 static char *illegalChars = "\\/:*?\"<>|";
39 BOOL isWindows2000 = FALSE;
40
41 smb_vc_t *dead_vcp = NULL;
42 smb_vc_t *active_vcp = NULL;
43
44 /* TODO; logout mechanism needs to be thread-safe */
45 char *loggedOutName = NULL;
46 smb_user_t *loggedOutUserp = NULL;
47 unsigned long loggedOutTime;
48 int loggedOut = 0;
49 #ifdef DJGPP
50 int smbShutdownFlag = 0;
51 #endif /* DJGPP */
52
53 int smb_LogoffTokenTransfer;
54 unsigned long smb_LogoffTransferTimeout;
55
56 DWORD last_msg_time = 0;
57
58 long ongoingOps = 0;
59
60 unsigned int sessionGen = 0;
61
62 extern void afsi_log(char *pattern, ...);
63 extern HANDLE afsi_file;
64
65 osi_hyper_t hzero = {0, 0};
66 osi_hyper_t hones = {0xFFFFFFFF, -1};
67
68 osi_log_t *  smb_logp;
69 osi_rwlock_t smb_globalLock;
70 osi_rwlock_t smb_rctLock;
71 osi_mutex_t  smb_ListenerLock;
72  
73 char smb_LANadapter;
74 unsigned char smb_sharename[NCBNAMSZ+1] = {0};
75
76 /* for debugging */
77 long smb_maxObsConcurrentCalls=0;
78 long smb_concurrentCalls=0;
79
80 smb_dispatch_t smb_dispatchTable[SMB_NOPCODES];
81
82 smb_packet_t *smb_packetFreeListp;
83 smb_ncb_t *smb_ncbFreeListp;
84
85 int smb_NumServerThreads;
86
87 int numNCBs, numSessions;
88
89 int smb_maxVCPerServer;
90 int smb_maxMpxRequests;
91
92 #define NCBmax MAXIMUM_WAIT_OBJECTS
93 EVENT_HANDLE NCBavails[NCBmax], NCBevents[NCBmax];
94 EVENT_HANDLE **NCBreturns;
95 DWORD NCBsessions[NCBmax];
96 NCB *NCBs[NCBmax];
97 struct smb_packet *bufs[NCBmax];
98
99 #define Sessionmax MAXIMUM_WAIT_OBJECTS
100 EVENT_HANDLE SessionEvents[Sessionmax];
101 unsigned short LSNs[Sessionmax];
102 int lanas[Sessionmax];
103 BOOL dead_sessions[Sessionmax];
104 LANA_ENUM lana_list;
105
106 /* for raw I/O */
107 osi_mutex_t smb_RawBufLock;
108 #ifdef DJGPP
109 #define SMB_RAW_BUFS 4
110 dos_ptr smb_RawBufs;
111 int smb_RawBufSel[SMB_RAW_BUFS];
112 #else
113 char *smb_RawBufs;
114 #endif /* DJGPP */
115
116 #define RAWTIMEOUT INFINITE
117
118 /* for raw write */
119 typedef struct raw_write_cont {
120         long code;
121         osi_hyper_t offset;
122         long count;
123 #ifndef DJGPP
124         char *buf;
125 #else
126         dos_ptr buf;
127 #endif /* DJGPP */
128         int writeMode;
129         long alreadyWritten;
130 } raw_write_cont_t;
131
132 /* dir search stuff */
133 long smb_dirSearchCounter = 1;
134 smb_dirSearch_t *smb_firstDirSearchp;
135 smb_dirSearch_t *smb_lastDirSearchp;
136
137 /* hide dot files? */
138 int smb_hideDotFiles;
139
140 /* global state about V3 protocols */
141 int smb_useV3;          /* try to negotiate V3 */
142
143 #ifndef DJGPP
144 /* MessageBox or something like it */
145 int (WINAPI *smb_MBfunc)(HWND, LPCTSTR, LPCTSTR, UINT) = NULL;
146 #endif /* DJGPP */
147
148 /* GMT time info:
149  * Time in Unix format of midnight, 1/1/1970 local time.
150  * When added to dosUTime, gives Unix (AFS) time.
151  */
152 long smb_localZero;
153
154 /* Time difference for converting to kludge-GMT */
155 int smb_NowTZ;
156
157 char *smb_localNamep = NULL;
158
159 smb_vc_t *smb_allVCsp;
160
161 smb_username_t *usernamesp = NULL;
162
163 smb_waitingLock_t *smb_allWaitingLocks;
164
165 /* forward decl */
166 void smb_DispatchPacket(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp,
167         NCB *ncbp, raw_write_cont_t *rwcp);
168 void smb_NetbiosInit();
169 #ifdef DJGPP
170 #ifndef AFS_WIN95_ENV
171 DWORD smb_ServerExceptionFilter(void);
172 #endif
173
174 extern char cm_HostName[];
175 extern char cm_confDir[];
176 #endif
177
178 #ifdef DJGPP
179 #define LPTSTR char *
180 #define GetComputerName(str, sizep) \
181        strcpy((str), cm_HostName); \
182        *(sizep) = strlen(cm_HostName)
183 #endif /* DJGPP */
184
185 extern char AFSConfigKeyName[];
186
187 /*
188  * Demo expiration
189  *
190  * To build an expiring version, comment out the definition of NOEXPIRE,
191  * and set the definition of EXPIREDATE to the desired value.
192  */
193 #define NOEXPIRE 1
194 #define EXPIREDATE 834000000            /* Wed Jun 5 1996 */
195
196
197 char * myCrt_Dispatch(int i)
198 {
199         switch (i)
200         {
201         default:
202                 return "unknown SMB op";
203         case 0x00:
204                 return "(00)ReceiveCoreMakeDir";
205         case 0x01:
206                 return "(01)ReceiveCoreRemoveDir";
207         case 0x02:
208                 return "(02)ReceiveCoreOpen";
209         case 0x03:
210                 return "(03)ReceiveCoreCreate";
211         case 0x04:
212                 return "(04)ReceiveCoreClose";
213         case 0x05:
214                 return "(05)ReceiveCoreFlush";
215         case 0x06:
216                 return "(06)ReceiveCoreUnlink";
217         case 0x07:
218                 return "(07)ReceiveCoreRename";
219         case 0x08:
220                 return "(08)ReceiveCoreGetFileAttributes";
221         case 0x09:
222                 return "(09)ReceiveCoreSetFileAttributes";
223         case 0x0a:
224                 return "(0a)ReceiveCoreRead";
225         case 0x0b:
226                 return "(0b)ReceiveCoreWrite";
227         case 0x0c:
228                 return "(0c)ReceiveCoreLockRecord";
229         case 0x0d:
230                 return "(0d)ReceiveCoreUnlockRecord";
231         case 0x0e:
232                 return "(0e)SendCoreBadOp";
233         case 0x0f:
234                 return "(0f)ReceiveCoreCreate";
235         case 0x10:
236                 return "(10)ReceiveCoreCheckPath";
237         case 0x11:
238                 return "(11)SendCoreBadOp";
239         case 0x12:
240                 return "(12)ReceiveCoreSeek";
241         case 0x1a:
242                 return "(1a)ReceiveCoreReadRaw";
243         case 0x1d:
244                 return "(1d)ReceiveCoreWriteRawDummy";
245         case 0x22:
246                 return "(22)ReceiveV3SetAttributes";
247         case 0x23:
248                 return "(23)ReceiveV3GetAttributes";
249         case 0x24:
250                 return "(24)ReceiveV3LockingX";
251         case 0x29:
252                 return "(29)SendCoreBadOp";
253         case 0x2b:
254                 return "(2b)ReceiveCoreEcho";
255         case 0x2d:
256                 return "(2d)ReceiveV3OpenX";
257         case 0x2e:
258                 return "(2e)ReceiveV3ReadX";
259         case 0x32:
260                 return "(32)ReceiveV3Tran2A";
261         case 0x33:
262                 return "(33)ReceiveV3Tran2A";
263         case 0x34:
264                 return "(34)ReceiveV3FindClose";
265         case 0x35:
266                 return "(35)ReceiveV3FindNotifyClose";
267         case 0x70:
268                 return "(70)ReceiveCoreTreeConnect";
269         case 0x71:
270                 return "(71)ReceiveCoreTreeDisconnect";
271         case 0x72:
272                 return "(72)ReceiveNegotiate";
273         case 0x73:
274                 return "(73)ReceiveV3SessionSetupX";
275         case 0x74:
276                 return "(74)ReceiveV3UserLogoffX";
277         case 0x75:
278                 return "(75)ReceiveV3TreeConnectX";
279         case 0x80:
280                 return "(80)ReceiveCoreGetDiskAttributes";
281         case 0x81:
282                 return "(81)ReceiveCoreSearchDir";
283         case 0xA0:
284                 return "(A0)ReceiveNTTransact";
285         case 0xA2:
286                 return "(A2)ReceiveNTCreateX";
287         case 0xA4:
288                 return "(A4)ReceiveNTCancel";
289         case 0xc0:
290                 return "(c0)SendCoreBadOp";
291         case 0xc1:
292                 return "(c1)SendCoreBadOp";
293         case 0xc2:
294                 return "(c2)SendCoreBadOp";
295         case 0xc3:
296                 return "(c3)SendCoreBadOp";
297         }
298 }
299
300 char * myCrt_2Dispatch(int i)
301 {
302         switch (i)
303         {
304         default:
305                 return "unknown SMB op-2";
306         case 0:
307                 return "S(00)CreateFile";
308         case 1:
309                 return "S(01)FindFirst";
310         case 2:
311                 return "S(02)FindNext"; /* FindNext */
312         case 3:
313                 return "S(03)QueryFileSystem_ReceiveTran2QFSInfo";
314         case 4:
315                 return "S(04)??";
316         case 5:
317                 return "S(05)QueryFileInfo_ReceiveTran2QPathInfo";
318         case 6:
319                 return "S(06)SetFileInfo_ReceiveTran2SetPathInfo";
320         case 7:
321                 return "S(07)SetInfoHandle_ReceiveTran2QFileInfo";
322         case 8:
323                 return "S(08)??_ReceiveTran2SetFileInfo";
324         case 9:
325                 return "S(09)??_ReceiveTran2FSCTL";
326         case 10:
327                 return "S(0a)_ReceiveTran2IOCTL";
328         case 11:
329                 return "S(0b)_ReceiveTran2FindNotifyFirst";
330         case 12:
331                 return "S(0c)_ReceiveTran2FindNotifyNext";
332         case 13:
333                 return "S(0d)CreateDirectory_ReceiveTran2MKDir";
334         }
335 }
336
337 /* scache must be locked */
338 unsigned int smb_Attributes(cm_scache_t *scp)
339 {
340         unsigned int attrs;
341
342         if (scp->fileType == CM_SCACHETYPE_DIRECTORY
343                 || scp->fileType == CM_SCACHETYPE_MOUNTPOINT)
344                         attrs = SMB_ATTR_DIRECTORY;
345         else
346                 attrs = 0;
347
348         /*
349          * We used to mark a file RO if it was in an RO volume, but that
350          * turns out to be impolitic in NT.  See defect 10007.
351          */
352 #ifdef notdef
353         if ((scp->unixModeBits & 0222) == 0 || (scp->flags & CM_SCACHEFLAG_RO))
354 #endif
355         if ((scp->unixModeBits & 0222) == 0)
356                 attrs |= SMB_ATTR_READONLY;     /* turn on read-only flag */
357
358         return attrs;
359 }
360
361 /* Check if the named file/dir is a dotfile/dotdir */
362 /* String pointed to by lastComp can have leading slashes, but otherwise should have
363    no other patch components */
364 unsigned int smb_IsDotFile(char *lastComp) {
365         char *s;
366         if(lastComp) {
367                 /* skip over slashes */
368         for(s=lastComp;*s && (*s == '\\' || *s == '/'); s++);
369         }
370         else
371                 return 0;
372
373     /* nulls, curdir and parent dir doesn't count */
374         if(!*s) return 0;
375         if(*s == '.') {
376                 if(!*(s + 1)) return 0;
377                 if(*(s+1) == '.' && !*(s + 2)) return 0;
378                 return 1;
379         }
380         return 0;
381 }
382
383 static int ExtractBits(WORD bits, short start, short len)
384 {
385         int end;
386         WORD num;
387
388         end = start + len;
389         
390         num = bits << (16 - end);
391         num = num >> ((16 - end) + start);
392         
393         return (int)num;
394 }
395
396 #ifndef DJGPP
397 void ShowUnixTime(char *FuncName, long unixTime)
398 {
399         FILETIME ft;
400         WORD wDate, wTime;
401
402         smb_LargeSearchTimeFromUnixTime(&ft, unixTime);
403                 
404         if (!FileTimeToDosDateTime(&ft, &wDate, &wTime))
405                 osi_Log1(afsd_logp, "Failed to convert filetime to dos datetime: %d", GetLastError());
406         else {
407                 int day, month, year, sec, min, hour;
408                 char msg[256];
409                 
410                 day = ExtractBits(wDate, 0, 5);
411                 month = ExtractBits(wDate, 5, 4);
412                 year = ExtractBits(wDate, 9, 7) + 1980;
413                 
414                 sec = ExtractBits(wTime, 0, 5);
415                 min = ExtractBits(wTime, 5, 6);
416                 hour = ExtractBits(wTime, 11, 5);
417                 
418                 sprintf(msg, "%s = %02d-%02d-%04d %02d:%02d:%02d", FuncName, month, day, year, hour, min, sec);
419                 osi_Log1(afsd_logp, "%s", osi_LogSaveString(afsd_logp, msg));
420         }
421 }
422 #endif /* DJGPP */
423
424 #ifndef DJGPP
425 /* Determine if we are observing daylight savings time */
426 void GetTimeZoneInfo(BOOL *pDST, LONG *pDstBias, LONG *pBias)
427 {
428         TIME_ZONE_INFORMATION timeZoneInformation;
429         SYSTEMTIME utc, local, localDST;
430
431         /* Get the time zone info. NT uses this to calc if we are in DST. */
432         GetTimeZoneInformation(&timeZoneInformation);
433  
434         /* Return the daylight bias */
435         *pDstBias = timeZoneInformation.DaylightBias;
436
437         /* Return the bias */
438         *pBias = timeZoneInformation.Bias;
439
440         /* Now determine if DST is being observed */
441
442         /* Get the UTC (GMT) time */
443         GetSystemTime(&utc);
444
445         /* Convert UTC time to local time using the time zone info.  If we are
446            observing DST, the calculated local time will include this. 
447         */
448         SystemTimeToTzSpecificLocalTime(&timeZoneInformation, &utc, &localDST);
449
450         /* Set the daylight bias to 0.  The daylight bias is the amount of change
451            in time that we use for daylight savings time.  By setting this to 0
452            we cause there to be no change in time during daylight savings time. 
453         */
454         timeZoneInformation.DaylightBias = 0;
455
456         /* Convert the utc time to local time again, but this time without any
457            adjustment for daylight savings time. 
458         */
459         SystemTimeToTzSpecificLocalTime(&timeZoneInformation, &utc, &local);
460
461         /* If the two times are different, then it means that the localDST that
462            we calculated includes the daylight bias, and therefore we are
463            observing daylight savings time.
464         */
465         *pDST = localDST.wHour != local.wHour;
466 }
467 #else
468 /* Determine if we are observing daylight savings time */
469 void GetTimeZoneInfo(BOOL *pDST, LONG *pDstBias, LONG *pBias)
470 {
471   struct timeb t;
472
473   ftime(&t);
474   *pDST = t.dstflag;
475   *pDstBias = -60;    /* where can this be different? */
476   *pBias = t.timezone;
477 }
478 #endif /* DJGPP */
479  
480
481 void CompensateForSmbClientLastWriteTimeBugs(long *pLastWriteTime)
482 {
483         BOOL dst;       /* Will be TRUE if observing DST */
484         LONG dstBias;   /* Offset from local time if observing DST */
485         LONG bias;      /* Offset from GMT for local time */
486         
487         /*
488          * This function will adjust the last write time to compensate
489          * for two bugs in the smb client:
490          *
491          *    1) During Daylight Savings Time, the LastWriteTime is ahead
492          *       in time by the DaylightBias (ignoring the sign - the
493          *       DaylightBias is always stored as a negative number).  If
494          *       the DaylightBias is -60, then the LastWriteTime will be
495          *       ahead by 60 minutes.
496          *
497          *    2) If the local time zone is a positive offset from GMT, then
498          *       the LastWriteTime will be the correct local time plus the
499          *       Bias (ignoring the sign - a positive offset from GMT is
500          *       always stored as a negative Bias).  If the Bias is -120,
501          *       then the LastWriteTime will be ahead by 120 minutes.
502          *
503          *    These bugs can occur at the same time.
504          */
505
506         GetTimeZoneInfo(&dst, &dstBias, &bias);
507          
508          /* First adjust for DST */
509         if (dst)
510                 *pLastWriteTime -= (-dstBias * 60);     /* Convert dstBias to seconds */
511                 
512         /* Now adjust for a positive offset from GMT (a negative bias). */
513         if (bias < 0)
514                 *pLastWriteTime -= (-bias * 60);        /* Convert bias to seconds */
515 }
516
517 /*
518  * Calculate the difference (in seconds) between local time and GMT.
519  * This enables us to convert file times to kludge-GMT.
520  */
521 static void
522 smb_CalculateNowTZ()
523 {
524         time_t t;
525         struct tm gmt_tm, local_tm;
526         int days, hours, minutes, seconds;
527
528         t = time(NULL);
529         gmt_tm = *(gmtime(&t));
530         local_tm = *(localtime(&t));
531
532         days = local_tm.tm_yday - gmt_tm.tm_yday;
533         hours = 24 * days + local_tm.tm_hour - gmt_tm.tm_hour;
534         minutes = 60 * hours + local_tm.tm_min - gmt_tm.tm_min;
535         seconds = 60 * minutes + local_tm.tm_sec - gmt_tm.tm_sec;
536
537         smb_NowTZ = seconds;
538 }
539
540 #ifndef DJGPP
541 void smb_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, long unixTime)
542 {
543         struct tm *ltp;
544         SYSTEMTIME stm;
545         struct tm localJunk;
546         long ersatz_unixTime;
547
548         /*
549          * Must use kludge-GMT instead of real GMT.
550          * kludge-GMT is computed by adding time zone difference to localtime.
551          *
552          * real GMT would be:
553          * ltp = gmtime(&unixTime);
554          */
555         ersatz_unixTime = unixTime - smb_NowTZ;
556         ltp = localtime(&ersatz_unixTime);
557
558         /* if we fail, make up something */
559         if (!ltp) {
560                 ltp = &localJunk;
561                 localJunk.tm_year = 89 - 20;
562                 localJunk.tm_mon = 4;
563                 localJunk.tm_mday = 12;
564                 localJunk.tm_hour = 0;
565                 localJunk.tm_min = 0;
566                 localJunk.tm_sec = 0;
567         }
568
569         stm.wYear = ltp->tm_year + 1900;
570         stm.wMonth = ltp->tm_mon + 1;
571         stm.wDayOfWeek = ltp->tm_wday;
572         stm.wDay = ltp->tm_mday;
573         stm.wHour = ltp->tm_hour;
574         stm.wMinute = ltp->tm_min;
575         stm.wSecond = ltp->tm_sec;
576         stm.wMilliseconds = 0;
577
578         SystemTimeToFileTime(&stm, largeTimep);
579 }
580 #else /* DJGPP */
581 void smb_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, long unixTime)
582 {
583   /* unixTime: seconds since 1/1/1970 00:00:00 GMT */
584   /* FILETIME: 100ns intervals since 1/1/1601 00:00:00 ??? */
585   LARGE_INTEGER *ft = (LARGE_INTEGER *) largeTimep;
586   LARGE_INTEGER ut;
587   int leap_years = 89;   /* leap years betw 1/1/1601 and 1/1/1970 */
588
589   /* set ft to number of 100ns intervals betw 1/1/1601 and 1/1/1970 GMT */
590   *ft = ConvertLongToLargeInteger(((EPOCH_YEAR-1601) * 365 + leap_years)
591                                    * 24 * 60);
592   *ft = LargeIntegerMultiplyByLong(*ft, 60);
593   *ft = LargeIntegerMultiplyByLong(*ft, 10000000);
594
595   /* add unix time */
596   ut = ConvertLongToLargeInteger(unixTime);
597   ut = LargeIntegerMultiplyByLong(ut, 10000000);
598   *ft = LargeIntegerAdd(*ft, ut);
599 }
600 #endif /* !DJGPP */
601
602 #ifndef DJGPP
603 void smb_UnixTimeFromLargeSearchTime(long *unixTimep, FILETIME *largeTimep)
604 {
605         SYSTEMTIME stm;
606         struct tm lt;
607         long save_timezone;
608
609         FileTimeToSystemTime(largeTimep, &stm);
610
611         lt.tm_year = stm.wYear - 1900;
612         lt.tm_mon = stm.wMonth - 1;
613         lt.tm_wday = stm.wDayOfWeek;
614         lt.tm_mday = stm.wDay;
615         lt.tm_hour = stm.wHour;
616         lt.tm_min = stm.wMinute;
617         lt.tm_sec = stm.wSecond;
618         lt.tm_isdst = -1;
619
620         save_timezone = _timezone;
621         _timezone += smb_NowTZ;
622         *unixTimep = mktime(&lt);
623         _timezone = save_timezone;
624 }
625 #else /* DJGPP */
626 void smb_UnixTimeFromLargeSearchTime(long *unixTimep, FILETIME *largeTimep)
627 {
628   /* unixTime: seconds since 1/1/1970 00:00:00 GMT */
629   /* FILETIME: 100ns intervals since 1/1/1601 00:00:00 GMT? */
630   LARGE_INTEGER *ft = (LARGE_INTEGER *) largeTimep;
631   LARGE_INTEGER a;
632   int leap_years = 89;
633
634   /* set to number of 100ns intervals betw 1/1/1601 and 1/1/1970 */
635   a = ConvertLongToLargeInteger(((EPOCH_YEAR-1601) * 365 + leap_years) * 24 * 60
636 );
637   a = LargeIntegerMultiplyByLong(a, 60);
638   a = LargeIntegerMultiplyByLong(a, 10000000);
639
640   /* subtract it from ft */
641   a = LargeIntegerSubtract(*ft, a);
642
643   /* divide down to seconds */
644   *unixTimep = LargeIntegerDivideByLong(a, 10000000);
645 }
646 #endif /* !DJGPP */
647
648 void smb_SearchTimeFromUnixTime(long *dosTimep, long unixTime)
649 {
650         struct tm *ltp;
651         int dosDate;
652         int dosTime;
653         struct tm localJunk;
654
655         ltp = localtime((time_t*) &unixTime);
656
657         /* if we fail, make up something */
658         if (!ltp) {
659                 ltp = &localJunk;
660                 localJunk.tm_year = 89 - 20;
661                 localJunk.tm_mon = 4;
662                 localJunk.tm_mday = 12;
663                 localJunk.tm_hour = 0;
664                 localJunk.tm_min = 0;
665                 localJunk.tm_sec = 0;
666         }
667
668         dosDate = ((ltp->tm_year-80)<<9) | ((ltp->tm_mon+1) << 5) | (ltp->tm_mday);
669         dosTime = (ltp->tm_hour<<11) | (ltp->tm_min << 5) | (ltp->tm_sec / 2);
670         *dosTimep = (dosDate<<16) | dosTime;
671 }
672
673 void smb_UnixTimeFromSearchTime(long *unixTimep, long searchTime)
674 {
675         unsigned short dosDate;
676         unsigned short dosTime;
677         struct tm localTm;
678         
679         dosDate = searchTime & 0xffff;
680         dosTime = (searchTime >> 16) & 0xffff;
681         
682         localTm.tm_year = 80 + ((dosDate>>9) & 0x3f);
683         localTm.tm_mon = ((dosDate >> 5) & 0xf) - 1;    /* January is 0 in localTm */
684         localTm.tm_mday = (dosDate) & 0x1f;
685         localTm.tm_hour = (dosTime>>11) & 0x1f;
686         localTm.tm_min = (dosTime >> 5) & 0x3f;
687         localTm.tm_sec = (dosTime & 0x1f) * 2;
688         localTm.tm_isdst = -1;                          /* compute whether DST in effect */
689         
690         *unixTimep = mktime(&localTm);
691 }
692
693 void smb_DosUTimeFromUnixTime(long *dosUTimep, long unixTime)
694 {
695         *dosUTimep = unixTime - smb_localZero;
696 }
697
698 void smb_UnixTimeFromDosUTime(long *unixTimep, long dosTime)
699 {
700 #ifndef DJGPP
701         *unixTimep = dosTime + smb_localZero;
702 #else /* DJGPP */
703         /* dosTime seems to be already adjusted for GMT */
704         *unixTimep = dosTime;
705 #endif /* !DJGPP */
706 }
707
708 smb_vc_t *smb_FindVC(unsigned short lsn, int flags, int lana)
709 {
710         smb_vc_t *vcp;
711
712         lock_ObtainWrite(&smb_rctLock);
713         for(vcp = smb_allVCsp; vcp; vcp=vcp->nextp) {
714                 if (lsn == vcp->lsn && lana == vcp->lana) {
715                         vcp->refCount++;
716                         break;
717                 }
718         }
719         if (!vcp && (flags & SMB_FLAG_CREATE)) {
720                 vcp = malloc(sizeof(*vcp));
721                 memset(vcp, 0, sizeof(*vcp));
722                 vcp->refCount = 1;
723                 vcp->tidCounter = 1;
724                 vcp->fidCounter = 1;
725                 vcp->uidCounter = 1;  /* UID 0 is reserved for blank user */
726                 vcp->nextp = smb_allVCsp;
727                 smb_allVCsp = vcp;
728                 lock_InitializeMutex(&vcp->mx, "vc_t mutex");
729                 vcp->lsn = lsn;
730                 vcp->lana = lana;
731         }
732         lock_ReleaseWrite(&smb_rctLock);
733         return vcp;
734 }
735
736 int smb_IsStarMask(char *maskp)
737 {
738         int i;
739         char tc;
740         
741         for(i=0; i<11; i++) {
742                 tc = *maskp++;
743                 if (tc == '?' || tc == '*' || tc == '>') return 1;        
744         }
745         return 0;
746 }
747
748 void smb_ReleaseVC(smb_vc_t *vcp)
749 {
750         lock_ObtainWrite(&smb_rctLock);
751         osi_assert(vcp->refCount-- > 0);
752         lock_ReleaseWrite(&smb_rctLock);
753 }
754
755 void smb_HoldVC(smb_vc_t *vcp)
756 {
757         lock_ObtainWrite(&smb_rctLock);
758         vcp->refCount++;
759         lock_ReleaseWrite(&smb_rctLock);
760 }
761
762 smb_tid_t *smb_FindTID(smb_vc_t *vcp, unsigned short tid, int flags)
763 {
764         smb_tid_t *tidp;
765
766         lock_ObtainWrite(&smb_rctLock);
767         for(tidp = vcp->tidsp; tidp; tidp = tidp->nextp) {
768                 if (tid == tidp->tid) {
769                         tidp->refCount++;
770                         break;
771                 }
772         }
773         if (!tidp && (flags & SMB_FLAG_CREATE)) {
774                 tidp = malloc(sizeof(*tidp));
775                 memset(tidp, 0, sizeof(*tidp));
776                 tidp->nextp = vcp->tidsp;
777                 tidp->refCount = 1;
778                 tidp->vcp = vcp;
779                 vcp->tidsp = tidp;
780                 lock_InitializeMutex(&tidp->mx, "tid_t mutex");
781                 tidp->tid = tid;
782         }
783         lock_ReleaseWrite(&smb_rctLock);
784         return tidp;
785 }
786
787 void smb_ReleaseTID(smb_tid_t *tidp)
788 {
789         smb_tid_t *tp;
790         smb_tid_t **ltpp;
791         cm_user_t *userp;
792
793         userp = NULL;
794         lock_ObtainWrite(&smb_rctLock);
795         osi_assert(tidp->refCount-- > 0);
796         if (tidp->refCount == 0 && (tidp->flags & SMB_TIDFLAG_DELETE)) {
797                 ltpp = &tidp->vcp->tidsp;
798                 for(tp = *ltpp; tp; ltpp = &tp->nextp, tp = *ltpp) {
799                         if (tp == tidp) break;
800                 }
801                 osi_assert(tp != NULL);
802                 *ltpp = tp->nextp;
803                 lock_FinalizeMutex(&tidp->mx);
804                 userp = tidp->userp;    /* remember to drop ref later */
805         }
806         lock_ReleaseWrite(&smb_rctLock);
807         if (userp) {
808                 cm_ReleaseUser(userp);
809         }
810 }
811
812 smb_user_t *smb_FindUID(smb_vc_t *vcp, unsigned short uid, int flags)
813 {
814         smb_user_t *uidp = NULL;
815
816         lock_ObtainWrite(&smb_rctLock);
817         for(uidp = vcp->usersp; uidp; uidp = uidp->nextp) {
818                 if (uid == uidp->userID) {
819                         uidp->refCount++;
820                         osi_LogEvent("AFS smb_FindUID (Find by UID)",NULL," VCP[%x] found-uid[%d] name[%s]",(int)vcp,uidp->userID,(uidp->unp) ? uidp->unp->name : "");
821                 break;
822                 }
823         }
824         if (!uidp && (flags & SMB_FLAG_CREATE)) {
825                 uidp = malloc(sizeof(*uidp));
826                 memset(uidp, 0, sizeof(*uidp));
827                 uidp->nextp = vcp->usersp;
828                 uidp->refCount = 1;
829                 uidp->vcp = vcp;
830                 vcp->usersp = uidp;
831                 lock_InitializeMutex(&uidp->mx, "uid_t mutex");
832                 uidp->userID = uid;
833                                 osi_LogEvent("AFS smb_FindUID (Find by UID)",NULL,"VCP[%x] new-uid[%d] name[%s]",(int)vcp,uidp->userID,(uidp->unp ? uidp->unp->name : ""));
834         }
835         lock_ReleaseWrite(&smb_rctLock);
836         return uidp;
837 }
838
839 smb_username_t *smb_FindUserByName(char *usern, char *machine, int flags)
840 {
841         smb_username_t *unp= NULL;
842
843         lock_ObtainWrite(&smb_rctLock);
844         for(unp = usernamesp; unp; unp = unp->nextp) {
845                 if (stricmp(unp->name, usern) == 0 &&
846                     stricmp(unp->machine, machine) == 0) {
847                         unp->refCount++;
848                         break;
849                 }
850         }
851         if (!unp && (flags & SMB_FLAG_CREATE)) {
852           unp = malloc(sizeof(*unp));
853           memset(unp, 0, sizeof(*unp));
854           unp->refCount = 1;
855           unp->nextp = usernamesp;
856           unp->name = strdup(usern);
857           unp->machine = strdup(machine);
858           usernamesp = unp;
859           lock_InitializeMutex(&unp->mx, "username_t mutex");
860         }
861         lock_ReleaseWrite(&smb_rctLock);
862         return unp;
863 }
864
865 smb_user_t *smb_FindUserByNameThisSession(smb_vc_t *vcp, char *usern)
866 {
867         smb_user_t *uidp= NULL;
868
869         lock_ObtainWrite(&smb_rctLock);
870         for(uidp = vcp->usersp; uidp; uidp = uidp->nextp) {
871           if (!uidp->unp) 
872             continue;
873           if (stricmp(uidp->unp->name, usern) == 0) {
874             uidp->refCount++;
875                         osi_LogEvent("AFS smb_FindUserByNameThisSession",NULL,"VCP[%x] uid[%d] match-name[%s]",(int)vcp,uidp->userID,usern);
876             break;
877           } else
878             continue;
879         }
880         lock_ReleaseWrite(&smb_rctLock);
881         return uidp;
882 }
883 void smb_ReleaseUID(smb_user_t *uidp)
884 {
885         smb_user_t *up;
886         smb_user_t **lupp;
887         cm_user_t *userp;
888
889         userp = NULL;
890         lock_ObtainWrite(&smb_rctLock);
891         osi_assert(uidp->refCount-- > 0);
892         if (uidp->refCount == 0 && (uidp->flags & SMB_USERFLAG_DELETE)) {
893                 lupp = &uidp->vcp->usersp;
894                 for(up = *lupp; up; lupp = &up->nextp, up = *lupp) {
895                         if (up == uidp) break;
896                 }
897                 osi_assert(up != NULL);
898                 *lupp = up->nextp;
899                 lock_FinalizeMutex(&uidp->mx);
900                 if (uidp->unp)
901                   userp = uidp->unp->userp;     /* remember to drop ref later */
902         }
903         lock_ReleaseWrite(&smb_rctLock);
904         if (userp) {
905                 cm_ReleaseUserVCRef(userp);
906                 cm_ReleaseUser(userp);
907         }
908 }
909
910 /* retrieve a held reference to a user structure corresponding to an incoming
911  * request.
912  * corresponding release function is cm_ReleaseUser.
913  */
914 cm_user_t *smb_GetUser(smb_vc_t *vcp, smb_packet_t *inp)
915 {
916         smb_user_t *uidp;
917         cm_user_t *up;
918         smb_t *smbp;
919         
920         smbp = (smb_t *) inp;
921         uidp = smb_FindUID(vcp, smbp->uid, 0);
922         if ((!uidp) ||  (!uidp->unp))
923                  return NULL;
924         
925         lock_ObtainMutex(&uidp->mx);
926         up = uidp->unp->userp;
927         cm_HoldUser(up);
928         lock_ReleaseMutex(&uidp->mx);
929
930         smb_ReleaseUID(uidp);
931         
932         return up;
933 }
934
935 /*
936  * Return a pointer to a pathname extracted from a TID structure.  The
937  * TID structure is not held; assume it won't go away.
938  */
939 char *smb_GetTIDPath(smb_vc_t *vcp, unsigned short tid)
940 {
941         smb_tid_t *tidp;
942         char *tpath;
943
944         tidp = smb_FindTID(vcp, tid, 0);
945     if (!tidp) 
946         return NULL;
947         tpath = tidp->pathname;
948         smb_ReleaseTID(tidp);
949         return tpath;
950 }
951
952 /* check to see if we have a chained fid, that is, a fid that comes from an
953  * OpenAndX message that ran earlier in this packet.  In this case, the fid
954  * field in a read, for example, request, isn't set, since the value is
955  * supposed to be inherited from the openAndX call.
956  */
957 int smb_ChainFID(int fid, smb_packet_t *inp)
958 {
959         if (inp->fid == 0 || inp->inCount == 0) return fid;
960         else return inp->fid;
961 }
962
963 /* are we a priv'd user?  What does this mean on NT? */
964 int smb_SUser(cm_user_t *userp)
965 {
966         return 1;
967 }
968
969 /* find a file ID.  If pass in 0, we'll allocate on on a create operation. */
970 smb_fid_t *smb_FindFID(smb_vc_t *vcp, unsigned short fid, int flags)
971 {
972         smb_fid_t *fidp;
973         int newFid;
974         
975         /* figure out if we need to allocate a new file ID */
976         if (fid == 0) {
977                 newFid = 1;
978                 fid = vcp->fidCounter;
979         }
980         else newFid = 0;
981
982         lock_ObtainWrite(&smb_rctLock);
983 retry:
984         for(fidp = vcp->fidsp; fidp; fidp = (smb_fid_t *) osi_QNext(&fidp->q)) {
985                 if (fid == fidp->fid) {
986                         if (newFid) {
987                                 fid++;
988                 if (fid == 0) fid = 1;
989                 goto retry;
990             }
991                         fidp->refCount++;
992             break;
993                 }
994     }
995     if (!fidp && (flags & SMB_FLAG_CREATE)) {
996         char eventName[MAX_PATH];
997         sprintf(eventName,"fid_t event fid=%d", fid);
998                 fidp = malloc(sizeof(*fidp));
999         memset(fidp, 0, sizeof(*fidp));
1000                 osi_QAdd((osi_queue_t **)&vcp->fidsp, &fidp->q);
1001         fidp->refCount = 1;
1002         fidp->vcp = vcp;
1003         lock_InitializeMutex(&fidp->mx, "fid_t mutex");
1004         fidp->fid = fid;
1005                 fidp->curr_chunk = fidp->prev_chunk = -2;
1006                 fidp->raw_write_event = thrd_CreateEvent(NULL, FALSE, TRUE, eventName);
1007         if ( GetLastError() == ERROR_ALREADY_EXISTS )
1008             afsi_log("Event Object Already Exists: %s", eventName);
1009         if (newFid) {
1010                         vcp->fidCounter = fid+1;
1011             if (vcp->fidCounter == 0) vcp->fidCounter = 1;
1012         }
1013     }
1014     lock_ReleaseWrite(&smb_rctLock);
1015     return fidp;
1016 }
1017
1018 void smb_ReleaseFID(smb_fid_t *fidp)
1019 {
1020         cm_scache_t *scp;
1021     smb_vc_t *vcp;
1022     smb_ioctl_t *ioctlp;
1023
1024     if (!fidp)
1025         return NULL;
1026
1027         scp = NULL;
1028         lock_ObtainWrite(&smb_rctLock);
1029         osi_assert(fidp->refCount-- > 0);
1030     if (fidp->refCount == 0 && (fidp->flags & SMB_FID_DELETE)) {
1031                 vcp = fidp->vcp;
1032                 if (!(fidp->flags & SMB_FID_IOCTL))
1033                         scp = fidp->scp;
1034                 osi_QRemove((osi_queue_t **) &vcp->fidsp, &fidp->q);
1035                 thrd_CloseHandle(fidp->raw_write_event);
1036
1037                 /* and see if there is ioctl stuff to free */
1038         ioctlp = fidp->ioctlp;
1039         if (ioctlp) {
1040                         if (ioctlp->prefix) cm_FreeSpace(ioctlp->prefix);
1041                         if (ioctlp->inAllocp) free(ioctlp->inAllocp);
1042                         if (ioctlp->outAllocp) free(ioctlp->outAllocp);
1043                         free(ioctlp);
1044         }
1045
1046         free(fidp);
1047     }
1048         lock_ReleaseWrite(&smb_rctLock);
1049
1050         /* now release the scache structure */
1051         if (scp) cm_ReleaseSCache(scp);
1052 }
1053
1054 /*
1055  * Case-insensitive search for one string in another;
1056  * used to find variable names in submount pathnames.
1057  */
1058 static char *smb_stristr(char *str1, char *str2)
1059 {
1060         char *cursor;
1061
1062         for (cursor = str1; *cursor; cursor++)
1063                 if (stricmp(cursor, str2) == 0)
1064                         return cursor;
1065
1066         return NULL;
1067 }
1068
1069 /*
1070  * Substitute a variable value for its name in a submount pathname.  Variable
1071  * name has been identified by smb_stristr() and is in substr.  Variable name
1072  * length (plus one) is in substr_size.  Variable value is in newstr.
1073  */
1074 static void smb_subst(char *str1, char *substr, unsigned int substr_size,
1075         char *newstr)
1076 {
1077         char temp[1024];
1078
1079         strcpy(temp, substr + substr_size - 1);
1080         strcpy(substr, newstr);
1081         strcat(str1, temp);
1082 }
1083
1084 char VNUserName[] = "%USERNAME%";
1085 char VNLCUserName[] = "%LCUSERNAME%";
1086 char VNComputerName[] = "%COMPUTERNAME%";
1087 char VNLCComputerName[] = "%LCCOMPUTERNAME%";
1088
1089 /* List available shares */
1090 int smb_ListShares()
1091 {
1092         char sbmtpath[256];
1093         char pathName[256];
1094         char shareBuf[4096];
1095         int num_shares=0;
1096         char *this_share;
1097         int len;
1098         char *p;
1099         int print_afs = 0;
1100         int code;
1101
1102         /*strcpy(shareNameList[num_shares], "all");
1103           strcpy(pathNameList[num_shares++], "/afs");*/
1104         fprintf(stderr, "The following shares are available:\n");
1105         fprintf(stderr, "Share Name (AFS Path)\n");
1106         fprintf(stderr, "---------------------\n");
1107         fprintf(stderr, "\\\\%s\\%-16s (%s)\n", smb_localNamep, "ALL", cm_mountRoot);
1108
1109 #ifndef DJGPP
1110         code = GetWindowsDirectory(sbmtpath, sizeof(sbmtpath));
1111         if (code == 0 || code > sizeof(sbmtpath)) return -1;
1112 #else
1113         strcpy(sbmtpath, cm_confDir);
1114 #endif /* !DJGPP */
1115         strcat(sbmtpath, "/afsdsbmt.ini");
1116         len = GetPrivateProfileString("AFS Submounts", NULL, NULL,
1117                                       shareBuf, sizeof(shareBuf),
1118                                       sbmtpath);
1119         if (len == 0) {
1120           return num_shares;
1121         }
1122
1123         this_share = shareBuf;
1124         do
1125         {
1126           print_afs = 0;
1127           /*strcpy(shareNameList[num_shares], this_share);*/
1128           len = GetPrivateProfileString("AFS Submounts", this_share,
1129                                         NULL,
1130                                         pathName, 256,
1131                                         sbmtpath);
1132           if (!len) return num_shares;
1133           p = pathName;
1134           if (strncmp(p, cm_mountRoot, strlen(cm_mountRoot)) != 0)
1135             print_afs = 1;
1136           while (*p) {
1137             if (*p == '\\') *p = '/';    /* change to / */
1138             p++;
1139           }
1140
1141           fprintf(stderr, "\\\\%s\\%-16s (%s%s)\n",
1142                   smb_localNamep, this_share, (print_afs ? cm_mountRoot : "\0"),
1143                   pathName);
1144           num_shares++;
1145           while (*this_share != 0) this_share++;  /* find next NUL */
1146           this_share++;   /* skip past the NUL */
1147         } while (*this_share != 0);  /* stop at final NUL */
1148
1149         return num_shares;
1150 }
1151
1152 /* find a shareName in the table of submounts */
1153 int smb_FindShare(smb_vc_t *vcp, smb_packet_t *inp, char *shareName,
1154         char **pathNamep)
1155 {
1156         DWORD len;
1157         char pathName[1024];
1158         char *var;
1159         smb_user_t *uidp;
1160         char temp[1024];
1161         DWORD sizeTemp;
1162     char sbmtpath[MAX_PATH];
1163     char *p, *q;
1164         HKEY parmKey;
1165         DWORD code;
1166     DWORD allSubmount = 1;
1167
1168         if (strcmp(shareName, "IPC$") == 0) {
1169                 *pathNamep = NULL;
1170                 return 0;
1171         }
1172
1173     /* if allSubmounts == 0, only return the //mountRoot/all share 
1174      * if in fact it has been been created in the subMounts table.  
1175      * This is to allow sites that want to restrict access to the 
1176      * world to do so.
1177      */
1178         code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSConfigKeyName,
1179                                 0, KEY_QUERY_VALUE, &parmKey);
1180         if (code == ERROR_SUCCESS) {
1181         len = sizeof(allSubmount);
1182         code = RegQueryValueEx(parmKey, "AllSubmount", NULL, NULL,
1183                                 (BYTE *) &allSubmount, &len);
1184         if (code != ERROR_SUCCESS) {
1185             allSubmount = 1;
1186         }
1187         RegCloseKey (parmKey);
1188         }
1189
1190         if (allSubmount && _stricmp(shareName, "all") == 0) {
1191                 *pathNamep = NULL;
1192                 return 1;
1193         }
1194
1195     /* In case, the all share is disabled we need to still be able
1196      * to handle ioctl requests 
1197      */
1198         if (_stricmp(shareName, "ioctl$") == 0) {
1199                 *pathNamep = strdup("/.__ioctl__");
1200                 return 1;
1201         }
1202
1203 #ifndef DJGPP
1204     strcpy(sbmtpath, "afsdsbmt.ini");
1205 #else /* DJGPP */
1206     strcpy(sbmtpath, cm_confDir);
1207     strcat(sbmtpath, "/afsdsbmt.ini");
1208 #endif /* !DJGPP */
1209         len = GetPrivateProfileString("AFS Submounts", shareName, "",
1210                                   pathName, sizeof(pathName), sbmtpath);
1211         if (len != 0 && len != sizeof(pathName) - 1) {
1212         /* We can accept either unix or PC style AFS pathnames.  Convert
1213          * Unix-style to PC style here for internal use. 
1214          */
1215         p = pathName;
1216         if (strncmp(p, cm_mountRoot, strlen(cm_mountRoot)) == 0)
1217             p += strlen(cm_mountRoot);  /* skip mount path */
1218         q = p;
1219         while (*q) {
1220             if (*q == '/') *q = '\\';    /* change to \ */
1221             q++;
1222         }
1223
1224         while (1)
1225         {
1226             if (var = smb_stristr(p, VNUserName)) {
1227                 uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
1228                 if (uidp && uidp->unp)
1229                     smb_subst(p, var, sizeof(VNUserName),uidp->unp->name);
1230                 else
1231                     smb_subst(p, var, sizeof(VNUserName)," ");
1232                 if (uidp)
1233                     smb_ReleaseUID(uidp);
1234             }
1235             else if (var = smb_stristr(p, VNLCUserName)) 
1236             {
1237                 uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
1238                 if (uidp && uidp->unp)
1239                     strcpy(temp, uidp->unp->name);
1240                 else 
1241                     strcpy(temp, " ");
1242                 _strlwr(temp);
1243                 smb_subst(p, var, sizeof(VNLCUserName), temp);
1244                 if (uidp)
1245                     smb_ReleaseUID(uidp);
1246             }
1247             else if (var = smb_stristr(p, VNComputerName)) 
1248             {
1249                 sizeTemp = sizeof(temp);
1250                 GetComputerName((LPTSTR)temp, &sizeTemp);
1251                 smb_subst(p, var, sizeof(VNComputerName), temp);
1252             }
1253             else if (var = smb_stristr(p, VNLCComputerName)) 
1254             {
1255                 sizeTemp = sizeof(temp);
1256                 GetComputerName((LPTSTR)temp, &sizeTemp);
1257                 _strlwr(temp);
1258                 smb_subst(p, var, sizeof(VNLCComputerName), temp);
1259             }
1260             else     
1261                 break;
1262         }
1263         *pathNamep = strdup(p);
1264         return 1;
1265     } 
1266     else /* create  \\<netbiosName>\<cellname>  */
1267     {
1268         if (cm_GetCell_Gen(shareName, temp, CM_FLAG_CREATE))
1269         {   
1270             if (!stricmp(shareName, temp)) {  /* no partial matches allowed */
1271                 sprintf(pathName,"/%s/",shareName);
1272                 *pathNamep = strdup(strlwr(pathName));
1273                                 return 1;
1274             }
1275         } 
1276         }
1277     /* failure */
1278     *pathNamep = NULL;
1279     return 0;
1280 }
1281
1282 /* find a dir search structure by cookie value, and return it held.
1283  * Must be called with smb_globalLock held.
1284  */
1285 smb_dirSearch_t *smb_FindDirSearchNL(long cookie)
1286 {
1287         smb_dirSearch_t *dsp;
1288         
1289         for(dsp = smb_firstDirSearchp; dsp; dsp = (smb_dirSearch_t *) osi_QNext(&dsp->q)) {
1290                 if (dsp->cookie == cookie) {
1291                         if (dsp != smb_firstDirSearchp) {
1292                                 /* move to head of LRU queue, too, if we're not already there */
1293                                 if (smb_lastDirSearchp == (smb_dirSearch_t *) &dsp->q)
1294                                         smb_lastDirSearchp = (smb_dirSearch_t *)
1295                                                 osi_QPrev(&dsp->q);
1296                                 osi_QRemove((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1297                                 osi_QAdd((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1298                                 if (!smb_lastDirSearchp)
1299                                         smb_lastDirSearchp = (smb_dirSearch_t *) &dsp->q;
1300                         }
1301                         dsp->refCount++;
1302                         break;
1303                 }
1304         }
1305         return dsp;
1306 }
1307
1308 void smb_DeleteDirSearch(smb_dirSearch_t *dsp)
1309 {
1310         lock_ObtainWrite(&smb_globalLock);
1311         dsp->flags |= SMB_DIRSEARCH_DELETE;
1312         lock_ReleaseWrite(&smb_globalLock);
1313         lock_ObtainMutex(&dsp->mx);
1314         if(dsp->scp != NULL) {
1315               lock_ObtainMutex(&dsp->scp->mx);
1316               if (dsp->flags & SMB_DIRSEARCH_BULKST) {
1317                     dsp->flags &= ~SMB_DIRSEARCH_BULKST;
1318                     dsp->scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
1319                     dsp->scp->bulkStatProgress = hones;
1320               }
1321               lock_ReleaseMutex(&dsp->scp->mx);
1322         }
1323         lock_ReleaseMutex(&dsp->mx);
1324 }
1325
1326 void smb_ReleaseDirSearch(smb_dirSearch_t *dsp)
1327 {
1328         cm_scache_t *scp;
1329         
1330         scp = NULL;
1331
1332         lock_ObtainWrite(&smb_globalLock);
1333         osi_assert(dsp->refCount-- > 0);
1334         if (dsp->refCount == 0 && (dsp->flags & SMB_DIRSEARCH_DELETE)) {
1335                 if (&dsp->q == (osi_queue_t *) smb_lastDirSearchp)
1336                         smb_lastDirSearchp = (smb_dirSearch_t *) osi_QPrev(&smb_lastDirSearchp->q);
1337                 osi_QRemove((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1338                 lock_FinalizeMutex(&dsp->mx);
1339                 scp = dsp->scp;
1340                 free(dsp);
1341         }
1342         lock_ReleaseWrite(&smb_globalLock);
1343         
1344         /* do this now to avoid spurious locking hierarchy creation */
1345         if (scp) cm_ReleaseSCache(scp);
1346 }
1347
1348 /* find a dir search structure by cookie value, and return it held */
1349 smb_dirSearch_t *smb_FindDirSearch(long cookie)
1350 {
1351         smb_dirSearch_t *dsp;
1352
1353         lock_ObtainWrite(&smb_globalLock);
1354         dsp = smb_FindDirSearchNL(cookie);
1355         lock_ReleaseWrite(&smb_globalLock);
1356         return dsp;
1357 }
1358
1359 /* GC some dir search entries, in the address space expected by the specific protocol.
1360  * Must be called with smb_globalLock held; release the lock temporarily.
1361  */
1362 #define SMB_DIRSEARCH_GCMAX     10      /* how many at once */
1363 void smb_GCDirSearches(int isV3)
1364 {
1365         smb_dirSearch_t *prevp;
1366         smb_dirSearch_t *tp;
1367         smb_dirSearch_t *victimsp[SMB_DIRSEARCH_GCMAX];
1368         int victimCount;
1369         int i;
1370         
1371         victimCount = 0;        /* how many have we got so far */
1372         for(tp = smb_lastDirSearchp; tp; tp=prevp) {
1373                 prevp = (smb_dirSearch_t *) osi_QPrev(&tp->q);  /* we'll move tp from queue, so
1374                                                                  * do this early.
1375                                                                  */
1376                 /* if no one is using this guy, and we're either in the new protocol,
1377                  * or we're in the old one and this is a small enough ID to be useful
1378                  * to the old protocol, GC this guy.
1379                  */
1380                 if (tp->refCount == 0 && (isV3 || tp->cookie <= 255)) {
1381                         /* hold and delete */
1382                         tp->flags |= SMB_DIRSEARCH_DELETE;
1383                         victimsp[victimCount++] = tp;
1384                         tp->refCount++;
1385                 }
1386
1387                 /* don't do more than this */
1388                 if (victimCount >= SMB_DIRSEARCH_GCMAX) break;
1389         }
1390         
1391         /* now release them */
1392         lock_ReleaseWrite(&smb_globalLock);
1393         for(i = 0; i < victimCount; i++) {
1394                 smb_ReleaseDirSearch(victimsp[i]);
1395         }
1396         lock_ObtainWrite(&smb_globalLock);
1397 }
1398
1399 /* function for allocating a dir search entry.  We need these to remember enough context
1400  * since we don't get passed the path from call to call during a directory search.
1401  *
1402  * Returns a held dir search structure, and bumps the reference count on the vnode,
1403  * since it saves a pointer to the vnode.
1404  */
1405 smb_dirSearch_t *smb_NewDirSearch(int isV3)
1406 {
1407         smb_dirSearch_t *dsp;
1408         int counter;
1409         int maxAllowed;
1410
1411         lock_ObtainWrite(&smb_globalLock);
1412         counter = 0;
1413
1414         /* what's the biggest ID allowed in this version of the protocol */
1415         if (isV3) maxAllowed = 65535;
1416         else maxAllowed = 255;
1417
1418         while(1) {
1419                 /* twice so we have enough tries to find guys we GC after one pass;
1420                  * 10 extra is just in case I mis-counted.
1421                  */
1422                 if (++counter > 2*maxAllowed+10) osi_panic("afsd: dir search cookie leak",
1423                         __FILE__, __LINE__);
1424                 if (smb_dirSearchCounter > maxAllowed) {
1425                         smb_dirSearchCounter = 1;
1426                         smb_GCDirSearches(isV3);        /* GC some (drops global lock) */
1427                 }
1428                 dsp = smb_FindDirSearchNL(smb_dirSearchCounter);
1429                 if (dsp) {
1430                         /* don't need to watch for refcount zero and deleted, since
1431                          * we haven't dropped the global lock.
1432                          */
1433                         dsp->refCount--;
1434                         ++smb_dirSearchCounter;
1435                         continue;
1436                 }
1437                 
1438                 dsp = malloc(sizeof(*dsp));
1439                 memset(dsp, 0, sizeof(*dsp));
1440                 osi_QAdd((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1441                 if (!smb_lastDirSearchp) smb_lastDirSearchp = (smb_dirSearch_t *) &dsp->q;
1442                 dsp->cookie = smb_dirSearchCounter;
1443                 ++smb_dirSearchCounter;
1444                 dsp->refCount = 1;
1445                 lock_InitializeMutex(&dsp->mx, "cm_dirSearch_t");
1446                 dsp->lastTime = osi_Time();
1447                 break;
1448         }
1449         lock_ReleaseWrite(&smb_globalLock);
1450         return dsp;
1451 }
1452
1453 static smb_packet_t *GetPacket(void)
1454 {
1455         smb_packet_t *tbp;
1456 #ifdef DJGPP
1457         unsigned int npar, seg, tb_sel;
1458 #endif
1459
1460         lock_ObtainWrite(&smb_globalLock);
1461         tbp = smb_packetFreeListp;
1462     if (tbp) 
1463         smb_packetFreeListp = tbp->nextp;
1464         lock_ReleaseWrite(&smb_globalLock);
1465     if (!tbp) {
1466 #ifndef DJGPP
1467         tbp = calloc(65540,1);
1468 #else /* DJGPP */
1469         tbp = malloc(sizeof(smb_packet_t));
1470 #endif /* !DJGPP */
1471         tbp->magic = SMB_PACKETMAGIC;
1472                 tbp->ncbp = NULL;
1473                 tbp->vcp = NULL;
1474                 tbp->resumeCode = 0;
1475                 tbp->inCount = 0;
1476                 tbp->fid = 0;
1477                 tbp->wctp = NULL;
1478                 tbp->inCom = 0;
1479                 tbp->oddByte = 0;
1480                 tbp->ncb_length = 0;
1481                 tbp->flags = 0;
1482         tbp->spacep = NULL;
1483         
1484 #ifdef DJGPP
1485         npar = SMB_PACKETSIZE >> 4;  /* number of paragraphs */
1486         {
1487             signed int retval =
1488                 __dpmi_allocate_dos_memory(npar, &tb_sel); /* DOS segment */
1489             if (retval == -1) {
1490                 afsi_log("Cannot allocate %d paragraphs of DOS memory",
1491                           npar);
1492                 osi_panic("",__FILE__,__LINE__);
1493             }
1494             else {
1495                 afsi_log("Allocated %d paragraphs of DOS mem at 0x%X",
1496                           npar, retval);
1497                 seg = retval;
1498             }
1499         }
1500         tbp->dos_pkt = (seg * 16) + 0;  /* DOS physical address */
1501         tbp->dos_pkt_sel = tb_sel;
1502 #endif /* DJGPP */
1503         }
1504     osi_assert(tbp->magic == SMB_PACKETMAGIC);
1505
1506     return tbp;
1507 }
1508
1509 smb_packet_t *smb_CopyPacket(smb_packet_t *pkt)
1510 {
1511         smb_packet_t *tbp;
1512         tbp = GetPacket();
1513         memcpy(tbp, pkt, sizeof(smb_packet_t));
1514         tbp->wctp = tbp->data + ((unsigned int)pkt->wctp - (unsigned int)pkt->data);
1515         return tbp;
1516 }
1517
1518 static NCB *GetNCB(void)
1519 {
1520         smb_ncb_t *tbp;
1521     NCB *ncbp;
1522 #ifdef DJGPP
1523     unsigned int npar, seg, tb_sel;
1524 #endif /* DJGPP */
1525
1526         lock_ObtainWrite(&smb_globalLock);
1527         tbp = smb_ncbFreeListp;
1528     if (tbp) 
1529         smb_ncbFreeListp = tbp->nextp;
1530         lock_ReleaseWrite(&smb_globalLock);
1531     if (!tbp) {
1532 #ifndef DJGPP
1533         tbp = calloc(sizeof(*tbp),1);
1534 #else /* DJGPP */
1535         tbp = malloc(sizeof(*tbp));
1536         npar = (sizeof(NCB)+15) >> 4;  /* number of paragraphs */
1537         {
1538             signed int retval =
1539                 __dpmi_allocate_dos_memory(npar, &tb_sel); /* DOS segment */
1540             if (retval == -1) {
1541                 afsi_log("Cannot allocate %d paragraphs of DOS mem in GetNCB",
1542                           npar);
1543                 osi_panic("",__FILE__,__LINE__);
1544             } else {
1545                 afsi_log("Allocated %d paragraphs of DOS mem at 0x%X in GetNCB",
1546                           npar, retval);
1547                 seg = retval;
1548             }
1549         }
1550         tbp->dos_ncb = (seg * 16) + 0;  /* DOS physical address */
1551         tbp->dos_ncb_sel = tb_sel;
1552 #endif /* !DJGPP */
1553         tbp->magic = SMB_NCBMAGIC;
1554         }
1555         
1556     osi_assert(tbp->magic == SMB_NCBMAGIC);
1557
1558         memset(&tbp->ncb, 0, sizeof(NCB));
1559     ncbp = &tbp->ncb;
1560 #ifdef DJGPP
1561     dos_memset(tbp->dos_ncb, 0, sizeof(NCB));
1562 #endif /* DJGPP */
1563     return ncbp;
1564 }
1565
1566 void smb_FreePacket(smb_packet_t *tbp)
1567 {
1568     osi_assert(tbp->magic == SMB_PACKETMAGIC);
1569         
1570     lock_ObtainWrite(&smb_globalLock);
1571         tbp->nextp = smb_packetFreeListp;
1572         smb_packetFreeListp = tbp;
1573         tbp->magic = SMB_PACKETMAGIC;
1574         tbp->ncbp = NULL;
1575         tbp->vcp = NULL;
1576         tbp->resumeCode = 0;
1577         tbp->inCount = 0;
1578         tbp->fid = 0;
1579         tbp->wctp = NULL;
1580         tbp->inCom = 0;
1581         tbp->oddByte = 0;
1582         tbp->ncb_length = 0;
1583         tbp->flags = 0;
1584     lock_ReleaseWrite(&smb_globalLock);
1585 }
1586
1587 static void FreeNCB(NCB *bufferp)
1588 {
1589         smb_ncb_t *tbp;
1590         
1591     tbp = (smb_ncb_t *) bufferp;
1592     osi_assert(tbp->magic == SMB_NCBMAGIC);
1593         
1594     lock_ObtainWrite(&smb_globalLock);
1595         tbp->nextp = smb_ncbFreeListp;
1596         smb_ncbFreeListp = tbp;
1597     lock_ReleaseWrite(&smb_globalLock);
1598 }
1599
1600 /* get a ptr to the data part of a packet, and its count */
1601 unsigned char *smb_GetSMBData(smb_packet_t *smbp, int *nbytesp)
1602 {
1603     int parmBytes;
1604     int dataBytes;
1605     unsigned char *afterParmsp;
1606
1607     parmBytes = *smbp->wctp << 1;
1608         afterParmsp = smbp->wctp + parmBytes + 1;
1609         
1610     dataBytes = afterParmsp[0] + (afterParmsp[1]<<8);
1611     if (nbytesp) *nbytesp = dataBytes;
1612         
1613         /* don't forget to skip the data byte count, since it follows
1614      * the parameters; that's where the "2" comes from below.
1615      */
1616     return (unsigned char *) (afterParmsp + 2);
1617 }
1618
1619 /* must set all the returned parameters before playing around with the
1620  * data region, since the data region is located past the end of the
1621  * variable number of parameters.
1622  */
1623 void smb_SetSMBDataLength(smb_packet_t *smbp, unsigned int dsize)
1624 {
1625         unsigned char *afterParmsp;
1626
1627         afterParmsp = smbp->wctp + ((*smbp->wctp)<<1) + 1;
1628         
1629         *afterParmsp++ = dsize & 0xff;
1630         *afterParmsp = (dsize>>8) & 0xff;
1631 }
1632
1633 /* return the parm'th parameter in the smbp packet */
1634 unsigned int smb_GetSMBParm(smb_packet_t *smbp, int parm)
1635 {
1636         int parmCount;
1637         unsigned char *parmDatap;
1638
1639         parmCount = *smbp->wctp;
1640
1641         if (parm >= parmCount) {
1642 #ifndef DJGPP
1643         HANDLE h;
1644                 char *ptbuf[1];
1645                 char s[100];
1646                 h = RegisterEventSource(NULL, AFS_DAEMON_EVENT_NAME);
1647                 sprintf(s, "Bad SMB param %d out of %d, ncb len %d",
1648                         parm, parmCount, smbp->ncb_length);
1649                 ptbuf[0] = s;
1650                 ReportEvent(h, EVENTLOG_ERROR_TYPE, 0, 1006, NULL,
1651                             1, smbp->ncb_length, ptbuf, smbp);
1652                 DeregisterEventSource(h);
1653 #else /* DJGPP */
1654                 char s[100];
1655
1656                 sprintf(s, "Bad SMB param %d out of %d, ncb len %d",
1657                         parm, parmCount, smbp->ncb_length);
1658                 osi_Log0(afsd_logp, s);
1659 #endif /* !DJGPP */
1660                 osi_panic(s, __FILE__, __LINE__);
1661         }
1662         parmDatap = smbp->wctp + (2*parm) + 1;
1663         
1664         return parmDatap[0] + (parmDatap[1] << 8);
1665 }
1666
1667 /* return the parm'th parameter in the smbp packet */
1668 unsigned int smb_GetSMBOffsetParm(smb_packet_t *smbp, int parm, int offset)
1669 {
1670         int parmCount;
1671         unsigned char *parmDatap;
1672
1673         parmCount = *smbp->wctp;
1674
1675         if (parm * 2 + offset >= parmCount * 2) {
1676 #ifndef DJGPP
1677                 HANDLE h;
1678                 char *ptbuf[1];
1679                 char s[100];
1680                 h = RegisterEventSource(NULL, AFS_DAEMON_EVENT_NAME);
1681                 sprintf(s, "Bad SMB param %d offset %d out of %d, ncb len %d",
1682                         parm, offset, parmCount, smbp->ncb_length);
1683                 ptbuf[0] = s;
1684                 ReportEvent(h, EVENTLOG_ERROR_TYPE, 0, 1006, NULL,
1685                             1, smbp->ncb_length, ptbuf, smbp);
1686                 DeregisterEventSource(h);
1687 #else /* DJGPP */
1688                 char s[100];
1689                 
1690                 sprintf(s, "Bad SMB param %d offset %d out of %d, "
1691                         "ncb len %d",
1692                         parm, offset, parmCount, smbp->ncb_length);
1693                 osi_Log0(afsd_logp, s);
1694 #endif /* !DJGPP */
1695
1696                 osi_panic(s, __FILE__, __LINE__);
1697         }
1698         parmDatap = smbp->wctp + (2*parm) + 1 + offset;
1699         
1700         return parmDatap[0] + (parmDatap[1] << 8);
1701 }
1702
1703 void smb_SetSMBParm(smb_packet_t *smbp, int slot, unsigned int parmValue)
1704 {
1705         char *parmDatap;
1706
1707         /* make sure we have enough slots */
1708         if (*smbp->wctp <= slot) *smbp->wctp = slot+1;
1709         
1710         parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
1711         *parmDatap++ = parmValue & 0xff;
1712         *parmDatap = (parmValue>>8) & 0xff;
1713 }
1714
1715 void smb_SetSMBParmLong(smb_packet_t *smbp, int slot, unsigned int parmValue)
1716 {
1717         char *parmDatap;
1718
1719         /* make sure we have enough slots */
1720         if (*smbp->wctp <= slot) *smbp->wctp = slot+2;
1721
1722         parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
1723         *parmDatap++ = parmValue & 0xff;
1724         *parmDatap++ = (parmValue>>8) & 0xff;
1725         *parmDatap++ = (parmValue>>16) & 0xff;
1726         *parmDatap++ = (parmValue>>24) & 0xff;
1727 }
1728
1729 void smb_SetSMBParmDouble(smb_packet_t *smbp, int slot, char *parmValuep)
1730 {
1731         char *parmDatap;
1732         int i;
1733
1734         /* make sure we have enough slots */
1735         if (*smbp->wctp <= slot) *smbp->wctp = slot+4;
1736
1737         parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
1738         for (i=0; i<8; i++)
1739                 *parmDatap++ = *parmValuep++;
1740 }
1741
1742 void smb_SetSMBParmByte(smb_packet_t *smbp, int slot, unsigned int parmValue)
1743 {
1744         char *parmDatap;
1745
1746         /* make sure we have enough slots */
1747         if (*smbp->wctp <= slot) {
1748                 if (smbp->oddByte) {
1749                         smbp->oddByte = 0;
1750                         *smbp->wctp = slot+1;
1751                 } else
1752                         smbp->oddByte = 1;
1753         }
1754
1755         parmDatap = smbp->wctp + 2*slot + 1 + (1 - smbp->oddByte);
1756         *parmDatap++ = parmValue & 0xff;
1757 }
1758
1759 void smb_StripLastComponent(char *outPathp, char **lastComponentp, char *inPathp)
1760 {
1761         char *lastSlashp;
1762         
1763         lastSlashp = strrchr(inPathp, '\\');
1764         if (lastComponentp)
1765                 *lastComponentp = lastSlashp;
1766         if (lastSlashp) {
1767                 while (1) {
1768                         if (inPathp == lastSlashp) break;
1769                         *outPathp++ = *inPathp++;
1770                 }
1771                 *outPathp++ = 0;
1772         }
1773         else {
1774                 *outPathp++ = 0;
1775         }
1776 }
1777
1778 unsigned char *smb_ParseASCIIBlock(unsigned char *inp, char **chainpp)
1779 {
1780         if (*inp++ != 0x4) return NULL;
1781         if (chainpp) {
1782                 *chainpp = inp + strlen(inp) + 1;       /* skip over null-terminated string */
1783         }
1784         return inp;
1785 }
1786
1787 unsigned char *smb_ParseVblBlock(unsigned char *inp, char **chainpp, int *lengthp)
1788 {
1789         int tlen;
1790
1791         if (*inp++ != 0x5) return NULL;
1792         tlen = inp[0] + (inp[1]<<8);
1793         inp += 2;               /* skip length field */
1794         
1795         if (chainpp) {
1796                 *chainpp = inp + tlen;
1797         }
1798         
1799         if (lengthp) *lengthp = tlen;
1800         
1801         return inp;
1802 }
1803
1804 /* format a packet as a response */
1805 void smb_FormatResponsePacket(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *op)
1806 {
1807         smb_t *outp;
1808         smb_t *inSmbp;
1809
1810         outp = (smb_t *) op;
1811         
1812         /* zero the basic structure through the smb_wct field, and zero the data
1813          * size field, assuming that wct stays zero; otherwise, you have to 
1814          * explicitly set the data size field, too.
1815          */
1816         inSmbp = (smb_t *) inp;
1817         memset(outp, 0, sizeof(smb_t)+2);
1818         outp->id[0] = 0xff;
1819         outp->id[1] = 'S';
1820         outp->id[2] = 'M';
1821         outp->id[3] = 'B';
1822         if (inp) {
1823                 outp->com = inSmbp->com;
1824                 outp->tid = inSmbp->tid;
1825                 outp->pid = inSmbp->pid;
1826                 outp->uid = inSmbp->uid;
1827                 outp->mid = inSmbp->mid;
1828                 outp->res[0] = inSmbp->res[0];
1829                 outp->res[1] = inSmbp->res[1];
1830                 op->inCom = inSmbp->com;
1831         }
1832         outp->reb = 0x80;       /* SERVER_RESP */
1833         outp->flg2 = 0x1;       /* KNOWS_LONG_NAMES */
1834
1835         /* copy fields in generic packet area */
1836         op->wctp = &outp->wct;
1837 }
1838
1839 /* send a (probably response) packet; vcp tells us to whom to send it.
1840  * we compute the length by looking at wct and bcc fields.
1841  */
1842 void smb_SendPacket(smb_vc_t *vcp, smb_packet_t *inp)
1843 {
1844         NCB *ncbp;
1845         int extra;
1846         long code;
1847         unsigned char *tp;
1848         int localNCB = 0;
1849 #ifdef DJGPP
1850         dos_ptr dos_ncb;
1851 #endif /* DJGPP */
1852         
1853         ncbp = inp->ncbp;
1854         if (ncbp == NULL) {
1855                 ncbp = GetNCB();
1856                 localNCB = 1;
1857         }
1858 #ifdef DJGPP
1859         dos_ncb = ((smb_ncb_t *)ncbp)->dos_ncb;
1860 #endif /* DJGPP */
1861  
1862         memset((char *)ncbp, 0, sizeof(NCB));
1863
1864         extra = 2 * (*inp->wctp);       /* space used by parms, in bytes */
1865         tp = inp->wctp + 1+ extra;      /* points to count of data bytes */
1866         extra += tp[0] + (tp[1]<<8);
1867         extra += ((unsigned int)inp->wctp - (unsigned int)inp->data);   /* distance to last wct field */
1868         extra += 3;                     /* wct and length fields */
1869         
1870         ncbp->ncb_length = extra;       /* bytes to send */
1871         ncbp->ncb_lsn = (unsigned char) vcp->lsn;       /* vc to use */
1872         ncbp->ncb_lana_num = vcp->lana;
1873         ncbp->ncb_command = NCBSEND;    /* op means send data */
1874 #ifndef DJGPP
1875         ncbp->ncb_buffer = (char *) inp;/* packet */
1876         code = Netbios(ncbp);
1877 #else /* DJGPP */
1878         ncbp->ncb_buffer = inp->dos_pkt;/* packet */
1879         ((smb_ncb_t*)ncbp)->orig_pkt = inp;
1880
1881         /* copy header information from virtual to DOS address space */
1882         dosmemput((char*)inp, SMB_PACKETSIZE, inp->dos_pkt);
1883         code = Netbios(ncbp, dos_ncb);
1884 #endif /* !DJGPP */
1885         
1886         if (code != 0)
1887                 osi_Log1(afsd_logp, "SendPacket failure code %d", code);
1888
1889         if (localNCB)
1890                 FreeNCB(ncbp);
1891 }
1892
1893 void smb_MapNTError(long code, unsigned long *NTStatusp)
1894 {
1895         unsigned long NTStatus;
1896
1897         /* map CM_ERROR_* errors to NT 32-bit status codes */
1898         if (code == CM_ERROR_NOSUCHCELL) {
1899                 NTStatus = 0xC000000FL; /* No such file */
1900         }
1901         else if (code == CM_ERROR_NOSUCHVOLUME) {
1902                 NTStatus = 0xC000000FL; /* No such file */
1903         }
1904         else if (code == CM_ERROR_TIMEDOUT) {
1905             NTStatus = 0xC00000CFL;     /* Sharing Paused */
1906         }
1907         else if (code == CM_ERROR_RETRY) {
1908                 NTStatus = 0xC000022DL; /* Retry */
1909         }
1910         else if (code == CM_ERROR_NOACCESS) {
1911                 NTStatus = 0xC0000022L; /* Access denied */
1912         }
1913         else if (code == CM_ERROR_READONLY) {
1914                 NTStatus = 0xC00000A2L; /* Write protected */
1915         }
1916         else if (code == CM_ERROR_NOSUCHFILE) {
1917                 NTStatus = 0xC000000FL; /* No such file */
1918         }
1919         else if (code == CM_ERROR_NOSUCHPATH) {
1920                 NTStatus = 0xC000003AL; /* Object path not found */
1921         }
1922         else if (code == CM_ERROR_TOOBIG) {
1923                 NTStatus = 0xC000007BL; /* Invalid image format */
1924         }
1925         else if (code == CM_ERROR_INVAL) {
1926                 NTStatus = 0xC000000DL; /* Invalid parameter */
1927         }
1928         else if (code == CM_ERROR_BADFD) {
1929                 NTStatus = 0xC0000008L; /* Invalid handle */
1930         }
1931         else if (code == CM_ERROR_BADFDOP) {
1932                 NTStatus = 0xC0000022L; /* Access denied */
1933         }
1934         else if (code == CM_ERROR_EXISTS) {
1935                 NTStatus = 0xC0000035L; /* Object name collision */
1936         }
1937         else if (code == CM_ERROR_NOTEMPTY) {
1938                 NTStatus = 0xC0000101L; /* Directory not empty */
1939         }
1940         else if (code == CM_ERROR_CROSSDEVLINK) {
1941                 NTStatus = 0xC00000D4L; /* Not same device */
1942         }
1943         else if (code == CM_ERROR_NOTDIR) {
1944                 NTStatus = 0xC0000103L; /* Not a directory */
1945         }
1946         else if (code == CM_ERROR_ISDIR) {
1947                 NTStatus = 0xC00000BAL; /* File is a directory */
1948         }
1949         else if (code == CM_ERROR_BADOP) {
1950                 NTStatus = 0xC09820FFL; /* SMB no support */
1951         }
1952         else if (code == CM_ERROR_BADSHARENAME) {
1953                 NTStatus = 0xC00000CCL; /* Bad network name */
1954         }
1955         else if (code == CM_ERROR_NOIPC) {
1956 #ifdef COMMENT
1957                 NTStatus = 0xC0000022L; /* Access Denied */
1958 #else
1959         NTStatus = 0xC000013DL; /* Remote Resources */
1960 #endif
1961         }
1962         else if (code == CM_ERROR_CLOCKSKEW) {
1963                 NTStatus = 0xC0000133L; /* Time difference at DC */
1964         }
1965         else if (code == CM_ERROR_BADTID) {
1966                 NTStatus = 0xC0982005L; /* SMB bad TID */
1967         }
1968         else if (code == CM_ERROR_USESTD) {
1969                 NTStatus = 0xC09820FBL; /* SMB use standard */
1970         }
1971         else if (code == CM_ERROR_QUOTA) {
1972                 NTStatus = 0xC0000044L; /* Quota exceeded */
1973         }
1974         else if (code == CM_ERROR_SPACE) {
1975                 NTStatus = 0xC000007FL; /* Disk full */
1976         }
1977         else if (code == CM_ERROR_ATSYS) {
1978                 NTStatus = 0xC0000033L; /* Object name invalid */
1979         }
1980         else if (code == CM_ERROR_BADNTFILENAME) {
1981                 NTStatus = 0xC0000033L; /* Object name invalid */
1982         }
1983         else if (code == CM_ERROR_WOULDBLOCK) {
1984                 NTStatus = 0xC0000055L; /* Lock not granted */
1985         }
1986         else if (code == CM_ERROR_PARTIALWRITE) {
1987                 NTStatus = 0xC000007FL; /* Disk full */
1988         }
1989         else if (code == CM_ERROR_BUFFERTOOSMALL) {
1990                 NTStatus = 0xC0000023L; /* Buffer too small */
1991         }
1992         else {
1993                 NTStatus = 0xC0982001L; /* SMB non-specific error */
1994         }
1995
1996         *NTStatusp = NTStatus;
1997         osi_Log2(afsd_logp, "SMB SEND code %x as NT %x", code, NTStatus);
1998 }
1999
2000 void smb_MapCoreError(long code, smb_vc_t *vcp, unsigned short *scodep,
2001         unsigned char *classp)
2002 {
2003         unsigned char class;
2004         unsigned short error;
2005
2006         /* map CM_ERROR_* errors to SMB errors */
2007         if (code == CM_ERROR_NOSUCHCELL) {
2008                 class = 1;
2009                 error = 3;      /* bad path */
2010         }
2011         else if (code == CM_ERROR_NOSUCHVOLUME) {
2012                 class = 1;
2013                 error = 3;      /* bad path */
2014         }
2015         else if (code == CM_ERROR_TIMEDOUT) {
2016                 class = 2;
2017                 error = 81;     /* server is paused */
2018         }
2019         else if (code == CM_ERROR_RETRY) {
2020                 class = 2;      /* shouldn't happen */
2021                 error = 1;
2022         }
2023         else if (code == CM_ERROR_NOACCESS) {
2024                 class = 2;
2025                 error = 4;      /* bad access */
2026         }
2027         else if (code == CM_ERROR_READONLY) {
2028                 class = 3;
2029                 error = 19;     /* read only */
2030         }
2031         else if (code == CM_ERROR_NOSUCHFILE) {
2032                 class = 1;
2033                 error = 2;      /* ENOENT! */
2034         }
2035         else if (code == CM_ERROR_NOSUCHPATH) {
2036                 class = 1;
2037                 error = 3;      /* Bad path */
2038         }
2039         else if (code == CM_ERROR_TOOBIG) {
2040                 class = 1;
2041                 error = 11;     /* bad format */
2042         }
2043         else if (code == CM_ERROR_INVAL) {
2044                 class = 2;      /* server non-specific error code */
2045                 error = 1;
2046         }
2047         else if (code == CM_ERROR_BADFD) {
2048                 class = 1;
2049                 error = 6;      /* invalid file handle */
2050         }
2051         else if (code == CM_ERROR_BADFDOP) {
2052                 class = 1;      /* invalid op on FD */
2053                 error = 5;
2054         }
2055         else if (code == CM_ERROR_EXISTS) {
2056                 class = 1;
2057                 error = 80;     /* file already exists */
2058         }
2059         else if (code == CM_ERROR_NOTEMPTY) {
2060                 class = 1;
2061                 error = 5;      /* delete directory not empty */
2062         }
2063         else if (code == CM_ERROR_CROSSDEVLINK) {
2064                 class = 1;
2065                 error = 17;     /* EXDEV */
2066         }
2067         else if (code == CM_ERROR_NOTDIR) {
2068                 class = 1;      /* bad path */
2069                 error = 3;
2070         }
2071         else if (code == CM_ERROR_ISDIR) {
2072                 class = 1;      /* access denied; DOS doesn't have a good match */
2073                 error = 5;
2074         }
2075         else if (code == CM_ERROR_BADOP) {
2076                 class = 2;
2077                 error = 65535;
2078         }
2079         else if (code == CM_ERROR_BADSHARENAME) {
2080                 class = 2;
2081                 error = 6;
2082         }
2083         else if (code == CM_ERROR_NOIPC) {
2084                 class = 2;
2085                 error = 4; /* bad access */
2086         }
2087         else if (code == CM_ERROR_CLOCKSKEW) {
2088                 class = 1;      /* invalid function */
2089                 error = 1;
2090         }
2091         else if (code == CM_ERROR_BADTID) {
2092                 class = 2;
2093                 error = 5;
2094         }
2095         else if (code == CM_ERROR_USESTD) {
2096                 class = 2;
2097                 error = 251;
2098         }
2099         else if (code == CM_ERROR_REMOTECONN) {
2100                 class = 2;
2101                 error = 82;
2102         }
2103         else if (code == CM_ERROR_QUOTA) {
2104                 if (vcp->flags & SMB_VCFLAG_USEV3) {
2105                         class = 3;
2106                         error = 39;     /* disk full */
2107                 }
2108                 else {
2109                         class = 1;
2110                         error = 5;      /* access denied */
2111                 }
2112         }
2113         else if (code == CM_ERROR_SPACE) {
2114                 if (vcp->flags & SMB_VCFLAG_USEV3) {
2115                         class = 3;
2116                         error = 39;     /* disk full */
2117                 }
2118                 else {
2119                         class = 1;
2120                         error = 5;      /* access denied */
2121                 }
2122         }
2123         else if (code == CM_ERROR_PARTIALWRITE) {
2124                 class = 3;
2125                 error = 39;     /* disk full */
2126         }
2127         else if (code == CM_ERROR_ATSYS) {
2128                 class = 1;
2129                 error = 2;      /* ENOENT */
2130         }
2131         else if (code == CM_ERROR_WOULDBLOCK) {
2132                 class = 1;
2133                 error = 33;     /* lock conflict */
2134         }
2135         else if (code == CM_ERROR_NOFILES) {
2136                 class = 1;
2137                 error = 18;     /* no files in search */
2138         }
2139         else if (code == CM_ERROR_RENAME_IDENTICAL) {
2140                 class = 1;
2141                 error = 183;     /* Samba uses this */
2142         }
2143         else {
2144                 class = 2;
2145                 error = 1;
2146         }
2147
2148         *scodep = error;
2149         *classp = class;
2150         osi_Log3(afsd_logp, "SMB SEND code %x as SMB %d: %d", code, class, error);
2151 }
2152
2153 long smb_SendCoreBadOp(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2154 {
2155         return CM_ERROR_BADOP;
2156 }
2157
2158 long smb_ReceiveCoreEcho(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2159 {
2160         unsigned short EchoCount, i;
2161         char *data, *outdata;
2162         int dataSize;
2163
2164         EchoCount = (unsigned short) smb_GetSMBParm(inp, 0);
2165
2166         for (i=1; i<=EchoCount; i++) {
2167             data = smb_GetSMBData(inp, &dataSize);
2168             smb_SetSMBParm(outp, 0, i);
2169             smb_SetSMBDataLength(outp, dataSize);
2170             outdata = smb_GetSMBData(outp, NULL);
2171             memcpy(outdata, data, dataSize);
2172             smb_SendPacket(vcp, outp);
2173         }
2174
2175         return 0;
2176 }
2177
2178 long smb_ReceiveCoreReadRaw(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2179 {
2180         osi_hyper_t offset;
2181         long count, minCount, finalCount;
2182         unsigned short fd;
2183         smb_fid_t *fidp;
2184         long code;
2185         cm_user_t *userp = NULL;
2186     NCB *ncbp;
2187     int rc;
2188 #ifndef DJGPP
2189     char *rawBuf = NULL;
2190 #else
2191     dos_ptr rawBuf = NULL;
2192     dos_ptr dos_ncb;
2193 #endif /* DJGPP */
2194
2195         rawBuf = NULL;
2196         finalCount = 0;
2197
2198         fd = smb_GetSMBParm(inp, 0);
2199         count = smb_GetSMBParm(inp, 3);
2200         minCount = smb_GetSMBParm(inp, 4);
2201         offset.HighPart = 0;    /* too bad */
2202         offset.LowPart = smb_GetSMBParm(inp, 1) | (smb_GetSMBParm(inp, 2) << 16);
2203
2204         osi_Log3(afsd_logp, "smb_ReceieveCoreReadRaw fd %d, off 0x%x, size 0x%x",
2205              fd, offset.LowPart, count);
2206
2207         fidp = smb_FindFID(vcp, fd, 0);
2208         if (!fidp)
2209                 goto send1;
2210
2211         lock_ObtainMutex(&smb_RawBufLock);
2212         if (smb_RawBufs) {
2213                 /* Get a raw buf, from head of list */
2214                 rawBuf = smb_RawBufs;
2215 #ifndef DJGPP
2216                 smb_RawBufs = *(char **)smb_RawBufs;
2217 #else /* DJGPP */
2218         smb_RawBufs = _farpeekl(_dos_ds, smb_RawBufs);
2219 #endif /* !DJGPP */
2220         }
2221         lock_ReleaseMutex(&smb_RawBufLock);
2222         if (!rawBuf)
2223                 goto send1a;
2224
2225     if (fidp->flags & SMB_FID_IOCTL)
2226     {
2227 #ifndef DJGPP
2228         rc = smb_IoctlReadRaw(fidp, vcp, inp, outp);
2229 #else
2230         rc = smb_IoctlReadRaw(fidp, vcp, inp, outp, rawBuf);
2231 #endif
2232         if (rawBuf) {
2233             /* Give back raw buffer */
2234             lock_ObtainMutex(&smb_RawBufLock);
2235 #ifndef DJGPP
2236             *((char **) rawBuf) = smb_RawBufs;
2237 #else /* DJGPP */
2238             _farpokel(_dos_ds, rawBuf, smb_RawBufs);
2239 #endif /* !DJGPP */
2240             
2241             smb_RawBufs = rawBuf;
2242             lock_ReleaseMutex(&smb_RawBufLock);
2243         }
2244
2245         smb_ReleaseFID(fidp);
2246         return rc;
2247     }
2248         
2249     userp = smb_GetUser(vcp, inp);
2250
2251 #ifndef DJGPP
2252         code = smb_ReadData(fidp, &offset, count, rawBuf, userp, &finalCount);
2253 #else /* DJGPP */
2254     /* have to give ReadData flag so it will treat buffer as DOS mem. */
2255     code = smb_ReadData(fidp, &offset, count, (unsigned char *)rawBuf,
2256                         userp, &finalCount, TRUE /* rawFlag */);
2257 #endif /* !DJGPP */
2258
2259         if (code != 0)
2260                 goto send;
2261
2262   send:
2263     cm_ReleaseUser(userp);
2264
2265   send1a:
2266         smb_ReleaseFID(fidp);
2267
2268   send1:
2269         ncbp = outp->ncbp;
2270 #ifdef DJGPP
2271     dos_ncb = ((smb_ncb_t *)ncbp)->dos_ncb;
2272 #endif /* DJGPP */
2273         memset((char *)ncbp, 0, sizeof(NCB));
2274
2275         ncbp->ncb_length = (unsigned short) finalCount;
2276         ncbp->ncb_lsn = (unsigned char) vcp->lsn;
2277         ncbp->ncb_lana_num = vcp->lana;
2278         ncbp->ncb_command = NCBSEND;
2279         ncbp->ncb_buffer = rawBuf;
2280
2281 #ifndef DJGPP
2282         code = Netbios(ncbp);
2283 #else /* DJGPP */
2284         code = Netbios(ncbp, dos_ncb);
2285 #endif /* !DJGPP */
2286         if (code != 0)
2287                 osi_Log1(afsd_logp, "ReadRaw send failure code %d", code);
2288
2289         if (rawBuf) {
2290                 /* Give back raw buffer */
2291                 lock_ObtainMutex(&smb_RawBufLock);
2292 #ifndef DJGPP
2293                 *((char **) rawBuf) = smb_RawBufs;
2294 #else /* DJGPP */
2295         _farpokel(_dos_ds, rawBuf, smb_RawBufs);
2296 #endif /* !DJGPP */
2297
2298                 smb_RawBufs = rawBuf;
2299                 lock_ReleaseMutex(&smb_RawBufLock);
2300         }
2301
2302         return 0;
2303 }
2304
2305 long smb_ReceiveCoreLockRecord(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2306 {
2307         return 0;
2308 }
2309
2310 long smb_ReceiveCoreUnlockRecord(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2311 {
2312         return 0;
2313 }
2314
2315 long smb_ReceiveNegotiate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2316 {
2317         char *namep;
2318         int coreProtoIndex;
2319         int v3ProtoIndex;
2320         int NTProtoIndex;
2321         int protoIndex;                 /* index we're using */
2322         int namex;
2323         int dbytes;
2324         int entryLength;
2325         int tcounter;
2326         char protocol_array[10][1024]; /* protocol signature of the client */
2327
2328         
2329         osi_Log1(afsd_logp, "SMB receive negotiate; %d + 1 ongoing ops",
2330                  ongoingOps - 1);
2331         if (!isGateway) {
2332                 if (active_vcp) {
2333                         DWORD now = GetCurrentTime();
2334                         if (now - last_msg_time >= 30000
2335                               && now - last_msg_time <= 90000) {
2336                                 osi_Log1(afsd_logp,
2337                                          "Setting dead_vcp %x", active_vcp);
2338                                 dead_vcp = active_vcp;
2339                                 dead_vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
2340                         }
2341                 }
2342         }
2343
2344         inp->flags |= SMB_PACKETFLAG_PROFILE_UPDATE_OK;
2345
2346         namep = smb_GetSMBData(inp, &dbytes);
2347         namex = 0;
2348         tcounter = 0;
2349         coreProtoIndex = -1;            /* not found */
2350         v3ProtoIndex = -1;
2351         NTProtoIndex = -1;
2352         while(namex < dbytes) {
2353                 osi_Log1(afsd_logp, "Protocol %s",
2354                          osi_LogSaveString(afsd_logp, namep+1));
2355                 strcpy(protocol_array[tcounter], namep+1);
2356
2357                 /* namep points at the first protocol, or really, a 0x02
2358                  * byte preceding the null-terminated ASCII name.
2359                  */
2360                 if (strcmp("PC NETWORK PROGRAM 1.0", namep+1) == 0) {
2361                         coreProtoIndex = tcounter;
2362                 }
2363                 else if (smb_useV3 && strcmp("LM1.2X002", namep+1) == 0) {
2364                         v3ProtoIndex = tcounter;
2365                 }
2366                 else if (smb_useV3 && strcmp("NT LM 0.12", namep+1) == 0) {
2367                         NTProtoIndex = tcounter;
2368                 }
2369
2370                 /* compute size of protocol entry */
2371                 entryLength = strlen(namep+1);
2372         entryLength += 2;       /* 0x02 bytes and null termination */
2373                 
2374         /* advance over this protocol entry */
2375                 namex += entryLength;
2376         namep += entryLength;
2377         tcounter++;             /* which proto entry we're looking at */
2378         }
2379 #ifndef NOMOREFILESFIX
2380         /* 
2381          * NOTE: We can determine what OS (NT4.0, W2K, W9X, etc)
2382          * the client is running by reading the protocol signature.
2383          * ie. the order in which it sends us the protocol list.
2384          *
2385          * Special handling for Windows 2000 clients (defect 11765 )
2386      * <asanka:11Jun03> Proto signature is the same for Win XP. </>
2387          */
2388         if (tcounter == 6) {
2389                int i = 0;
2390                smb_t *ip = (smb_t *) inp;
2391                smb_t *op = (smb_t *) outp;
2392
2393                if ((strcmp("PC NETWORK PROGRAM 1.0", protocol_array[0]) == 0) &&
2394                    (strcmp("LANMAN1.0", protocol_array[1]) == 0) &&
2395                    (strcmp("Windows for Workgroups 3.1a", protocol_array[2]) == 0) &&
2396                    (strcmp("LM1.2X002", protocol_array[3]) == 0) &&
2397                    (strcmp("LANMAN2.1", protocol_array[4]) == 0) &&
2398                    (strcmp("NT LM 0.12", protocol_array[5]) == 0)) {
2399                       isWindows2000 = TRUE;
2400                       osi_Log0(afsd_logp, "Looks like a Windows 2000 client");
2401                       /* 
2402                        * HACK: for now - just negotiate a lower protocol till we 
2403                        * figure out which flag/flag2 or some other field 
2404                        * (capabilities maybe?) to set in order for this to work
2405                        * correctly with Windows 2000 clients (defect 11765)
2406                        */
2407                       NTProtoIndex = -1;
2408                       /* Things to try (after looking at tcpdump output could be
2409                        * setting flags and flags2 to 0x98 and 0xc853 like this
2410                        * op->reb = 0x98; op->flg2 = 0xc853;
2411                        * osi_Log2(afsd_logp, "Flags:0x%x Flags2:0x%x", ip->reb, ip->flg2);
2412                        */
2413                }
2414         }
2415 #endif /* NOMOREFILESFIX */
2416
2417         if (NTProtoIndex != -1) {
2418                 protoIndex = NTProtoIndex;
2419                 vcp->flags |= (SMB_VCFLAG_USENT | SMB_VCFLAG_USEV3);
2420         }
2421         else if (v3ProtoIndex != -1) {
2422                 protoIndex = v3ProtoIndex;
2423                 vcp->flags |= SMB_VCFLAG_USEV3;
2424         }
2425         else if (coreProtoIndex != -1) {
2426                 protoIndex = coreProtoIndex;
2427                 vcp->flags |= SMB_VCFLAG_USECORE;
2428         }
2429         else protoIndex = -1;
2430
2431         if (protoIndex == -1)
2432                 return CM_ERROR_INVAL;
2433         else if (NTProtoIndex != -1) {
2434                 smb_SetSMBParm(outp, 0, protoIndex);
2435         smb_SetSMBParmByte(outp, 1, 0); /* share level security, no passwd encrypt */
2436         smb_SetSMBParm(outp, 1, smb_maxMpxRequests);    /* max multiplexed requests */
2437         smb_SetSMBParm(outp, 2, smb_maxVCPerServer);    /* max VCs per consumer/server connection */
2438         smb_SetSMBParmLong(outp, 3, SMB_PACKETSIZE); /* xmit buffer size */
2439                 smb_SetSMBParmLong(outp, 5, 65536);     /* raw buffer size */
2440         smb_SetSMBParm(outp, 7, 1);     /* next 2: session key */
2441         smb_SetSMBParm(outp, 8, 1);
2442                 /* 
2443                  * Tried changing the capabilities to support for W2K - defect 117695
2444                  * Maybe something else needs to be changed here?
2445                  */
2446                 /*
2447                   if (isWindows2000) 
2448                   smb_SetSMBParmLong(outp, 9, 0x43fd);
2449                   else 
2450                   smb_SetSMBParmLong(outp, 9, 0x251);
2451                   */
2452                 smb_SetSMBParmLong(outp, 9, 0x251);     /* Capabilities: *
2453                                                  * 32-bit error codes *
2454                                                  * and NT Find *
2455                                                  * and NT SMB's *
2456                                                  * and raw mode */
2457                 smb_SetSMBParmLong(outp, 11, 0);/* XXX server time: do we need? */
2458                 smb_SetSMBParmLong(outp, 13, 0);/* XXX server date: do we need? */
2459                 smb_SetSMBParm(outp, 15, 0);    /* XXX server tzone: do we need? */
2460                 smb_SetSMBParmByte(outp, 16, 0);/* Encryption key length */
2461                 smb_SetSMBDataLength(outp, 0);  /* perhaps should specify 8 bytes anyway */
2462         }
2463         else if (v3ProtoIndex != -1) {
2464                 smb_SetSMBParm(outp, 0, protoIndex);
2465                 smb_SetSMBParm(outp, 1, 0);     /* share level security, no passwd encrypt */
2466                 smb_SetSMBParm(outp, 2, SMB_PACKETSIZE);
2467                 smb_SetSMBParm(outp, 3, smb_maxMpxRequests);    /* max multiplexed requests */
2468                 smb_SetSMBParm(outp, 4, smb_maxVCPerServer);    /* max VCs per consumer/server connection */
2469                 smb_SetSMBParm(outp, 5, 0);     /* no support of block mode for read or write */
2470                 smb_SetSMBParm(outp, 6, 1);     /* next 2: session key */
2471                 smb_SetSMBParm(outp, 7, 1);
2472                 smb_SetSMBParm(outp, 8, 0);     /* XXX server time: do we need? */
2473                 smb_SetSMBParm(outp, 9, 0);     /* XXX server date: do we need? */
2474                 smb_SetSMBParm(outp, 10, 0);    /* XXX server tzone: do we need? */
2475                 smb_SetSMBParm(outp, 11, 0);    /* resvd */
2476                 smb_SetSMBParm(outp, 12, 0);    /* resvd */
2477                 smb_SetSMBDataLength(outp, 0);  /* perhaps should specify 8 bytes anyway */
2478         }
2479         else if (coreProtoIndex != -1) {
2480                 smb_SetSMBParm(outp, 0, protoIndex);
2481                 smb_SetSMBDataLength(outp, 0);
2482         }
2483         return 0;
2484 }
2485
2486 void smb_Daemon(void *parmp)
2487 {
2488         int count = 0;
2489
2490         while(1) {
2491                 count++;
2492                 thrd_Sleep(10000);
2493                 if ((count % 360) == 0)         /* every hour */
2494                         smb_CalculateNowTZ();
2495                 /* XXX GC dir search entries */
2496         }
2497 }
2498
2499 void smb_WaitingLocksDaemon()
2500 {
2501         smb_waitingLock_t *wL, *nwL;
2502         int first;
2503         smb_vc_t *vcp;
2504         smb_packet_t *inp, *outp;
2505         NCB *ncbp;
2506         long code;
2507
2508         while(1) {
2509                 lock_ObtainWrite(&smb_globalLock);
2510                 nwL = smb_allWaitingLocks;
2511                 if (nwL == NULL) {
2512                         osi_SleepW((long)&smb_allWaitingLocks, &smb_globalLock);
2513                         thrd_Sleep(1000);
2514                         continue;
2515                 }
2516                 else first = 1;
2517                 do {
2518                         if (first)
2519                                 first = 0;
2520                         else
2521                                 lock_ObtainWrite(&smb_globalLock);
2522                         wL = nwL;
2523                         nwL = (smb_waitingLock_t *) osi_QNext(&wL->q);
2524                         lock_ReleaseWrite(&smb_globalLock);
2525                         code = cm_RetryLock((cm_file_lock_t *) wL->lockp,
2526                                 wL->vcp->flags & SMB_VCFLAG_ALREADYDEAD);
2527                         if (code == CM_ERROR_WOULDBLOCK) {
2528                                 /* no progress */
2529                                 if (wL->timeRemaining != 0xffffffff
2530                                     && (wL->timeRemaining -= 1000) < 0)
2531                                         goto endWait;
2532                                 continue;
2533                         }
2534 endWait:
2535                         vcp = wL->vcp;
2536                         inp = wL->inp;
2537                         outp = wL->outp;
2538                         ncbp = GetNCB();
2539                         ncbp->ncb_length = inp->ncb_length;
2540                         inp->spacep = cm_GetSpace();
2541
2542                         /* Remove waitingLock from list */
2543                         lock_ObtainWrite(&smb_globalLock);
2544                         osi_QRemove((osi_queue_t **)&smb_allWaitingLocks,
2545                                     &wL->q);
2546                         lock_ReleaseWrite(&smb_globalLock);
2547
2548                         /* Resume packet processing */
2549                         if (code == 0)
2550                                 smb_SetSMBDataLength(outp, 0);
2551                         outp->flags |= SMB_PACKETFLAG_SUSPENDED;
2552                         outp->resumeCode = code;
2553                         outp->ncbp = ncbp;
2554                         smb_DispatchPacket(vcp, inp, outp, ncbp, NULL);
2555
2556                         /* Clean up */
2557                         cm_FreeSpace(inp->spacep);
2558                         smb_FreePacket(inp);
2559                         smb_FreePacket(outp);
2560                         FreeNCB(ncbp);
2561                         free(wL);
2562                 } while (nwL);
2563                 thrd_Sleep(1000);
2564         }
2565 }
2566
2567 long smb_ReceiveCoreGetDiskAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2568 {
2569         osi_Log0(afsd_logp, "SMB receive get disk attributes");
2570
2571         smb_SetSMBParm(outp, 0, 32000);
2572         smb_SetSMBParm(outp, 1, 64);
2573         smb_SetSMBParm(outp, 2, 1024);
2574         smb_SetSMBParm(outp, 3, 30000);
2575         smb_SetSMBParm(outp, 4, 0);
2576         smb_SetSMBDataLength(outp, 0);
2577         return 0;
2578 }
2579
2580 long smb_ReceiveCoreTreeConnect(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *rsp)
2581 {
2582         smb_tid_t *tidp;
2583         unsigned short newTid;
2584         char shareName[256];
2585         char *sharePath;
2586         int shareFound;
2587         char *tp;
2588         char *pathp;
2589         char *passwordp;
2590         cm_user_t *userp;
2591         
2592         osi_Log0(afsd_logp, "SMB receive tree connect");
2593
2594         /* parse input parameters */
2595         tp = smb_GetSMBData(inp, NULL);
2596         pathp = smb_ParseASCIIBlock(tp, &tp);
2597         passwordp = smb_ParseASCIIBlock(tp, &tp);
2598         tp = strrchr(pathp, '\\');
2599         if (!tp)
2600                 return CM_ERROR_BADSMB;
2601         strcpy(shareName, tp+1);
2602
2603         userp = smb_GetUser(vcp, inp);
2604
2605         lock_ObtainMutex(&vcp->mx);
2606         newTid = vcp->tidCounter++;
2607         lock_ReleaseMutex(&vcp->mx);
2608         
2609         tidp = smb_FindTID(vcp, newTid, SMB_FLAG_CREATE);
2610         shareFound = smb_FindShare(vcp, inp, shareName, &sharePath);
2611         if (!shareFound) {
2612                 smb_ReleaseTID(tidp);
2613                 return CM_ERROR_BADSHARENAME;
2614         }
2615         lock_ObtainMutex(&tidp->mx);
2616         tidp->userp = userp;
2617         tidp->pathname = sharePath;
2618         lock_ReleaseMutex(&tidp->mx);
2619         smb_ReleaseTID(tidp);
2620
2621         smb_SetSMBParm(rsp, 0, SMB_PACKETSIZE);
2622         smb_SetSMBParm(rsp, 1, newTid);
2623         smb_SetSMBDataLength(rsp, 0);
2624         
2625         osi_Log1(afsd_logp, "SMB tree connect created ID %d", newTid);
2626         return 0;
2627 }
2628
2629 unsigned char *smb_ParseDataBlock(unsigned char *inp, char **chainpp, int *lengthp)
2630 {
2631         int tlen;
2632
2633         if (*inp++ != 0x1) return NULL;
2634         tlen = inp[0] + (inp[1]<<8);
2635         inp += 2;               /* skip length field */
2636         
2637         if (chainpp) {
2638                 *chainpp = inp + tlen;
2639         }
2640         
2641         if (lengthp) *lengthp = tlen;
2642         
2643         return inp;
2644 }
2645
2646 /* set maskp to the mask part of the incoming path.
2647  * Mask is 11 bytes long (8.3 with the dot elided).
2648  * Returns true if succeeds with a valid name, otherwise it does
2649  * its best, but returns false.
2650  */
2651 int smb_Get8Dot3MaskFromPath(unsigned char *maskp, unsigned char *pathp)
2652 {
2653         char *tp;
2654         char *up;
2655         int i;
2656         int tc;
2657         int valid8Dot3;
2658
2659         /* starts off valid */
2660         valid8Dot3 = 1;
2661
2662         /* mask starts out all blanks */
2663         memset(maskp, ' ', 11);
2664
2665         /* find last backslash, or use whole thing if there is none */
2666         tp = strrchr(pathp, '\\');
2667         if (!tp) tp = pathp;
2668         else tp++;      /* skip slash */
2669         
2670         up = maskp;
2671
2672         /* names starting with a dot are illegal */
2673         if (*tp == '.') valid8Dot3 = 0;
2674
2675     for(i=0;; i++) {
2676                 tc = *tp++;
2677         if (tc == 0) return valid8Dot3;
2678         if (tc == '.' || tc == '"') break;
2679         if (i < 8) *up++ = tc;
2680         else valid8Dot3 = 0;
2681     }
2682         
2683     /* if we get here, tp point after the dot */
2684     up = maskp+8;       /* ext goes here */
2685     for(i=0;;i++) {
2686         tc = *tp++;
2687         if (tc == 0) return valid8Dot3;
2688
2689         /* too many dots */
2690         if (tc == '.' || tc == '"') valid8Dot3 = 0;
2691
2692         /* copy extension if not too long */
2693         if (i < 3) *up++ = tc;
2694         else valid8Dot3 = 0;
2695     }   
2696
2697     /* unreachable */
2698 }
2699
2700 int smb_Match8Dot3Mask(char *unixNamep, char *maskp)
2701 {
2702         char umask[11];
2703         int valid;
2704         int i;
2705         char tc1;
2706         char tc2;
2707         char *tp1;
2708         char *tp2;
2709         
2710         /* XXX redo this, calling smb_V3MatchMask with a converted mask */
2711
2712         valid = smb_Get8Dot3MaskFromPath(umask, unixNamep);
2713         if (!valid) return 0;
2714  
2715         /* otherwise, we have a valid 8.3 name; see if we have a match,
2716          * treating '?' as a wildcard in maskp (but not in the file name).
2717          */
2718         tp1 = umask;    /* real name, in mask format */
2719         tp2 = maskp;    /* mask, in mask format */
2720         for(i=0; i<11; i++) {
2721                 tc1 = *tp1++;   /* char from real name */
2722                 tc2 = *tp2++;   /* char from mask */
2723                 tc1 = (char) cm_foldUpper[(unsigned char)tc1];
2724                 tc2 = (char) cm_foldUpper[(unsigned char)tc2];
2725                 if (tc1 == tc2) continue;
2726                 if (tc2 == '?' && tc1 != ' ') continue;
2727                 if (tc2 == '>') continue;
2728                 return 0;
2729         }
2730
2731         /* we got a match */
2732         return 1;
2733 }
2734
2735 char *smb_FindMask(char *pathp)
2736 {
2737         char *tp;
2738         
2739         tp = strrchr(pathp, '\\');      /* find last slash */
2740
2741         if (tp) return tp+1;    /* skip the slash */
2742         else return pathp;      /* no slash, return the entire path */
2743 }
2744
2745 long smb_ReceiveCoreSearchVolume(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2746 {
2747         unsigned char *pathp;
2748         unsigned char *tp;
2749         unsigned char mask[11];
2750         unsigned char *statBlockp;
2751         unsigned char initStatBlock[21];
2752         int statLen;
2753         
2754         osi_Log0(afsd_logp, "SMB receive search volume");
2755
2756         /* pull pathname and stat block out of request */
2757         tp = smb_GetSMBData(inp, NULL);
2758         pathp = smb_ParseASCIIBlock(tp, (char **) &tp);
2759         osi_assert(pathp != NULL);
2760         statBlockp = smb_ParseVblBlock(tp, (char **) &tp, &statLen);
2761         osi_assert(statBlockp != NULL);
2762         if (statLen == 0) {
2763                 statBlockp = initStatBlock;
2764                 statBlockp[0] = 8;
2765         }
2766         
2767         /* for returning to caller */
2768         smb_Get8Dot3MaskFromPath(mask, pathp);
2769         
2770         smb_SetSMBParm(outp, 0, 1);             /* we're returning one entry */
2771         tp = smb_GetSMBData(outp, NULL);
2772         *tp++ = 5;
2773         *tp++ = 43;     /* bytes in a dir entry */
2774         *tp++ = 0;      /* high byte in counter */
2775         
2776         /* now marshall the dir entry, starting with the search status */
2777         *tp++ = statBlockp[0];          /* Reserved */
2778         memcpy(tp, mask, 11); tp += 11; /* FileName */
2779
2780         /* now pass back server use info, with 1st byte non-zero */
2781         *tp++ = 1;
2782         memset(tp, 0, 4); tp += 4;      /* reserved for server use */
2783         
2784         memcpy(tp, statBlockp+17, 4); tp += 4;  /* reserved for consumer */
2785         
2786         *tp++ = 0x8;            /* attribute: volume */
2787
2788         /* copy out time */
2789         *tp++ = 0;
2790         *tp++ = 0;
2791         
2792         /* copy out date */
2793         *tp++ = 18;
2794         *tp++ = 178;
2795         
2796         /* 4 byte file size */
2797         *tp++ = 0;
2798         *tp++ = 0;
2799         *tp++ = 0;
2800         *tp++ = 0;
2801
2802         /* finally, null-terminated 8.3 pathname, which we set to AFS */
2803         memset(tp, ' ', 13);
2804         strcpy(tp, "AFS");
2805         
2806         /* set the length of the data part of the packet to 43 + 3, for the dir
2807          * entry plus the 5 and the length fields.
2808          */
2809         smb_SetSMBDataLength(outp, 46);
2810         return 0;
2811 }
2812
2813 long smb_ApplyDirListPatches(smb_dirListPatch_t **dirPatchespp,
2814         cm_user_t *userp, cm_req_t *reqp)
2815 {
2816         long code;
2817         cm_scache_t *scp;
2818         char *dptr;
2819         long dosTime;
2820         u_short shortTemp;
2821         char attr;
2822         smb_dirListPatch_t *patchp;
2823         smb_dirListPatch_t *npatchp;
2824         
2825         for(patchp = *dirPatchespp; patchp; patchp =
2826                 (smb_dirListPatch_t *) osi_QNext(&patchp->q)) {
2827                 code = cm_GetSCache(&patchp->fid, &scp, userp, reqp);
2828                 if (code) continue;
2829                 lock_ObtainMutex(&scp->mx);
2830                 code = cm_SyncOp(scp, NULL, userp, reqp, 0,
2831                         CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
2832                 if (code) {
2833                         lock_ReleaseMutex(&scp->mx);
2834                         cm_ReleaseSCache(scp);
2835                         continue;
2836                 }
2837                 dptr = patchp->dptr;
2838
2839                 attr = smb_Attributes(scp);
2840         /* check hidden attribute (the flag is only ON when dot file hiding is on ) */
2841         if( patchp->flags & SMB_DIRLISTPATCH_DOTFILE )
2842             attr |= SMB_ATTR_HIDDEN;
2843         *dptr++ = attr;
2844
2845                 /* get dos time */
2846                 smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
2847                 
2848                 /* copy out time */
2849                 shortTemp = dosTime & 0xffff;
2850                 *((u_short *)dptr) = shortTemp;
2851                 dptr += 2;
2852
2853                 /* and copy out date */
2854                 shortTemp = (dosTime>>16) & 0xffff;
2855                 *((u_short *)dptr) = shortTemp;
2856                 dptr += 2;
2857                 
2858                 /* copy out file length */
2859                 *((u_long *)dptr) = scp->length.LowPart;
2860                 dptr += 4;
2861                 lock_ReleaseMutex(&scp->mx);
2862                 cm_ReleaseSCache(scp);
2863         }
2864         
2865         /* now free the patches */
2866         for(patchp = *dirPatchespp; patchp; patchp = npatchp) {
2867                 npatchp = (smb_dirListPatch_t *) osi_QNext(&patchp->q);
2868                 free(patchp);
2869         }
2870         
2871         /* and mark the list as empty */
2872         *dirPatchespp = NULL;
2873
2874         return code;
2875 }
2876
2877 long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
2878 {
2879         int attribute;
2880         long nextCookie;
2881         char *tp;
2882         long code;
2883         char *pathp;
2884         cm_dirEntry_t *dep;
2885         int maxCount;
2886         smb_dirListPatch_t *dirListPatchesp;
2887         smb_dirListPatch_t *curPatchp;
2888         int dataLength;
2889         cm_buf_t *bufferp;
2890         long temp;
2891         osi_hyper_t dirLength;
2892         osi_hyper_t bufferOffset;
2893         osi_hyper_t curOffset;
2894         osi_hyper_t thyper;
2895         unsigned char *inCookiep;
2896         smb_dirSearch_t *dsp;
2897         cm_scache_t *scp;
2898         long entryInDir;
2899         long entryInBuffer;
2900         unsigned long clientCookie;
2901         cm_pageHeader_t *pageHeaderp;
2902         cm_user_t *userp = NULL;
2903         int slotInPage;
2904         char shortName[13];
2905         char *actualName;
2906         char *shortNameEnd;
2907         char mask[11];
2908         int returnedNames;
2909         long nextEntryCookie;
2910         int numDirChunks;               /* # of 32 byte dir chunks in this entry */
2911         char resByte;                   /* reserved byte from the cookie */
2912         char *op;                       /* output data ptr */
2913         char *origOp;                   /* original value of op */
2914         cm_space_t *spacep;             /* for pathname buffer */
2915         int starPattern;
2916         int rootPath = 0;
2917         int caseFold;
2918         char *tidPathp;
2919         cm_req_t req;
2920         cm_fid_t fid;
2921         int fileType;
2922
2923         cm_InitReq(&req);
2924
2925         maxCount = smb_GetSMBParm(inp, 0);
2926
2927         dirListPatchesp = NULL;
2928         
2929         caseFold = CM_FLAG_CASEFOLD;
2930
2931         tp = smb_GetSMBData(inp, NULL);
2932         pathp = smb_ParseASCIIBlock(tp, &tp);
2933         inCookiep = smb_ParseVblBlock(tp, &tp, &dataLength);
2934         
2935         /* bail out if request looks bad */
2936         if (!tp || !pathp) {
2937                 return CM_ERROR_BADSMB;
2938         }
2939
2940         /* We can handle long names */
2941         if (vcp->flags & SMB_VCFLAG_USENT)
2942                 ((smb_t *)outp)->flg2 |= 0x40;  /* IS_LONG_NAME */
2943         
2944         /* make sure we got a whole search status */
2945         if (dataLength < 21) {
2946                 nextCookie = 0;         /* start at the beginning of the dir */
2947                 resByte = 0;
2948                 clientCookie = 0;
2949                 attribute = smb_GetSMBParm(inp, 1);
2950
2951                 /* handle volume info in another function */
2952                 if (attribute & 0x8)
2953                         return smb_ReceiveCoreSearchVolume(vcp, inp, outp);
2954
2955                 osi_Log2(afsd_logp, "SMB receive search dir count %d [%s]",
2956                          maxCount, osi_LogSaveString(afsd_logp, pathp));
2957
2958                 if (*pathp == 0) {      /* null pathp, treat as root dir */
2959                         if (!(attribute & SMB_ATTR_DIRECTORY))  /* exclude dirs */
2960                                 return CM_ERROR_NOFILES;
2961                         rootPath = 1;
2962                 }
2963
2964                 dsp = smb_NewDirSearch(0);
2965                 dsp->attribute = attribute;
2966                 smb_Get8Dot3MaskFromPath(mask, pathp);
2967                 memcpy(dsp->mask, mask, 11);
2968
2969                 /* track if this is likely to match a lot of entries */
2970                 if (smb_IsStarMask(mask)) starPattern = 1;
2971                 else starPattern = 0;
2972         }
2973         else {
2974                 /* pull the next cookie value out of the search status block */
2975                 nextCookie = inCookiep[13] + (inCookiep[14]<<8) + (inCookiep[15]<<16)
2976                         + (inCookiep[16]<<24);
2977                 dsp = smb_FindDirSearch(inCookiep[12]);
2978                 if (!dsp) {
2979                         /* can't find dir search status; fatal error */
2980                         return CM_ERROR_BADFD;
2981                 }
2982                 attribute = dsp->attribute;
2983                 resByte = inCookiep[0];
2984
2985                 /* copy out client cookie, in host byte order.  Don't bother
2986                  * interpreting it, since we're just passing it through, anyway.
2987                  */
2988                 memcpy(&clientCookie, &inCookiep[17], 4);
2989
2990                 memcpy(mask, dsp->mask, 11);
2991
2992                 /* assume we're doing a star match if it has continued for more
2993                  * than one call.
2994                  */
2995                 starPattern = 1;
2996         }
2997
2998         osi_Log3(afsd_logp, "SMB dir search cookie 0x%x, connection %d, attr 0x%x",
2999                 nextCookie, dsp->cookie, attribute);
3000
3001         userp = smb_GetUser(vcp, inp);
3002
3003         /* try to get the vnode for the path name next */
3004         lock_ObtainMutex(&dsp->mx);
3005         if (dsp->scp) {
3006                 scp = dsp->scp;
3007                 cm_HoldSCache(scp);
3008                 code = 0;
3009         }
3010         else {
3011                 spacep = inp->spacep;
3012                 smb_StripLastComponent(spacep->data, NULL, pathp);
3013                 lock_ReleaseMutex(&dsp->mx);
3014                 tidPathp = smb_GetTIDPath(vcp, ((smb_t *)inp)->tid);
3015                 code = cm_NameI(cm_rootSCachep, spacep->data,
3016                         caseFold | CM_FLAG_FOLLOW, userp, tidPathp, &req, &scp);
3017                 lock_ObtainMutex(&dsp->mx);
3018                 if (code == 0) {
3019                         if (dsp->scp != 0) cm_ReleaseSCache(dsp->scp);
3020                         dsp->scp = scp;
3021                         /* we need one hold for the entry we just stored into,
3022                          * and one for our own processing.  When we're done with this
3023                          * function, we'll drop the one for our own processing.
3024                          * We held it once from the namei call, and so we do another hold
3025                          * now.
3026                          */
3027                         cm_HoldSCache(scp);
3028                         lock_ObtainMutex(&scp->mx);
3029                         if ((scp->flags & CM_SCACHEFLAG_BULKSTATTING) == 0
3030                             && LargeIntegerGreaterOrEqualToZero(scp->bulkStatProgress)) {
3031                                 scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
3032                                 dsp->flags |= SMB_DIRSEARCH_BULKST;
3033                         }
3034                         lock_ReleaseMutex(&scp->mx);
3035                 }
3036         }
3037         lock_ReleaseMutex(&dsp->mx);
3038         if (code) {
3039                 cm_ReleaseUser(userp);
3040                 smb_DeleteDirSearch(dsp);
3041                 smb_ReleaseDirSearch(dsp);
3042                 return code;
3043         }
3044
3045         /* reserves space for parameter; we'll adjust it again later to the
3046          * real count of the # of entries we returned once we've actually
3047          * assembled the directory listing.
3048          */
3049         smb_SetSMBParm(outp, 0, 0);
3050         
3051         /* get the directory size */
3052         lock_ObtainMutex(&scp->mx);
3053         code = cm_SyncOp(scp, NULL, userp, &req, 0,
3054                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
3055         if (code) {
3056                 lock_ReleaseMutex(&scp->mx);
3057                 cm_ReleaseSCache(scp);
3058                 cm_ReleaseUser(userp);
3059                 smb_DeleteDirSearch(dsp);
3060                 smb_ReleaseDirSearch(dsp);
3061                 return code;
3062         }
3063         
3064         dirLength = scp->length;
3065         bufferp = NULL;
3066         bufferOffset.LowPart = bufferOffset.HighPart = 0;
3067         curOffset.HighPart = 0;
3068         curOffset.LowPart = nextCookie;
3069         origOp = op = smb_GetSMBData(outp, NULL);
3070         /* and write out the basic header */
3071         *op++ = 5;              /* variable block */
3072         op += 2;                /* skip vbl block length; we'll fill it in later */
3073         code = 0;
3074         returnedNames = 0;
3075         while (1) {
3076                 /* make sure that curOffset.LowPart doesn't point to the first
3077                  * 32 bytes in the 2nd through last dir page, and that it doesn't
3078                  * point at the first 13 32-byte chunks in the first dir page,
3079                  * since those are dir and page headers, and don't contain useful
3080                  * information.
3081                  */
3082                 temp = curOffset.LowPart & (2048-1);
3083                 if (curOffset.HighPart == 0 && curOffset.LowPart < 2048) {
3084                         /* we're in the first page */
3085                         if (temp < 13*32) temp = 13*32;
3086                 }
3087                 else {
3088                         /* we're in a later dir page */
3089                         if (temp < 32) temp = 32;
3090                 }
3091                 
3092                 /* make sure the low order 5 bits are zero */
3093                 temp &= ~(32-1);
3094                 
3095                 /* now put temp bits back ito curOffset.LowPart */
3096                 curOffset.LowPart &= ~(2048-1);
3097                 curOffset.LowPart |= temp;
3098
3099                 /* check if we've returned all the names that will fit in the
3100                  * response packet.
3101                  */
3102                 if (returnedNames >= maxCount) break;
3103                 
3104                 /* check if we've passed the dir's EOF */
3105                 if (LargeIntegerGreaterThanOrEqualTo(curOffset, dirLength)) break;
3106                 
3107                 /* see if we can use the bufferp we have now; compute in which page
3108                  * the current offset would be, and check whether that's the offset
3109                  * of the buffer we have.  If not, get the buffer.
3110                  */
3111                 thyper.HighPart = curOffset.HighPart;
3112                 thyper.LowPart = curOffset.LowPart & ~(buf_bufferSize-1);
3113                 if (!bufferp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
3114                         /* wrong buffer */
3115                         if (bufferp) {
3116                                 buf_Release(bufferp);
3117                                 bufferp = NULL;
3118                         }
3119                         lock_ReleaseMutex(&scp->mx);
3120                         lock_ObtainRead(&scp->bufCreateLock);
3121                         code = buf_Get(scp, &thyper, &bufferp);
3122                         lock_ReleaseRead(&scp->bufCreateLock);
3123
3124                         /* now, if we're doing a star match, do bulk fetching of all of 
3125                          * the status info for files in the dir.
3126                          */
3127                         if (starPattern) {
3128                                 smb_ApplyDirListPatches(&dirListPatchesp, userp,
3129                                                         &req);
3130                                 if ((dsp->flags & SMB_DIRSEARCH_BULKST)
3131                                     && LargeIntegerGreaterThanOrEqualTo(thyper, 
3132                                                                         scp->bulkStatProgress)) {
3133                                   /* Don't bulk stat if risking timeout */
3134                                   int now = GetCurrentTime();
3135                                   if (now - req.startTime > 5000) {
3136                                     scp->bulkStatProgress = thyper;
3137                                     scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
3138                                     dsp->flags &= ~SMB_DIRSEARCH_BULKST;
3139                                   } else
3140                                     cm_TryBulkStat(scp, &thyper,
3141                                                    userp, &req);
3142                                 }
3143                         }
3144
3145                         lock_ObtainMutex(&scp->mx);
3146                         if (code) break;
3147                         bufferOffset = thyper;
3148
3149                         /* now get the data in the cache */
3150                         while (1) {
3151                                 code = cm_SyncOp(scp, bufferp, userp, &req,
3152                                         PRSFS_LOOKUP,
3153                                         CM_SCACHESYNC_NEEDCALLBACK
3154                                         | CM_SCACHESYNC_READ);
3155                                 if (code) break;
3156                                 
3157                                 if (cm_HaveBuffer(scp, bufferp, 0)) break;
3158                                 
3159                                 /* otherwise, load the buffer and try again */
3160                                 code = cm_GetBuffer(scp, bufferp, NULL, userp,
3161                                                     &req);
3162                                 if (code) break;
3163                         }
3164                         if (code) {
3165                                 buf_Release(bufferp);
3166                                 bufferp = NULL;
3167                                 break;
3168                         }
3169                 }       /* if (wrong buffer) ... */
3170                 
3171                 /* now we have the buffer containing the entry we're interested in; copy
3172                  * it out if it represents a non-deleted entry.
3173                  */
3174                 entryInDir = curOffset.LowPart & (2048-1);
3175                 entryInBuffer = curOffset.LowPart & (buf_bufferSize - 1);
3176
3177                 /* page header will help tell us which entries are free.  Page header
3178                  * can change more often than once per buffer, since AFS 3 dir page size
3179                  * may be less than (but not more than a buffer package buffer.
3180                  */
3181                 temp = curOffset.LowPart & (buf_bufferSize - 1);  /* only look intra-buffer */
3182                 temp &= ~(2048 - 1);    /* turn off intra-page bits */
3183                 pageHeaderp = (cm_pageHeader_t *) (bufferp->datap + temp);
3184
3185                 /* now determine which entry we're looking at in the page.  If it is
3186                  * free (there's a free bitmap at the start of the dir), we should
3187                  * skip these 32 bytes.
3188                  */
3189                 slotInPage = (entryInDir & 0x7e0) >> 5;
3190                 if (!(pageHeaderp->freeBitmap[slotInPage>>3] & (1 << (slotInPage & 0x7)))) {
3191                         /* this entry is free */
3192                         numDirChunks = 1;               /* only skip this guy */
3193                         goto nextEntry;
3194                 }
3195
3196                 tp = bufferp->datap + entryInBuffer;
3197                 dep = (cm_dirEntry_t *) tp;             /* now points to AFS3 dir entry */
3198
3199                 /* while we're here, compute the next entry's location, too,
3200                  * since we'll need it when writing out the cookie into the dir
3201                  * listing stream.
3202                  *
3203                  * XXXX Probably should do more sanity checking.
3204                  */
3205                 numDirChunks = cm_NameEntries(dep->name, NULL);
3206                 
3207                 /* compute the offset of the cookie representing the next entry */
3208                 nextEntryCookie = curOffset.LowPart + (CM_DIR_CHUNKSIZE * numDirChunks);
3209
3210                 /* Compute 8.3 name if necessary */
3211                 actualName = dep->name;
3212                 if (dep->fid.vnode != 0 && !cm_Is8Dot3(actualName)) {
3213                         cm_Gen8Dot3Name(dep, shortName, &shortNameEnd);
3214                         actualName = shortName;
3215                 }
3216
3217             if (dep->fid.vnode != 0 && smb_Match8Dot3Mask(actualName, mask)) {
3218                 /* this is one of the entries to use: it is not deleted
3219                  * and it matches the star pattern we're looking for.
3220                  */
3221
3222                 /* Eliminate entries that don't match requested
3223                    attributes */
3224                  
3225                 /* no hidden files */
3226                 if(smb_hideDotFiles && !(dsp->attribute & SMB_ATTR_HIDDEN) && smb_IsDotFile(actualName))
3227                     goto nextEntry;
3228                 
3229                 if (!(dsp->attribute & SMB_ATTR_DIRECTORY))  /* no directories */
3230                 {
3231                            /* We have already done the cm_TryBulkStat above */
3232                            fid.cell = scp->fid.cell;
3233                            fid.volume = scp->fid.volume;
3234                            fid.vnode = ntohl(dep->fid.vnode);
3235                            fid.unique = ntohl(dep->fid.unique);
3236                            fileType = cm_FindFileType(&fid);
3237                            osi_Log2(afsd_logp, "smb_ReceiveCoreSearchDir: file %s "
3238                                     "has filetype %d", dep->name,
3239                                     fileType);
3240                            if (fileType == CM_SCACHETYPE_DIRECTORY)
3241                               goto nextEntry;
3242                         }
3243
3244                         *op++ = resByte;
3245                         memcpy(op, mask, 11); op += 11;
3246                         *op++ = (char) dsp->cookie;     /* they say it must be non-zero */
3247                         *op++ = nextEntryCookie & 0xff;
3248                         *op++ = (nextEntryCookie>>8) & 0xff;
3249                         *op++ = (nextEntryCookie>>16) & 0xff;
3250                         *op++ = (nextEntryCookie>>24) & 0xff;
3251                         memcpy(op, &clientCookie, 4); op += 4;
3252                         
3253                         /* now we emit the attribute.  This is sort of tricky,
3254                          * since we need to really stat the file to find out
3255                          * what type of entry we've got.  Right now, we're
3256                          * copying out data from a buffer, while holding the
3257                          * scp locked, so it isn't really convenient to stat
3258                          * something now.  We'll put in a place holder now,
3259                          * and make a second pass before returning this to get
3260                          * the real attributes.  So, we just skip the data for
3261                          * now, and adjust it later.  We allocate a patch
3262                          * record to make it easy to find this point later.
3263                          * The replay will happen at a time when it is safe to
3264                          * unlock the directory.
3265                          */
3266                 curPatchp = malloc(sizeof(*curPatchp));
3267                 osi_QAdd((osi_queue_t **) &dirListPatchesp, &curPatchp->q);
3268                 curPatchp->dptr = op;
3269                 curPatchp->fid.cell = scp->fid.cell;
3270                 curPatchp->fid.volume = scp->fid.volume;
3271                 curPatchp->fid.vnode = ntohl(dep->fid.vnode);
3272                 curPatchp->fid.unique = ntohl(dep->fid.unique);
3273
3274                 /* do hidden attribute here since name won't be around when applying
3275                  * dir list patches
3276                  */
3277
3278                 if ( smb_hideDotFiles && smb_IsDotFile(actualName) )
3279                     curPatchp->flags = SMB_DIRLISTPATCH_DOTFILE;
3280                 else
3281                     curPatchp->flags = 0;
3282
3283                 op += 9;        /* skip attr, time, date and size */
3284                         
3285                         /* zero out name area.  The spec says to pad with
3286                          * spaces, but Samba doesn't, and neither do we.
3287                          */
3288                         memset(op, 0, 13);
3289
3290                         /* finally, we get to copy out the name; we know that
3291                          * it fits in 8.3 or the pattern wouldn't match, but it
3292                          * never hurts to be sure.
3293                          */
3294                         strncpy(op, actualName, 13);
3295
3296                         /* Uppercase if requested by client */
3297                         if ((((smb_t *)inp)->flg2 & 1) == 0)
3298                                 _strupr(op);
3299
3300                         op += 13;
3301
3302                         /* now, adjust the # of entries copied */
3303                         returnedNames++;
3304                 }       /* if we're including this name */
3305                 
3306 nextEntry:
3307                 /* and adjust curOffset to be where the new cookie is */
3308                 thyper.HighPart = 0;
3309                 thyper.LowPart = CM_DIR_CHUNKSIZE * numDirChunks;
3310                 curOffset = LargeIntegerAdd(thyper, curOffset);
3311         }               /* while copying data for dir listing */
3312
3313         /* release the mutex */
3314         lock_ReleaseMutex(&scp->mx);
3315         if (bufferp) buf_Release(bufferp);
3316
3317         /* apply and free last set of patches; if not doing a star match, this
3318          * will be empty, but better safe (and freeing everything) than sorry.
3319          */
3320         smb_ApplyDirListPatches(&dirListPatchesp, userp, &req);
3321
3322         /* special return code for unsuccessful search */
3323         if (code == 0 && dataLength < 21 && returnedNames == 0)
3324                 code = CM_ERROR_NOFILES;
3325
3326         osi_Log2(afsd_logp, "SMB search dir done, %d names, code %d",
3327                  returnedNames, code);
3328
3329         if (code != 0) {
3330                 smb_DeleteDirSearch(dsp);
3331                 smb_ReleaseDirSearch(dsp);
3332                 cm_ReleaseSCache(scp);
3333                 cm_ReleaseUser(userp);
3334                 return code;
3335         }
3336
3337         /* finalize the output buffer */
3338         smb_SetSMBParm(outp, 0, returnedNames);
3339         temp = (long) (op - origOp);
3340         smb_SetSMBDataLength(outp, temp);
3341
3342         /* the data area is a variable block, which has a 5 (already there)
3343          * followed by the length of the # of data bytes.  We now know this to
3344          * be "temp," although that includes the 3 bytes of vbl block header.
3345          * Deduct for them and fill in the length field.
3346          */
3347         temp -= 3;              /* deduct vbl block info */
3348         osi_assert(temp == (43 * returnedNames));
3349         origOp[1] = temp & 0xff;
3350         origOp[2] = (temp>>8) & 0xff;
3351         if (returnedNames == 0) smb_DeleteDirSearch(dsp);
3352         smb_ReleaseDirSearch(dsp);
3353         cm_ReleaseSCache(scp);
3354         cm_ReleaseUser(userp);
3355         return code;
3356 }
3357
3358 /* verify that this is a valid path to a directory.  I don't know why they
3359  * don't use the get file attributes call.
3360  */
3361 long smb_ReceiveCoreCheckPath(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3362 {
3363         char *pathp;
3364         long code;
3365         cm_scache_t *rootScp;
3366         cm_scache_t *newScp;
3367         cm_user_t *userp;
3368         unsigned int attrs;
3369         int caseFold;
3370         char *tidPathp;
3371         cm_req_t req;
3372
3373         cm_InitReq(&req);
3374
3375         pathp = smb_GetSMBData(inp, NULL);
3376         pathp = smb_ParseASCIIBlock(pathp, NULL);
3377         osi_Log1(afsd_logp, "SMB receive check path %s",
3378                         osi_LogSaveString(afsd_logp, pathp));
3379         
3380         if (!pathp) {
3381                 return CM_ERROR_BADFD;
3382         }
3383         
3384         rootScp = cm_rootSCachep;
3385         
3386         userp = smb_GetUser(vcp, inp);
3387
3388         caseFold = CM_FLAG_CASEFOLD;
3389
3390         tidPathp = smb_GetTIDPath(vcp, ((smb_t *)inp)->tid);
3391         code = cm_NameI(rootScp, pathp,
3392                         caseFold | CM_FLAG_FOLLOW | CM_FLAG_CHECKPATH,
3393                         userp, tidPathp, &req, &newScp);
3394
3395         if (code) {
3396                 cm_ReleaseUser(userp);
3397                 return code;
3398         }
3399         
3400         /* now lock the vnode with a callback; returns with newScp locked */
3401         lock_ObtainMutex(&newScp->mx);
3402         code = cm_SyncOp(newScp, NULL, userp, &req, PRSFS_LOOKUP,
3403                 CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
3404         if (code && code != CM_ERROR_NOACCESS) {
3405                 lock_ReleaseMutex(&newScp->mx);
3406                 cm_ReleaseSCache(newScp);
3407                 cm_ReleaseUser(userp);
3408                 return code;
3409         }
3410
3411         attrs = smb_Attributes(newScp);
3412
3413         if (!(attrs & 0x10))
3414                 code = CM_ERROR_NOTDIR;
3415
3416         lock_ReleaseMutex(&newScp->mx);
3417         
3418         cm_ReleaseSCache(newScp);
3419         cm_ReleaseUser(userp);
3420         return code;
3421 }
3422
3423 long smb_ReceiveCoreSetFileAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3424 {
3425         char *pathp;
3426         long code;
3427         cm_scache_t *rootScp;
3428         unsigned short attribute;
3429         cm_attr_t attr;
3430         cm_scache_t *newScp;
3431         long dosTime;
3432         cm_user_t *userp;
3433         int caseFold;
3434         char *tidPathp;
3435         cm_req_t req;
3436
3437         cm_InitReq(&req);
3438
3439         /* decode basic attributes we're passed */
3440         attribute = smb_GetSMBParm(inp, 0);
3441         dosTime = smb_GetSMBParm(inp, 1) | (smb_GetSMBParm(inp, 2) << 16);
3442
3443         pathp = smb_GetSMBData(inp, NULL);
3444         pathp = smb_ParseASCIIBlock(pathp, NULL);
3445         
3446         if (!pathp) {
3447                 return CM_ERROR_BADSMB;