windows-unicode-support-20080509
[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 #include <afs/param.h>
11 #include <afs/stds.h>
12
13 #include <windows.h>
14 #pragma warning(push)
15 #pragma warning(disable: 4005)
16 #include <ntstatus.h>
17 #pragma warning(pop)
18 #include <stddef.h>
19 #include <stdlib.h>
20 #include <malloc.h>
21 #include <string.h>
22 #include <stdio.h>
23 #include <time.h>
24
25 #include "afsd.h"
26 #include <osi.h>
27 #include <rx\rx.h>
28 #include <rx/rx_prototypes.h>
29 #include <WINNT\afsreg.h>
30
31 #include "smb.h"
32 #include "lanahelper.h"
33
34 #define STRSAFE_NO_DEPRECATE
35 #include <strsafe.h>
36
37 /* These characters are illegal in Windows filenames */
38 static char *illegalChars = "\\/:*?\"<>|";
39
40 static int smbShutdownFlag = 0;
41 static int smb_ListenerState = SMB_LISTENER_UNINITIALIZED;
42
43 int smb_LogoffTokenTransfer;
44 time_t smb_LogoffTransferTimeout;
45
46 int smb_StoreAnsiFilenames = 0;
47
48 DWORD last_msg_time = 0;
49
50 long ongoingOps = 0;
51
52 unsigned int sessionGen = 0;
53
54 extern void afsi_log(char *pattern, ...);
55 extern HANDLE afsi_file;
56 extern int powerStateSuspended;
57
58 osi_hyper_t hzero = {0, 0};
59 osi_hyper_t hones = {0xFFFFFFFF, -1};
60
61 osi_log_t *  smb_logp;
62 osi_rwlock_t smb_globalLock;
63 osi_rwlock_t smb_rctLock;
64 osi_mutex_t  smb_ListenerLock;
65 osi_mutex_t  smb_StartedLock;
66  
67 unsigned char smb_LANadapter = LANA_INVALID;
68 unsigned char smb_sharename[NCBNAMSZ+1] = {0};
69 int  smb_LanAdapterChangeDetected = 0;
70 afs_uint32    smb_AsyncStore = 1;
71 afs_uint32    smb_AsyncStoreSize = CM_CONFIGDEFAULT_ASYNCSTORESIZE;
72
73 BOOL isGateway = FALSE;
74
75 /* for debugging */
76 long smb_maxObsConcurrentCalls=0;
77 long smb_concurrentCalls=0;
78
79 smb_dispatch_t smb_dispatchTable[SMB_NOPCODES];
80
81 smb_packet_t *smb_packetFreeListp;
82 smb_ncb_t *smb_ncbFreeListp;
83
84 afs_uint32 smb_NumServerThreads;
85
86 afs_uint32 numNCBs, numSessions, numVCs;
87
88 int smb_maxVCPerServer;
89 int smb_maxMpxRequests;
90
91 int smb_authType = SMB_AUTH_EXTENDED; /* type of SMB auth to use. One of SMB_AUTH_* */
92 HANDLE smb_lsaHandle;
93 ULONG smb_lsaSecPackage;
94 LSA_STRING smb_lsaLogonOrigin;
95
96 #define NCB_MAX MAXIMUM_WAIT_OBJECTS
97 EVENT_HANDLE NCBavails[NCB_MAX], NCBevents[NCB_MAX];
98 EVENT_HANDLE **NCBreturns;
99 EVENT_HANDLE **NCBShutdown;
100 EVENT_HANDLE *smb_ServerShutdown;
101 EVENT_HANDLE ListenerShutdown[256];
102 DWORD NCBsessions[NCB_MAX];
103 NCB *NCBs[NCB_MAX];
104 struct smb_packet *bufs[NCB_MAX];
105
106 #define SESSION_MAX MAXIMUM_WAIT_OBJECTS - 4
107 EVENT_HANDLE SessionEvents[SESSION_MAX];
108 unsigned short LSNs[SESSION_MAX];
109 int lanas[SESSION_MAX];
110 BOOL dead_sessions[SESSION_MAX];
111 LANA_ENUM lana_list;
112 /* for raw I/O */
113 osi_mutex_t smb_RawBufLock;
114 char *smb_RawBufs;
115
116 #define SMB_MASKFLAG_TILDE 1
117 #define SMB_MASKFLAG_CASEFOLD 2
118
119 #define RAWTIMEOUT INFINITE
120
121 /* for raw write */
122 typedef struct raw_write_cont {
123         long code;
124         osi_hyper_t offset;
125         long count;
126         char *buf;
127         int writeMode;
128         long alreadyWritten;
129 } raw_write_cont_t;
130
131 /* dir search stuff */
132 long smb_dirSearchCounter = 1;
133 smb_dirSearch_t *smb_firstDirSearchp;
134 smb_dirSearch_t *smb_lastDirSearchp;
135
136 /* hide dot files? */
137 int smb_hideDotFiles;
138
139 /* Negotiate Unicode support? */
140 LONG smb_UseUnicode;
141
142 /* global state about V3 protocols */
143 int smb_useV3;          /* try to negotiate V3 */
144
145 static showErrors = 0;
146 /* MessageBox or something like it */
147 int (_stdcall *smb_MBfunc)(HWND, LPCTSTR, LPCTSTR, UINT) = NULL;
148
149 /* GMT time info:
150  * Time in Unix format of midnight, 1/1/1970 local time.
151  * When added to dosUTime, gives Unix (AFS) time.
152  */
153 time_t smb_localZero = 0;
154
155 #define USE_NUMERIC_TIME_CONV 1
156
157 #ifndef USE_NUMERIC_TIME_CONV
158 /* Time difference for converting to kludge-GMT */
159 afs_uint32 smb_NowTZ;
160 #endif /* USE_NUMERIC_TIME_CONV */
161
162 char *smb_localNamep = NULL;
163
164 smb_vc_t *smb_allVCsp;
165 smb_vc_t *smb_deadVCsp;
166
167 smb_username_t *usernamesp = NULL;
168
169 smb_waitingLockRequest_t *smb_allWaitingLocks;
170
171 DWORD smb_TlsRequestSlot = -1;
172
173 /* forward decl */
174 void smb_DispatchPacket(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp,
175                         NCB *ncbp, raw_write_cont_t *rwcp);
176 int smb_NetbiosInit(int);
177
178 #ifdef LOG_PACKET
179 void smb_LogPacket(smb_packet_t *packet);
180 #endif /* LOG_PACKET */
181
182 char smb_ServerDomainName[MAX_COMPUTERNAME_LENGTH + 1] = ""; /* domain name */
183 int smb_ServerDomainNameLength = 0;
184 char smb_ServerOS[] = "Windows 5.0"; /* Faux OS String */
185 int smb_ServerOSLength = sizeof(smb_ServerOS);
186 char smb_ServerLanManager[] = "Windows 2000 LAN Manager"; /* Faux LAN Manager string */
187 int smb_ServerLanManagerLength = sizeof(smb_ServerLanManager);
188
189 /* Faux server GUID. This is never checked. */
190 GUID smb_ServerGUID = { 0x40015cb8, 0x058a, 0x44fc, { 0xae, 0x7e, 0xbb, 0x29, 0x52, 0xee, 0x7e, 0xff }};
191
192 void smb_ResetServerPriority()
193 {
194     void * p = TlsGetValue(smb_TlsRequestSlot);
195     if (p) {
196         free(p);
197         TlsSetValue(smb_TlsRequestSlot, NULL);
198         SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
199     }
200 }
201
202 void smb_SetRequestStartTime()
203 {
204     time_t * tp = TlsGetValue(smb_TlsRequestSlot);
205     if (!tp)
206         tp = malloc(sizeof(time_t));
207     if (tp) {
208         *tp = osi_Time();
209
210         if (!TlsSetValue(smb_TlsRequestSlot, tp))
211             free(tp);
212     }   
213 }
214
215 void smb_UpdateServerPriority()
216 {       
217     time_t *tp = TlsGetValue(smb_TlsRequestSlot);
218
219     if (tp) {
220         time_t now = osi_Time();
221
222         /* Give one priority boost for each 15 seconds */
223         SetThreadPriority(GetCurrentThread(), (int)((now - *tp) / 15));
224     }
225 }
226
227
228 const char * ncb_error_string(int code)
229 {
230     const char * s;
231     switch ( code ) {
232     case 0x01: s = "llegal buffer length";                      break; 
233     case 0x03: s = "illegal command";                           break; 
234     case 0x05: s = "command timed out";                         break; 
235     case 0x06: s = "message incomplete, issue another command"; break; 
236     case 0x07: s = "illegal buffer address";                    break; 
237     case 0x08: s = "session number out of range";               break; 
238     case 0x09: s = "no resource available";                     break; 
239     case 0x0a: s = "session closed";                            break; 
240     case 0x0b: s = "command cancelled";                         break; 
241     case 0x0d: s = "duplicate name";                            break; 
242     case 0x0e: s = "name table full";                           break; 
243     case 0x0f: s = "no deletions, name has active sessions";    break; 
244     case 0x11: s = "local session table full";                  break; 
245     case 0x12: s = "remote session table full";                 break; 
246     case 0x13: s = "illegal name number";                       break; 
247     case 0x14: s = "no callname";                               break; 
248     case 0x15: s = "cannot put * in NCB_NAME";                  break; 
249     case 0x16: s = "name in use on remote adapter";             break; 
250     case 0x17: s = "name deleted";                              break; 
251     case 0x18: s = "session ended abnormally";                  break; 
252     case 0x19: s = "name conflict detected";                    break; 
253     case 0x21: s = "interface busy, IRET before retrying";      break; 
254     case 0x22: s = "too many commands outstanding, retry later";break;
255     case 0x23: s = "ncb_lana_num field invalid";                break; 
256     case 0x24: s = "command completed while cancel occurring "; break; 
257     case 0x26: s = "command not valid to cancel";               break; 
258     case 0x30: s = "name defined by anther local process";      break; 
259     case 0x34: s = "environment undefined. RESET required";     break; 
260     case 0x35: s = "required OS resources exhausted";           break; 
261     case 0x36: s = "max number of applications exceeded";       break; 
262     case 0x37: s = "no saps available for netbios";             break; 
263     case 0x38: s = "requested resources are not available";     break; 
264     case 0x39: s = "invalid ncb address or length > segment";   break; 
265     case 0x3B: s = "invalid NCB DDID";                          break; 
266     case 0x3C: s = "lock of user area failed";                  break; 
267     case 0x3f: s = "NETBIOS not loaded";                        break; 
268     case 0x40: s = "system error";                              break;                 
269     default:   s = "unknown error";
270     }
271     return s;
272 }
273
274
275 char * myCrt_Dispatch(int i)
276 {
277     switch (i)
278     {
279     case 0x00:
280         return "(00)ReceiveCoreMakeDir";
281     case 0x01:
282         return "(01)ReceiveCoreRemoveDir";
283     case 0x02:
284         return "(02)ReceiveCoreOpen";
285     case 0x03:
286         return "(03)ReceiveCoreCreate";
287     case 0x04:
288         return "(04)ReceiveCoreClose";
289     case 0x05:
290         return "(05)ReceiveCoreFlush";
291     case 0x06:
292         return "(06)ReceiveCoreUnlink";
293     case 0x07:
294         return "(07)ReceiveCoreRename";
295     case 0x08:
296         return "(08)ReceiveCoreGetFileAttributes";
297     case 0x09:
298         return "(09)ReceiveCoreSetFileAttributes";
299     case 0x0a:
300         return "(0a)ReceiveCoreRead";
301     case 0x0b:
302         return "(0b)ReceiveCoreWrite";
303     case 0x0c:
304         return "(0c)ReceiveCoreLockRecord";
305     case 0x0d:
306         return "(0d)ReceiveCoreUnlockRecord";
307     case 0x0e:
308         return "(0e)SendCoreBadOp";
309     case 0x0f:
310         return "(0f)ReceiveCoreCreate";
311     case 0x10:
312         return "(10)ReceiveCoreCheckPath";
313     case 0x11:
314         return "(11)SendCoreBadOp";
315     case 0x12:
316         return "(12)ReceiveCoreSeek";
317     case 0x1a:
318         return "(1a)ReceiveCoreReadRaw";
319     case 0x1d:
320         return "(1d)ReceiveCoreWriteRawDummy";
321     case 0x22:
322         return "(22)ReceiveV3SetAttributes";
323     case 0x23:
324         return "(23)ReceiveV3GetAttributes";
325     case 0x24:
326         return "(24)ReceiveV3LockingX";
327     case 0x25:
328         return "(25)ReceiveV3Trans";
329     case 0x26:
330         return "(26)ReceiveV3Trans[aux]";
331     case 0x29:
332         return "(29)SendCoreBadOp";
333     case 0x2b:
334         return "(2b)ReceiveCoreEcho";
335     case 0x2d:
336         return "(2d)ReceiveV3OpenX";
337     case 0x2e:
338         return "(2e)ReceiveV3ReadX";
339     case 0x2f:
340         return "(2f)ReceiveV3WriteX";
341     case 0x32:
342         return "(32)ReceiveV3Tran2A";
343     case 0x33:
344         return "(33)ReceiveV3Tran2A[aux]";
345     case 0x34:
346         return "(34)ReceiveV3FindClose";
347     case 0x35:
348         return "(35)ReceiveV3FindNotifyClose";
349     case 0x70:
350         return "(70)ReceiveCoreTreeConnect";
351     case 0x71:
352         return "(71)ReceiveCoreTreeDisconnect";
353     case 0x72:
354         return "(72)ReceiveNegotiate";
355     case 0x73:
356         return "(73)ReceiveV3SessionSetupX";
357     case 0x74:
358         return "(74)ReceiveV3UserLogoffX";
359     case 0x75:
360         return "(75)ReceiveV3TreeConnectX";
361     case 0x80:
362         return "(80)ReceiveCoreGetDiskAttributes";
363     case 0x81:
364         return "(81)ReceiveCoreSearchDir";
365     case 0x82:
366         return "(82)Find";
367     case 0x83:
368         return "(83)FindUnique";
369     case 0x84:
370         return "(84)FindClose";
371     case 0xA0:
372         return "(A0)ReceiveNTTransact";
373     case 0xA2:
374         return "(A2)ReceiveNTCreateX";
375     case 0xA4:
376         return "(A4)ReceiveNTCancel";
377     case 0xA5:
378         return "(A5)ReceiveNTRename";
379     case 0xc0:
380         return "(C0)OpenPrintFile";
381     case 0xc1:
382         return "(C1)WritePrintFile";
383     case 0xc2:
384         return "(C2)ClosePrintFile";
385     case 0xc3:
386         return "(C3)GetPrintQueue";
387     case 0xd8:
388         return "(D8)ReadBulk";
389     case 0xd9:
390         return "(D9)WriteBulk";
391     case 0xda:
392         return "(DA)WriteBulkData";
393     default:
394         return "unknown SMB op";
395     }
396 }       
397
398 char * myCrt_2Dispatch(int i)
399 {
400     switch (i)
401     {
402     default:
403         return "unknown SMB op-2";
404     case 0:
405         return "S(00)CreateFile_ReceiveTran2Open";
406     case 1:
407         return "S(01)FindFirst_ReceiveTran2SearchDir";
408     case 2:
409         return "S(02)FindNext_ReceiveTran2SearchDir";   /* FindNext */
410     case 3:
411         return "S(03)QueryFileSystem_ReceiveTran2QFSInfo";
412     case 4:
413         return "S(04)SetFileSystem_ReceiveTran2SetFSInfo";
414     case 5:
415         return "S(05)QueryPathInfo_ReceiveTran2QPathInfo";
416     case 6:
417         return "S(06)SetPathInfo_ReceiveTran2SetPathInfo";
418     case 7:
419         return "S(07)QueryFileInfo_ReceiveTran2QFileInfo";
420     case 8:
421         return "S(08)SetFileInfo_ReceiveTran2SetFileInfo";
422     case 9:
423         return "S(09)_ReceiveTran2FSCTL";
424     case 10:
425         return "S(0a)_ReceiveTran2IOCTL";
426     case 11:
427         return "S(0b)_ReceiveTran2FindNotifyFirst";
428     case 12:
429         return "S(0c)_ReceiveTran2FindNotifyNext";
430     case 13:
431         return "S(0d)_ReceiveTran2CreateDirectory";
432     case 14:
433         return "S(0e)_ReceiveTran2SessionSetup";
434     case 15:
435         return "S(0f)_QueryFileSystemInformationFid";
436     case 16:
437         return "S(10)_ReceiveTran2GetDfsReferral";
438     case 17:
439         return "S(11)_ReceiveTran2ReportDfsInconsistency";
440     }
441 }       
442
443 char * myCrt_RapDispatch(int i)
444 {
445     switch(i)
446     {
447     default:
448         return "unknown RAP OP";
449     case 0:
450         return "RAP(0)NetShareEnum";
451     case 1:
452         return "RAP(1)NetShareGetInfo";
453     case 13:
454         return "RAP(13)NetServerGetInfo";
455     case 63:
456         return "RAP(63)NetWkStaGetInfo";
457     }
458 }       
459
460 /* scache must be locked */
461 unsigned int smb_Attributes(cm_scache_t *scp)
462 {
463     unsigned int attrs;
464
465     if ( scp->fileType == CM_SCACHETYPE_DIRECTORY ||
466          scp->fileType == CM_SCACHETYPE_MOUNTPOINT ||
467          scp->fileType == CM_SCACHETYPE_INVALID)
468     {
469         attrs = SMB_ATTR_DIRECTORY;
470 #ifdef SPECIAL_FOLDERS
471         attrs |= SMB_ATTR_SYSTEM;               /* FILE_ATTRIBUTE_SYSTEM */
472 #endif /* SPECIAL_FOLDERS */
473     } else if (scp->fileType == CM_SCACHETYPE_DFSLINK) {
474         attrs = SMB_ATTR_DIRECTORY | SMB_ATTR_SPARSE_FILE;
475     } else
476         attrs = 0;
477
478     /*
479      * We used to mark a file RO if it was in an RO volume, but that
480      * turns out to be impolitic in NT.  See defect 10007.
481      */
482 #ifdef notdef
483     if ((scp->unixModeBits & 0222) == 0 || (scp->flags & CM_SCACHEFLAG_RO))
484         attrs |= SMB_ATTR_READONLY;     /* turn on read-only flag */
485 #else
486     if ((scp->unixModeBits & 0222) == 0)
487         attrs |= SMB_ATTR_READONLY;     /* turn on read-only flag */
488 #endif
489
490     return attrs;
491 }
492
493 /* Check if the named file/dir is a dotfile/dotdir */
494 /* String pointed to by lastComp can have leading slashes, but otherwise should have
495    no other patch components */
496 unsigned int smb_IsDotFile(char *lastComp) {
497     char *s;
498     if(lastComp) {
499         /* skip over slashes */
500         for(s=lastComp;*s && (*s == '\\' || *s == '/'); s++);
501     }
502     else
503         return 0;
504
505     /* nulls, curdir and parent dir doesn't count */
506     if (!*s) 
507         return 0;
508     if (*s == '.') {
509         if (!*(s + 1)) 
510             return 0;
511         if(*(s+1) == '.' && !*(s + 2)) 
512             return 0;
513         return 1;
514     }
515     return 0;
516 }
517
518 static int ExtractBits(WORD bits, short start, short len)
519 {
520     int end;
521     WORD num;
522
523     end = start + len;
524         
525     num = bits << (16 - end);
526     num = num >> ((16 - end) + start);
527
528     return (int)num;
529 }
530
531 void ShowUnixTime(char *FuncName, time_t unixTime)
532 {
533     FILETIME ft;
534     WORD wDate, wTime;
535
536     smb_LargeSearchTimeFromUnixTime(&ft, unixTime);
537
538     if (!FileTimeToDosDateTime(&ft, &wDate, &wTime))
539         osi_Log1(smb_logp, "Failed to convert filetime to dos datetime: %d", GetLastError());
540     else {
541         int day, month, year, sec, min, hour;
542         char msg[256];
543
544         day = ExtractBits(wDate, 0, 5);
545         month = ExtractBits(wDate, 5, 4);
546         year = ExtractBits(wDate, 9, 7) + 1980;
547
548         sec = ExtractBits(wTime, 0, 5);
549         min = ExtractBits(wTime, 5, 6);
550         hour = ExtractBits(wTime, 11, 5);
551
552         sprintf(msg, "%s = %02d-%02d-%04d %02d:%02d:%02d", FuncName, month, day, year, hour, min, sec);
553         osi_Log1(smb_logp, "%s", osi_LogSaveString(smb_logp, msg));
554     }
555 }       
556
557 /* Determine if we are observing daylight savings time */
558 void GetTimeZoneInfo(BOOL *pDST, LONG *pDstBias, LONG *pBias)
559 {
560     TIME_ZONE_INFORMATION timeZoneInformation;
561     SYSTEMTIME utc, local, localDST;
562
563     /* Get the time zone info. NT uses this to calc if we are in DST. */
564     GetTimeZoneInformation(&timeZoneInformation);
565
566     /* Return the daylight bias */
567     *pDstBias = timeZoneInformation.DaylightBias;
568
569     /* Return the bias */
570     *pBias = timeZoneInformation.Bias;
571
572     /* Now determine if DST is being observed */
573
574     /* Get the UTC (GMT) time */
575     GetSystemTime(&utc);
576
577     /* Convert UTC time to local time using the time zone info.  If we are
578        observing DST, the calculated local time will include this. 
579      */
580     SystemTimeToTzSpecificLocalTime(&timeZoneInformation, &utc, &localDST);
581
582     /* Set the daylight bias to 0.  The daylight bias is the amount of change
583      * in time that we use for daylight savings time.  By setting this to 0
584      * we cause there to be no change in time during daylight savings time. 
585      */
586     timeZoneInformation.DaylightBias = 0;
587
588     /* Convert the utc time to local time again, but this time without any
589        adjustment for daylight savings time. 
590        */
591     SystemTimeToTzSpecificLocalTime(&timeZoneInformation, &utc, &local);
592
593     /* If the two times are different, then it means that the localDST that
594        we calculated includes the daylight bias, and therefore we are
595        observing daylight savings time.
596      */
597     *pDST = localDST.wHour != local.wHour;
598 }       
599  
600
601 void CompensateForSmbClientLastWriteTimeBugs(afs_uint32 *pLastWriteTime)
602 {
603     BOOL dst;       /* Will be TRUE if observing DST */
604     LONG dstBias;   /* Offset from local time if observing DST */
605     LONG bias;      /* Offset from GMT for local time */
606
607     /*
608      * This function will adjust the last write time to compensate
609      * for two bugs in the smb client:
610      *
611      *    1) During Daylight Savings Time, the LastWriteTime is ahead
612      *       in time by the DaylightBias (ignoring the sign - the
613      *       DaylightBias is always stored as a negative number).  If
614      *       the DaylightBias is -60, then the LastWriteTime will be
615      *       ahead by 60 minutes.
616      *
617      *    2) If the local time zone is a positive offset from GMT, then
618      *       the LastWriteTime will be the correct local time plus the
619      *       Bias (ignoring the sign - a positive offset from GMT is
620      *       always stored as a negative Bias).  If the Bias is -120,
621      *       then the LastWriteTime will be ahead by 120 minutes.
622      *
623      *    These bugs can occur at the same time.
624      */
625
626     GetTimeZoneInfo(&dst, &dstBias, &bias);
627
628     /* First adjust for DST */
629     if (dst)
630         *pLastWriteTime -= (-dstBias * 60);     /* Convert dstBias to seconds */
631
632     /* Now adjust for a positive offset from GMT (a negative bias). */
633     if (bias < 0)
634         *pLastWriteTime -= (-bias * 60);        /* Convert bias to seconds */
635 }                       
636
637 #ifndef USE_NUMERIC_TIME_CONV
638 /*
639  * Calculate the difference (in seconds) between local time and GMT.
640  * This enables us to convert file times to kludge-GMT.
641  */
642 static void
643 smb_CalculateNowTZ()
644 {
645     time_t t;
646     struct tm gmt_tm, local_tm;
647     int days, hours, minutes, seconds;
648
649     t = time(NULL);
650     gmt_tm = *(gmtime(&t));
651     local_tm = *(localtime(&t));
652
653     days = local_tm.tm_yday - gmt_tm.tm_yday;
654     hours = 24 * days + local_tm.tm_hour - gmt_tm.tm_hour;
655     minutes = 60 * hours + local_tm.tm_min - gmt_tm.tm_min; 
656     seconds = 60 * minutes + local_tm.tm_sec - gmt_tm.tm_sec;
657
658     smb_NowTZ = seconds;
659 }
660 #endif /* USE_NUMERIC_TIME_CONV */
661
662 #ifdef USE_NUMERIC_TIME_CONV
663 void smb_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, time_t unixTime)
664 {
665     // Note that LONGLONG is a 64-bit value
666     LONGLONG ll;
667
668     ll = Int32x32To64(unixTime, 10000000) + 116444736000000000;
669     largeTimep->dwLowDateTime = (DWORD)(ll & 0xFFFFFFFF);
670     largeTimep->dwHighDateTime = (DWORD)(ll >> 32);
671 }
672 #else
673 void smb_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, time_t unixTime)
674 {
675     struct tm *ltp;
676     SYSTEMTIME stm;
677     struct tm localJunk;
678     time_t ersatz_unixTime;
679
680     /*
681      * Must use kludge-GMT instead of real GMT.
682      * kludge-GMT is computed by adding time zone difference to localtime.
683      *
684      * real GMT would be:
685      * ltp = gmtime(&unixTime);
686      */
687     ersatz_unixTime = unixTime - smb_NowTZ;
688     ltp = localtime(&ersatz_unixTime);
689
690     /* if we fail, make up something */
691     if (!ltp) {
692         ltp = &localJunk;
693         localJunk.tm_year = 89 - 20;
694         localJunk.tm_mon = 4;
695         localJunk.tm_mday = 12;
696         localJunk.tm_hour = 0;
697         localJunk.tm_min = 0;
698         localJunk.tm_sec = 0;
699     }
700
701     stm.wYear = ltp->tm_year + 1900;
702     stm.wMonth = ltp->tm_mon + 1;
703     stm.wDayOfWeek = ltp->tm_wday;
704     stm.wDay = ltp->tm_mday;
705     stm.wHour = ltp->tm_hour;
706     stm.wMinute = ltp->tm_min;
707     stm.wSecond = ltp->tm_sec;
708     stm.wMilliseconds = 0;
709
710     SystemTimeToFileTime(&stm, largeTimep);
711 }
712 #endif /* USE_NUMERIC_TIME_CONV */
713
714 #ifdef USE_NUMERIC_TIME_CONV
715 void smb_UnixTimeFromLargeSearchTime(time_t *unixTimep, FILETIME *largeTimep)
716 {
717     // Note that LONGLONG is a 64-bit value
718     LONGLONG ll;
719
720     ll = largeTimep->dwHighDateTime;
721     ll <<= 32;
722     ll += largeTimep->dwLowDateTime;
723
724     ll -= 116444736000000000;
725     ll /= 10000000;
726
727     *unixTimep = (DWORD)ll;
728 }
729 #else /* USE_NUMERIC_TIME_CONV */
730 void smb_UnixTimeFromLargeSearchTime(time_t *unixTimep, FILETIME *largeTimep)
731 {
732     SYSTEMTIME stm;
733     struct tm lt;
734     long save_timezone;
735
736     FileTimeToSystemTime(largeTimep, &stm);
737
738     lt.tm_year = stm.wYear - 1900;
739     lt.tm_mon = stm.wMonth - 1;
740     lt.tm_wday = stm.wDayOfWeek;
741     lt.tm_mday = stm.wDay;
742     lt.tm_hour = stm.wHour;
743     lt.tm_min = stm.wMinute;
744     lt.tm_sec = stm.wSecond;
745     lt.tm_isdst = -1;
746
747     save_timezone = _timezone;
748     _timezone += smb_NowTZ;
749     *unixTimep = mktime(&lt);
750     _timezone = save_timezone;
751 }       
752 #endif /* USE_NUMERIC_TIME_CONV */
753
754 void smb_SearchTimeFromUnixTime(afs_uint32 *searchTimep, time_t unixTime)
755 {
756     struct tm *ltp;
757     int dosDate;
758     int dosTime;
759     struct tm localJunk;
760     time_t t = unixTime;
761
762     ltp = localtime(&t);
763
764     /* if we fail, make up something */
765     if (!ltp) {
766         ltp = &localJunk;
767         localJunk.tm_year = 89 - 20;
768         localJunk.tm_mon = 4;
769         localJunk.tm_mday = 12;
770         localJunk.tm_hour = 0;
771         localJunk.tm_min = 0;
772         localJunk.tm_sec = 0;
773     }   
774
775     dosDate = ((ltp->tm_year-80)<<9) | ((ltp->tm_mon+1) << 5) | (ltp->tm_mday);
776     dosTime = (ltp->tm_hour<<11) | (ltp->tm_min << 5) | (ltp->tm_sec / 2);
777     *searchTimep = (dosDate<<16) | dosTime;
778 }       
779
780 void smb_UnixTimeFromSearchTime(time_t *unixTimep, afs_uint32 searchTime)
781 {
782     unsigned short dosDate;
783     unsigned short dosTime;
784     struct tm localTm;
785         
786     dosDate = (unsigned short) (searchTime & 0xffff);
787     dosTime = (unsigned short) ((searchTime >> 16) & 0xffff);
788
789     localTm.tm_year = 80 + ((dosDate>>9) & 0x3f);
790     localTm.tm_mon = ((dosDate >> 5) & 0xf) - 1;        /* January is 0 in localTm */
791     localTm.tm_mday = (dosDate) & 0x1f;
792     localTm.tm_hour = (dosTime>>11) & 0x1f;
793     localTm.tm_min = (dosTime >> 5) & 0x3f;
794     localTm.tm_sec = (dosTime & 0x1f) * 2;
795     localTm.tm_isdst = -1;                              /* compute whether DST in effect */
796
797     *unixTimep = mktime(&localTm);
798 }
799
800 void smb_DosUTimeFromUnixTime(afs_uint32 *dosUTimep, time_t unixTime)
801 {
802     time_t diff_t = unixTime - smb_localZero;
803 #if defined(DEBUG) && !defined(_USE_32BIT_TIME_T)
804     osi_assertx(diff_t < _UI32_MAX, "time_t > _UI32_MAX");
805 #endif
806     *dosUTimep = (afs_uint32)diff_t;
807 }
808
809 void smb_UnixTimeFromDosUTime(time_t *unixTimep, afs_uint32 dosTime)
810 {
811     *unixTimep = dosTime + smb_localZero;
812 }
813
814 smb_vc_t *smb_FindVC(unsigned short lsn, int flags, int lana)
815 {
816     smb_vc_t *vcp;
817
818     lock_ObtainWrite(&smb_globalLock);  /* for numVCs */
819     lock_ObtainWrite(&smb_rctLock);
820     for (vcp = smb_allVCsp; vcp; vcp=vcp->nextp) {
821         if (vcp->magic != SMB_VC_MAGIC)
822             osi_panic("afsd: invalid smb_vc_t detected in smb_allVCsp", 
823                        __FILE__, __LINE__);
824
825         if (lsn == vcp->lsn && lana == vcp->lana &&
826             !(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
827             smb_HoldVCNoLock(vcp);
828             break;
829         }
830     }
831     if (!vcp && (flags & SMB_FLAG_CREATE)) {
832         vcp = malloc(sizeof(*vcp));
833         memset(vcp, 0, sizeof(*vcp));
834         vcp->vcID = ++numVCs;
835         vcp->magic = SMB_VC_MAGIC;
836         vcp->refCount = 2;      /* smb_allVCsp and caller */
837         vcp->tidCounter = 1;
838         vcp->fidCounter = 1;
839         vcp->uidCounter = 1;    /* UID 0 is reserved for blank user */
840         vcp->nextp = smb_allVCsp;
841         smb_allVCsp = vcp;
842         lock_InitializeMutex(&vcp->mx, "vc_t mutex");
843         vcp->lsn = lsn;
844         vcp->lana = lana;
845         vcp->secCtx = NULL;
846
847         if (smb_authType == SMB_AUTH_NTLM || smb_authType == SMB_AUTH_EXTENDED) {
848             /* We must obtain a challenge for extended auth 
849              * in case the client negotiates smb v3 
850              */
851             NTSTATUS nts = STATUS_UNSUCCESSFUL, ntsEx = STATUS_UNSUCCESSFUL;
852             MSV1_0_LM20_CHALLENGE_REQUEST lsaReq;
853             PMSV1_0_LM20_CHALLENGE_RESPONSE lsaResp = NULL;
854             ULONG lsaRespSize = 0;
855
856             lsaReq.MessageType = MsV1_0Lm20ChallengeRequest;
857
858             nts = LsaCallAuthenticationPackage( smb_lsaHandle,
859                                                 smb_lsaSecPackage,
860                                                 &lsaReq,
861                                                 sizeof(lsaReq),
862                                                 &lsaResp,
863                                                 &lsaRespSize,
864                                                 &ntsEx);
865             if (nts != STATUS_SUCCESS || ntsEx != STATUS_SUCCESS) {
866                 osi_Log4(smb_logp,"MsV1_0Lm20ChallengeRequest failure: nts 0x%x ntsEx 0x%x respSize is %u needs %u",
867                          nts, ntsEx, sizeof(lsaReq), lsaRespSize);
868                     afsi_log("MsV1_0Lm20ChallengeRequest failure: nts 0x%x ntsEx 0x%x respSize %u",
869                          nts, ntsEx, lsaRespSize);
870             }
871             osi_assertx(nts == STATUS_SUCCESS, "LsaCallAuthenticationPackage failed"); /* this had better work! */
872
873             if (ntsEx == STATUS_SUCCESS) {
874                 memcpy(vcp->encKey, lsaResp->ChallengeToClient, MSV1_0_CHALLENGE_LENGTH);
875                 LsaFreeReturnBuffer(lsaResp);
876             } else {
877                 /* 
878                  * This will cause the subsequent authentication to fail but
879                  * that is better than us dereferencing a NULL pointer and 
880                  * crashing.
881                  */
882                 memset(vcp->encKey, 0, MSV1_0_CHALLENGE_LENGTH);
883             }
884         }
885         else
886             memset(vcp->encKey, 0, MSV1_0_CHALLENGE_LENGTH);
887
888         if (numVCs >= CM_SESSION_RESERVED) {
889             numVCs = 0;
890             osi_Log0(smb_logp, "WARNING: numVCs wrapping around");
891         }
892     }
893     lock_ReleaseWrite(&smb_rctLock);
894     lock_ReleaseWrite(&smb_globalLock);
895     return vcp;
896 }
897
898 int smb_IsStarMask(char *maskp)
899 {
900     int i;
901     char tc;
902         
903     for(i=0; i<11; i++) {
904         tc = *maskp++;
905         if (tc == '?' || tc == '*' || tc == '>')
906             return 1;
907     }   
908     return 0;
909 }
910
911 void smb_ReleaseVCInternal(smb_vc_t *vcp)
912 {
913     smb_vc_t **vcpp;
914     smb_vc_t * avcp;
915
916     vcp->refCount--;
917
918     if (vcp->refCount == 0) {
919         if (vcp->flags & SMB_VCFLAG_ALREADYDEAD) {
920             /* remove VCP from smb_deadVCsp */
921             for (vcpp = &smb_deadVCsp; *vcpp; vcpp = &((*vcpp)->nextp)) {
922                 if (*vcpp == vcp) {
923                     *vcpp = vcp->nextp;
924                     break;
925                 }
926             } 
927             lock_FinalizeMutex(&vcp->mx);
928             memset(vcp,0,sizeof(smb_vc_t));
929             free(vcp);
930         } else {
931             for (avcp = smb_allVCsp; avcp; avcp = avcp->nextp) {
932                 if (avcp == vcp)
933                     break;
934             }
935             osi_Log3(smb_logp,"VCP not dead and %sin smb_allVCsp vcp %x ref %d",
936                       avcp?"not ":"",vcp, vcp->refCount);
937 #ifdef DEBUG
938             GenerateMiniDump(NULL);
939 #endif
940             /* This is a wrong.  However, I suspect that there is an undercount
941              * and I don't want to release 1.4.1 in a state that will allow
942              * smb_vc_t objects to be deallocated while still in the
943              * smb_allVCsp list.  The list is supposed to keep a reference
944              * to the smb_vc_t.  Put it back.
945              */
946             vcp->refCount++;
947         }
948     }
949 }
950
951 void smb_ReleaseVCNoLock(smb_vc_t *vcp)
952 {
953     osi_Log2(smb_logp,"smb_ReleaseVCNoLock vcp %x ref %d",vcp, vcp->refCount);
954     smb_ReleaseVCInternal(vcp);
955 }       
956
957 void smb_ReleaseVC(smb_vc_t *vcp)
958 {
959     lock_ObtainWrite(&smb_rctLock);
960     osi_Log2(smb_logp,"smb_ReleaseVC       vcp %x ref %d",vcp, vcp->refCount);
961     smb_ReleaseVCInternal(vcp);
962     lock_ReleaseWrite(&smb_rctLock);
963 }       
964
965 void smb_HoldVCNoLock(smb_vc_t *vcp)
966 {
967     vcp->refCount++;
968     osi_Log2(smb_logp,"smb_HoldVCNoLock vcp %x ref %d",vcp, vcp->refCount);
969 }       
970
971 void smb_HoldVC(smb_vc_t *vcp)
972 {
973     lock_ObtainWrite(&smb_rctLock);
974     vcp->refCount++;
975     osi_Log2(smb_logp,"smb_HoldVC       vcp %x ref %d",vcp, vcp->refCount);
976     lock_ReleaseWrite(&smb_rctLock);
977 }       
978
979 void smb_CleanupDeadVC(smb_vc_t *vcp)
980 {
981     smb_fid_t *fidpIter;
982     smb_fid_t *fidpNext;
983     unsigned short fid;
984     smb_tid_t *tidpIter;
985     smb_tid_t *tidpNext;
986     unsigned short tid;
987     smb_user_t *uidpIter;
988     smb_user_t *uidpNext;
989     smb_vc_t **vcpp;
990
991
992     lock_ObtainMutex(&vcp->mx);
993     if (vcp->flags & SMB_VCFLAG_CLEAN_IN_PROGRESS) {
994         lock_ReleaseMutex(&vcp->mx);
995         osi_Log1(smb_logp, "Clean of dead vcp 0x%x in progress", vcp);
996         return;
997     }
998     vcp->flags |= SMB_VCFLAG_CLEAN_IN_PROGRESS;
999     lock_ReleaseMutex(&vcp->mx);
1000     osi_Log1(smb_logp, "Cleaning up dead vcp 0x%x", vcp);
1001
1002     lock_ObtainWrite(&smb_rctLock);
1003     /* remove VCP from smb_allVCsp */
1004     for (vcpp = &smb_allVCsp; *vcpp; vcpp = &((*vcpp)->nextp)) {
1005         if ((*vcpp)->magic != SMB_VC_MAGIC)
1006             osi_panic("afsd: invalid smb_vc_t detected in smb_allVCsp", 
1007                        __FILE__, __LINE__);
1008         if (*vcpp == vcp) {
1009             *vcpp = vcp->nextp;
1010             vcp->nextp = smb_deadVCsp;
1011             smb_deadVCsp = vcp;
1012             /* Hold onto the reference until we are done with this function */
1013             break;
1014         }
1015     }
1016
1017     for (fidpIter = vcp->fidsp; fidpIter; fidpIter = fidpNext) {
1018         fidpNext = (smb_fid_t *) osi_QNext(&fidpIter->q);
1019
1020         if (fidpIter->delete)
1021             continue;
1022
1023         fid = fidpIter->fid;
1024         osi_Log2(smb_logp, " Cleanup FID %d (fidp=0x%x)", fid, fidpIter);
1025
1026         smb_HoldFIDNoLock(fidpIter);
1027         lock_ReleaseWrite(&smb_rctLock);
1028
1029         smb_CloseFID(vcp, fidpIter, NULL, 0);
1030         smb_ReleaseFID(fidpIter);
1031
1032         lock_ObtainWrite(&smb_rctLock);
1033         fidpNext = vcp->fidsp;
1034     }
1035
1036     for (tidpIter = vcp->tidsp; tidpIter; tidpIter = tidpNext) {
1037         tidpNext = tidpIter->nextp;
1038         if (tidpIter->delete)
1039             continue;
1040         tidpIter->delete = 1;
1041
1042         tid = tidpIter->tid;
1043         osi_Log2(smb_logp, "  Cleanup TID %d (tidp=0x%x)", tid, tidpIter);
1044
1045         smb_HoldTIDNoLock(tidpIter);
1046         smb_ReleaseTID(tidpIter, TRUE);
1047         tidpNext = vcp->tidsp;
1048     }
1049
1050     for (uidpIter = vcp->usersp; uidpIter; uidpIter = uidpNext) {
1051         uidpNext = uidpIter->nextp;
1052         if (uidpIter->delete)
1053             continue;
1054         uidpIter->delete = 1;
1055
1056         /* do not add an additional reference count for the smb_user_t
1057          * as the smb_vc_t already is holding a reference */
1058         lock_ReleaseWrite(&smb_rctLock);
1059
1060         smb_ReleaseUID(uidpIter);
1061
1062         lock_ObtainWrite(&smb_rctLock);
1063         uidpNext = vcp->usersp;
1064     }
1065
1066     /* The vcp is now on the deadVCsp list.  We intentionally drop the
1067      * reference so that the refcount can reach 0 and we can delete it */
1068     smb_ReleaseVCNoLock(vcp);
1069     
1070     lock_ReleaseWrite(&smb_rctLock);
1071     osi_Log1(smb_logp, "Finished cleaning up dead vcp 0x%x", vcp);
1072 }
1073
1074 smb_tid_t *smb_FindTID(smb_vc_t *vcp, unsigned short tid, int flags)
1075 {
1076     smb_tid_t *tidp;
1077
1078     lock_ObtainWrite(&smb_rctLock);
1079   retry:
1080     for (tidp = vcp->tidsp; tidp; tidp = tidp->nextp) {
1081         if (tidp->refCount == 0 && tidp->delete) {
1082             tidp->refCount++;
1083             smb_ReleaseTID(tidp, TRUE);
1084             goto retry;
1085         }
1086
1087         if (tid == tidp->tid) {
1088             tidp->refCount++;
1089             break;
1090         }       
1091     }
1092     if (!tidp && (flags & SMB_FLAG_CREATE)) {
1093         tidp = malloc(sizeof(*tidp));
1094         memset(tidp, 0, sizeof(*tidp));
1095         tidp->nextp = vcp->tidsp;
1096         tidp->refCount = 1;
1097         tidp->vcp = vcp;
1098         smb_HoldVCNoLock(vcp);
1099         vcp->tidsp = tidp;
1100         lock_InitializeMutex(&tidp->mx, "tid_t mutex");
1101         tidp->tid = tid;
1102     }
1103     lock_ReleaseWrite(&smb_rctLock);
1104     return tidp;
1105 }               
1106
1107 void smb_HoldTIDNoLock(smb_tid_t *tidp)
1108 {
1109     tidp->refCount++;
1110 }
1111
1112 void smb_ReleaseTID(smb_tid_t *tidp, afs_uint32 locked)
1113 {
1114     smb_tid_t *tp;
1115     smb_tid_t **ltpp;
1116     cm_user_t *userp;
1117
1118     userp = NULL;
1119     if (!locked)
1120         lock_ObtainWrite(&smb_rctLock);
1121     osi_assertx(tidp->refCount-- > 0, "smb_tid_t refCount 0");
1122     if (tidp->refCount == 0 && (tidp->delete)) {
1123         ltpp = &tidp->vcp->tidsp;
1124         for(tp = *ltpp; tp; ltpp = &tp->nextp, tp = *ltpp) {
1125             if (tp == tidp) 
1126                 break;
1127         }
1128         osi_assertx(tp != NULL, "null smb_tid_t");
1129         *ltpp = tp->nextp;
1130         lock_FinalizeMutex(&tidp->mx);
1131         userp = tidp->userp;    /* remember to drop ref later */
1132         tidp->userp = NULL;
1133         smb_ReleaseVCNoLock(tidp->vcp);
1134         tidp->vcp = NULL;
1135     }
1136     if (!locked)
1137         lock_ReleaseWrite(&smb_rctLock);
1138     if (userp)
1139         cm_ReleaseUser(userp);
1140 }               
1141
1142 smb_user_t *smb_FindUID(smb_vc_t *vcp, unsigned short uid, int flags)
1143 {
1144     smb_user_t *uidp = NULL;
1145
1146     lock_ObtainWrite(&smb_rctLock);
1147     for(uidp = vcp->usersp; uidp; uidp = uidp->nextp) {
1148         if (uid == uidp->userID) {
1149             uidp->refCount++;
1150             osi_Log3(smb_logp, "smb_FindUID vcp[0x%p] found-uid[%d] name[%s]",
1151                      vcp, uidp->userID, 
1152                      osi_LogSaveString(smb_logp, (uidp->unp) ? uidp->unp->name : ""));
1153             break;
1154         }
1155     }
1156     if (!uidp && (flags & SMB_FLAG_CREATE)) {
1157         uidp = malloc(sizeof(*uidp));
1158         memset(uidp, 0, sizeof(*uidp));
1159         uidp->nextp = vcp->usersp;
1160         uidp->refCount = 2; /* one for the vcp and one for the caller */
1161         uidp->vcp = vcp;
1162         smb_HoldVCNoLock(vcp);
1163         vcp->usersp = uidp;
1164         lock_InitializeMutex(&uidp->mx, "user_t mutex");
1165         uidp->userID = uid;
1166         osi_Log3(smb_logp, "smb_FindUID vcp[0x%p] new-uid[%d] name[%s]",
1167                  vcp, uidp->userID, 
1168                  osi_LogSaveString(smb_logp,uidp->unp ? uidp->unp->name : ""));
1169     }
1170     lock_ReleaseWrite(&smb_rctLock);
1171     return uidp;
1172 }               
1173
1174 smb_username_t *smb_FindUserByName(char *usern, char *machine, afs_uint32 flags)
1175 {
1176     smb_username_t *unp= NULL;
1177
1178     lock_ObtainWrite(&smb_rctLock);
1179     for(unp = usernamesp; unp; unp = unp->nextp) {
1180         if (stricmp(unp->name, usern) == 0 &&
1181              stricmp(unp->machine, machine) == 0) {
1182             unp->refCount++;
1183             break;
1184         }
1185     }
1186     if (!unp && (flags & SMB_FLAG_CREATE)) {
1187         unp = malloc(sizeof(*unp));
1188         memset(unp, 0, sizeof(*unp));
1189         unp->refCount = 1;
1190         unp->nextp = usernamesp;
1191         unp->name = strdup(usern);
1192         unp->machine = strdup(machine);
1193         usernamesp = unp;
1194         lock_InitializeMutex(&unp->mx, "username_t mutex");
1195         if (flags & SMB_FLAG_AFSLOGON)
1196             unp->flags = SMB_USERNAMEFLAG_AFSLOGON;
1197     }
1198
1199     lock_ReleaseWrite(&smb_rctLock);
1200     return unp;
1201 }       
1202
1203 smb_user_t *smb_FindUserByNameThisSession(smb_vc_t *vcp, char *usern)
1204 {
1205     smb_user_t *uidp= NULL;
1206
1207     lock_ObtainWrite(&smb_rctLock);
1208     for(uidp = vcp->usersp; uidp; uidp = uidp->nextp) {
1209         if (!uidp->unp) 
1210             continue;
1211         if (stricmp(uidp->unp->name, usern) == 0) {
1212             uidp->refCount++;
1213             osi_Log3(smb_logp,"smb_FindUserByNameThisSession vcp[0x%p] uid[%d] match-name[%s]",
1214                      vcp,uidp->userID,osi_LogSaveString(smb_logp,usern));
1215             break;
1216         } else
1217             continue;
1218     }           
1219     lock_ReleaseWrite(&smb_rctLock);
1220     return uidp;
1221 }       
1222
1223 void smb_ReleaseUsername(smb_username_t *unp)
1224 {
1225     smb_username_t *up;
1226     smb_username_t **lupp;
1227     cm_user_t *userp = NULL;
1228     time_t      now = osi_Time();
1229
1230     lock_ObtainWrite(&smb_rctLock);
1231     osi_assertx(unp->refCount-- > 0, "smb_username_t refCount 0");
1232     if (unp->refCount == 0 && !(unp->flags & SMB_USERNAMEFLAG_AFSLOGON) &&
1233         (unp->flags & SMB_USERNAMEFLAG_LOGOFF)) {
1234         lupp = &usernamesp;
1235         for(up = *lupp; up; lupp = &up->nextp, up = *lupp) {
1236             if (up == unp) 
1237                 break;
1238         }
1239         osi_assertx(up != NULL, "null smb_username_t");
1240         *lupp = up->nextp;
1241         up->nextp = NULL;                       /* do not remove this */
1242         lock_FinalizeMutex(&unp->mx);
1243         userp = unp->userp;
1244         free(unp->name);
1245         free(unp->machine);
1246         free(unp);
1247     }           
1248     lock_ReleaseWrite(&smb_rctLock);
1249     if (userp)
1250         cm_ReleaseUser(userp);
1251 }       
1252
1253 void smb_HoldUIDNoLock(smb_user_t *uidp)
1254 {
1255     uidp->refCount++;
1256 }
1257
1258 void smb_ReleaseUID(smb_user_t *uidp)
1259 {
1260     smb_user_t *up;
1261     smb_user_t **lupp;
1262     smb_username_t *unp = NULL;
1263
1264     lock_ObtainWrite(&smb_rctLock);
1265     osi_assertx(uidp->refCount-- > 0, "smb_user_t refCount 0");
1266     if (uidp->refCount == 0) {
1267         lupp = &uidp->vcp->usersp;
1268         for(up = *lupp; up; lupp = &up->nextp, up = *lupp) {
1269             if (up == uidp) 
1270                 break;
1271         }
1272         osi_assertx(up != NULL, "null smb_user_t");
1273         *lupp = up->nextp;
1274         lock_FinalizeMutex(&uidp->mx);
1275         unp = uidp->unp;
1276         smb_ReleaseVCNoLock(uidp->vcp);
1277         uidp->vcp = NULL;
1278         free(uidp);
1279     }           
1280     lock_ReleaseWrite(&smb_rctLock);
1281
1282     if (unp) {
1283         if (unp->userp)
1284             cm_ReleaseUserVCRef(unp->userp);
1285         smb_ReleaseUsername(unp);
1286     }
1287 }       
1288
1289 cm_user_t *smb_GetUserFromUID(smb_user_t *uidp)
1290 {
1291     cm_user_t *up = NULL;
1292
1293     if (!uidp)
1294         return NULL;
1295     
1296     lock_ObtainMutex(&uidp->mx);
1297     if (uidp->unp) {
1298         up = uidp->unp->userp;
1299         cm_HoldUser(up);
1300     }
1301     lock_ReleaseMutex(&uidp->mx);
1302
1303     return up;
1304 }
1305
1306
1307 /* retrieve a held reference to a user structure corresponding to an incoming
1308  * request.
1309  * corresponding release function is cm_ReleaseUser.
1310  */
1311 cm_user_t *smb_GetUserFromVCP(smb_vc_t *vcp, smb_packet_t *inp)
1312 {
1313     smb_user_t *uidp;
1314     cm_user_t *up = NULL;
1315     smb_t *smbp;
1316
1317     smbp = (smb_t *) inp;
1318     uidp = smb_FindUID(vcp, smbp->uid, 0);
1319     if (!uidp)
1320         return NULL;
1321     
1322     up = smb_GetUserFromUID(uidp);
1323
1324     smb_ReleaseUID(uidp);
1325     return up;
1326 }
1327
1328 /*
1329  * Return a pointer to a pathname extracted from a TID structure.  The
1330  * TID structure is not held; assume it won't go away.
1331  */
1332 long smb_LookupTIDPath(smb_vc_t *vcp, unsigned short tid, char ** treepath)
1333 {
1334     smb_tid_t *tidp;
1335     long code = 0;
1336
1337     tidp = smb_FindTID(vcp, tid, 0);
1338     if (!tidp) {
1339         *treepath = NULL;
1340     } else {
1341         if (tidp->flags & SMB_TIDFLAG_IPC) {
1342             code = CM_ERROR_TIDIPC;
1343             /* tidp->pathname would be NULL, but that's fine */
1344         }
1345         *treepath = tidp->pathname;
1346         smb_ReleaseTID(tidp, FALSE);
1347     }
1348     return code;
1349 }
1350
1351 /* check to see if we have a chained fid, that is, a fid that comes from an
1352  * OpenAndX message that ran earlier in this packet.  In this case, the fid
1353  * field in a read, for example, request, isn't set, since the value is
1354  * supposed to be inherited from the openAndX call.
1355  */
1356 int smb_ChainFID(int fid, smb_packet_t *inp)
1357 {
1358     if (inp->fid == 0 || inp->inCount == 0) 
1359         return fid;
1360     else 
1361         return inp->fid;
1362 }
1363
1364 /* are we a priv'd user?  What does this mean on NT? */
1365 int smb_SUser(cm_user_t *userp)
1366 {
1367     return 1;
1368 }
1369
1370 /* find a file ID.  If we pass in 0 we select an unused File ID.
1371  * If the SMB_FLAG_CREATE flag is set, we allocate a new  
1372  * smb_fid_t data structure if desired File ID cannot be found.
1373  */
1374 smb_fid_t *smb_FindFID(smb_vc_t *vcp, unsigned short fid, int flags)
1375 {
1376     smb_fid_t *fidp;
1377     int newFid = 0;
1378         
1379     if (fid == 0 && !(flags & SMB_FLAG_CREATE))
1380         return NULL;
1381
1382     lock_ObtainWrite(&smb_rctLock);
1383     /* figure out if we need to allocate a new file ID */
1384     if (fid == 0) {
1385         newFid = 1;
1386         fid = vcp->fidCounter;
1387     }
1388
1389   retry:
1390     for(fidp = vcp->fidsp; fidp; fidp = (smb_fid_t *) osi_QNext(&fidp->q)) {
1391         if (fidp->refCount == 0 && fidp->delete) {
1392             fidp->refCount++;
1393             lock_ReleaseWrite(&smb_rctLock);
1394             smb_ReleaseFID(fidp);
1395             lock_ObtainWrite(&smb_rctLock);
1396             goto retry;
1397         }
1398         if (fid == fidp->fid) {
1399             if (newFid) {
1400                 fid++;
1401                 if (fid == 0xFFFF) {
1402                     osi_Log1(smb_logp,
1403                              "New FID number wraps on vcp 0x%x", vcp);
1404                     fid = 1;
1405                 }
1406                 goto retry;
1407             }
1408             fidp->refCount++;
1409             break;
1410         }
1411     }
1412
1413     if (!fidp && (flags & SMB_FLAG_CREATE)) {
1414         char eventName[MAX_PATH];
1415         EVENT_HANDLE event;
1416         sprintf(eventName,"fid_t event vcp=%d fid=%d", vcp->vcID, fid);
1417         event = thrd_CreateEvent(NULL, FALSE, TRUE, eventName);
1418         if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
1419             osi_Log1(smb_logp, "Event Object Already Exists: %s", osi_LogSaveString(smb_logp, eventName));
1420             thrd_CloseHandle(event);
1421             fid++;
1422             if (fid == 0xFFFF) {
1423                 osi_Log1(smb_logp, "New FID wraps around for vcp 0x%x", vcp);
1424                 fid = 1;
1425             }
1426             goto retry;
1427         }
1428
1429         fidp = malloc(sizeof(*fidp));
1430         memset(fidp, 0, sizeof(*fidp));
1431         osi_QAdd((osi_queue_t **)&vcp->fidsp, &fidp->q);
1432         fidp->refCount = 1;
1433         fidp->vcp = vcp;
1434         smb_HoldVCNoLock(vcp);
1435         lock_InitializeMutex(&fidp->mx, "fid_t mutex");
1436         fidp->fid = fid;
1437         fidp->curr_chunk = fidp->prev_chunk = -2;
1438         fidp->raw_write_event = event;
1439         if (newFid) {
1440             vcp->fidCounter = fid+1;
1441             if (vcp->fidCounter == 0xFFFF) {
1442                 osi_Log1(smb_logp, "fidCounter wrapped around for vcp 0x%x",
1443                          vcp);
1444                 vcp->fidCounter = 1;
1445             }
1446         }
1447     }
1448
1449     lock_ReleaseWrite(&smb_rctLock);
1450     return fidp;
1451 }
1452
1453 smb_fid_t *smb_FindFIDByScache(smb_vc_t *vcp, cm_scache_t * scp)
1454 {
1455     smb_fid_t *fidp = NULL;
1456     int newFid = 0;
1457         
1458     if (!scp)
1459         return NULL;
1460
1461     lock_ObtainWrite(&smb_rctLock);
1462     for(fidp = vcp->fidsp; fidp; fidp = (smb_fid_t *) osi_QNext(&fidp->q)) {
1463         if (scp == fidp->scp) {
1464             fidp->refCount++;
1465             break;
1466         }
1467     }
1468     lock_ReleaseWrite(&smb_rctLock);
1469     return fidp;
1470 }
1471
1472 void smb_HoldFIDNoLock(smb_fid_t *fidp)
1473 {
1474     fidp->refCount++;
1475 }
1476
1477
1478 /* smb_ReleaseFID cannot be called while an cm_scache_t mutex lock is held */
1479 /* the sm_fid_t->mx and smb_rctLock must not be held */
1480 void smb_ReleaseFID(smb_fid_t *fidp)
1481 {
1482     cm_scache_t *scp = NULL;
1483     cm_user_t *userp = NULL;
1484     smb_vc_t *vcp = NULL;
1485     smb_ioctl_t *ioctlp;
1486
1487     lock_ObtainMutex(&fidp->mx);
1488     lock_ObtainWrite(&smb_rctLock);
1489     osi_assertx(fidp->refCount-- > 0, "smb_fid_t refCount 0");
1490     if (fidp->refCount == 0 && (fidp->delete)) {
1491         vcp = fidp->vcp;
1492         fidp->vcp = NULL;
1493         scp = fidp->scp;    /* release after lock is released */
1494         if (scp) {
1495             lock_ObtainWrite(&scp->rw);
1496             scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
1497             lock_ReleaseWrite(&scp->rw);
1498             osi_Log2(smb_logp,"smb_ReleaseFID fidp 0x%p scp 0x%p", fidp, scp);
1499             fidp->scp = NULL;
1500         }
1501         userp = fidp->userp;
1502         fidp->userp = NULL;
1503
1504         if (vcp->fidsp) 
1505             osi_QRemove((osi_queue_t **) &vcp->fidsp, &fidp->q);
1506         thrd_CloseHandle(fidp->raw_write_event);
1507
1508         /* and see if there is ioctl stuff to free */
1509         ioctlp = fidp->ioctlp;
1510         if (ioctlp) {
1511             if (ioctlp->prefix)
1512                 cm_FreeSpace(ioctlp->prefix);
1513             if (ioctlp->inAllocp)
1514                 free(ioctlp->inAllocp);
1515             if (ioctlp->outAllocp)
1516                 free(ioctlp->outAllocp);
1517             free(ioctlp);
1518         }       
1519         lock_ReleaseMutex(&fidp->mx);
1520         lock_FinalizeMutex(&fidp->mx);
1521         free(fidp);
1522
1523         if (vcp)
1524             smb_ReleaseVCNoLock(vcp);
1525     } else {
1526         lock_ReleaseMutex(&fidp->mx);
1527     }
1528     lock_ReleaseWrite(&smb_rctLock);
1529
1530     /* now release the scache structure */
1531     if (scp) 
1532         cm_ReleaseSCache(scp);
1533
1534     if (userp)
1535         cm_ReleaseUser(userp);
1536 }       
1537
1538 /*
1539  * Case-insensitive search for one string in another;
1540  * used to find variable names in submount pathnames.
1541  */
1542 static char *smb_stristr(char *str1, char *str2)
1543 {
1544     char *cursor;
1545
1546     for (cursor = str1; *cursor; cursor++)
1547         if (stricmp(cursor, str2) == 0)
1548             return cursor;
1549
1550     return NULL;
1551 }
1552
1553 /*
1554  * Substitute a variable value for its name in a submount pathname.  Variable
1555  * name has been identified by smb_stristr() and is in substr.  Variable name
1556  * length (plus one) is in substr_size.  Variable value is in newstr.
1557  */
1558 static void smb_subst(char *str1, char *substr, unsigned int substr_size,
1559                       char *newstr)
1560 {
1561     char temp[1024];
1562
1563     strcpy(temp, substr + substr_size - 1);
1564     strcpy(substr, newstr);
1565     strcat(str1, temp);
1566 }       
1567
1568 char VNUserName[] = "%USERNAME%";
1569 char VNLCUserName[] = "%LCUSERNAME%";
1570 char VNComputerName[] = "%COMPUTERNAME%";
1571 char VNLCComputerName[] = "%LCCOMPUTERNAME%";
1572
1573
1574 typedef struct smb_findShare_rock {
1575     char * shareName;
1576     char * match;
1577     int matchType;
1578 } smb_findShare_rock_t;
1579
1580 #define SMB_FINDSHARE_EXACT_MATCH 1
1581 #define SMB_FINDSHARE_PARTIAL_MATCH 2
1582
1583 long smb_FindShareProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp,
1584                        osi_hyper_t *offp)
1585 {
1586     int matchType = 0;
1587     smb_findShare_rock_t * vrock = (smb_findShare_rock_t *) rockp;
1588     if (!strnicmp(dep->name, vrock->shareName, 12)) {
1589         if(!stricmp(dep->name, vrock->shareName))
1590             matchType = SMB_FINDSHARE_EXACT_MATCH;
1591         else
1592             matchType = SMB_FINDSHARE_PARTIAL_MATCH;
1593         if(vrock->match) free(vrock->match);
1594         vrock->match = strdup(dep->name);
1595         vrock->matchType = matchType;
1596
1597         if(matchType == SMB_FINDSHARE_EXACT_MATCH)
1598             return CM_ERROR_STOPNOW;
1599     }
1600     return 0;
1601 }
1602
1603
1604 /* find a shareName in the table of submounts */
1605 int smb_FindShare(smb_vc_t *vcp, smb_user_t *uidp, char *shareName,
1606         char **pathNamep)
1607 {
1608     DWORD len;
1609     char pathName[1024];
1610     char *var;
1611     char temp[1024];
1612     DWORD sizeTemp;
1613     char *p, *q;
1614     HKEY parmKey;
1615     DWORD code;
1616     DWORD allSubmount = 1;
1617
1618     /* if allSubmounts == 0, only return the //mountRoot/all share 
1619      * if in fact it has been been created in the subMounts table.  
1620      * This is to allow sites that want to restrict access to the 
1621      * world to do so.
1622      */
1623     code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
1624                          0, KEY_QUERY_VALUE, &parmKey);
1625     if (code == ERROR_SUCCESS) {
1626         len = sizeof(allSubmount);
1627         code = RegQueryValueEx(parmKey, "AllSubmount", NULL, NULL,
1628                                 (BYTE *) &allSubmount, &len);
1629         if (code != ERROR_SUCCESS) {
1630             allSubmount = 1;
1631         }
1632         RegCloseKey (parmKey);
1633     }
1634
1635     if (allSubmount && _stricmp(shareName, "all") == 0) {
1636         *pathNamep = NULL;
1637         return 1;
1638     }
1639
1640     /* In case, the all share is disabled we need to still be able
1641      * to handle ioctl requests 
1642      */
1643     if (_stricmp(shareName, "ioctl$") == 0) {
1644         *pathNamep = strdup("/.__ioctl__");
1645         return 1;
1646     }
1647
1648     if (_stricmp(shareName, "IPC$") == 0 ||
1649         _stricmp(shareName, "srvsvc") == 0 ||
1650         _stricmp(shareName, "wkssvc") == 0 ||
1651         _stricmp(shareName, SMB_IOCTL_FILENAME_NOSLASH) == 0 ||
1652         _stricmp(shareName, "DESKTOP.INI") == 0
1653          ) {
1654         *pathNamep = NULL;
1655         return 0;
1656     }
1657
1658     /* Check for volume references
1659      * 
1660      * They look like <cell>{%,#}<volume>
1661      */
1662     if (strchr(shareName, '%') != NULL ||
1663         strchr(shareName, '#') != NULL) {
1664         char pathstr[CELL_MAXNAMELEN + VL_MAXNAMELEN + 1 + CM_PREFIX_VOL_CCH];
1665                                 /* make room for '/@vol:' + mountchar + NULL terminator*/
1666
1667         osi_Log1(smb_logp, "smb_FindShare found volume reference [%s]",
1668                  osi_LogSaveString(smb_logp, shareName));
1669
1670         snprintf(pathstr, sizeof(pathstr)/sizeof(char),
1671                  "/" CM_PREFIX_VOL "%s", shareName);
1672         pathstr[sizeof(pathstr)/sizeof(char) - 1] = '\0';
1673         len = (DWORD)(strlen(pathstr) + 1);
1674
1675         *pathNamep = malloc(len);
1676         if (*pathNamep) {
1677             strcpy(*pathNamep, pathstr);
1678             strlwr(*pathNamep);
1679             osi_Log1(smb_logp, "   returning pathname [%s]",
1680                      osi_LogSaveString(smb_logp, *pathNamep));
1681
1682             return 1;
1683         } else {
1684             return 0;
1685         }
1686     }
1687
1688     code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_OPENAFS_SUBKEY "\\Submounts",
1689                          0, KEY_QUERY_VALUE, &parmKey);
1690     if (code == ERROR_SUCCESS) {
1691         len = sizeof(pathName);
1692         code = RegQueryValueEx(parmKey, shareName, NULL, NULL,
1693                                 (BYTE *) pathName, &len);
1694         if (code != ERROR_SUCCESS)
1695             len = 0;
1696         RegCloseKey (parmKey);
1697     } else {
1698         len = 0;
1699     }   
1700     if (len != 0 && len != sizeof(pathName) - 1) {
1701         /* We can accept either unix or PC style AFS pathnames.  Convert
1702          * Unix-style to PC style here for internal use. 
1703          */
1704         p = pathName;
1705         if (strncmp(p, cm_mountRoot, strlen(cm_mountRoot)) == 0)
1706             p += strlen(cm_mountRoot);  /* skip mount path */
1707         q = p;
1708         while (*q) {
1709             if (*q == '/') *q = '\\';    /* change to \ */
1710             q++;
1711         }
1712
1713         while (1)
1714         {
1715             if (var = smb_stristr(p, VNUserName)) {
1716                 if (uidp && uidp->unp)
1717                     smb_subst(p, var, sizeof(VNUserName),uidp->unp->name);
1718                 else
1719                     smb_subst(p, var, sizeof(VNUserName)," ");
1720             }
1721             else if (var = smb_stristr(p, VNLCUserName)) 
1722             {
1723                 if (uidp && uidp->unp)
1724                     strcpy(temp, uidp->unp->name);
1725                 else 
1726                     strcpy(temp, " ");
1727                 _strlwr(temp);
1728                 smb_subst(p, var, sizeof(VNLCUserName), temp);
1729             }
1730             else if (var = smb_stristr(p, VNComputerName)) 
1731             {
1732                 sizeTemp = sizeof(temp);
1733                 GetComputerName((LPTSTR)temp, &sizeTemp);
1734                 smb_subst(p, var, sizeof(VNComputerName), temp);
1735             }
1736             else if (var = smb_stristr(p, VNLCComputerName)) 
1737             {
1738                 sizeTemp = sizeof(temp);
1739                 GetComputerName((LPTSTR)temp, &sizeTemp);
1740                 _strlwr(temp);
1741                 smb_subst(p, var, sizeof(VNLCComputerName), temp);
1742             }
1743             else     
1744                 break;
1745         }
1746         *pathNamep = strdup(p);
1747         return 1;
1748     } 
1749     else
1750     {
1751         /* First lookup shareName in root.afs */
1752         cm_req_t req;
1753         smb_findShare_rock_t vrock;
1754         osi_hyper_t thyper;
1755         char * p = shareName; 
1756         int rw = 0;
1757
1758         /*  attempt to locate a partial match in root.afs.  This is because
1759             when using the ANSI RAP calls, the share name is limited to 13 chars
1760             and hence is truncated. Of course we prefer exact matches. */
1761         cm_InitReq(&req);
1762         thyper.HighPart = 0;
1763         thyper.LowPart = 0;
1764
1765         vrock.shareName = shareName;
1766         vrock.match = NULL;
1767         vrock.matchType = 0;
1768
1769         cm_HoldSCache(cm_data.rootSCachep);
1770         code = cm_ApplyDir(cm_data.rootSCachep, smb_FindShareProc, &vrock, &thyper,
1771             (uidp? (uidp->unp ? uidp->unp->userp : NULL) : NULL), &req, NULL);
1772         cm_ReleaseSCache(cm_data.rootSCachep);
1773
1774         if (vrock.matchType) {
1775             sprintf(pathName,"/%s/",vrock.match);
1776             *pathNamep = strdup(strlwr(pathName));
1777             free(vrock.match);
1778             return 1;
1779         }
1780
1781         /* if we get here, there was no match for the share in root.afs */
1782         /* so try to create  \\<netbiosName>\<cellname>  */
1783         if ( *p == '.' ) {
1784             p++;
1785             rw = 1;
1786         }
1787         /* Get the full name for this cell */
1788         code = cm_SearchCellFile(p, temp, 0, 0);
1789 #ifdef AFS_AFSDB_ENV
1790         if (code && cm_dnsEnabled) {
1791             int ttl;
1792             code = cm_SearchCellByDNS(p, temp, &ttl, 0, 0);
1793         }
1794 #endif
1795         /* construct the path */
1796         if (code == 0) {     
1797             sprintf(pathName,rw ? "/.%s/" : "/%s/",temp);
1798             *pathNamep = strdup(strlwr(pathName));
1799             return 1;
1800         }
1801     }
1802     /* failure */
1803     *pathNamep = NULL;
1804     return 0;
1805 }
1806
1807 /* Client-side offline caching policy types */
1808 #define CSC_POLICY_MANUAL 0
1809 #define CSC_POLICY_DOCUMENTS 1
1810 #define CSC_POLICY_PROGRAMS 2
1811 #define CSC_POLICY_DISABLE 3
1812
1813 int smb_FindShareCSCPolicy(char *shareName)
1814 {
1815     DWORD len;
1816     char policy[1024];
1817     DWORD dwType;
1818     HKEY hkCSCPolicy;
1819     int  retval = CSC_POLICY_MANUAL;
1820
1821     RegCreateKeyEx( HKEY_LOCAL_MACHINE, 
1822                     AFSREG_CLT_OPENAFS_SUBKEY "\\CSCPolicy",
1823                     0, 
1824                     "AFS", 
1825                     REG_OPTION_NON_VOLATILE,
1826                     KEY_READ,
1827                     NULL, 
1828                     &hkCSCPolicy,
1829                     NULL );
1830
1831     len = sizeof(policy);
1832     if ( RegQueryValueEx( hkCSCPolicy, shareName, 0, &dwType, policy, &len ) ||
1833          len == 0) {
1834         retval = stricmp("all",shareName) ? CSC_POLICY_MANUAL : CSC_POLICY_DISABLE;
1835     }
1836     else if (stricmp(policy, "documents") == 0)
1837     {
1838         retval = CSC_POLICY_DOCUMENTS;
1839     }
1840     else if (stricmp(policy, "programs") == 0)
1841     {
1842         retval = CSC_POLICY_PROGRAMS;
1843     }
1844     else if (stricmp(policy, "disable") == 0)
1845     {
1846         retval = CSC_POLICY_DISABLE;
1847     }
1848         
1849     RegCloseKey(hkCSCPolicy);
1850     return retval;
1851 }
1852
1853 /* find a dir search structure by cookie value, and return it held.
1854  * Must be called with smb_globalLock held.
1855  */
1856 smb_dirSearch_t *smb_FindDirSearchNoLock(long cookie)
1857 {
1858     smb_dirSearch_t *dsp;
1859         
1860     for (dsp = smb_firstDirSearchp; dsp; dsp = (smb_dirSearch_t *) osi_QNext(&dsp->q)) {
1861         if (dsp->cookie == cookie) {
1862             if (dsp != smb_firstDirSearchp) {
1863                 /* move to head of LRU queue, too, if we're not already there */
1864                 if (smb_lastDirSearchp == (smb_dirSearch_t *) &dsp->q)
1865                     smb_lastDirSearchp = (smb_dirSearch_t *) osi_QPrev(&dsp->q);
1866                 osi_QRemove((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1867                 osi_QAdd((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1868                 if (!smb_lastDirSearchp)
1869                     smb_lastDirSearchp = (smb_dirSearch_t *) &dsp->q;
1870             }
1871             lock_ObtainMutex(&dsp->mx);
1872             dsp->refCount++;
1873             lock_ReleaseMutex(&dsp->mx);
1874             break;
1875         }
1876     }
1877
1878     if (dsp == NULL) {
1879         osi_Log1(smb_logp,"smb_FindDirSearch(%d) == NULL",cookie);
1880         for (dsp = smb_firstDirSearchp; dsp; dsp = (smb_dirSearch_t *) osi_QNext(&dsp->q)) {
1881             osi_Log1(smb_logp,"... valid id: %d", dsp->cookie);
1882         }
1883     }
1884     return dsp;
1885 }       
1886
1887 void smb_DeleteDirSearch(smb_dirSearch_t *dsp)
1888 {
1889     lock_ObtainWrite(&smb_globalLock);
1890     lock_ObtainMutex(&dsp->mx);
1891     osi_Log3(smb_logp,"smb_DeleteDirSearch cookie %d dsp 0x%p scp 0x%p", 
1892               dsp->cookie, dsp, dsp->scp);
1893     dsp->flags |= SMB_DIRSEARCH_DELETE;
1894     if (dsp->scp != NULL) {
1895         lock_ObtainWrite(&dsp->scp->rw);
1896         if (dsp->flags & SMB_DIRSEARCH_BULKST) {
1897             dsp->flags &= ~SMB_DIRSEARCH_BULKST;
1898             dsp->scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
1899             dsp->scp->bulkStatProgress = hzero;
1900         }       
1901         lock_ReleaseWrite(&dsp->scp->rw);
1902     }   
1903     lock_ReleaseMutex(&dsp->mx);
1904     lock_ReleaseWrite(&smb_globalLock);
1905 }               
1906
1907 /* Must be called with the smb_globalLock held */
1908 void smb_ReleaseDirSearchNoLock(smb_dirSearch_t *dsp)
1909 {
1910     cm_scache_t *scp = NULL;
1911
1912     lock_ObtainMutex(&dsp->mx);
1913     osi_assertx(dsp->refCount-- > 0, "cm_scache_t refCount 0");
1914     if (dsp->refCount == 0 && (dsp->flags & SMB_DIRSEARCH_DELETE)) {
1915         if (&dsp->q == (osi_queue_t *) smb_lastDirSearchp)
1916             smb_lastDirSearchp = (smb_dirSearch_t *) osi_QPrev(&smb_lastDirSearchp->q);
1917         osi_QRemove((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
1918         lock_ReleaseMutex(&dsp->mx);
1919         lock_FinalizeMutex(&dsp->mx);
1920         scp = dsp->scp;
1921         osi_Log3(smb_logp,"smb_ReleaseDirSearch cookie %d dsp 0x%p scp 0x%p", 
1922                  dsp->cookie, dsp, scp);
1923         free(dsp);
1924     } else {
1925         lock_ReleaseMutex(&dsp->mx);
1926     }
1927     /* do this now to avoid spurious locking hierarchy creation */
1928     if (scp) 
1929         cm_ReleaseSCache(scp);
1930 }       
1931
1932 void smb_ReleaseDirSearch(smb_dirSearch_t *dsp)
1933 {
1934     lock_ObtainWrite(&smb_globalLock);
1935     smb_ReleaseDirSearchNoLock(dsp);
1936     lock_ReleaseWrite(&smb_globalLock);
1937 }       
1938
1939 /* find a dir search structure by cookie value, and return it held */
1940 smb_dirSearch_t *smb_FindDirSearch(long cookie)
1941 {
1942     smb_dirSearch_t *dsp;
1943
1944     lock_ObtainWrite(&smb_globalLock);
1945     dsp = smb_FindDirSearchNoLock(cookie);
1946     lock_ReleaseWrite(&smb_globalLock);
1947     return dsp;
1948 }
1949
1950 /* GC some dir search entries, in the address space expected by the specific protocol.
1951  * Must be called with smb_globalLock held; release the lock temporarily.
1952  */
1953 #define SMB_DIRSEARCH_GCMAX     10      /* how many at once */
1954 void smb_GCDirSearches(int isV3)
1955 {
1956     smb_dirSearch_t *prevp;
1957     smb_dirSearch_t *tp;
1958     smb_dirSearch_t *victimsp[SMB_DIRSEARCH_GCMAX];
1959     int victimCount;
1960     int i;
1961         
1962     victimCount = 0;    /* how many have we got so far */
1963     for (tp = smb_lastDirSearchp; tp; tp=prevp) {
1964         /* we'll move tp from queue, so
1965          * do this early.
1966          */
1967         prevp = (smb_dirSearch_t *) osi_QPrev(&tp->q);  
1968         /* if no one is using this guy, and we're either in the new protocol,
1969          * or we're in the old one and this is a small enough ID to be useful
1970          * to the old protocol, GC this guy.
1971          */
1972         if (tp->refCount == 0 && (isV3 || tp->cookie <= 255)) {
1973             /* hold and delete */
1974             lock_ObtainMutex(&tp->mx);
1975             tp->flags |= SMB_DIRSEARCH_DELETE;
1976             lock_ReleaseMutex(&tp->mx);
1977             victimsp[victimCount++] = tp;
1978             tp->refCount++;
1979         }
1980
1981         /* don't do more than this */
1982         if (victimCount >= SMB_DIRSEARCH_GCMAX) 
1983             break;
1984     }
1985         
1986     /* now release them */
1987     for (i = 0; i < victimCount; i++) {
1988         smb_ReleaseDirSearchNoLock(victimsp[i]);
1989     }
1990 }
1991
1992 /* function for allocating a dir search entry.  We need these to remember enough context
1993  * since we don't get passed the path from call to call during a directory search.
1994  *
1995  * Returns a held dir search structure, and bumps the reference count on the vnode,
1996  * since it saves a pointer to the vnode.
1997  */
1998 smb_dirSearch_t *smb_NewDirSearch(int isV3)
1999 {
2000     smb_dirSearch_t *dsp;
2001     int counter;
2002     int maxAllowed;
2003     int start;
2004     int wrapped = 0;
2005
2006     lock_ObtainWrite(&smb_globalLock);
2007     counter = 0;
2008
2009     /* what's the biggest ID allowed in this version of the protocol */
2010     /* TODO: do we really want a non v3 dir search request to wrap
2011        smb_dirSearchCounter? */
2012     maxAllowed = isV3 ? 65535 : 255;
2013     if (smb_dirSearchCounter > maxAllowed)
2014         smb_dirSearchCounter = 1;
2015
2016     start = smb_dirSearchCounter;
2017
2018     while (1) {
2019         /* twice so we have enough tries to find guys we GC after one pass;
2020          * 10 extra is just in case I mis-counted.
2021          */
2022         if (++counter > 2*maxAllowed+10) 
2023             osi_panic("afsd: dir search cookie leak", __FILE__, __LINE__);
2024
2025         if (smb_dirSearchCounter > maxAllowed) {        
2026             smb_dirSearchCounter = 1;
2027         }
2028         if (smb_dirSearchCounter == start) {
2029             if (wrapped)
2030                 smb_GCDirSearches(isV3);
2031             wrapped++;
2032         }
2033         dsp = smb_FindDirSearchNoLock(smb_dirSearchCounter);
2034         if (dsp) {
2035             /* don't need to watch for refcount zero and deleted, since
2036             * we haven't dropped the global lock.
2037             */
2038             lock_ObtainMutex(&dsp->mx);
2039             dsp->refCount--;
2040             lock_ReleaseMutex(&dsp->mx);
2041             ++smb_dirSearchCounter;
2042             continue;
2043         }       
2044
2045         dsp = malloc(sizeof(*dsp));
2046         memset(dsp, 0, sizeof(*dsp));
2047         dsp->cookie = smb_dirSearchCounter;
2048         ++smb_dirSearchCounter;
2049         dsp->refCount = 1;
2050         lock_InitializeMutex(&dsp->mx, "cm_dirSearch_t");
2051         dsp->lastTime = osi_Time();
2052         osi_QAdd((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
2053         if (!smb_lastDirSearchp) 
2054             smb_lastDirSearchp = (smb_dirSearch_t *) &dsp->q;
2055     
2056         osi_Log2(smb_logp,"smb_NewDirSearch cookie %d dsp 0x%p", 
2057                  dsp->cookie, dsp);
2058         break;
2059     }   
2060     lock_ReleaseWrite(&smb_globalLock);
2061     return dsp;
2062 }
2063
2064 static smb_packet_t *GetPacket(void)
2065 {
2066     smb_packet_t *tbp;
2067
2068     lock_ObtainWrite(&smb_globalLock);
2069     tbp = smb_packetFreeListp;
2070     if (tbp) 
2071         smb_packetFreeListp = tbp->nextp;
2072     lock_ReleaseWrite(&smb_globalLock);
2073     if (!tbp) {
2074         tbp = calloc(sizeof(*tbp),1);
2075         tbp->magic = SMB_PACKETMAGIC;
2076         tbp->ncbp = NULL;
2077         tbp->vcp = NULL;
2078         tbp->resumeCode = 0;
2079         tbp->inCount = 0;
2080         tbp->fid = 0;
2081         tbp->wctp = NULL;
2082         tbp->inCom = 0;
2083         tbp->oddByte = 0;
2084         tbp->ncb_length = 0;
2085         tbp->flags = 0;
2086         tbp->spacep = NULL;
2087         tbp->stringsp = NULL;
2088     }
2089     osi_assertx(tbp->magic == SMB_PACKETMAGIC, "invalid smb_packet_t magic");
2090
2091     return tbp;
2092 }
2093
2094 smb_packet_t *smb_CopyPacket(smb_packet_t *pkt)
2095 {
2096     smb_packet_t *tbp;
2097     tbp = GetPacket();
2098     memcpy(tbp, pkt, sizeof(smb_packet_t));
2099     tbp->wctp = tbp->data + (unsigned int)(pkt->wctp - pkt->data);
2100     tbp->stringsp = NULL;
2101     if (tbp->vcp)
2102         smb_HoldVC(tbp->vcp);
2103     return tbp;
2104 }
2105
2106 static NCB *GetNCB(void)
2107 {
2108     smb_ncb_t *tbp;
2109     NCB *ncbp;
2110
2111     lock_ObtainWrite(&smb_globalLock);
2112     tbp = smb_ncbFreeListp;
2113     if (tbp) 
2114         smb_ncbFreeListp = tbp->nextp;
2115     lock_ReleaseWrite(&smb_globalLock);
2116     if (!tbp) {
2117         tbp = calloc(sizeof(*tbp),1);
2118         tbp->magic = SMB_NCBMAGIC;
2119     }
2120         
2121     osi_assertx(tbp->magic == SMB_NCBMAGIC, "invalid smb_packet_t magic");
2122
2123     memset(&tbp->ncb, 0, sizeof(NCB));
2124     ncbp = &tbp->ncb;
2125     return ncbp;
2126 }
2127
2128 static void FreeSMBStrings(smb_packet_t * pkt)
2129 {
2130     cm_space_t * s;
2131     cm_space_t * ns;
2132
2133     for (s = pkt->stringsp; s; s = ns) {
2134         ns = s->nextp;
2135         cm_FreeSpace(s);
2136     }
2137     pkt->stringsp = NULL;
2138 }
2139
2140 void smb_FreePacket(smb_packet_t *tbp)
2141 {
2142     smb_vc_t * vcp = NULL;
2143     osi_assertx(tbp->magic == SMB_PACKETMAGIC, "invalid smb_packet_t magic");
2144         
2145     lock_ObtainWrite(&smb_globalLock);
2146     tbp->nextp = smb_packetFreeListp;
2147     smb_packetFreeListp = tbp;
2148     tbp->magic = SMB_PACKETMAGIC;
2149     tbp->ncbp = NULL;
2150     vcp = tbp->vcp;
2151     tbp->vcp = NULL;
2152     tbp->resumeCode = 0;
2153     tbp->inCount = 0;
2154     tbp->fid = 0;
2155     tbp->wctp = NULL;
2156     tbp->inCom = 0;
2157     tbp->oddByte = 0;
2158     tbp->ncb_length = 0;
2159     tbp->flags = 0;
2160     FreeSMBStrings(tbp);
2161     lock_ReleaseWrite(&smb_globalLock);
2162
2163     if (vcp)
2164         smb_ReleaseVC(vcp);
2165 }
2166
2167 static void FreeNCB(NCB *bufferp)
2168 {
2169     smb_ncb_t *tbp;
2170         
2171     tbp = (smb_ncb_t *) bufferp;
2172     osi_assertx(tbp->magic == SMB_NCBMAGIC, "invalid smb_packet_t magic");
2173         
2174     lock_ObtainWrite(&smb_globalLock);
2175     tbp->nextp = smb_ncbFreeListp;
2176     smb_ncbFreeListp = tbp;
2177     lock_ReleaseWrite(&smb_globalLock);
2178 }
2179
2180 /* get a ptr to the data part of a packet, and its count */
2181 unsigned char *smb_GetSMBData(smb_packet_t *smbp, int *nbytesp)
2182 {
2183     int parmBytes;
2184     int dataBytes;
2185     unsigned char *afterParmsp;
2186
2187     parmBytes = *smbp->wctp << 1;
2188     afterParmsp = smbp->wctp + parmBytes + 1;
2189         
2190     dataBytes = afterParmsp[0] + (afterParmsp[1]<<8);
2191     if (nbytesp) *nbytesp = dataBytes;
2192         
2193     /* don't forget to skip the data byte count, since it follows
2194      * the parameters; that's where the "2" comes from below.
2195      */
2196     return (unsigned char *) (afterParmsp + 2);
2197 }
2198
2199 /* must set all the returned parameters before playing around with the
2200  * data region, since the data region is located past the end of the
2201  * variable number of parameters.
2202  */
2203 void smb_SetSMBDataLength(smb_packet_t *smbp, unsigned int dsize)
2204 {
2205     unsigned char *afterParmsp;
2206
2207     afterParmsp = smbp->wctp + ((*smbp->wctp)<<1) + 1;
2208         
2209     *afterParmsp++ = dsize & 0xff;
2210     *afterParmsp = (dsize>>8) & 0xff;
2211 }       
2212
2213 /* return the parm'th parameter in the smbp packet */
2214 unsigned short smb_GetSMBParm(smb_packet_t *smbp, int parm)
2215 {
2216     int parmCount;
2217     unsigned char *parmDatap;
2218
2219     parmCount = *smbp->wctp;
2220
2221     if (parm >= parmCount) {
2222         char s[100];
2223
2224         sprintf(s, "Bad SMB param %d out of %d, ncb len %d",
2225                 parm, parmCount, smbp->ncb_length);
2226         osi_Log3(smb_logp,"Bad SMB param %d out of %d, ncb len %d",
2227                  parm, parmCount, smbp->ncb_length);
2228         LogEvent(EVENTLOG_ERROR_TYPE, MSG_BAD_SMB_PARAM, 
2229                  __FILE__, __LINE__, parm, parmCount, smbp->ncb_length);
2230         osi_panic(s, __FILE__, __LINE__);
2231     }
2232     parmDatap = smbp->wctp + (2*parm) + 1;
2233         
2234     return parmDatap[0] + (parmDatap[1] << 8);
2235 }
2236
2237 /* return the parm'th parameter in the smbp packet */
2238 unsigned char smb_GetSMBParmByte(smb_packet_t *smbp, int parm)
2239 {
2240     int parmCount;
2241     unsigned char *parmDatap;
2242
2243     parmCount = *smbp->wctp;
2244
2245     if (parm >= parmCount) {
2246         char s[100];
2247
2248         sprintf(s, "Bad SMB param %d out of %d, ncb len %d",
2249                 parm, parmCount, smbp->ncb_length);
2250         osi_Log3(smb_logp,"Bad SMB param %d out of %d, ncb len %d",
2251                  parm, parmCount, smbp->ncb_length);
2252         LogEvent(EVENTLOG_ERROR_TYPE, MSG_BAD_SMB_PARAM, 
2253                  __FILE__, __LINE__, parm, parmCount, smbp->ncb_length);
2254         osi_panic(s, __FILE__, __LINE__);
2255     }
2256     parmDatap = smbp->wctp + (2*parm) + 1;
2257         
2258     return parmDatap[0];
2259 }
2260
2261 /* return the parm'th parameter in the smbp packet */
2262 unsigned int smb_GetSMBParmLong(smb_packet_t *smbp, int parm)
2263 {
2264     int parmCount;
2265     unsigned char *parmDatap;
2266
2267     parmCount = *smbp->wctp;
2268
2269     if (parm + 1 >= parmCount) {
2270         char s[100];
2271
2272         sprintf(s, "Bad SMB param %d out of %d, ncb len %d",
2273                 parm, parmCount, smbp->ncb_length);
2274         osi_Log3(smb_logp,"Bad SMB param %d out of %d, ncb len %d",
2275                  parm, parmCount, smbp->ncb_length);
2276         LogEvent(EVENTLOG_ERROR_TYPE, MSG_BAD_SMB_PARAM, 
2277                  __FILE__, __LINE__, parm, parmCount, smbp->ncb_length);
2278         osi_panic(s, __FILE__, __LINE__);
2279     }
2280     parmDatap = smbp->wctp + (2*parm) + 1;
2281         
2282     return parmDatap[0] + (parmDatap[1] << 8) + (parmDatap[2] << 16) + (parmDatap[3] << 24);
2283 }
2284
2285 /* return the parm'th parameter in the smbp packet */
2286 unsigned int smb_GetSMBOffsetParm(smb_packet_t *smbp, int parm, int offset)
2287 {
2288     int parmCount;
2289     unsigned char *parmDatap;
2290
2291     parmCount = *smbp->wctp;
2292
2293     if (parm * 2 + offset >= parmCount * 2) {
2294         char s[100];
2295
2296         sprintf(s, "Bad SMB param %d offset %d out of %d, ncb len %d",
2297                 parm, offset, parmCount, smbp->ncb_length);
2298         LogEvent(EVENTLOG_ERROR_TYPE, MSG_BAD_SMB_PARAM_WITH_OFFSET, 
2299                  __FILE__, __LINE__, parm, offset, parmCount, smbp->ncb_length);
2300         osi_Log4(smb_logp, "Bad SMB param %d offset %d out of %d, ncb len %d",
2301                 parm, offset, parmCount, smbp->ncb_length);
2302         osi_panic(s, __FILE__, __LINE__);
2303     }
2304     parmDatap = smbp->wctp + (2*parm) + 1 + offset;
2305         
2306     return parmDatap[0] + (parmDatap[1] << 8);
2307 }
2308
2309 void smb_SetSMBParm(smb_packet_t *smbp, int slot, unsigned int parmValue)
2310 {
2311     char *parmDatap;
2312
2313     /* make sure we have enough slots */
2314     if (*smbp->wctp <= slot) 
2315         *smbp->wctp = slot+1;
2316         
2317     parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
2318     *parmDatap++ = parmValue & 0xff;
2319     *parmDatap = (parmValue>>8) & 0xff;
2320 }       
2321
2322 void smb_SetSMBParmLong(smb_packet_t *smbp, int slot, unsigned int parmValue)
2323 {
2324     char *parmDatap;
2325
2326     /* make sure we have enough slots */
2327     if (*smbp->wctp <= slot) 
2328         *smbp->wctp = slot+2;
2329
2330     parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
2331     *parmDatap++ = parmValue & 0xff;
2332     *parmDatap++ = (parmValue>>8) & 0xff;
2333     *parmDatap++ = (parmValue>>16) & 0xff;
2334     *parmDatap   = (parmValue>>24) & 0xff;
2335 }
2336
2337 void smb_SetSMBParmDouble(smb_packet_t *smbp, int slot, char *parmValuep)
2338 {
2339     char *parmDatap;
2340     int i;
2341
2342     /* make sure we have enough slots */
2343     if (*smbp->wctp <= slot) 
2344         *smbp->wctp = slot+4;
2345
2346     parmDatap = smbp->wctp + 2*slot + 1 + smbp->oddByte;
2347     for (i=0; i<8; i++)
2348         *parmDatap++ = *parmValuep++;
2349 }       
2350
2351 void smb_SetSMBParmByte(smb_packet_t *smbp, int slot, unsigned int parmValue)
2352 {
2353     char *parmDatap;
2354
2355     /* make sure we have enough slots */
2356     if (*smbp->wctp <= slot) {
2357         if (smbp->oddByte) {
2358             smbp->oddByte = 0;
2359             *smbp->wctp = slot+1;
2360         } else
2361             smbp->oddByte = 1;
2362     }
2363
2364     parmDatap = smbp->wctp + 2*slot + 1 + (1 - smbp->oddByte);
2365     *parmDatap++ = parmValue & 0xff;
2366 }
2367
2368
2369
2370 void smb_StripLastComponent(char *outPathp, char **lastComponentp, char *inPathp)
2371 {
2372     char *lastSlashp;
2373         
2374     lastSlashp = strrchr(inPathp, '\\');
2375     if (lastComponentp)
2376         *lastComponentp = lastSlashp;
2377     if (lastSlashp) {
2378         while (1) {
2379             if (inPathp == lastSlashp) 
2380                 break;
2381             *outPathp++ = *inPathp++;
2382         }
2383         *outPathp++ = 0;
2384     }
2385     else {
2386         *outPathp++ = 0;
2387     }
2388 }
2389
2390 unsigned char *smb_ParseASCIIBlock(smb_packet_t * pktp, unsigned char *inp,
2391                                    char **chainpp, int flags)
2392 {
2393     size_t cb;
2394
2395     if (*inp++ != 0x4) 
2396         return NULL;
2397
2398 #ifdef SMB_UNICODE
2399     if (!WANTS_UNICODE(pktp))
2400         flags |= SMB_STRF_FORCEASCII;
2401 #endif
2402
2403     cb = sizeof(pktp->data) - (inp - pktp->data);
2404     if (inp < pktp->data || inp >= pktp->data + sizeof(pktp->data)) {
2405 #ifdef DEBUG_UNICODE
2406         DebugBreak();
2407 #endif
2408         cb = sizeof(pktp->data);
2409     }
2410     return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
2411 }
2412
2413 unsigned char *smb_ParseString(smb_packet_t * pktp, unsigned char * inp,
2414                                char ** chainpp, int flags)
2415 {
2416     size_t cb;
2417
2418 #ifdef SMB_UNICODE
2419     if (!WANTS_UNICODE(pktp))
2420         flags |= SMB_STRF_FORCEASCII;
2421 #endif
2422
2423     cb = sizeof(pktp->data) - (inp - pktp->data);
2424     if (inp < pktp->data || inp >= pktp->data + sizeof(pktp->data)) {
2425 #ifdef DEBUG_UNICODE
2426         DebugBreak();
2427 #endif
2428         cb = sizeof(pktp->data);
2429     }
2430     return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
2431 }
2432
2433 unsigned char *smb_ParseStringCb(smb_packet_t * pktp, unsigned char * inp,
2434                                  size_t cb, char ** chainpp, int flags)
2435 {
2436 #ifdef SMB_UNICODE
2437     if (!WANTS_UNICODE(pktp))
2438         flags |= SMB_STRF_FORCEASCII;
2439 #endif
2440
2441     return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
2442 }
2443
2444 unsigned char *smb_ParseStringCch(smb_packet_t * pktp, unsigned char * inp,
2445                                   size_t cch, char ** chainpp, int flags)
2446 {
2447     size_t cb = cch;
2448
2449 #ifdef SMB_UNICODE
2450     if (!WANTS_UNICODE(pktp))
2451         flags |= SMB_STRF_FORCEASCII;
2452     else
2453         cb = cch * sizeof(wchar_t);
2454 #endif
2455
2456     return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
2457 }
2458
2459 unsigned char *smb_ParseStringBuf(const unsigned char * bufbase,
2460                                   cm_space_t ** stringspp,
2461                                   unsigned char *inp, size_t *pcb_max,
2462                                   char **chainpp, int flags)
2463 {
2464 #ifdef SMB_UNICODE
2465     if (!(flags & SMB_STRF_FORCEASCII)) {
2466         size_t cch_src;
2467         int    cb_dest;
2468         cm_space_t * spacep;
2469         int    null_terms = 0;
2470
2471         if (bufbase && ((inp - bufbase) % 2) != 0) {
2472             inp++;              /* unicode strings are always word aligned */
2473         }
2474
2475         if (*pcb_max > 0) {
2476             if (FAILED(StringCchLengthW((const wchar_t *) inp, *pcb_max / sizeof(wchar_t),
2477                                         &cch_src))) {
2478                 cch_src = *pcb_max / sizeof(wchar_t);
2479                 *pcb_max = 0;
2480                 null_terms = 0;
2481             } else {
2482                 *pcb_max -= (cch_src + 1) * sizeof(wchar_t);
2483                 null_terms = 1;
2484             }
2485         } else {
2486             return NULL;
2487         }
2488
2489         spacep = cm_GetSpace();
2490         spacep->nextp = *stringspp;
2491         *stringspp = spacep;
2492
2493         if (cch_src == 0) {
2494             if (chainpp) {
2495                 *chainpp = inp + sizeof(wchar_t);
2496             }
2497
2498             spacep->data[0] = '\0';
2499             return spacep->data;
2500         }
2501
2502         cb_dest = cm_NormalizeUtf16StringToUtf8((const wchar_t *) inp, cch_src,
2503                                                 spacep->data, sizeof(spacep->data));
2504         if (cb_dest == 0) {
2505             *stringspp = spacep->nextp;
2506             cm_FreeSpace(spacep);
2507 #ifdef DEBUG_UNICODE
2508             DebugBreak();
2509 #endif
2510             return NULL;
2511         }
2512
2513         if (chainpp)
2514             *chainpp = inp + (cch_src + null_terms)*sizeof(wchar_t);
2515
2516         if (cb_dest == 0) {
2517 #ifdef DEBUG_UNICODE
2518             DebugBreak();
2519 #endif
2520         } else if (spacep->data[cb_dest - 1] != 0) {
2521             spacep->data[cb_dest++] = 0;
2522         }
2523
2524         return spacep->data;
2525
2526     } else {
2527 #endif
2528         /* Not using Unicode */
2529     if (chainpp) {
2530             *chainpp = inp + strlen(inp) + 1;
2531     }
2532         if ((flags & SMB_STRF_ANSIPATH) && smb_StoreAnsiFilenames)
2533             OemToChar(inp, inp);
2534     return inp;
2535 #ifdef SMB_UNICODE
2536     }
2537 #endif
2538 }
2539
2540 unsigned char * smb_UnparseString(smb_packet_t * pktp, unsigned char * outp,
2541                                   unsigned char * str,
2542                                   size_t * plen, int flags)
2543 {
2544     size_t buffersize;
2545     int align = 0;
2546
2547     if (outp == NULL) {
2548         /* we are only calculating the required size */
2549 #ifdef SMB_UNICODE
2550
2551         if (WANTS_UNICODE(pktp) && !(flags & SMB_STRF_FORCEASCII)) {
2552             int nchars;
2553
2554             nchars = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
2555                                          str, -1, NULL, 0);
2556             if (nchars == 0 && GetLastError() == ERROR_NO_UNICODE_TRANSLATION) {
2557
2558                 if ((flags & SMB_STRF_ANSIPATH) && smb_StoreAnsiFilenames)
2559                     nchars = MultiByteToWideChar(1252 /* ANSI - Latin1 */,
2560                                                  0, str, -1, NULL, 0);
2561                 else
2562                     nchars = MultiByteToWideChar(CP_OEMCP,
2563                                                  0, str, -1, NULL, 0);
2564             }
2565
2566             if (nchars == 0) {
2567                 osi_Log2(smb_logp, "UnparseString: Can't convert string to Unicode [%S], GLE=%d",
2568                          osi_LogSaveString(smb_logp, str),
2569                          GetLastError());
2570                 if (plen)
2571                     *plen = 0;
2572                 return NULL;
2573             }
2574
2575             if (plen)
2576                 *plen = sizeof(wchar_t) * ((flags & SMB_STRF_IGNORENULL)? nchars - 1 : nchars);
2577
2578             return (unsigned char *) 1; /* return TRUE if we are using unicode */
2579         }
2580         else
2581 #endif
2582         {
2583             /* Storing ANSI */
2584             size_t len;
2585
2586             len = strlen(str);
2587             if (plen)
2588                 *plen = ((flags & SMB_STRF_IGNORENULL)? len: len+1);
2589
2590             return NULL;
2591         }
2592     }
2593
2594     /* Number of bytes left in the buffer. */
2595     if (outp >= pktp->data && outp < pktp->data + sizeof(pktp->data)) {
2596         align = ((outp - pktp->data) % 2);
2597         buffersize = (pktp->data + sizeof(pktp->data)) - ((char *) outp);
2598     } else {
2599         align = (((size_t) outp) % 2);
2600         buffersize = sizeof(pktp->data);
2601     }
2602
2603 #ifdef SMB_UNICODE
2604
2605     if (WANTS_UNICODE(pktp) && !(flags & SMB_STRF_FORCEASCII)) {
2606         int nchars;
2607
2608         if (align)
2609             *outp++ = '\0';
2610
2611         if (*str == '\0') {
2612
2613             if (buffersize < sizeof(wchar_t))
2614                 return NULL;
2615
2616             *((wchar_t *) outp) = L'\0';
2617             if (plen && !(flags & SMB_STRF_IGNORENULL))
2618                 *plen += sizeof(wchar_t);
2619             return outp + sizeof(wchar_t);
2620         }
2621
2622         nchars = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
2623                                      str, -1, (wchar_t *) outp, buffersize);
2624         if (nchars == 0 && GetLastError() == ERROR_NO_UNICODE_TRANSLATION) {
2625
2626             /* If we failed to translate the string from UTF-8 to
2627                UTF-16, then chances are the string wasn't UTF-8 to
2628                begin with.  If StoreAnsiFileNames is set and this is
2629                possibly an ANSI file name, we try assuming that the
2630                source name is in ANSI.  otherwise we try OEM. */
2631
2632             if ((flags & SMB_STRF_ANSIPATH) && smb_StoreAnsiFilenames)
2633                 nchars = MultiByteToWideChar(1252 /* ANSI - Latin1 */,
2634                                              0, str, -1, (wchar_t *) outp, buffersize);
2635             else
2636                 nchars = MultiByteToWideChar(CP_OEMCP,
2637                                              0, str, -1, (wchar_t *) outp, buffersize);
2638         }
2639
2640         if (nchars == 0) {
2641             /* Both 1252 and OEM should translate to Unicode without a
2642                complaint.  This is something else. */
2643             osi_Log2(smb_logp, "UnparseString: Can't convert string to Unicode [%S], GLE=%d",
2644                      osi_LogSaveString(smb_logp, str),
2645                      GetLastError());
2646             return NULL;
2647         }
2648
2649         if (plen)
2650             *plen += sizeof(wchar_t) * ((flags & SMB_STRF_IGNORENULL)? nchars - 1: nchars);
2651
2652         return outp + sizeof(wchar_t) * nchars;
2653     }
2654     else
2655 #endif
2656     {
2657         /* Storing ANSI */
2658         size_t len;
2659
2660         len = strlen(str); len++;
2661         if (len > buffersize)
2662             return NULL;
2663
2664         strcpy(outp, str);
2665         if (plen)
2666             *plen += ((flags & SMB_STRF_IGNORENULL)? len - 1: len);
2667
2668         return outp + len;
2669     }
2670 }
2671
2672 unsigned char *smb_ParseVblBlock(unsigned char *inp, char **chainpp, int *lengthp)
2673 {
2674     int tlen;
2675
2676     if (*inp++ != 0x5) 
2677         return NULL;
2678     tlen = inp[0] + (inp[1]<<8);
2679     inp += 2;           /* skip length field */
2680
2681     if (chainpp) {
2682         *chainpp = inp + tlen;
2683     }
2684         
2685     if (lengthp) 
2686         *lengthp = tlen;
2687         
2688     return inp;
2689 }       
2690
2691 unsigned char *smb_ParseDataBlock(unsigned char *inp, char **chainpp, int *lengthp)
2692 {
2693     int tlen;
2694
2695     if (*inp++ != 0x1) return NULL;
2696     tlen = inp[0] + (inp[1]<<8);
2697     inp += 2;           /* skip length field */
2698         
2699     if (chainpp) {
2700         *chainpp = inp + tlen;
2701     }   
2702
2703     if (lengthp) *lengthp = tlen;
2704         
2705     return inp;
2706 }
2707
2708 /* format a packet as a response */
2709 void smb_FormatResponsePacket(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *op)
2710 {
2711     smb_t *outp;
2712     smb_t *inSmbp;
2713
2714     outp = (smb_t *) op;
2715         
2716     /* zero the basic structure through the smb_wct field, and zero the data
2717      * size field, assuming that wct stays zero; otherwise, you have to 
2718      * explicitly set the data size field, too.
2719      */
2720     inSmbp = (smb_t *) inp;
2721     memset(outp, 0, sizeof(smb_t)+2);
2722     outp->id[0] = 0xff;
2723     outp->id[1] = 'S';
2724     outp->id[2] = 'M';
2725     outp->id[3] = 'B';
2726     if (inp) {
2727         outp->com = inSmbp->com;
2728         outp->tid = inSmbp->tid;
2729         outp->pid = inSmbp->pid;
2730         outp->uid = inSmbp->uid;
2731         outp->mid = inSmbp->mid;
2732         outp->res[0] = inSmbp->res[0];
2733         outp->res[1] = inSmbp->res[1];
2734         op->inCom = inSmbp->com;
2735     }
2736     outp->reb = SMB_FLAGS_SERVER_TO_CLIENT;
2737 #ifdef SEND_CANONICAL_PATHNAMES
2738     outp->reb |= SMB_FLAGS_CANONICAL_PATHNAMES;
2739 #endif
2740     outp->flg2 = SMB_FLAGS2_KNOWS_LONG_NAMES;
2741 #ifdef SMB_UNICODE
2742     if ((vcp->flags & SMB_VCFLAG_USEUNICODE) == SMB_VCFLAG_USEUNICODE)
2743         outp->flg2 |= SMB_FLAGS2_UNICODE;
2744 #endif
2745
2746     /* copy fields in generic packet area */
2747     op->wctp = &outp->wct;
2748 }       
2749
2750 /* send a (probably response) packet; vcp tells us to whom to send it.
2751  * we compute the length by looking at wct and bcc fields.
2752  */
2753 void smb_SendPacket(smb_vc_t *vcp, smb_packet_t *inp)
2754 {
2755     NCB *ncbp;
2756     int extra;
2757     long code = 0;
2758     unsigned char *tp;
2759     int localNCB = 0;
2760         
2761     ncbp = inp->ncbp;
2762     if (ncbp == NULL) {
2763         ncbp = GetNCB();
2764         localNCB = 1;
2765     }
2766  
2767     memset((char *)ncbp, 0, sizeof(NCB));
2768
2769     extra = 2 * (*inp->wctp);   /* space used by parms, in bytes */
2770     tp = inp->wctp + 1+ extra;  /* points to count of data bytes */
2771     extra += tp[0] + (tp[1]<<8);
2772     extra += (unsigned int)(inp->wctp - inp->data);     /* distance to last wct field */
2773     extra += 3;                 /* wct and length fields */
2774         
2775     ncbp->ncb_length = extra;   /* bytes to send */
2776     ncbp->ncb_lsn = (unsigned char) vcp->lsn;   /* vc to use */
2777     ncbp->ncb_lana_num = vcp->lana;
2778     ncbp->ncb_command = NCBSEND;        /* op means send data */
2779     ncbp->ncb_buffer = (char *) inp;/* packet */
2780     code = Netbios(ncbp);
2781         
2782     if (code != 0) {
2783         const char * s = ncb_error_string(code);
2784         osi_Log2(smb_logp, "SendPacket failure code %d \"%s\"", code, s);
2785         LogEvent(EVENTLOG_WARNING_TYPE, MSG_SMB_SEND_PACKET_FAILURE, s);
2786
2787         lock_ObtainMutex(&vcp->mx);
2788         if (!(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
2789             osi_Log2(smb_logp, "marking dead vcp 0x%x, user struct 0x%x",
2790                       vcp, vcp->usersp);
2791             vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
2792             lock_ReleaseMutex(&vcp->mx);
2793             lock_ObtainWrite(&smb_globalLock);
2794             dead_sessions[vcp->session] = TRUE;
2795             lock_ReleaseWrite(&smb_globalLock);
2796             smb_CleanupDeadVC(vcp);
2797         } else {
2798             lock_ReleaseMutex(&vcp->mx);
2799         }
2800     }
2801
2802     if (localNCB)
2803         FreeNCB(ncbp);
2804 }
2805
2806 void smb_MapNTError(long code, unsigned long *NTStatusp)
2807 {
2808     unsigned long NTStatus;
2809
2810     /* map CM_ERROR_* errors to NT 32-bit status codes */
2811     /* NT Status codes are listed in ntstatus.h not winerror.h */
2812     if (code == CM_ERROR_NOSUCHCELL) {
2813         NTStatus = 0xC000000FL; /* No such file */
2814     }
2815     else if (code == CM_ERROR_NOSUCHVOLUME) {
2816         NTStatus = 0xC000000FL; /* No such file */
2817     }
2818     else if (code == CM_ERROR_TIMEDOUT) {
2819 #ifdef COMMENT
2820         NTStatus = 0xC00000CFL; /* Sharing Paused */
2821 #else
2822         NTStatus = 0x00000102L; /* Timeout */
2823 #endif
2824     }
2825     else if (code == CM_ERROR_RETRY) {
2826         NTStatus = 0xC000022DL; /* Retry */
2827     }
2828     else if (code == CM_ERROR_NOACCESS) {
2829         NTStatus = 0xC0000022L; /* Access denied */
2830     }
2831     else if (code == CM_ERROR_READONLY) {
2832         NTStatus = 0xC00000A2L; /* Write protected */
2833     }
2834     else if (code == CM_ERROR_NOSUCHFILE ||
2835              code == CM_ERROR_BPLUS_NOMATCH) {
2836         NTStatus = 0xC000000FL; /* No such file */
2837     }
2838     else if (code == CM_ERROR_NOSUCHPATH) {
2839         NTStatus = 0xC000003AL; /* Object path not found */
2840     }           
2841     else if (code == CM_ERROR_TOOBIG) {
2842         NTStatus = 0xC000007BL; /* Invalid image format */
2843     }
2844     else if (code == CM_ERROR_INVAL) {
2845         NTStatus = 0xC000000DL; /* Invalid parameter */
2846     }
2847     else if (code == CM_ERROR_BADFD) {
2848         NTStatus = 0xC0000008L; /* Invalid handle */
2849     }
2850     else if (code == CM_ERROR_BADFDOP) {
2851         NTStatus = 0xC0000022L; /* Access denied */
2852     }
2853     else if (code == CM_ERROR_EXISTS) {
2854         NTStatus = 0xC0000035L; /* Object name collision */
2855     }
2856     else if (code == CM_ERROR_NOTEMPTY) {
2857         NTStatus = 0xC0000101L; /* Directory not empty */
2858     }   
2859     else if (code == CM_ERROR_CROSSDEVLINK) {
2860         NTStatus = 0xC00000D4L; /* Not same device */
2861     }
2862     else if (code == CM_ERROR_NOTDIR) {
2863         NTStatus = 0xC0000103L; /* Not a directory */
2864     }
2865     else if (code == CM_ERROR_ISDIR) {
2866         NTStatus = 0xC00000BAL; /* File is a directory */
2867     }
2868     else if (code == CM_ERROR_BADOP) {
2869 #ifdef COMMENT
2870         /* I have no idea where this comes from */
2871         NTStatus = 0xC09820FFL; /* SMB no support */
2872 #else
2873         NTStatus = 0xC00000BBL;     /* Not supported */
2874 #endif /* COMMENT */
2875     }
2876     else if (code == CM_ERROR_BADSHARENAME) {
2877         NTStatus = 0xC00000CCL; /* Bad network name */
2878     }
2879     else if (code == CM_ERROR_NOIPC) {
2880 #ifdef COMMENT
2881         NTStatus = 0xC0000022L; /* Access Denied */
2882 #else   
2883         NTStatus = 0xC000013DL; /* Remote Resources */
2884 #endif
2885     }
2886     else if (code == CM_ERROR_CLOCKSKEW) {
2887         NTStatus = 0xC0000133L; /* Time difference at DC */
2888     }
2889     else if (code == CM_ERROR_BADTID) {
2890         NTStatus = 0xC0982005L; /* SMB bad TID */
2891     }
2892     else if (code == CM_ERROR_USESTD) {
2893         NTStatus = 0xC09820FBL; /* SMB use standard */
2894     }
2895     else if (code == CM_ERROR_QUOTA) {
2896         NTStatus = 0xC0000044L; /* Quota exceeded */
2897     }
2898     else if (code == CM_ERROR_SPACE) {
2899         NTStatus = 0xC000007FL; /* Disk full */
2900     }
2901     else if (code == CM_ERROR_ATSYS) {
2902         NTStatus = 0xC0000033L; /* Object name invalid */
2903     }
2904     else if (code == CM_ERROR_BADNTFILENAME) {
2905         NTStatus = 0xC0000033L; /* Object name invalid */
2906     }
2907     else if (code == CM_ERROR_WOULDBLOCK) {
2908         NTStatus = 0xC0000055L; /* Lock not granted */
2909     }
2910     else if (code == CM_ERROR_SHARING_VIOLATION) {
2911         NTStatus = 0xC0000043L; /* Sharing violation */
2912     }
2913     else if (code == CM_ERROR_LOCK_CONFLICT) {
2914         NTStatus = 0xC0000054L; /* Lock conflict */
2915     }
2916     else if (code == CM_ERROR_PARTIALWRITE) {
2917         NTStatus = 0xC000007FL; /* Disk full */
2918     }
2919     else if (code == CM_ERROR_BUFFERTOOSMALL) {
2920         NTStatus = 0xC0000023L; /* Buffer too small */
2921     }
2922     else if (code == CM_ERROR_AMBIGUOUS_FILENAME) {
2923         NTStatus = 0xC0000035L; /* Object name collision */
2924     }   
2925     else if (code == CM_ERROR_BADPASSWORD) {
2926         NTStatus = 0xC000006DL; /* unknown username or bad password */
2927     }
2928     else if (code == CM_ERROR_BADLOGONTYPE) {
2929         NTStatus = 0xC000015BL; /* logon type not granted */
2930     }
2931     else if (code == CM_ERROR_GSSCONTINUE) {
2932         NTStatus = 0xC0000016L; /* more processing required */
2933     }
2934     else if (code == CM_ERROR_TOO_MANY_SYMLINKS) {
2935 #ifdef COMMENT
2936         NTStatus = 0xC0000280L; /* reparse point not resolved */
2937 #else
2938         NTStatus = 0xC0000022L; /* Access Denied */
2939 #endif
2940     }
2941     else if (code == CM_ERROR_PATH_NOT_COVERED) {
2942         NTStatus = 0xC0000257L; /* Path Not Covered */
2943     } 
2944     else if (code == CM_ERROR_ALLBUSY) {
2945         NTStatus = 0xC000022DL; /* Retry */
2946     } 
2947     else if (code == CM_ERROR_ALLOFFLINE || code == CM_ERROR_ALLDOWN) {
2948         NTStatus = 0xC00000BEL; /* Bad Network Path */
2949     } 
2950     else if (code >= ERROR_TABLE_BASE_RXK && code < ERROR_TABLE_BASE_RXK + 256) {
2951         NTStatus = 0xC0000322L; /* No Kerberos key */
2952     } 
2953     else if (code == CM_ERROR_BAD_LEVEL) {
2954         NTStatus = 0xC0000148L; /* Invalid Level */
2955     } 
2956     else if (code == CM_ERROR_RANGE_NOT_LOCKED) {
2957         NTStatus = 0xC000007EL; /* Range Not Locked */
2958     } 
2959     else if (code == CM_ERROR_NOSUCHDEVICE) {
2960         NTStatus = 0xC000000EL; /* No Such Device */
2961     }
2962     else if (code == CM_ERROR_LOCK_NOT_GRANTED) {
2963         NTStatus = 0xC0000055L; /* Lock Not Granted */
2964     } else {
2965         NTStatus = 0xC0982001L; /* SMB non-specific error */
2966     }
2967
2968     *NTStatusp = NTStatus;
2969     osi_Log2(smb_logp, "SMB SEND code %lX as NT %lX", code, NTStatus);
2970 }       
2971
2972 void smb_MapCoreError(long code, smb_vc_t *vcp, unsigned short *scodep,
2973                       unsigned char *classp)
2974 {
2975     unsigned char class;
2976     unsigned short error;
2977
2978     /* map CM_ERROR_* errors to SMB errors */
2979     if (code == CM_ERROR_NOSUCHCELL) {
2980         class = 1;
2981         error = 3;      /* bad path */
2982     }
2983     else if (code == CM_ERROR_NOSUCHVOLUME) {
2984         class = 1;
2985         error = 3;      /* bad path */
2986     }
2987     else if (code == CM_ERROR_TIMEDOUT) {
2988         class = 2;
2989         error = 81;     /* server is paused */
2990     }
2991     else if (code == CM_ERROR_RETRY) {
2992         class = 2;      /* shouldn't happen */
2993         error = 1;
2994     }
2995     else if (code == CM_ERROR_NOACCESS) {
2996         class = 2;
2997         error = 4;      /* bad access */
2998     }
2999     else if (code == CM_ERROR_READONLY) {
3000         class = 3;
3001         error = 19;     /* read only */
3002     }
3003     else if (code == CM_ERROR_NOSUCHFILE ||
3004              code == CM_ERROR_BPLUS_NOMATCH) {
3005         class = 1;
3006         error = 2;      /* ENOENT! */
3007     }
3008     else if (code == CM_ERROR_NOSUCHPATH) {
3009         class = 1;
3010         error = 3;      /* Bad path */
3011     }
3012     else if (code == CM_ERROR_TOOBIG) {
3013         class = 1;
3014         error = 11;     /* bad format */
3015     }
3016     else if (code == CM_ERROR_INVAL) {
3017         class = 2;      /* server non-specific error code */
3018         error = 1;
3019     }
3020     else if (code == CM_ERROR_BADFD) {
3021         class = 1;
3022         error = 6;      /* invalid file handle */
3023     }
3024     else if (code == CM_ERROR_BADFDOP) {
3025         class = 1;      /* invalid op on FD */
3026         error = 5;
3027     }
3028     else if (code == CM_ERROR_EXISTS) {
3029         class = 1;
3030         error = 80;     /* file already exists */
3031     }
3032     else if (code == CM_ERROR_NOTEMPTY) {
3033         class = 1;
3034         error = 5;      /* delete directory not empty */
3035     }
3036     else if (code == CM_ERROR_CROSSDEVLINK) {
3037         class = 1;
3038         error = 17;     /* EXDEV */
3039     }
3040     else if (code == CM_ERROR_NOTDIR) {
3041         class = 1;      /* bad path */
3042         error = 3;
3043     }
3044     else if (code == CM_ERROR_ISDIR) {
3045         class = 1;      /* access denied; DOS doesn't have a good match */
3046         error = 5;
3047     }       
3048     else if (code == CM_ERROR_BADOP) {
3049         class = 2;
3050         error = 65535;
3051     }
3052     else if (code == CM_ERROR_BADSHARENAME) {
3053         class = 2;
3054         error = 6;
3055     }
3056     else if (code == CM_ERROR_NOIPC) {
3057         class = 2;
3058         error = 4; /* bad access */
3059     }
3060     else if (code == CM_ERROR_CLOCKSKEW) {
3061         class = 1;      /* invalid function */
3062         error = 1;
3063     }
3064     else if (code == CM_ERROR_BADTID) {
3065         class = 2;
3066         error = 5;
3067     }
3068     else if (code == CM_ERROR_USESTD) {
3069         class = 2;
3070         error = 251;
3071     }
3072     else if (code == CM_ERROR_REMOTECONN) {
3073         class = 2;
3074         error = 82;
3075     }
3076     else if (code == CM_ERROR_QUOTA) {
3077         if (vcp->flags & SMB_VCFLAG_USEV3) {
3078             class = 3;
3079             error = 39; /* disk full */
3080         }
3081         else {
3082             class = 1;
3083             error = 5;  /* access denied */
3084         }
3085     }
3086     else if (code == CM_ERROR_SPACE) {
3087         if (vcp->flags & SMB_VCFLAG_USEV3) {
3088             class = 3;
3089             error = 39; /* disk full */
3090         }
3091         else {
3092             class = 1;
3093             error = 5;  /* access denied */
3094         }
3095     }
3096     else if (code == CM_ERROR_PARTIALWRITE) {
3097         class = 3;
3098         error = 39;     /* disk full */
3099     }
3100     else if (code == CM_ERROR_ATSYS) {
3101         class = 1;
3102         error = 2;      /* ENOENT */
3103     }
3104     else if (code == CM_ERROR_WOULDBLOCK) {
3105         class = 1;
3106         error = 33;     /* lock conflict */
3107     }
3108     else if (code == CM_ERROR_LOCK_CONFLICT) {
3109         class = 1;
3110         error = 33;     /* lock conflict */
3111     }
3112     else if (code == CM_ERROR_SHARING_VIOLATION) {
3113         class = 1;
3114         error = 33;     /* lock conflict */
3115     }
3116     else if (code == CM_ERROR_NOFILES) {
3117         class = 1;
3118         error = 18;     /* no files in search */
3119     }
3120     else if (code == CM_ERROR_RENAME_IDENTICAL) {
3121         class = 1;
3122         error = 183;     /* Samba uses this */
3123     }
3124     else if (code == CM_ERROR_BADPASSWORD || code == CM_ERROR_BADLOGONTYPE) {
3125         /* we don't have a good way of reporting CM_ERROR_BADLOGONTYPE */
3126         class = 2;
3127         error = 2; /* bad password */
3128     }
3129     else if (code == CM_ERROR_PATH_NOT_COVERED) {
3130         class = 2;
3131         error = 3;     /* bad path */
3132     }
3133     else {
3134         class = 2;
3135         error = 1;
3136     }
3137
3138     *scodep = error;
3139     *classp = class;
3140     osi_Log3(smb_logp, "SMB SEND code %lX as SMB %d: %d", code, class, error);
3141 }       
3142
3143 long smb_SendCoreBadOp(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3144 {
3145     osi_Log0(smb_logp,"SendCoreBadOp - NOT_SUPPORTED");
3146     return CM_ERROR_BADOP;
3147 }
3148
3149 /* SMB_COM_ECHO */
3150 long smb_ReceiveCoreEcho(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3151 {
3152     unsigned short EchoCount, i;
3153     char *data, *outdata;
3154     int dataSize;
3155
3156     EchoCount = (unsigned short) smb_GetSMBParm(inp, 0);
3157
3158     for (i=1; i<=EchoCount; i++) {
3159         data = smb_GetSMBData(inp, &dataSize);
3160         smb_SetSMBParm(outp, 0, i);
3161         smb_SetSMBDataLength(outp, dataSize);
3162         outdata = smb_GetSMBData(outp, NULL);
3163         memcpy(outdata, data, dataSize);
3164         smb_SendPacket(vcp, outp);
3165     }
3166
3167     return 0;
3168 }
3169
3170 /* SMB_COM_READ_RAW */
3171 long smb_ReceiveCoreReadRaw(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3172 {
3173     osi_hyper_t offset;
3174     long count, minCount, finalCount;
3175     unsigned short fd;
3176     unsigned pid;
3177     smb_fid_t *fidp;
3178     smb_t *smbp = (smb_t*) inp;
3179     long code = 0;
3180     cm_user_t *userp = NULL;
3181     NCB *ncbp;
3182     int rc;
3183     char *rawBuf = NULL;
3184
3185     rawBuf = NULL;
3186     finalCount = 0;
3187
3188     fd = smb_GetSMBParm(inp, 0);
3189     count = smb_GetSMBParm(inp, 3);
3190     minCount = smb_GetSMBParm(inp, 4);
3191     offset.LowPart = smb_GetSMBParm(inp, 1) | (smb_GetSMBParm(inp, 2) << 16);
3192
3193     if (*inp->wctp == 10) {
3194         /* we were sent a request with 64-bit file offsets */
3195 #ifdef AFS_LARGEFILES
3196         offset.HighPart = smb_GetSMBParm(inp, 8) | (smb_GetSMBParm(inp, 9) << 16);
3197
3198         if (LargeIntegerLessThanZero(offset)) {
3199             osi_Log0(smb_logp, "smb_ReceiveCoreReadRaw received negative 64-bit offset");
3200             goto send1;
3201         }
3202 #else
3203         if ((smb_GetSMBParm(inp, 8) | (smb_GetSMBParm(inp, 9) << 16)) != 0) {
3204             osi_Log0(smb_logp, "smb_ReceiveCoreReadRaw received 64-bit file offset.  Dropping request.");
3205             goto send1;
3206         } else {
3207             offset.HighPart = 0;
3208         }
3209 #endif
3210     } else {
3211         /* we were sent a request with 32-bit file offsets */
3212         offset.HighPart = 0;
3213     }
3214
3215     osi_Log4(smb_logp, "smb_ReceieveCoreReadRaw fd %d, off 0x%x:%08x, size 0x%x",
3216              fd, offset.HighPart, offset.LowPart, count);
3217
3218     fidp = smb_FindFID(vcp, fd, 0);
3219     if (!fidp)
3220         goto send1;
3221
3222     if (fidp->scp && (fidp->scp->flags & CM_SCACHEFLAG_DELETED)) {
3223         smb_CloseFID(vcp, fidp, NULL, 0);
3224         code = CM_ERROR_NOSUCHFILE;
3225         goto send1a;
3226     }
3227
3228
3229     pid = smbp->pid;
3230     {
3231         LARGE_INTEGER LOffset, LLength;
3232         cm_key_t key;
3233
3234         key = cm_GenerateKey(vcp->vcID, pid, fd);
3235
3236         LOffset.HighPart = offset.HighPart;
3237         LOffset.LowPart = offset.LowPart;
3238         LLength.HighPart = 0;
3239         LLength.LowPart = count;
3240
3241         lock_ObtainWrite(&fidp->scp->rw);
3242         code = cm_LockCheckRead(fidp->scp, LOffset, LLength, key);
3243         lock_ReleaseWrite(&fidp->scp->rw);
3244     }    
3245     if (code) {
3246         goto send1a;
3247     }
3248
3249     lock_ObtainMutex(&smb_RawBufLock);
3250     if (smb_RawBufs) {
3251         /* Get a raw buf, from head of list */
3252         rawBuf = smb_RawBufs;
3253         smb_RawBufs = *(char **)smb_RawBufs;
3254     }
3255     lock_ReleaseMutex(&smb_RawBufLock);
3256     if (!rawBuf)
3257         goto send1a;
3258
3259     lock_ObtainMutex(&fidp->mx);
3260     if (fidp->flags & SMB_FID_IOCTL)
3261     {
3262         lock_ReleaseMutex(&fidp->mx);
3263         rc = smb_IoctlReadRaw(fidp, vcp, inp, outp);
3264         if (rawBuf) {
3265             /* Give back raw buffer */
3266             lock_ObtainMutex(&smb_RawBufLock);
3267             *((char **) rawBuf) = smb_RawBufs;
3268             
3269             smb_RawBufs = rawBuf;
3270             lock_ReleaseMutex(&smb_RawBufLock);
3271         }
3272
3273         lock_ReleaseMutex(&fidp->mx);
3274         smb_ReleaseFID(fidp);
3275         return rc;
3276     }
3277     lock_ReleaseMutex(&fidp->mx);
3278
3279     userp = smb_GetUserFromVCP(vcp, inp);
3280
3281     code = smb_ReadData(fidp, &offset, count, rawBuf, userp, &finalCount);
3282
3283     if (code != 0)
3284         goto send;
3285
3286   send:
3287     cm_ReleaseUser(userp);
3288
3289   send1a:
3290     smb_ReleaseFID(fidp);
3291
3292   send1:
3293     ncbp = outp->ncbp;
3294     memset((char *)ncbp, 0, sizeof(NCB));
3295
3296     ncbp->ncb_length = (unsigned short) finalCount;
3297     ncbp->ncb_lsn = (unsigned char) vcp->lsn;
3298     ncbp->ncb_lana_num = vcp->lana;
3299     ncbp->ncb_command = NCBSEND;
3300     ncbp->ncb_buffer = rawBuf;
3301
3302     code = Netbios(ncbp);
3303     if (code != 0)
3304         osi_Log1(smb_logp, "ReadRaw send failure code %d", code);
3305
3306     if (rawBuf) {
3307         /* Give back raw buffer */
3308         lock_ObtainMutex(&smb_RawBufLock);
3309         *((char **) rawBuf) = smb_RawBufs;
3310
3311         smb_RawBufs = rawBuf;
3312         lock_ReleaseMutex(&smb_RawBufLock);
3313     }
3314
3315     return 0;
3316 }
3317
3318 long smb_ReceiveCoreLockRecord(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3319 {
3320     osi_Log1(smb_logp, "SMB receive core lock record (not implemented); %d + 1 ongoing ops",
3321                          ongoingOps - 1);
3322     return 0;
3323 }
3324
3325 long smb_ReceiveCoreUnlockRecord(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3326 {
3327     osi_Log1(smb_logp, "SMB receive core unlock record (not implemented); %d + 1 ongoing ops",
3328                          ongoingOps - 1);
3329     return 0;
3330 }
3331
3332 /* SMB_COM_NEGOTIATE */
3333 long smb_ReceiveNegotiate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
3334 {
3335     char *namep;
3336     char *datap;
3337     int coreProtoIndex;
3338     int v3ProtoIndex;
3339     int NTProtoIndex;
3340     int VistaProtoIndex;
3341     int protoIndex;                             /* index we're using */
3342     int namex;
3343     int dbytes;
3344     int entryLength;
3345     int tcounter;
3346     char protocol_array[10][1024];  /* protocol signature of the client */
3347     int caps;                       /* capabilities */
3348     time_t unixTime;
3349     afs_uint32 dosTime;
3350     TIME_ZONE_INFORMATION tzi;
3351
3352     osi_Log1(smb_logp, "SMB receive negotiate; %d + 1 ongoing ops",
3353                          ongoingOps - 1);
3354
3355     namep = smb_GetSMBData(inp, &dbytes);
3356     namex = 0;
3357     tcounter = 0;
3358     coreProtoIndex = -1;                /* not found */
3359     v3ProtoIndex = -1;
3360     NTProtoIndex = -1;
3361     VistaProtoIndex = -1;
3362     while(namex < dbytes) {
3363         osi_Log1(smb_logp, "Protocol %s",
3364                   osi_LogSaveString(smb_logp, namep+1));
3365         strcpy(protocol_array[tcounter], namep+1);
3366
3367         /* namep points at the first protocol, or really, a 0x02
3368          * byte preceding the null-terminated ASCII name.
3369          */
3370         if (strcmp("PC NETWORK PROGRAM 1.0", namep+1) == 0) {
3371             coreProtoIndex = tcounter;
3372         }       
3373         else if (smb_useV3 && strcmp("LM1.2X002", namep+1) == 0) {
3374             v3ProtoIndex = tcounter;
3375         }
3376         else if (smb_useV3 && strcmp("NT LM 0.12", namep+1) == 0) {
3377             NTProtoIndex = tcounter;
3378         }
3379         else if (smb_useV3 && strcmp("SMB 2.001", namep+1) == 0) {
3380             VistaProtoIndex = tcounter;
3381         }
3382
3383         /* compute size of protocol entry */
3384         entryLength = (int)strlen(namep+1);
3385         entryLength += 2;       /* 0x02 bytes and null termination */
3386
3387         /* advance over this protocol entry */
3388         namex += entryLength;
3389         namep += entryLength;
3390         tcounter++;             /* which proto entry we're looking at */
3391     }
3392
3393     lock_ObtainMutex(&vcp->mx);
3394 #if 0
3395     if (VistaProtoIndex != -1) {
3396         protoIndex = VistaProtoIndex;
3397         vcp->flags |= (SMB_VCFLAG_USENT | SMB_VCFLAG_USEV3);
3398     } else 
3399 #endif  
3400         if (NTProtoIndex != -1) {
3401         protoIndex = NTProtoIndex;
3402         vcp->flags |= (SMB_VCFLAG_USENT | SMB_VCFLAG_USEV3);
3403     }
3404     else if (v3ProtoIndex != -1) {
3405         protoIndex = v3ProtoIndex;
3406         vcp->flags |= SMB_VCFLAG_USEV3;
3407     }   
3408     else if (coreProtoIndex != -1) {
3409         protoIndex = coreProtoIndex;
3410         vcp->flags |= SMB_VCFLAG_USECORE;
3411     }   
3412     else protoIndex = -1;
3413     lock_ReleaseMutex(&vcp->mx);
3414
3415     if (protoIndex == -1)
3416         return CM_ERROR_INVAL;
3417     else if (VistaProtoIndex != 1 || NTProtoIndex != -1) {
3418         smb_SetSMBParm(outp, 0, protoIndex);
3419         if (smb_authType != SMB_AUTH_NONE) {
3420             smb_SetSMBParmByte(outp, 1,
3421                                NEGOTIATE_SECURITY_USER_LEVEL |
3422                                NEGOTIATE_SECURITY_CHALLENGE_RESPONSE);  /* user level security, challenge response */
3423         } else {
3424             smb_SetSMBParmByte(outp, 1, 0); /* share level auth with plaintext password. */
3425         }
3426         smb_SetSMBParm(outp, 1, smb_maxMpxRequests);    /* max multiplexed requests */
3427         smb_SetSMBParm(outp, 2, smb_maxVCPerServer);    /* max VCs per consumer/server connection */
3428         smb_SetSMBParmLong(outp, 3, SMB_PACKETSIZE);    /* xmit buffer size */
3429         smb_SetSMBParmLong(outp, 5, SMB_MAXRAWSIZE);    /* raw buffer size */
3430         /* The session key is not a well documented field however most clients
3431          * will echo back the session key to the server.  Currently we are using
3432          * the same value for all sessions.  We should generate a random value
3433          * and store it into the vcp 
3434          */
3435         smb_SetSMBParm(outp, 7, 1);     /* next 2: session key */
3436         smb_SetSMBParm(outp, 8, 1);
3437         /* 
3438          * Tried changing the capabilities to support for W2K - defect 117695
3439          * Maybe something else needs to be changed here?
3440          */
3441         /*
3442         if (isWindows2000) 
3443         smb_SetSMBParmLong(outp, 9, 0x43fd);
3444         else 
3445         smb_SetSMBParmLong(outp, 9, 0x251);
3446         */
3447         /* Capabilities: *
3448          * 32-bit error codes *
3449          * and NT Find *
3450          * and NT SMB's *
3451          * and raw mode 
3452          * and DFS
3453          * and Unicode */
3454         caps = NTNEGOTIATE_CAPABILITY_NTSTATUS |
3455 #ifdef DFS_SUPPORT
3456                NTNEGOTIATE_CAPABILITY_DFS |
3457 #endif
3458 #ifdef AFS_LARGEFILES
3459                NTNEGOTIATE_CAPABILITY_LARGEFILES |
3460 #endif
3461                NTNEGOTIATE_CAPABILITY_NTFIND |
3462                NTNEGOTIATE_CAPABILITY_RAWMODE |
3463                NTNEGOTIATE_CAPABILITY_NTSMB;
3464
3465         if ( smb_authType == SMB_AUTH_EXTENDED )
3466             caps |= NTNEGOTIATE_CAPABILITY_EXTENDED_SECURITY;
3467
3468 #ifdef SMB_UNICODE
3469         if ( smb_UseUnicode ) {
3470             caps |= NTNEGOTIATE_CAPABILITY_UNICODE;
3471         }
3472 #endif
3473
3474         smb_SetSMBParmLong(outp, 9, caps);
3475         time(&unixTime);
3476         smb_SearchTimeFromUnixTime(&dosTime, unixTime);
3477         smb_SetSMBParmLong(outp, 11, LOWORD(dosTime));/* server time */
3478         smb_SetSMBParmLong(outp, 13, HIWORD(dosTime));/* server date */
3479
3480         GetTimeZoneInformation(&tzi);
3481         smb_SetSMBParm(outp, 15, (unsigned short) tzi.Bias);    /* server tzone */
3482
3483         if (smb_authType == SMB_AUTH_NTLM) {
3484             smb_SetSMBParmByte(outp, 16, MSV1_0_CHALLENGE_LENGTH);/* Encryption key length */
3485             smb_SetSMBDataLength(outp, MSV1_0_CHALLENGE_LENGTH + smb_ServerDomainNameLength);
3486             /* paste in encryption key */
3487             datap = smb_GetSMBData(outp, NULL);
3488             memcpy(datap,vcp->encKey,MSV1_0_CHALLENGE_LENGTH);
3489             /* and the faux domain name */
3490             strcpy(datap + MSV1_0_CHALLENGE_LENGTH,smb_ServerDomainName);
3491         } else if ( smb_authType == SMB_AUTH_EXTENDED ) {
3492             void * secBlob;
3493             int secBlobLength;
3494
3495             smb_SetSMBParmByte(outp, 16, 0); /* Encryption key length */
3496
3497             smb_NegotiateExtendedSecurity(&secBlob, &secBlobLength);
3498
3499             smb_SetSMBDataLength(outp, secBlobLength + sizeof(smb_ServerGUID));
3500                         
3501             datap = smb_GetSMBData(outp, NULL);
3502             memcpy(datap, &smb_ServerGUID, sizeof(smb_ServerGUID));
3503
3504             if (secBlob) {
3505                 datap += sizeof(smb_ServerGUID);
3506                 memcpy(datap, secBlob, secBlobLength);
3507                 free(secBlob);
3508             }
3509         } else {
3510             smb_SetSMBParmByte(outp, 16, 0); /* Encryption key length */
3511             smb_SetSMBDataLength(outp, 0);   /* Perhaps we should specify 8 bytes anyway */
3512         }
3513     }
3514     else if (v3ProtoIndex != -1) {
3515         smb_SetSMBParm(outp, 0, protoIndex);
3516
3517         /* NOTE: Extended authentication cannot be negotiated with v3
3518          * therefore we fail over to NTLM 
3519          */
3520         if (smb_authType == SMB_AUTH_NTLM || smb_authType == SMB_AUTH_EXTENDED) {
3521             smb_SetSMBParm(outp, 1,
3522                            NEGOTIATE_SECURITY_USER_LEVEL |
3523                            NEGOTIATE_SECURITY_CHALLENGE_RESPONSE);      /* user level security, challenge response */
3524         } else {
3525             smb_SetSMBParm(outp, 1, 0); /* share level auth with clear password */
3526         }
3527         smb_SetSMBParm(outp, 2, SMB_PACKETSIZE);
3528         smb_SetSMBParm(outp, 3, smb_maxMpxRequests);    /* max multiplexed requests */
3529         smb_SetSMBParm(outp, 4, smb_maxVCPerServer);    /* max VCs per consumer/server connection */
3530         smb_SetSMBParm(outp, 5, 0);     /* no support of block mode for read or write */
3531         smb_SetSMBParm(outp, 6, 1);     /* next 2: session key */
3532         smb_SetSMBParm(outp, 7, 1);
3533         time(&unixTime);
3534         smb_SearchTimeFromUnixTime(&dosTime, unixTime);
3535         smb_SetSMBParm(outp, 8, LOWORD(dosTime));       /* server time */
3536         smb_SetSMBParm(outp, 9, HIWORD(dosTime));       /* server date */
3537
3538         GetTimeZoneInformation(&tzi);
3539         smb_SetSMBParm(outp, 10, (unsigned short) tzi.Bias);    /* server tzone */
3540
3541         /* NOTE: Extended authentication cannot be negotiated with v3
3542          * therefore we fail over to NTLM 
3543          */
3544         if (smb_authType == SMB_AUTH_NTLM || smb_authType == SMB_AUTH_EXTENDED) {
3545             smb_SetSMBParm(outp, 11, MSV1_0_CHALLENGE_LENGTH);  /* encryption key length */
3546             smb_SetSMBParm(outp, 12, 0);        /* resvd */
3547             smb_SetSMBDataLength(outp, MSV1_0_CHALLENGE_LENGTH + smb_ServerDomainNameLength);   /* perhaps should specify 8 bytes anyway */
3548             datap = smb_GetSMBData(outp, NULL);
3549             /* paste in a new encryption key */
3550             memcpy(datap, vcp->encKey, MSV1_0_CHALLENGE_LENGTH);
3551             /* and the faux domain name */
3552             strcpy(datap + MSV1_0_CHALLENGE_LENGTH, smb_ServerDomainName);
3553         } else {
3554             smb_SetSMBParm(outp, 11, 0); /* encryption key length */
3555             smb_SetSMBParm(outp, 12, 0); /* resvd */
3556             smb_SetSMBDataLength(outp, 0);
3557         }
3558     }
3559     else if (coreProtoIndex != -1) {     /* not really supported anymore */
3560         smb_SetSMBParm(outp, 0, protoIndex);
3561         smb_SetSMBDataLength(outp, 0);
3562     }
3563     return 0;
3564 }
3565
3566 void smb_CheckVCs(void)
3567 {
3568     smb_vc_t * vcp, *nextp;
3569     smb_packet_t * outp = GetPacket();
3570     smb_t *smbp;
3571             
3572     lock_ObtainWrite(&smb_rctLock);
3573     for ( vcp=smb_allVCsp, nextp=NULL; vcp; vcp = nextp ) 
3574     {
3575         if (vcp->magic != SMB_VC_MAGIC)
3576             osi_panic("afsd: invalid smb_vc_t detected in smb_allVCsp", 
3577                        __FILE__, __LINE__);
3578
3579         nextp = vcp->nextp;
3580
3581         if (vcp->flags & SMB_VCFLAG_ALREADYDEAD)
3582             continue;
3583
3584         smb_HoldVCNoLock(vcp);
3585         if (nextp)
3586             smb_HoldVCNoLock(nextp);
3587         smb_FormatResponsePacket(vcp, NULL, outp);
3588         smbp = (smb_t *)outp;
3589         outp->inCom = smbp->com = 0x2b /* Echo */;
3590         smbp->tid = 0xFFFF;
3591         smbp->pid = 0;
3592         smbp->uid = 0;
3593         smbp->mid = 0;
3594         smbp->res[0] = 0;
3595         smbp->res[1] = 0;
3596
3597         smb_SetSMBParm(outp, 0, 0);
3598         smb_SetSMBDataLength(outp, 0);
3599         lock_ReleaseWrite(&smb_rctLock);
3600
3601         smb_SendPacket(vcp, outp);
3602
3603         lock_ObtainWrite(&smb_rctLock);
3604         smb_ReleaseVCNoLock(vcp);
3605         if (nextp)
3606             smb_ReleaseVCNoLock(nextp);
3607     }
3608     lock_ReleaseWrite(&smb_rctLock);
3609     smb_FreePacket(outp);
3610 }
3611
3612 void smb_Daemon(void *parmp)
3613 {
3614     afs_uint32 count = 0;
3615     smb_username_t    **unpp;
3616     time_t              now;
3617
3618     while(smbShutdownFlag == 0) {
3619         count++;
3620         thrd_Sleep(10000);
3621
3622         if (smbShutdownFlag == 1)
3623             break;
3624         
3625         if ((count % 72) == 0)  {       /* every five minutes */
3626             struct tm myTime;
3627             time_t old_localZero = smb_localZero;
3628                  
3629             /* Initialize smb_localZero */
3630             myTime.tm_isdst = -1;               /* compute whether on DST or not */
3631             myTime.tm_year = 70;
3632             myTime.tm_mon = 0;
3633             myTime.tm_mday = 1;
3634             myTime.tm_hour = 0;
3635             myTime.tm_min = 0;
3636             myTime.tm_sec = 0;
3637             smb_localZero = mktime(&myTime);
3638
3639 #ifndef USE_NUMERIC_TIME_CONV
3640             smb_CalculateNowTZ();
3641 #endif /* USE_NUMERIC_TIME_CONV */
3642 #ifdef AFS_FREELANCE
3643             if ( smb_localZero != old_localZero )
3644                 cm_noteLocalMountPointChange();
3645 #endif
3646
3647             smb_CheckVCs();
3648         }
3649
3650         /* GC smb_username_t objects that will no longer be used */
3651         now = osi_Time();
3652         lock_ObtainWrite(&smb_rctLock);
3653         for ( unpp=&usernamesp; *unpp; ) {
3654             int delete = 0;
3655             smb_username_t *unp;
3656
3657             lock_ObtainMutex(&(*unpp)->mx);
3658             if ( (*unpp)->refCount > 0 || 
3659                  ((*unpp)->flags & SMB_USERNAMEFLAG_AFSLOGON) || 
3660                  !((*unpp)->flags & SMB_USERNAMEFLAG_LOGOFF))
3661                 ;
3662             else if (!smb_LogoffTokenTransfer ||
3663                      ((*unpp)->last_logoff_t + smb_LogoffTransferTimeout < now))
3664                 delete = 1;
3665             lock_ReleaseMutex(&(*unpp)->mx);
3666
3667             if (delete) {
3668                 cm_user_t * userp;
3669
3670                 unp = *unpp;    
3671                 *unpp = unp->nextp;
3672                 unp->nextp = NULL;
3673                 lock_FinalizeMutex(&unp->mx);
3674                 userp = unp->userp;
3675                 free(unp->name);
3676                 free(unp->machine);
3677                 free(unp);
3678                 if (userp)
3679                     cm_ReleaseUser(userp);
3680             } else {
3681                 unpp = &(*unpp)->nextp;
3682             }
3683         }
3684         lock_ReleaseWrite(&smb_rctLock);
3685
3686         /* XXX GC dir search entries */
3687     }
3688 }
3689
3690 void smb_WaitingLocksDaemon()
3691 {
3692     smb_waitingLockRequest_t *wlRequest, *nwlRequest;
3693     smb_waitingLock_t *wl, *wlNext;
3694     int first;
3695     smb_vc_t *vcp;
3696     smb_packet_t *inp, *outp;
3697     NCB *ncbp;
3698     long code = 0;
3699
3700     while (smbShutdownFlag == 0) {
3701         lock_ObtainWrite(&smb_globalLock);
3702         nwlRequest = smb_allWaitingLocks;
3703         if (nwlRequest == NULL) {
3704             osi_SleepW((LONG_PTR)&smb_allWaitingLocks, &smb_globalLock);
3705             thrd_Sleep(1000);
3706             continue;
3707         } else {
3708             first = 1;
3709             osi_Log0(smb_logp, "smb_WaitingLocksDaemon starting wait lock check");
3710         }
3711
3712         do {
3713             if (first)
3714                 first = 0;
3715             else
3716                 lock_ObtainWrite(&smb_globalLock);
3717
3718             osi_Log1(smb_logp, "    Checking waiting lock request %p", nwlRequest);
3719