Changes include:
[samba.git] / source3 / smbd / server.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    Main SMB server routines
5    Copyright (C) Andrew Tridgell 1992-1998
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23 #include "trans2.h"
24
25 pstring servicesf = CONFIGFILE;
26 extern pstring debugf;
27 extern pstring sesssetup_user;
28 extern fstring myworkgroup;
29
30 char *InBuffer = NULL;
31 char *OutBuffer = NULL;
32 char *last_inbuf = NULL;
33
34 int am_parent = 1;
35 int atexit_set = 0;
36
37 /* the last message the was processed */
38 int last_message = -1;
39
40 /* a useful macro to debug the last message processed */
41 #define LAST_MESSAGE() smb_fn_name(last_message)
42
43 extern pstring scope;
44 extern int DEBUGLEVEL;
45 extern int case_default;
46 extern BOOL case_sensitive;
47 extern BOOL case_preserve;
48 extern BOOL use_mangled_map;
49 extern BOOL short_case_preserve;
50 extern BOOL case_mangle;
51 time_t smb_last_time=(time_t)0;
52
53 extern int smb_read_error;
54
55 extern pstring user_socket_options;
56
57 #ifdef DFS_AUTH
58 extern int dcelogin_atmost_once;
59 #endif /* DFS_AUTH */
60
61 connection_struct Connections[MAX_CONNECTIONS];
62 files_struct Files[MAX_OPEN_FILES];
63
64 /*
65  * Indirection for file fd's. Needed as POSIX locking
66  * is based on file/process, not fd/process.
67  */
68 file_fd_struct FileFd[MAX_OPEN_FILES];
69 int max_file_fd_used = 0;
70
71 extern int Protocol;
72
73 /* 
74  * Size of data we can send to client. Set
75  *  by the client for all protocols above CORE.
76  *  Set by us for CORE protocol.
77  */
78 int max_send = BUFFER_SIZE;
79 /*
80  * Size of the data we can receive. Set by us.
81  * Can be modified by the max xmit parameter.
82  */
83 int max_recv = BUFFER_SIZE;
84
85 /* a fnum to use when chaining */
86 int chain_fnum = -1;
87
88 /* number of open connections */
89 static int num_connections_open = 0;
90
91 /* Oplock ipc UDP socket. */
92 int oplock_sock = -1;
93 uint16 oplock_port = 0;
94 /* Current number of oplocks we have outstanding. */
95 int32 global_oplocks_open = 0;
96
97 BOOL global_oplock_break = False;
98
99 extern fstring remote_machine;
100
101 extern pstring OriginalDir;
102
103 /* these can be set by some functions to override the error codes */
104 int unix_ERR_class=SMB_SUCCESS;
105 int unix_ERR_code=0;
106
107
108 extern int extra_time_offset;
109
110 extern pstring myhostname;
111
112 static int find_free_connection(int hash);
113
114 /* for readability... */
115 #define IS_DOS_READONLY(test_mode) (((test_mode) & aRONLY) != 0)
116 #define IS_DOS_DIR(test_mode) (((test_mode) & aDIR) != 0)
117 #define IS_DOS_ARCHIVE(test_mode) (((test_mode) & aARCH) != 0)
118 #define IS_DOS_SYSTEM(test_mode) (((test_mode) & aSYSTEM) != 0)
119 #define IS_DOS_HIDDEN(test_mode) (((test_mode) & aHIDDEN) != 0)
120
121 /****************************************************************************
122   when exiting, take the whole family
123 ****************************************************************************/
124 void  *dflt_sig(void)
125 {
126   exit_server("caught signal");
127   return 0; /* Keep -Wall happy :-) */
128 }
129 /****************************************************************************
130   Send a SIGTERM to our process group.
131 *****************************************************************************/
132 void  killkids(void)
133 {
134   if(am_parent) kill(0,SIGTERM);
135 }
136
137 /****************************************************************************
138   change a dos mode to a unix mode
139     base permission for files:
140          everybody gets read bit set
141          dos readonly is represented in unix by removing everyone's write bit
142          dos archive is represented in unix by the user's execute bit
143          dos system is represented in unix by the group's execute bit
144          dos hidden is represented in unix by the other's execute bit
145          Then apply create mask,
146          then add force bits.
147     base permission for directories:
148          dos directory is represented in unix by unix's dir bit and the exec bit
149          Then apply create mask,
150          then add force bits.
151 ****************************************************************************/
152 mode_t unix_mode(int cnum,int dosmode)
153 {
154   mode_t result = (S_IRUSR | S_IRGRP | S_IROTH);
155
156   if ( !IS_DOS_READONLY(dosmode) )
157     result |= (S_IWUSR | S_IWGRP | S_IWOTH);
158  
159   if (IS_DOS_DIR(dosmode)) {
160     /* We never make directories read only for the owner as under DOS a user
161        can always create a file in a read-only directory. */
162     result |= (S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH | S_IWUSR);
163     /* Apply directory mask */
164     result &= lp_dir_mode(SNUM(cnum));
165     /* Add in force bits */
166     result |= lp_force_dir_mode(SNUM(cnum));
167   } else { 
168     if (MAP_ARCHIVE(cnum) && IS_DOS_ARCHIVE(dosmode))
169       result |= S_IXUSR;
170
171     if (MAP_SYSTEM(cnum) && IS_DOS_SYSTEM(dosmode))
172       result |= S_IXGRP;
173  
174     if (MAP_HIDDEN(cnum) && IS_DOS_HIDDEN(dosmode))
175       result |= S_IXOTH;  
176  
177     /* Apply mode mask */
178     result &= lp_create_mode(SNUM(cnum));
179     /* Add in force bits */
180     result |= lp_force_create_mode(SNUM(cnum));
181   }
182   return(result);
183 }
184
185
186 /****************************************************************************
187   change a unix mode to a dos mode
188 ****************************************************************************/
189 int dos_mode(int cnum,char *path,struct stat *sbuf)
190 {
191   int result = 0;
192   extern struct current_user current_user;
193
194   DEBUG(8,("dos_mode: %d %s\n", cnum, path));
195
196   if (CAN_WRITE(cnum) && !lp_alternate_permissions(SNUM(cnum))) {
197     if (!((sbuf->st_mode & S_IWOTH) ||
198           Connections[cnum].admin_user ||
199           ((sbuf->st_mode & S_IWUSR) && current_user.uid==sbuf->st_uid) ||
200           ((sbuf->st_mode & S_IWGRP) && 
201            in_group(sbuf->st_gid,current_user.gid,
202                     current_user.ngroups,current_user.igroups))))
203       result |= aRONLY;
204   } else {
205     if ((sbuf->st_mode & S_IWUSR) == 0)
206       result |= aRONLY;
207   }
208
209   if (MAP_ARCHIVE(cnum) && ((sbuf->st_mode & S_IXUSR) != 0))
210     result |= aARCH;
211
212   if (MAP_SYSTEM(cnum) && ((sbuf->st_mode & S_IXGRP) != 0))
213     result |= aSYSTEM;
214
215   if (MAP_HIDDEN(cnum) && ((sbuf->st_mode & S_IXOTH) != 0))
216     result |= aHIDDEN;   
217   
218   if (S_ISDIR(sbuf->st_mode))
219     result = aDIR | (result & aRONLY);
220
221 #ifdef S_ISLNK
222 #if LINKS_READ_ONLY
223   if (S_ISLNK(sbuf->st_mode) && S_ISDIR(sbuf->st_mode))
224     result |= aRONLY;
225 #endif
226 #endif
227
228   /* hide files with a name starting with a . */
229   if (lp_hide_dot_files(SNUM(cnum)))
230     {
231       char *p = strrchr(path,'/');
232       if (p)
233         p++;
234       else
235         p = path;
236       
237       if (p[0] == '.' && p[1] != '.' && p[1] != 0)
238         result |= aHIDDEN;
239     }
240
241   /* Optimization : Only call is_hidden_path if it's not already
242      hidden. */
243   if (!(result & aHIDDEN) && IS_HIDDEN_PATH(cnum,path))
244   {
245     result |= aHIDDEN;
246   }
247
248   DEBUG(8,("dos_mode returning "));
249
250   if (result & aHIDDEN) DEBUG(8, ("h"));
251   if (result & aRONLY ) DEBUG(8, ("r"));
252   if (result & aSYSTEM) DEBUG(8, ("s"));
253   if (result & aDIR   ) DEBUG(8, ("d"));
254   if (result & aARCH  ) DEBUG(8, ("a"));
255
256   DEBUG(8,("\n"));
257
258   return(result);
259 }
260
261 /*******************************************************************
262 chmod a file - but preserve some bits
263 ********************************************************************/
264 int dos_chmod(int cnum,char *fname,int dosmode,struct stat *st)
265 {
266   struct stat st1;
267   int mask=0;
268   int tmp;
269   int unixmode;
270
271   if (!st) {
272     st = &st1;
273     if (sys_stat(fname,st)) return(-1);
274   }
275
276   if (S_ISDIR(st->st_mode)) dosmode |= aDIR;
277
278   if (dos_mode(cnum,fname,st) == dosmode) return(0);
279
280   unixmode = unix_mode(cnum,dosmode);
281
282   /* preserve the s bits */
283   mask |= (S_ISUID | S_ISGID);
284
285   /* preserve the t bit */
286 #ifdef S_ISVTX
287   mask |= S_ISVTX;
288 #endif
289
290   /* possibly preserve the x bits */
291   if (!MAP_ARCHIVE(cnum)) mask |= S_IXUSR;
292   if (!MAP_SYSTEM(cnum)) mask |= S_IXGRP;
293   if (!MAP_HIDDEN(cnum)) mask |= S_IXOTH;
294
295   unixmode |= (st->st_mode & mask);
296
297   /* if we previously had any r bits set then leave them alone */
298   if ((tmp = st->st_mode & (S_IRUSR|S_IRGRP|S_IROTH))) {
299     unixmode &= ~(S_IRUSR|S_IRGRP|S_IROTH);
300     unixmode |= tmp;
301   }
302
303   /* if we previously had any w bits set then leave them alone 
304    if the new mode is not rdonly */
305   if (!IS_DOS_READONLY(dosmode) &&
306       (tmp = st->st_mode & (S_IWUSR|S_IWGRP|S_IWOTH))) {
307     unixmode &= ~(S_IWUSR|S_IWGRP|S_IWOTH);
308     unixmode |= tmp;
309   }
310
311   return(sys_chmod(fname,unixmode));
312 }
313
314 /*******************************************************************
315 Wrapper around sys_utime that possibly allows DOS semantics rather
316 than POSIX.
317 *******************************************************************/
318
319 int file_utime(int cnum, char *fname, struct utimbuf *times)
320 {
321   extern struct current_user current_user;
322   struct stat sb;
323   int ret = -1;
324
325   errno = 0;
326
327   if(sys_utime(fname, times) == 0)
328     return 0;
329
330   if((errno != EPERM) && (errno != EACCES))
331     return -1;
332
333   if(!lp_dos_filetimes(SNUM(cnum)))
334     return -1;
335
336   /* We have permission (given by the Samba admin) to
337      break POSIX semantics and allow a user to change
338      the time on a file they don't own but can write to
339      (as DOS does).
340    */
341
342   if(sys_stat(fname,&sb) != 0)
343     return -1;
344
345   /* Check if we have write access. */
346   if (CAN_WRITE(cnum)) {
347           if (((sb.st_mode & S_IWOTH) ||
348                Connections[cnum].admin_user ||
349                ((sb.st_mode & S_IWUSR) && current_user.uid==sb.st_uid) ||
350                ((sb.st_mode & S_IWGRP) &&
351                 in_group(sb.st_gid,current_user.gid,
352                          current_user.ngroups,current_user.igroups)))) {
353                   /* We are allowed to become root and change the filetime. */
354                   become_root(False);
355                   ret = sys_utime(fname, times);
356                   unbecome_root(False);
357           }
358   }
359
360   return ret;
361 }
362   
363 /*******************************************************************
364 Change a filetime - possibly allowing DOS semantics.
365 *******************************************************************/
366
367 BOOL set_filetime(int cnum, char *fname, time_t mtime)
368 {
369   struct utimbuf times;
370
371   if (null_mtime(mtime)) return(True);
372
373   times.modtime = times.actime = mtime;
374
375   if (file_utime(cnum, fname, &times)) {
376     DEBUG(4,("set_filetime(%s) failed: %s\n",fname,strerror(errno)));
377   }
378   
379   return(True);
380
381
382 /****************************************************************************
383 check if two filenames are equal
384
385 this needs to be careful about whether we are case sensitive
386 ****************************************************************************/
387 static BOOL fname_equal(char *name1, char *name2)
388 {
389   int l1 = strlen(name1);
390   int l2 = strlen(name2);
391
392   /* handle filenames ending in a single dot */
393   if (l1-l2 == 1 && name1[l1-1] == '.' && lp_strip_dot())
394     {
395       BOOL ret;
396       name1[l1-1] = 0;
397       ret = fname_equal(name1,name2);
398       name1[l1-1] = '.';
399       return(ret);
400     }
401
402   if (l2-l1 == 1 && name2[l2-1] == '.' && lp_strip_dot())
403     {
404       BOOL ret;
405       name2[l2-1] = 0;
406       ret = fname_equal(name1,name2);
407       name2[l2-1] = '.';
408       return(ret);
409     }
410
411   /* now normal filename handling */
412   if (case_sensitive)
413     return(strcmp(name1,name2) == 0);
414
415   return(strequal(name1,name2));
416 }
417
418
419 /****************************************************************************
420 mangle the 2nd name and check if it is then equal to the first name
421 ****************************************************************************/
422 static BOOL mangled_equal(char *name1, char *name2)
423 {
424   pstring tmpname;
425
426   if (is_8_3(name2, True))
427     return(False);
428
429   strcpy(tmpname,name2);
430   mangle_name_83(tmpname);
431
432   return(strequal(name1,tmpname));
433 }
434
435
436 /****************************************************************************
437 scan a directory to find a filename, matching without case sensitivity
438
439 If the name looks like a mangled name then try via the mangling functions
440 ****************************************************************************/
441 static BOOL scan_directory(char *path, char *name,int cnum,BOOL docache)
442 {
443   void *cur_dir;
444   char *dname;
445   BOOL mangled;
446   pstring name2;
447
448   mangled = is_mangled(name);
449
450   /* handle null paths */
451   if (*path == 0)
452     path = ".";
453
454   if (docache && (dname = DirCacheCheck(path,name,SNUM(cnum)))) {
455     strcpy(name, dname);        
456     return(True);
457   }      
458
459   /*
460    * The incoming name can be mangled, and if we de-mangle it
461    * here it will not compare correctly against the filename (name2)
462    * read from the directory and then mangled by the name_map_mangle()
463    * call. We need to mangle both names or neither.
464    * (JRA).
465    */
466   if (mangled)
467     mangled = !check_mangled_cache( name );
468
469   /* open the directory */
470   if (!(cur_dir = OpenDir(cnum, path, True))) 
471     {
472       DEBUG(3,("scan dir didn't open dir [%s]\n",path));
473       return(False);
474     }
475
476   /* now scan for matching names */
477   while ((dname = ReadDirName(cur_dir))) 
478     {
479       if (*dname == '.' &&
480           (strequal(dname,".") || strequal(dname,"..")))
481         continue;
482
483       pstrcpy(name2,dname);
484       if (!name_map_mangle(name2,False,SNUM(cnum))) continue;
485
486       if ((mangled && mangled_equal(name,name2))
487           || fname_equal(name, name2))
488         {
489           /* we've found the file, change it's name and return */
490           if (docache) DirCacheAdd(path,name,dname,SNUM(cnum));
491           strcpy(name, dname);
492           CloseDir(cur_dir);
493           return(True);
494         }
495     }
496
497   CloseDir(cur_dir);
498   return(False);
499 }
500
501 /****************************************************************************
502 This routine is called to convert names from the dos namespace to unix
503 namespace. It needs to handle any case conversions, mangling, format
504 changes etc.
505
506 We assume that we have already done a chdir() to the right "root" directory
507 for this service.
508
509 The function will return False if some part of the name except for the last
510 part cannot be resolved
511
512 If the saved_last_component != 0, then the unmodified last component
513 of the pathname is returned there. This is used in an exceptional
514 case in reply_mv (so far). If saved_last_component == 0 then nothing
515 is returned there.
516
517 The bad_path arg is set to True if the filename walk failed. This is
518 used to pick the correct error code to return between ENOENT and ENOTDIR
519 as Windows applications depend on ERRbadpath being returned if a component
520 of a pathname does not exist.
521 ****************************************************************************/
522 BOOL unix_convert(char *name,int cnum,pstring saved_last_component, BOOL *bad_path)
523 {
524   struct stat st;
525   char *start, *end;
526   pstring dirpath;
527   int saved_errno;
528
529   *dirpath = 0;
530   *bad_path = False;
531
532   if(saved_last_component)
533     *saved_last_component = 0;
534
535   /* convert to basic unix format - removing \ chars and cleaning it up */
536   unix_format(name);
537   unix_clean_name(name);
538
539   /* names must be relative to the root of the service - trim any leading /.
540    also trim trailing /'s */
541   trim_string(name,"/","/");
542
543   /*
544    * Ensure saved_last_component is valid even if file exists.
545    */
546   if(saved_last_component) {
547     end = strrchr(name, '/');
548     if(end)
549       strcpy(saved_last_component, end + 1);
550     else
551       strcpy(saved_last_component, name);
552   }
553
554   if (!case_sensitive && 
555       (!case_preserve || (is_8_3(name, False) && !short_case_preserve)))
556     strnorm(name);
557
558   /* check if it's a printer file */
559   if (Connections[cnum].printer)
560     {
561       if ((! *name) || strchr(name,'/') || !is_8_3(name, True))
562         {
563           char *s;
564           fstring name2;
565           sprintf(name2,"%.6s.XXXXXX",remote_machine);
566           /* sanitise the name */
567           for (s=name2 ; *s ; s++)
568             if (!issafe(*s)) *s = '_';
569           strcpy(name,(char *)mktemp(name2));     
570         }      
571       return(True);
572     }
573
574   /* stat the name - if it exists then we are all done! */
575   if (sys_stat(name,&st) == 0)
576     return(True);
577
578   saved_errno = errno;
579
580   DEBUG(5,("unix_convert(%s,%d)\n",name,cnum));
581
582   /* a special case - if we don't have any mangling chars and are case
583      sensitive then searching won't help */
584   if (case_sensitive && !is_mangled(name) && 
585       !lp_strip_dot() && !use_mangled_map && (saved_errno != ENOENT))
586     return(False);
587
588   /* now we need to recursively match the name against the real 
589      directory structure */
590
591   start = name;
592   while (strncmp(start,"./",2) == 0)
593     start += 2;
594
595   /* now match each part of the path name separately, trying the names
596      as is first, then trying to scan the directory for matching names */
597   for (;start;start = (end?end+1:(char *)NULL)) 
598     {
599       /* pinpoint the end of this section of the filename */
600       end = strchr(start, '/');
601
602       /* chop the name at this point */
603       if (end)  *end = 0;
604
605       if(saved_last_component != 0)
606         strcpy(saved_last_component, end ? end + 1 : start);
607
608       /* check if the name exists up to this point */
609       if (sys_stat(name, &st) == 0) 
610         {
611           /* it exists. it must either be a directory or this must be
612              the last part of the path for it to be OK */
613           if (end && !(st.st_mode & S_IFDIR)) 
614             {
615               /* an intermediate part of the name isn't a directory */
616               DEBUG(5,("Not a dir %s\n",start));
617               *end = '/';
618               return(False);
619             }
620         }
621       else 
622         {
623           pstring rest;
624
625           *rest = 0;
626
627           /* remember the rest of the pathname so it can be restored
628              later */
629           if (end) pstrcpy(rest,end+1);
630
631           /* try to find this part of the path in the directory */
632           if (strchr(start,'?') || strchr(start,'*') ||
633               !scan_directory(dirpath, start, cnum, end?True:False))
634             {
635               if (end) 
636                 {
637                   /* an intermediate part of the name can't be found */
638                   DEBUG(5,("Intermediate not found %s\n",start));
639                   *end = '/';
640                   /* We need to return the fact that the intermediate
641                      name resolution failed. This is used to return an
642                      error of ERRbadpath rather than ERRbadfile. Some
643                      Windows applications depend on the difference between
644                      these two errors.
645                    */
646                   *bad_path = True;
647                   return(False);
648                 }
649               
650               /* just the last part of the name doesn't exist */
651               /* we may need to strupper() or strlower() it in case
652                  this conversion is being used for file creation 
653                  purposes */
654               /* if the filename is of mixed case then don't normalise it */
655               if (!case_preserve && 
656                   (!strhasupper(start) || !strhaslower(start)))         
657                 strnorm(start);
658
659               /* check on the mangled stack to see if we can recover the 
660                  base of the filename */
661               if (is_mangled(start))
662                 check_mangled_cache( start );
663
664               DEBUG(5,("New file %s\n",start));
665               return(True); 
666             }
667
668           /* restore the rest of the string */
669           if (end) 
670             {
671               strcpy(start+strlen(start)+1,rest);
672               end = start + strlen(start);
673             }
674         }
675
676       /* add to the dirpath that we have resolved so far */
677       if (*dirpath) strcat(dirpath,"/");
678       strcat(dirpath,start);
679
680       /* restore the / that we wiped out earlier */
681       if (end) *end = '/';
682     }
683   
684   /* the name has been resolved */
685   DEBUG(5,("conversion finished %s\n",name));
686   return(True);
687 }
688
689
690 /****************************************************************************
691 normalise for DOS usage 
692 ****************************************************************************/
693 static void disk_norm(int *bsize,int *dfree,int *dsize)
694 {
695   /* check if the disk is beyond the max disk size */
696   int maxdisksize = lp_maxdisksize();
697   if (maxdisksize) {
698     /* convert to blocks - and don't overflow */
699     maxdisksize = ((maxdisksize*1024)/(*bsize))*1024;
700     if (*dsize > maxdisksize) *dsize = maxdisksize;
701     if (*dfree > maxdisksize) *dfree = maxdisksize-1; /* the -1 should stop 
702                                                          applications getting 
703                                                          div by 0 errors */
704   }  
705
706   while (*dfree > WORDMAX || *dsize > WORDMAX || *bsize < 512) 
707     {
708       *dfree /= 2;
709       *dsize /= 2;
710       *bsize *= 2;
711       if (*bsize > WORDMAX )
712         {
713           *bsize = WORDMAX;
714           if (*dsize > WORDMAX)
715             *dsize = WORDMAX;
716           if (*dfree >  WORDMAX)
717             *dfree = WORDMAX;
718           break;
719         }
720     }
721 }
722
723 /****************************************************************************
724   return number of 1K blocks available on a path and total number 
725 ****************************************************************************/
726 int disk_free(char *path,int *bsize,int *dfree,int *dsize)
727 {
728   char *df_command = lp_dfree_command();
729   int dfree_retval;
730 #ifdef QUOTAS
731   int dfreeq_retval;
732   int dfreeq = 0;
733   int bsizeq = *bsize;
734   int dsizeq = *dsize;
735 #endif
736
737 #ifndef NO_STATFS
738 #ifdef USE_STATVFS
739   struct statvfs fs;
740 #else
741 #ifdef ULTRIX
742   struct fs_data fs;
743 #else
744   struct statfs fs;
745 #endif
746 #endif
747 #endif
748
749   /* possibly use system() to get the result */
750   if (df_command && *df_command)
751     {
752       int ret;
753       pstring syscmd;
754       pstring outfile;
755           
756       sprintf(outfile,"%s/dfree.smb.%d",tmpdir(),(int)getpid());
757       sprintf(syscmd,"%s %s",df_command,path);
758       standard_sub_basic(syscmd);
759
760       ret = smbrun(syscmd,outfile,False);
761       DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret));
762           
763       {
764         FILE *f = fopen(outfile,"r");   
765         *dsize = 0;
766         *dfree = 0;
767         *bsize = 1024;
768         if (f)
769           {
770             fscanf(f,"%d %d %d",dsize,dfree,bsize);
771             fclose(f);
772           }
773         else
774           DEBUG(0,("Can't open %s\n",outfile));
775       }
776           
777       unlink(outfile);
778       disk_norm(bsize,dfree,dsize);
779       dfree_retval = ((*bsize)/1024)*(*dfree);
780 #ifdef QUOTAS
781       /* Ensure we return the min value between the users quota and
782          what's free on the disk. Thanks to Albrecht Gebhardt 
783          <albrecht.gebhardt@uni-klu.ac.at> for this fix.
784       */
785       if (disk_quotas(path, &bsizeq, &dfreeq, &dsizeq))
786         {
787           disk_norm(&bsizeq, &dfreeq, &dsizeq);
788           dfreeq_retval = ((bsizeq)/1024)*(dfreeq);
789           dfree_retval =  ( dfree_retval < dfreeq_retval ) ? 
790                            dfree_retval : dfreeq_retval ;
791           /* maybe dfree and dfreeq are calculated using different bsizes 
792              so convert dfree from bsize into bsizeq */
793           /* avoid overflows due to multiplication, so do not:
794                 *dfree = ((*dfree) * (*bsize)) / (bsizeq); 
795              bsize and bsizeq are powers of 2 so its better to
796              to divide them getting a multiplication or division factor
797              for dfree. Rene Nieuwenhuizen (07-10-1997) */
798           if (*bsize >= bsizeq) 
799             *dfree = *dfree * (*bsize / bsizeq);
800           else 
801             *dfree = *dfree / (bsizeq / *bsize);
802           *dfree = ( *dfree < dfreeq ) ? *dfree : dfreeq ; 
803           *bsize = bsizeq;
804           *dsize = dsizeq;
805         }
806 #endif
807       return(dfree_retval);
808     }
809
810 #ifdef NO_STATFS
811   DEBUG(1,("Warning - no statfs function\n"));
812   return(1);
813 #else
814 #ifdef STATFS4
815   if (statfs(path,&fs,sizeof(fs),0) != 0)
816 #else
817 #ifdef USE_STATVFS
818     if (statvfs(path, &fs))
819 #else
820 #ifdef STATFS3
821       if (statfs(path,&fs,sizeof(fs)) == -1)     
822 #else
823         if (statfs(path,&fs) == -1)
824 #endif /* STATFS3 */
825 #endif /* USE_STATVFS */
826 #endif /* STATFS4 */
827           {
828             DEBUG(3,("dfree call failed code errno=%d\n",errno));
829             *bsize = 1024;
830             *dfree = 1;
831             *dsize = 1;
832             return(((*bsize)/1024)*(*dfree));
833           }
834
835 #ifdef ULTRIX
836   *bsize = 1024;
837   *dfree = fs.fd_req.bfree;
838   *dsize = fs.fd_req.btot;
839 #else
840 #ifdef USE_STATVFS
841   *bsize = fs.f_frsize;
842 #else
843 #ifdef USE_F_FSIZE
844   /* eg: osf1 has f_fsize = fundamental filesystem block size, 
845      f_bsize = optimal transfer block size (MX: 94-04-19) */
846   *bsize = fs.f_fsize;
847 #else
848   *bsize = fs.f_bsize;
849 #endif /* STATFS3 */
850 #endif /* USE_STATVFS */
851
852 #ifdef STATFS4
853   *dfree = fs.f_bfree;
854 #else
855   *dfree = fs.f_bavail;
856 #endif /* STATFS4 */
857   *dsize = fs.f_blocks;
858 #endif /* ULTRIX */
859
860 #if defined(SCO) || defined(ISC) || defined(MIPS)
861   *bsize = 512;
862 #endif
863
864 /* handle rediculous bsize values - some OSes are broken */
865 if ((*bsize) < 512 || (*bsize)>0xFFFF) *bsize = 1024;
866
867   disk_norm(bsize,dfree,dsize);
868
869   if (*bsize < 256)
870     *bsize = 512;
871   if ((*dsize)<1)
872     {
873       DEBUG(0,("dfree seems to be broken on your system\n"));
874       *dsize = 20*1024*1024/(*bsize);
875       *dfree = MAX(1,*dfree);
876     }
877   dfree_retval = ((*bsize)/1024)*(*dfree);
878 #ifdef QUOTAS
879   /* Ensure we return the min value between the users quota and
880      what's free on the disk. Thanks to Albrecht Gebhardt 
881      <albrecht.gebhardt@uni-klu.ac.at> for this fix.
882   */
883   if (disk_quotas(path, &bsizeq, &dfreeq, &dsizeq))
884     {
885       disk_norm(&bsizeq, &dfreeq, &dsizeq);
886       dfreeq_retval = ((bsizeq)/1024)*(dfreeq);
887       dfree_retval = ( dfree_retval < dfreeq_retval ) ? 
888                        dfree_retval : dfreeq_retval ;
889       /* maybe dfree and dfreeq are calculated using different bsizes 
890          so convert dfree from bsize into bsizeq */
891       /* avoid overflows due to multiplication, so do not:
892               *dfree = ((*dfree) * (*bsize)) / (bsizeq); 
893        bsize and bsizeq are powers of 2 so its better to
894        to divide them getting a multiplication or division factor
895        for dfree. Rene Nieuwenhuizen (07-10-1997) */
896       if (*bsize >= bsizeq)
897         *dfree = *dfree * (*bsize / bsizeq);
898       else
899         *dfree = *dfree / (bsizeq / *bsize);
900       *dfree = ( *dfree < dfreeq ) ? *dfree : dfreeq ;
901       *bsize = bsizeq;
902       *dsize = dsizeq;
903     }
904 #endif
905   return(dfree_retval);
906 #endif
907 }
908
909
910 /****************************************************************************
911 wrap it to get filenames right
912 ****************************************************************************/
913 int sys_disk_free(char *path,int *bsize,int *dfree,int *dsize)
914 {
915   return(disk_free(dos_to_unix(path,False),bsize,dfree,dsize));
916 }
917
918
919
920 /****************************************************************************
921 check a filename - possibly caling reducename
922
923 This is called by every routine before it allows an operation on a filename.
924 It does any final confirmation necessary to ensure that the filename is
925 a valid one for the user to access.
926 ****************************************************************************/
927 BOOL check_name(char *name,int cnum)
928 {
929   BOOL ret;
930
931   errno = 0;
932
933   if( IS_VETO_PATH(cnum, name)) 
934     {
935       DEBUG(5,("file path name %s vetoed\n",name));
936       return(0);
937     }
938
939   ret = reduce_name(name,Connections[cnum].connectpath,lp_widelinks(SNUM(cnum)));
940
941   /* Check if we are allowing users to follow symlinks */
942   /* Patch from David Clerc <David.Clerc@cui.unige.ch>
943      University of Geneva */
944
945 #ifdef S_ISLNK
946   if (!lp_symlinks(SNUM(cnum)))
947     {
948       struct stat statbuf;
949       if ( (sys_lstat(name,&statbuf) != -1) &&
950           (S_ISLNK(statbuf.st_mode)) )
951         {
952           DEBUG(3,("check_name: denied: file path name %s is a symlink\n",name));
953           ret=0; 
954         }
955     }
956 #endif
957
958   if (!ret)
959     DEBUG(5,("check_name on %s failed\n",name));
960
961   return(ret);
962 }
963
964 /****************************************************************************
965 check a filename - possibly caling reducename
966 ****************************************************************************/
967 static void check_for_pipe(char *fname)
968 {
969   /* special case of pipe opens */
970   char s[10];
971   StrnCpy(s,fname,9);
972   strlower(s);
973   if (strstr(s,"pipe/"))
974     {
975       DEBUG(3,("Rejecting named pipe open for %s\n",fname));
976       unix_ERR_class = ERRSRV;
977       unix_ERR_code = ERRaccess;
978     }
979 }
980
981 /****************************************************************************
982 fd support routines - attempt to do a sys_open
983 ****************************************************************************/
984 static int fd_attempt_open(char *fname, int flags, int mode)
985 {
986   int fd = sys_open(fname,flags,mode);
987
988   /* Fix for files ending in '.' */
989   if((fd == -1) && (errno == ENOENT) &&
990      (strchr(fname,'.')==NULL))
991     {
992       strcat(fname,".");
993       fd = sys_open(fname,flags,mode);
994     }
995
996 #if (defined(ENAMETOOLONG) && defined(HAVE_PATHCONF))
997   if ((fd == -1) && (errno == ENAMETOOLONG))
998     {
999       int max_len;
1000       char *p = strrchr(fname, '/');
1001
1002       if (p == fname)   /* name is "/xxx" */
1003         {
1004           max_len = pathconf("/", _PC_NAME_MAX);
1005           p++;
1006         }
1007       else if ((p == NULL) || (p == fname))
1008         {
1009           p = fname;
1010           max_len = pathconf(".", _PC_NAME_MAX);
1011         }
1012       else
1013         {
1014           *p = '\0';
1015           max_len = pathconf(fname, _PC_NAME_MAX);
1016           *p = '/';
1017           p++;
1018         }
1019       if (strlen(p) > max_len)
1020         {
1021           char tmp = p[max_len];
1022
1023           p[max_len] = '\0';
1024           if ((fd = sys_open(fname,flags,mode)) == -1)
1025             p[max_len] = tmp;
1026         }
1027     }
1028 #endif
1029   return fd;
1030 }
1031
1032 /****************************************************************************
1033 fd support routines - attempt to find an already open file by dev
1034 and inode - increments the ref_count of the returned file_fd_struct *.
1035 ****************************************************************************/
1036 static file_fd_struct *fd_get_already_open(struct stat *sbuf)
1037 {
1038   int i;
1039   file_fd_struct *fd_ptr;
1040
1041   if(sbuf == 0)
1042     return 0;
1043
1044   for(i = 0; i <= max_file_fd_used; i++) {
1045     fd_ptr = &FileFd[i];
1046     if((fd_ptr->ref_count > 0) &&
1047        (((uint32)sbuf->st_dev) == fd_ptr->dev) &&
1048        (((uint32)sbuf->st_ino) == fd_ptr->inode)) {
1049       fd_ptr->ref_count++;
1050       DEBUG(3,
1051        ("Re-used file_fd_struct %d, dev = %x, inode = %x, ref_count = %d\n",
1052         i, fd_ptr->dev, fd_ptr->inode, fd_ptr->ref_count));
1053       return fd_ptr;
1054     }
1055   }
1056   return 0;
1057 }
1058
1059 /****************************************************************************
1060 fd support routines - attempt to find a empty slot in the FileFd array.
1061 Increments the ref_count of the returned entry.
1062 ****************************************************************************/
1063 static file_fd_struct *fd_get_new(void)
1064 {
1065   int i;
1066   file_fd_struct *fd_ptr;
1067
1068   for(i = 0; i < MAX_OPEN_FILES; i++) {
1069     fd_ptr = &FileFd[i];
1070     if(fd_ptr->ref_count == 0) {
1071       fd_ptr->dev = (uint32)-1;
1072       fd_ptr->inode = (uint32)-1;
1073       fd_ptr->fd = -1;
1074       fd_ptr->fd_readonly = -1;
1075       fd_ptr->fd_writeonly = -1;
1076       fd_ptr->real_open_flags = -1;
1077       fd_ptr->ref_count++;
1078       /* Increment max used counter if neccessary, cuts down
1079          on search time when re-using */
1080       if(i > max_file_fd_used)
1081         max_file_fd_used = i;
1082       DEBUG(3,("Allocated new file_fd_struct %d, dev = %x, inode = %x\n",
1083                i, fd_ptr->dev, fd_ptr->inode));
1084       return fd_ptr;
1085     }
1086   }
1087   DEBUG(1,("ERROR! Out of file_fd structures - perhaps increase MAX_OPEN_FILES?\
1088 n"));
1089   return 0;
1090 }
1091
1092 /****************************************************************************
1093 fd support routines - attempt to re-open an already open fd as O_RDWR.
1094 Save the already open fd (we cannot close due to POSIX file locking braindamage.
1095 ****************************************************************************/
1096 static void fd_attempt_reopen(char *fname, int mode, file_fd_struct *fd_ptr)
1097 {
1098   int fd = sys_open( fname, O_RDWR, mode);
1099
1100   if(fd == -1)
1101     return;
1102
1103   if(fd_ptr->real_open_flags == O_RDONLY)
1104     fd_ptr->fd_readonly = fd_ptr->fd;
1105   if(fd_ptr->real_open_flags == O_WRONLY)
1106     fd_ptr->fd_writeonly = fd_ptr->fd;
1107
1108   fd_ptr->fd = fd;
1109   fd_ptr->real_open_flags = O_RDWR;
1110 }
1111
1112 /****************************************************************************
1113 fd support routines - attempt to close the file referenced by this fd.
1114 Decrements the ref_count and returns it.
1115 ****************************************************************************/
1116 static int fd_attempt_close(file_fd_struct *fd_ptr)
1117 {
1118   DEBUG(3,("fd_attempt_close on file_fd_struct %d, fd = %d, dev = %x, inode = %x, open_flags = %d, ref_count = %d.\n",
1119            fd_ptr - &FileFd[0],
1120            fd_ptr->fd, fd_ptr->dev, fd_ptr->inode,
1121            fd_ptr->real_open_flags,
1122            fd_ptr->ref_count));
1123   if(fd_ptr->ref_count > 0) {
1124     fd_ptr->ref_count--;
1125     if(fd_ptr->ref_count == 0) {
1126       if(fd_ptr->fd != -1)
1127         close(fd_ptr->fd);
1128       if(fd_ptr->fd_readonly != -1)
1129         close(fd_ptr->fd_readonly);
1130       if(fd_ptr->fd_writeonly != -1)
1131         close(fd_ptr->fd_writeonly);
1132       fd_ptr->fd = -1;
1133       fd_ptr->fd_readonly = -1;
1134       fd_ptr->fd_writeonly = -1;
1135       fd_ptr->real_open_flags = -1;
1136       fd_ptr->dev = (uint32)-1;
1137       fd_ptr->inode = (uint32)-1;
1138     }
1139   } 
1140  return fd_ptr->ref_count;
1141 }
1142
1143 /****************************************************************************
1144 open a file
1145 ****************************************************************************/
1146 static void open_file(int fnum,int cnum,char *fname1,int flags,int mode, struct stat *sbuf)
1147 {
1148   extern struct current_user current_user;
1149   pstring fname;
1150   struct stat statbuf;
1151   file_fd_struct *fd_ptr;
1152   files_struct *fsp = &Files[fnum];
1153   int accmode = (flags & (O_RDONLY | O_WRONLY | O_RDWR));
1154
1155   fsp->open = False;
1156   fsp->fd_ptr = 0;
1157   fsp->granted_oplock = False;
1158   errno = EPERM;
1159
1160   pstrcpy(fname,fname1);
1161
1162   /* check permissions */
1163
1164   /*
1165    * This code was changed after seeing a client open request 
1166    * containing the open mode of (DENY_WRITE/read-only) with
1167    * the 'create if not exist' bit set. The previous code
1168    * would fail to open the file read only on a read-only share
1169    * as it was checking the flags parameter  directly against O_RDONLY,
1170    * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
1171    * JRA.
1172    */
1173
1174   if (!CAN_WRITE(cnum) && !Connections[cnum].printer) {
1175     /* It's a read-only share - fail if we wanted to write. */
1176     if(accmode != O_RDONLY) {
1177       DEBUG(3,("Permission denied opening %s\n",fname));
1178       check_for_pipe(fname);
1179       return;
1180     }
1181     else if(flags & O_CREAT) {
1182       /* We don't want to write - but we must make sure that O_CREAT
1183          doesn't create the file if we have write access into the
1184          directory.
1185        */
1186       flags &= ~O_CREAT;
1187     }
1188   }
1189
1190   /* this handles a bug in Win95 - it doesn't say to create the file when it 
1191      should */
1192   if (Connections[cnum].printer)
1193     flags |= O_CREAT;
1194
1195 /*
1196   if (flags == O_WRONLY)
1197     DEBUG(3,("Bug in client? Set O_WRONLY without O_CREAT\n"));
1198 */
1199
1200   /*
1201    * Ensure we have a valid struct stat so we can search the
1202    * open fd table.
1203    */
1204   if(sbuf == 0) {
1205     if(stat(fname, &statbuf) < 0) {
1206       if(errno != ENOENT) {
1207         DEBUG(3,("Error doing stat on file %s (%s)\n",
1208                  fname,strerror(errno)));
1209
1210         check_for_pipe(fname);
1211         return;
1212       }
1213       sbuf = 0;
1214     } else {
1215       sbuf = &statbuf;
1216     }
1217   }
1218
1219   /*
1220    * Check to see if we have this file already
1221    * open. If we do, just use the already open fd and increment the
1222    * reference count (fd_get_already_open increments the ref_count).
1223    */
1224   if((fd_ptr = fd_get_already_open(sbuf))!= 0) {
1225
1226     /* File was already open. */
1227     if((flags & O_CREAT) && (flags & O_EXCL)) {
1228       fd_ptr->ref_count--;
1229       errno = EEXIST;
1230       return;
1231     }
1232
1233     /* 
1234      * If not opened O_RDWR try
1235      * and do that here - a chmod may have been done
1236      * between the last open and now. 
1237      */
1238     if(fd_ptr->real_open_flags != O_RDWR)
1239       fd_attempt_reopen(fname, mode, fd_ptr);
1240
1241     /*
1242      * Ensure that if we wanted write access
1243      * it has been opened for write, and if we wanted read it
1244      * was open for read. 
1245      */
1246     if(((accmode == O_WRONLY) && (fd_ptr->real_open_flags == O_RDONLY)) ||
1247        ((accmode == O_RDONLY) && (fd_ptr->real_open_flags == O_WRONLY)) ||
1248        ((accmode == O_RDWR) && (fd_ptr->real_open_flags != O_RDWR))) {
1249       DEBUG(3,("Error opening (already open for flags=%d) file %s (%s) (flags=%d)\n",
1250                fd_ptr->real_open_flags, fname,strerror(EACCES),flags));
1251       check_for_pipe(fname);
1252       fd_ptr->ref_count--;
1253       return;
1254     }
1255
1256   } else {
1257     int open_flags;
1258     /* We need to allocate a new file_fd_struct (this increments the
1259        ref_count). */
1260     if((fd_ptr = fd_get_new()) == 0)
1261       return;
1262     /*
1263      * Whatever the requested flags, attempt read/write access,
1264      * as we don't know what flags future file opens may require.
1265      * If this fails, try again with the required flags. 
1266      * Even if we open read/write when only read access was 
1267      * requested the setting of the can_write flag in
1268      * the file_struct will protect us from errant
1269      * write requests. We never need to worry about O_APPEND
1270      * as this is not set anywhere in Samba.
1271      */
1272     fd_ptr->real_open_flags = O_RDWR;
1273     /* Set the flags as needed without the read/write modes. */
1274     open_flags = flags & ~(O_RDWR|O_WRONLY|O_RDONLY);
1275     fd_ptr->fd = fd_attempt_open(fname, open_flags|O_RDWR, mode);
1276     /*
1277      * On some systems opening a file for R/W access on a read only
1278      * filesystems sets errno to EROFS.
1279      */
1280 #ifdef EROFS
1281     if((fd_ptr->fd == -1) && ((errno == EACCES) || (errno == EROFS))) {
1282 #else /* No EROFS */
1283     if((fd_ptr->fd == -1) && (errno == EACCES)) {
1284 #endif /* EROFS */
1285       if(flags & O_WRONLY) {
1286         fd_ptr->fd = fd_attempt_open(fname, open_flags|O_WRONLY, mode);
1287         fd_ptr->real_open_flags = O_WRONLY;
1288       } else {
1289         fd_ptr->fd = fd_attempt_open(fname, open_flags|O_RDONLY, mode);
1290         fd_ptr->real_open_flags = O_RDONLY;
1291       }
1292     }
1293   }
1294
1295   if ((fd_ptr->fd >=0) && 
1296       Connections[cnum].printer && lp_minprintspace(SNUM(cnum))) {
1297     pstring dname;
1298     int dum1,dum2,dum3;
1299     char *p;
1300     pstrcpy(dname,fname);
1301     p = strrchr(dname,'/');
1302     if (p) *p = 0;
1303     if (sys_disk_free(dname,&dum1,&dum2,&dum3) < 
1304         lp_minprintspace(SNUM(cnum))) {
1305       fd_attempt_close(fd_ptr);
1306       fsp->fd_ptr = 0;
1307       if(fd_ptr->ref_count == 0)
1308         sys_unlink(fname);
1309       errno = ENOSPC;
1310       return;
1311     }
1312   }
1313     
1314   if (fd_ptr->fd < 0)
1315     {
1316       DEBUG(3,("Error opening file %s (%s) (flags=%d)\n",
1317                fname,strerror(errno),flags));
1318       /* Ensure the ref_count is decremented. */
1319       fd_attempt_close(fd_ptr);
1320       check_for_pipe(fname);
1321       return;
1322     }
1323
1324   if (fd_ptr->fd >= 0)
1325     {
1326       if(sbuf == 0) {
1327         /* Do the fstat */
1328         if(fstat(fd_ptr->fd, &statbuf) == -1) {
1329           /* Error - backout !! */
1330           DEBUG(3,("Error doing fstat on fd %d, file %s (%s)\n",
1331                    fd_ptr->fd, fname,strerror(errno)));
1332           /* Ensure the ref_count is decremented. */
1333           fd_attempt_close(fd_ptr);
1334           return;
1335         }
1336         sbuf = &statbuf;
1337       }
1338       /* Set the correct entries in fd_ptr. */
1339       fd_ptr->dev = (uint32)sbuf->st_dev;
1340       fd_ptr->inode = (uint32)sbuf->st_ino;
1341
1342       fsp->fd_ptr = fd_ptr;
1343       Connections[cnum].num_files_open++;
1344       fsp->mode = sbuf->st_mode;
1345       GetTimeOfDay(&fsp->open_time);
1346       fsp->vuid = current_user.vuid;
1347       fsp->size = 0;
1348       fsp->pos = -1;
1349       fsp->open = True;
1350       fsp->mmap_ptr = NULL;
1351       fsp->mmap_size = 0;
1352       fsp->can_lock = True;
1353       fsp->can_read = ((flags & O_WRONLY)==0);
1354       fsp->can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
1355       fsp->share_mode = 0;
1356       fsp->print_file = Connections[cnum].printer;
1357       fsp->modified = False;
1358       fsp->granted_oplock = False;
1359       fsp->sent_oplock_break = False;
1360       fsp->cnum = cnum;
1361       string_set(&fsp->name,dos_to_unix(fname,False));
1362       fsp->wbmpx_ptr = NULL;      
1363
1364       /*
1365        * If the printer is marked as postscript output a leading
1366        * file identifier to ensure the file is treated as a raw
1367        * postscript file.
1368        * This has a similar effect as CtrlD=0 in WIN.INI file.
1369        * tim@fsg.com 09/06/94
1370        */
1371       if (fsp->print_file && POSTSCRIPT(cnum) && 
1372           fsp->can_write) 
1373         {
1374           DEBUG(3,("Writing postscript line\n"));
1375           write_file(fnum,"%!\n",3);
1376         }
1377       
1378       DEBUG(2,("%s %s opened file %s read=%s write=%s (numopen=%d fnum=%d)\n",
1379                timestring(),Connections[cnum].user,fname,
1380                BOOLSTR(fsp->can_read),BOOLSTR(fsp->can_write),
1381                Connections[cnum].num_files_open,fnum));
1382
1383     }
1384
1385 #if USE_MMAP
1386   /* mmap it if read-only */
1387   if (!fsp->can_write)
1388     {
1389       fsp->mmap_size = file_size(fname);
1390       fsp->mmap_ptr = (char *)mmap(NULL,fsp->mmap_size,
1391                                           PROT_READ,MAP_SHARED,fsp->fd_ptr->fd,0);
1392
1393       if (fsp->mmap_ptr == (char *)-1 || !fsp->mmap_ptr)
1394         {
1395           DEBUG(3,("Failed to mmap() %s - %s\n",fname,strerror(errno)));
1396           fsp->mmap_ptr = NULL;
1397         }
1398     }
1399 #endif
1400 }
1401
1402 /*******************************************************************
1403 sync a file
1404 ********************************************************************/
1405 void sync_file(int fnum)
1406 {
1407 #ifndef NO_FSYNC
1408   fsync(Files[fnum].fd_ptr->fd);
1409 #endif
1410 }
1411
1412 /****************************************************************************
1413 run a file if it is a magic script
1414 ****************************************************************************/
1415 static void check_magic(int fnum,int cnum)
1416 {
1417   if (!*lp_magicscript(SNUM(cnum)))
1418     return;
1419
1420   DEBUG(5,("checking magic for %s\n",Files[fnum].name));
1421
1422   {
1423     char *p;
1424     if (!(p = strrchr(Files[fnum].name,'/')))
1425       p = Files[fnum].name;
1426     else
1427       p++;
1428
1429     if (!strequal(lp_magicscript(SNUM(cnum)),p))
1430       return;
1431   }
1432
1433   {
1434     int ret;
1435     pstring magic_output;
1436     pstring fname;
1437     pstrcpy(fname,Files[fnum].name);
1438
1439     if (*lp_magicoutput(SNUM(cnum)))
1440       pstrcpy(magic_output,lp_magicoutput(SNUM(cnum)));
1441     else
1442       sprintf(magic_output,"%s.out",fname);
1443
1444     chmod(fname,0755);
1445     ret = smbrun(fname,magic_output,False);
1446     DEBUG(3,("Invoking magic command %s gave %d\n",fname,ret));
1447     unlink(fname);
1448   }
1449 }
1450
1451
1452 /****************************************************************************
1453 close a file - possibly invalidating the read prediction
1454
1455 If normal_close is 1 then this came from a normal SMBclose (or equivalent)
1456 operation otherwise it came as the result of some other operation such as
1457 the closing of the connection. In the latter case printing and
1458 magic scripts are not run
1459 ****************************************************************************/
1460 void close_file(int fnum, BOOL normal_close)
1461 {
1462   files_struct *fs_p = &Files[fnum];
1463   int cnum = fs_p->cnum;
1464   uint32 dev = fs_p->fd_ptr->dev;
1465   uint32 inode = fs_p->fd_ptr->inode;
1466   int token;
1467
1468   Files[fnum].reserved = False;
1469
1470 #if USE_READ_PREDICTION
1471   invalidate_read_prediction(fs_p->fd_ptr->fd);
1472 #endif
1473
1474   fs_p->open = False;
1475   Connections[cnum].num_files_open--;
1476   if(fs_p->wbmpx_ptr) 
1477   {
1478     free((char *)fs_p->wbmpx_ptr);
1479     fs_p->wbmpx_ptr = NULL;
1480   }
1481
1482 #if USE_MMAP
1483   if(fs_p->mmap_ptr) 
1484   {
1485     munmap(fs_p->mmap_ptr,fs_p->mmap_size);
1486     fs_p->mmap_ptr = NULL;
1487   }
1488 #endif
1489
1490   if (lp_share_modes(SNUM(cnum)))
1491   {
1492     lock_share_entry( cnum, dev, inode, &token);
1493     del_share_mode(token, fnum);
1494   }
1495
1496   fd_attempt_close(fs_p->fd_ptr);
1497
1498   if (lp_share_modes(SNUM(cnum)))
1499     unlock_share_entry( cnum, dev, inode, token);
1500
1501   /* NT uses smbclose to start a print - weird */
1502   if (normal_close && fs_p->print_file)
1503     print_file(fnum);
1504
1505   /* check for magic scripts */
1506   if (normal_close)
1507     check_magic(fnum,cnum);
1508
1509   if(fs_p->granted_oplock == True)
1510     global_oplocks_open--;
1511
1512   fs_p->sent_oplock_break = False;
1513
1514   DEBUG(2,("%s %s closed file %s (numopen=%d)\n",
1515            timestring(),Connections[cnum].user,fs_p->name,
1516            Connections[cnum].num_files_open));
1517
1518   if (fs_p->name) {
1519           string_free(&fs_p->name);
1520   }
1521
1522   /* we will catch bugs faster by zeroing this structure */
1523   memset(fs_p, 0, sizeof(*fs_p));
1524 }
1525
1526 enum {AFAIL,AREAD,AWRITE,AALL};
1527
1528 /*******************************************************************
1529 reproduce the share mode access table
1530 ********************************************************************/
1531 static int access_table(int new_deny,int old_deny,int old_mode,
1532                         int share_pid,char *fname)
1533 {
1534   if (new_deny == DENY_ALL || old_deny == DENY_ALL) return(AFAIL);
1535
1536   if (new_deny == DENY_DOS || old_deny == DENY_DOS) {
1537     int pid = getpid();
1538     if (old_deny == new_deny && share_pid == pid) 
1539         return(AALL);    
1540
1541     if (old_mode == 0) return(AREAD);
1542
1543     /* the new smbpub.zip spec says that if the file extension is
1544        .com, .dll, .exe or .sym then allow the open. I will force
1545        it to read-only as this seems sensible although the spec is
1546        a little unclear on this. */
1547     if ((fname = strrchr(fname,'.'))) {
1548       if (strequal(fname,".com") ||
1549           strequal(fname,".dll") ||
1550           strequal(fname,".exe") ||
1551           strequal(fname,".sym"))
1552         return(AREAD);
1553     }
1554
1555     return(AFAIL);
1556   }
1557
1558   switch (new_deny) 
1559     {
1560     case DENY_WRITE:
1561       if (old_deny==DENY_WRITE && old_mode==0) return(AREAD);
1562       if (old_deny==DENY_READ && old_mode==0) return(AWRITE);
1563       if (old_deny==DENY_NONE && old_mode==0) return(AALL);
1564       return(AFAIL);
1565     case DENY_READ:
1566       if (old_deny==DENY_WRITE && old_mode==1) return(AREAD);
1567       if (old_deny==DENY_READ && old_mode==1) return(AWRITE);
1568       if (old_deny==DENY_NONE && old_mode==1) return(AALL);
1569       return(AFAIL);
1570     case DENY_NONE:
1571       if (old_deny==DENY_WRITE) return(AREAD);
1572       if (old_deny==DENY_READ) return(AWRITE);
1573       if (old_deny==DENY_NONE) return(AALL);
1574       return(AFAIL);      
1575     }
1576   return(AFAIL);      
1577 }
1578
1579 /*******************************************************************
1580 check if the share mode on a file allows it to be deleted or unlinked
1581 return True if sharing doesn't prevent the operation
1582 ********************************************************************/
1583 BOOL check_file_sharing(int cnum,char *fname, BOOL rename_op)
1584 {
1585   int i;
1586   int ret = False;
1587   share_mode_entry *old_shares = 0;
1588   int num_share_modes;
1589   struct stat sbuf;
1590   int token;
1591   int pid = getpid();
1592   uint32 dev, inode;
1593
1594   if(!lp_share_modes(SNUM(cnum)))
1595     return True;
1596
1597   if (stat(fname,&sbuf) == -1) return(True);
1598
1599   dev = (uint32)sbuf.st_dev;
1600   inode = (uint32)sbuf.st_ino;
1601
1602   lock_share_entry(cnum, dev, inode, &token);
1603   num_share_modes = get_share_modes(cnum, token, dev, inode, &old_shares);
1604
1605   /*
1606    * Check if the share modes will give us access.
1607    */
1608
1609   if(num_share_modes != 0)
1610   {
1611     BOOL broke_oplock;
1612
1613     do
1614     {
1615
1616       broke_oplock = False;
1617       for(i = 0; i < num_share_modes; i++)
1618       {
1619         share_mode_entry *share_entry = &old_shares[i];
1620
1621         /* 
1622          * Break oplocks before checking share modes. See comment in
1623          * open_file_shared for details. 
1624          * Check if someone has an oplock on this file. If so we must 
1625          * break it before continuing. 
1626          */
1627         if(share_entry->op_type & BATCH_OPLOCK)
1628         {
1629
1630           /*
1631            * It appears that the NT redirector may have a bug, in that
1632            * it tries to do an SMBmv on a file that it has open with a
1633            * batch oplock, and then fails to respond to the oplock break
1634            * request. This only seems to occur when the client is doing an
1635            * SMBmv to the smbd it is using - thus we try and detect this
1636            * condition by checking if the file being moved is open and oplocked by
1637            * this smbd process, and then not sending the oplock break in this
1638            * special case. If the file was open with a deny mode that 
1639            * prevents the move the SMBmv will fail anyway with a share
1640            * violation error. JRA.
1641            */
1642           if(rename_op && (share_entry->pid == pid))
1643           {
1644             DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
1645 batch oplocked file %s, dev = %x, inode = %x\n", fname, dev, inode));
1646             /* 
1647              * This next line is a test that allows the deny-mode
1648              * processing to be skipped. This seems to be needed as
1649              * NT insists on the rename succeeding (in Office 9x no less !).
1650              * This should be removed as soon as (a) MS fix the redirector
1651              * bug or (b) NT SMB support in Samba makes NT not issue the
1652              * call (as is my fervent hope). JRA.
1653              */ 
1654             continue;
1655           }
1656           else
1657           {
1658             DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
1659 dev = %x, inode = %x\n", share_entry->op_type, fname, dev, inode));
1660
1661             /* Oplock break.... */
1662             unlock_share_entry(cnum, dev, inode, token);
1663             if(request_oplock_break(share_entry, dev, inode) == False)
1664             {
1665               free((char *)old_shares);
1666               DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
1667 dev = %x, inode = %x\n", old_shares[i].op_type, fname, dev, inode));
1668               return False;
1669             }
1670             lock_share_entry(cnum, dev, inode, &token);
1671             broke_oplock = True;
1672             break;
1673           }
1674         }
1675
1676         /* someone else has a share lock on it, check to see 
1677            if we can too */
1678         if ((share_entry->share_mode != DENY_DOS) || (share_entry->pid != pid))
1679           goto free_and_exit;
1680
1681       } /* end for */
1682
1683       if(broke_oplock)
1684       {
1685         free((char *)old_shares);
1686         num_share_modes = get_share_modes(cnum, token, dev, inode, &old_shares);
1687       }
1688     } while(broke_oplock);
1689   }
1690
1691   /* XXXX exactly what share mode combinations should be allowed for
1692      deleting/renaming? */
1693   /* If we got here then either there were no share modes or
1694      all share modes were DENY_DOS and the pid == getpid() */
1695   ret = True;
1696
1697 free_and_exit:
1698
1699   unlock_share_entry(cnum, dev, inode, token);
1700   if(old_shares != NULL)
1701     free((char *)old_shares);
1702   return(ret);
1703 }
1704
1705 /****************************************************************************
1706   C. Hoch 11/22/95
1707   Helper for open_file_shared. 
1708   Truncate a file after checking locking; close file if locked.
1709   **************************************************************************/
1710 static void truncate_unless_locked(int fnum, int cnum, int token, 
1711                                    BOOL *share_locked)
1712 {
1713   if (Files[fnum].can_write){
1714     if (is_locked(fnum,cnum,0x3FFFFFFF,0)){
1715       /* If share modes are in force for this connection we
1716          have the share entry locked. Unlock it before closing. */
1717       if (*share_locked && lp_share_modes(SNUM(cnum)))
1718         unlock_share_entry( cnum, Files[fnum].fd_ptr->dev, 
1719                             Files[fnum].fd_ptr->inode, token);
1720       close_file(fnum,False);   
1721       /* Share mode no longer locked. */
1722       *share_locked = False;
1723       errno = EACCES;
1724       unix_ERR_class = ERRDOS;
1725       unix_ERR_code = ERRlock;
1726     }
1727     else
1728       ftruncate(Files[fnum].fd_ptr->fd,0); 
1729   }
1730 }
1731
1732 /****************************************************************************
1733 check if we can open a file with a share mode
1734 ****************************************************************************/
1735 int check_share_mode( share_mode_entry *share, int deny_mode, char *fname,
1736                       BOOL fcbopen, int *flags)
1737 {
1738   int old_open_mode = share->share_mode &0xF;
1739   int old_deny_mode = (share->share_mode >>4)&7;
1740
1741   if (old_deny_mode > 4 || old_open_mode > 2)
1742   {
1743     DEBUG(0,("Invalid share mode found (%d,%d,%d) on file %s\n",
1744                deny_mode,old_deny_mode,old_open_mode,fname));
1745     return False;
1746   }
1747
1748   {
1749     int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
1750                                 share->pid,fname);
1751
1752     if ((access_allowed == AFAIL) ||
1753         (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
1754         (access_allowed == AREAD && *flags == O_WRONLY) ||
1755         (access_allowed == AWRITE && *flags == O_RDONLY))
1756     {
1757       DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
1758                 deny_mode,old_deny_mode,old_open_mode,
1759                 share->pid,fname, fcbopen, *flags, access_allowed));
1760       return False;
1761     }
1762
1763     if (access_allowed == AREAD)
1764       *flags = O_RDONLY;
1765
1766     if (access_allowed == AWRITE)
1767       *flags = O_WRONLY;
1768
1769   }
1770   return True;
1771 }
1772
1773 /****************************************************************************
1774 open a file with a share mode
1775 ****************************************************************************/
1776 void open_file_shared(int fnum,int cnum,char *fname,int share_mode,int ofun,
1777                       int mode,int oplock_request, int *Access,int *action)
1778 {
1779   files_struct *fs_p = &Files[fnum];
1780   int flags=0;
1781   int flags2=0;
1782   int deny_mode = (share_mode>>4)&7;
1783   struct stat sbuf;
1784   BOOL file_existed = file_exist(fname,&sbuf);
1785   BOOL share_locked = False;
1786   BOOL fcbopen = False;
1787   int token;
1788   uint32 dev = 0;
1789   uint32 inode = 0;
1790   int num_share_modes = 0;
1791
1792   fs_p->open = False;
1793   fs_p->fd_ptr = 0;
1794
1795   /* this is for OS/2 EAs - try and say we don't support them */
1796   if (strstr(fname,".+,;=[].")) 
1797   {
1798     unix_ERR_class = ERRDOS;
1799     /* OS/2 Workplace shell fix may be main code stream in a later release. */ 
1800 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
1801     unix_ERR_code = ERRcannotopen;
1802 #else /* OS2_WPS_FIX */
1803     unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
1804 #endif /* OS2_WPS_FIX */
1805
1806     return;
1807   }
1808
1809   if ((ofun & 0x3) == 0 && file_existed)  
1810   {
1811     errno = EEXIST;
1812     return;
1813   }
1814       
1815   if (ofun & 0x10)
1816     flags2 |= O_CREAT;
1817   if ((ofun & 0x3) == 2)
1818     flags2 |= O_TRUNC;
1819
1820   /* note that we ignore the append flag as 
1821      append does not mean the same thing under dos and unix */
1822
1823   switch (share_mode&0xF)
1824   {
1825     case 1: 
1826       flags = O_WRONLY; 
1827       break;
1828     case 0xF: 
1829       fcbopen = True;
1830       flags = O_RDWR; 
1831       break;
1832     case 2: 
1833       flags = O_RDWR; 
1834       break;
1835     default:
1836       flags = O_RDONLY;
1837       break;
1838   }
1839
1840   if (share_mode&(1<<14)) {
1841           flags2 |= O_SYNC;
1842   }
1843   
1844   if (flags != O_RDONLY && file_existed && 
1845       (!CAN_WRITE(cnum) || IS_DOS_READONLY(dos_mode(cnum,fname,&sbuf)))) 
1846   {
1847     if (!fcbopen) 
1848     {
1849       errno = EACCES;
1850       return;
1851     }
1852     flags = O_RDONLY;
1853   }
1854
1855   if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) 
1856   {
1857     DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
1858     errno = EINVAL;
1859     return;
1860   }
1861
1862   if (deny_mode == DENY_FCB) deny_mode = DENY_DOS;
1863
1864   if (lp_share_modes(SNUM(cnum))) 
1865   {
1866     int i;
1867     share_mode_entry *old_shares = 0;
1868
1869     if (file_existed)
1870     {
1871       dev = (uint32)sbuf.st_dev;
1872       inode = (uint32)sbuf.st_ino;
1873       lock_share_entry(cnum, dev, inode, &token);
1874       share_locked = True;
1875       num_share_modes = get_share_modes(cnum, token, dev, inode, &old_shares);
1876     }
1877
1878     /*
1879      * Check if the share modes will give us access.
1880      */
1881
1882     if(share_locked && (num_share_modes != 0))
1883     {
1884       BOOL broke_oplock;
1885
1886       do
1887       {
1888
1889         broke_oplock = False;
1890         for(i = 0; i < num_share_modes; i++)
1891         {
1892           share_mode_entry *share_entry = &old_shares[i];
1893
1894           /* 
1895            * By observation of NetBench, oplocks are broken *before* share
1896            * modes are checked. This allows a file to be closed by the client
1897            * if the share mode would deny access and the client has an oplock. 
1898            * Check if someone has an oplock on this file. If so we must break 
1899            * it before continuing. 
1900            */
1901           if(share_entry->op_type & (EXCLUSIVE_OPLOCK|BATCH_OPLOCK))
1902           {
1903
1904             DEBUG(5,("open_file_shared: breaking oplock (%x) on file %s, \
1905 dev = %x, inode = %x\n", share_entry->op_type, fname, dev, inode));
1906
1907             /* Oplock break.... */
1908             unlock_share_entry(cnum, dev, inode, token);
1909             if(request_oplock_break(share_entry, dev, inode) == False)
1910             {
1911               free((char *)old_shares);
1912               DEBUG(0,("open_file_shared: FAILED when breaking oplock (%x) on file %s, \
1913 dev = %x, inode = %x\n", old_shares[i].op_type, fname, dev, inode));
1914               errno = EACCES;
1915               unix_ERR_class = ERRDOS;
1916               unix_ERR_code = ERRbadshare;
1917               return;
1918             }
1919             lock_share_entry(cnum, dev, inode, &token);
1920             broke_oplock = True;
1921             break;
1922           }
1923
1924           /* someone else has a share lock on it, check to see 
1925              if we can too */
1926           if(check_share_mode(share_entry, deny_mode, fname, fcbopen, &flags) == False)
1927           {
1928             free((char *)old_shares);
1929             unlock_share_entry(cnum, dev, inode, token);
1930             errno = EACCES;
1931             unix_ERR_class = ERRDOS;
1932             unix_ERR_code = ERRbadshare;
1933             return;
1934           }
1935
1936         } /* end for */
1937
1938         if(broke_oplock)
1939         {
1940           free((char *)old_shares);
1941           num_share_modes = get_share_modes(cnum, token, dev, inode, &old_shares);
1942         }
1943       } while(broke_oplock);
1944     }
1945
1946     if(old_shares != 0)
1947       free((char *)old_shares);
1948   }
1949
1950   DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1951            flags,flags2,mode));
1952
1953   open_file(fnum,cnum,fname,flags|(flags2&~(O_TRUNC)),mode,file_existed ? &sbuf : 0);
1954   if (!fs_p->open && flags==O_RDWR && errno!=ENOENT && fcbopen) 
1955   {
1956     flags = O_RDONLY;
1957     open_file(fnum,cnum,fname,flags,mode,file_existed ? &sbuf : 0 );
1958   }
1959
1960   if (fs_p->open) 
1961   {
1962     int open_mode=0;
1963
1964     if((share_locked == False) && lp_share_modes(SNUM(cnum)))
1965     {
1966       /* We created the file - thus we must now lock the share entry before creating it. */
1967       dev = fs_p->fd_ptr->dev;
1968       inode = fs_p->fd_ptr->inode;
1969       lock_share_entry(cnum, dev, inode, &token);
1970       share_locked = True;
1971     }
1972
1973     switch (flags) 
1974     {
1975       case O_RDONLY:
1976         open_mode = 0;
1977         break;
1978       case O_RDWR:
1979         open_mode = 2;
1980         break;
1981       case O_WRONLY:
1982         open_mode = 1;
1983         break;
1984     }
1985
1986     fs_p->share_mode = (deny_mode<<4) | open_mode;
1987
1988     if (Access)
1989       (*Access) = open_mode;
1990
1991     if (action) 
1992     {
1993       if (file_existed && !(flags2 & O_TRUNC)) *action = 1;
1994       if (!file_existed) *action = 2;
1995       if (file_existed && (flags2 & O_TRUNC)) *action = 3;
1996     }
1997     /* We must create the share mode entry before truncate as
1998        truncate can fail due to locking and have to close the
1999        file (which expects the share_mode_entry to be there).
2000      */
2001     if (lp_share_modes(SNUM(cnum)))
2002     {
2003       uint16 port = 0;
2004       /* JRA. Currently this only services Exlcusive and batch
2005          oplocks (no other opens on this file). This needs to
2006          be extended to level II oplocks (multiple reader
2007          oplocks). */
2008
2009       if(oplock_request && (num_share_modes == 0) && lp_oplocks(SNUM(cnum)) && 
2010               !IS_VETO_OPLOCK_PATH(cnum,fname))
2011       {
2012         fs_p->granted_oplock = True;
2013         fs_p->sent_oplock_break = False;
2014         global_oplocks_open++;
2015         port = oplock_port;
2016
2017         DEBUG(5,("open_file_shared: granted oplock (%x) on file %s, \
2018 dev = %x, inode = %x\n", oplock_request, fname, dev, inode));
2019
2020       }
2021       else
2022       {
2023         port = 0;
2024         oplock_request = 0;
2025       }
2026       set_share_mode(token, fnum, port, oplock_request);
2027     }
2028
2029     if ((flags2&O_TRUNC) && file_existed)
2030       truncate_unless_locked(fnum,cnum,token,&share_locked);
2031   }
2032
2033   if (share_locked && lp_share_modes(SNUM(cnum)))
2034     unlock_share_entry( cnum, dev, inode, token);
2035 }
2036
2037 /****************************************************************************
2038 seek a file. Try to avoid the seek if possible
2039 ****************************************************************************/
2040 int seek_file(int fnum,uint32 pos)
2041 {
2042   uint32 offset = 0;
2043   if (Files[fnum].print_file && POSTSCRIPT(Files[fnum].cnum))
2044     offset = 3;
2045
2046   Files[fnum].pos = (int)(lseek(Files[fnum].fd_ptr->fd,pos+offset,SEEK_SET) 
2047                                   - offset);
2048   return(Files[fnum].pos);
2049 }
2050
2051 /****************************************************************************
2052 read from a file
2053 ****************************************************************************/
2054 int read_file(int fnum,char *data,uint32 pos,int n)
2055 {
2056   int ret=0,readret;
2057
2058 #if USE_READ_PREDICTION
2059   if (!Files[fnum].can_write)
2060     {
2061       ret = read_predict(Files[fnum].fd_ptr->fd,pos,data,NULL,n);
2062
2063       data += ret;
2064       n -= ret;
2065       pos += ret;
2066     }
2067 #endif
2068
2069 #if USE_MMAP
2070   if (Files[fnum].mmap_ptr)
2071     {
2072       int num = (Files[fnum].mmap_size > pos) ? (Files[fnum].mmap_size - pos) : -1;
2073       num = MIN(n,num);
2074       if (num > 0)
2075         {
2076           memcpy(data,Files[fnum].mmap_ptr+pos,num);
2077           data += num;
2078           pos += num;
2079           n -= num;
2080           ret += num;
2081         }
2082     }
2083 #endif
2084
2085   if (n <= 0)
2086     return(ret);
2087
2088   if (seek_file(fnum,pos) != pos)
2089     {
2090       DEBUG(3,("Failed to seek to %d\n",pos));
2091       return(ret);
2092     }
2093   
2094   if (n > 0) {
2095     readret = read(Files[fnum].fd_ptr->fd,data,n);
2096     if (readret > 0) ret += readret;
2097   }
2098
2099   return(ret);
2100 }
2101
2102
2103 /****************************************************************************
2104 write to a file
2105 ****************************************************************************/
2106 int write_file(int fnum,char *data,int n)
2107 {
2108   if (!Files[fnum].can_write) {
2109     errno = EPERM;
2110     return(0);
2111   }
2112
2113   if (!Files[fnum].modified) {
2114     struct stat st;
2115     Files[fnum].modified = True;
2116     if (fstat(Files[fnum].fd_ptr->fd,&st) == 0) {
2117       int dosmode = dos_mode(Files[fnum].cnum,Files[fnum].name,&st);
2118       if (MAP_ARCHIVE(Files[fnum].cnum) && !IS_DOS_ARCHIVE(dosmode)) {  
2119         dos_chmod(Files[fnum].cnum,Files[fnum].name,dosmode | aARCH,&st);
2120       }
2121     }  
2122   }
2123
2124   return(write_data(Files[fnum].fd_ptr->fd,data,n));
2125 }
2126
2127
2128 /****************************************************************************
2129 load parameters specific to a connection/service
2130 ****************************************************************************/
2131 BOOL become_service(int cnum,BOOL do_chdir)
2132 {
2133   extern char magic_char;
2134   static int last_cnum = -1;
2135   int snum;
2136
2137   if (!OPEN_CNUM(cnum))
2138     {
2139       last_cnum = -1;
2140       return(False);
2141     }
2142
2143   Connections[cnum].lastused = smb_last_time;
2144
2145   snum = SNUM(cnum);
2146   
2147   if (do_chdir &&
2148       ChDir(Connections[cnum].connectpath) != 0 &&
2149       ChDir(Connections[cnum].origpath) != 0)
2150     {
2151       DEBUG(0,("%s chdir (%s) failed cnum=%d\n",timestring(),
2152             Connections[cnum].connectpath,cnum));     
2153       return(False);
2154     }
2155
2156   if (cnum == last_cnum)
2157     return(True);
2158
2159   last_cnum = cnum;
2160
2161   case_default = lp_defaultcase(snum);
2162   case_preserve = lp_preservecase(snum);
2163   short_case_preserve = lp_shortpreservecase(snum);
2164   case_mangle = lp_casemangle(snum);
2165   case_sensitive = lp_casesensitive(snum);
2166   magic_char = lp_magicchar(snum);
2167   use_mangled_map = (*lp_mangled_map(snum) ? True:False);
2168   return(True);
2169 }
2170
2171
2172 /****************************************************************************
2173   find a service entry
2174 ****************************************************************************/
2175 int find_service(char *service)
2176 {
2177    int iService;
2178
2179    string_sub(service,"\\","/");
2180
2181    iService = lp_servicenumber(service);
2182
2183    /* now handle the special case of a home directory */
2184    if (iService < 0)
2185    {
2186       char *phome_dir = get_home_dir(service);
2187       DEBUG(3,("checking for home directory %s gave %s\n",service,
2188             phome_dir?phome_dir:"(NULL)"));
2189       if (phome_dir)
2190       {   
2191          int iHomeService;
2192          if ((iHomeService = lp_servicenumber(HOMES_NAME)) >= 0)
2193          {
2194             lp_add_home(service,iHomeService,phome_dir);
2195             iService = lp_servicenumber(service);
2196          }
2197       }
2198    }
2199
2200    /* If we still don't have a service, attempt to add it as a printer. */
2201    if (iService < 0)
2202    {
2203       int iPrinterService;
2204
2205       if ((iPrinterService = lp_servicenumber(PRINTERS_NAME)) >= 0)
2206       {
2207          char *pszTemp;
2208
2209          DEBUG(3,("checking whether %s is a valid printer name...\n", service));
2210          pszTemp = PRINTCAP;
2211          if ((pszTemp != NULL) && pcap_printername_ok(service, pszTemp))
2212          {
2213             DEBUG(3,("%s is a valid printer name\n", service));
2214             DEBUG(3,("adding %s as a printer service\n", service));
2215             lp_add_printer(service,iPrinterService);
2216             iService = lp_servicenumber(service);
2217             if (iService < 0)
2218                DEBUG(0,("failed to add %s as a printer service!\n", service));
2219          }
2220          else
2221             DEBUG(3,("%s is not a valid printer name\n", service));
2222       }
2223    }
2224
2225    /* just possibly it's a default service? */
2226    if (iService < 0) 
2227      {
2228        char *pdefservice = lp_defaultservice();
2229        if (pdefservice && *pdefservice && !strequal(pdefservice,service)) {
2230          /*
2231           * We need to do a local copy here as lp_defaultservice() 
2232           * returns one of the rotating lp_string buffers that
2233           * could get overwritten by the recursive find_service() call
2234           * below. Fix from Josef Hinteregger <joehtg@joehtg.co.at>.
2235           */
2236          pstring defservice;
2237          pstrcpy(defservice, pdefservice);
2238          iService = find_service(defservice);
2239          if (iService >= 0) {
2240            string_sub(service,"_","/");
2241            iService = lp_add_service(service,iService);
2242          }
2243        }
2244      }
2245
2246    if (iService >= 0)
2247       if (!VALID_SNUM(iService))
2248       {
2249          DEBUG(0,("Invalid snum %d for %s\n",iService,service));
2250          iService = -1;
2251       }
2252
2253    if (iService < 0)
2254       DEBUG(3,("find_service() failed to find service %s\n", service));
2255
2256    return (iService);
2257 }
2258
2259
2260 /****************************************************************************
2261   create an error packet from a cached error.
2262 ****************************************************************************/
2263 int cached_error_packet(char *inbuf,char *outbuf,int fnum,int line)
2264 {
2265   write_bmpx_struct *wbmpx = Files[fnum].wbmpx_ptr;
2266
2267   int32 eclass = wbmpx->wr_errclass;
2268   int32 err = wbmpx->wr_error;
2269
2270   /* We can now delete the auxiliary struct */
2271   free((char *)wbmpx);
2272   Files[fnum].wbmpx_ptr = NULL;
2273   return error_packet(inbuf,outbuf,eclass,err,line);
2274 }
2275
2276
2277 struct
2278 {
2279   int unixerror;
2280   int smbclass;
2281   int smbcode;
2282 } unix_smb_errmap[] =
2283 {
2284   {EPERM,ERRDOS,ERRnoaccess},
2285   {EACCES,ERRDOS,ERRnoaccess},
2286   {ENOENT,ERRDOS,ERRbadfile},
2287   {ENOTDIR,ERRDOS,ERRbadpath},
2288   {EIO,ERRHRD,ERRgeneral},
2289   {EBADF,ERRSRV,ERRsrverror},
2290   {EINVAL,ERRSRV,ERRsrverror},
2291   {EEXIST,ERRDOS,ERRfilexists},
2292   {ENFILE,ERRDOS,ERRnofids},
2293   {EMFILE,ERRDOS,ERRnofids},
2294   {ENOSPC,ERRHRD,ERRdiskfull},
2295 #ifdef EDQUOT
2296   {EDQUOT,ERRHRD,ERRdiskfull},
2297 #endif
2298 #ifdef ENOTEMPTY
2299   {ENOTEMPTY,ERRDOS,ERRnoaccess},
2300 #endif
2301 #ifdef EXDEV
2302   {EXDEV,ERRDOS,ERRdiffdevice},
2303 #endif
2304   {EROFS,ERRHRD,ERRnowrite},
2305   {0,0,0}
2306 };
2307
2308 /****************************************************************************
2309   create an error packet from errno
2310 ****************************************************************************/
2311 int unix_error_packet(char *inbuf,char *outbuf,int def_class,uint32 def_code,int line)
2312 {
2313   int eclass=def_class;
2314   int ecode=def_code;
2315   int i=0;
2316
2317   if (unix_ERR_class != SMB_SUCCESS)
2318     {
2319       eclass = unix_ERR_class;
2320       ecode = unix_ERR_code;
2321       unix_ERR_class = SMB_SUCCESS;
2322       unix_ERR_code = 0;
2323     }
2324   else
2325     {
2326       while (unix_smb_errmap[i].smbclass != 0)
2327       {
2328             if (unix_smb_errmap[i].unixerror == errno)
2329             {
2330               eclass = unix_smb_errmap[i].smbclass;
2331               ecode = unix_smb_errmap[i].smbcode;
2332               break;
2333             }
2334           i++;
2335       }
2336     }
2337
2338   return(error_packet(inbuf,outbuf,eclass,ecode,line));
2339 }
2340
2341
2342 /****************************************************************************
2343   create an error packet. Normally called using the ERROR() macro
2344 ****************************************************************************/
2345 int error_packet(char *inbuf,char *outbuf,int error_class,uint32 error_code,int line)
2346 {
2347   int outsize = set_message(outbuf,0,0,True);
2348   int cmd = CVAL(inbuf,smb_com);
2349   int flgs2 = SVAL(outbuf,smb_flg2); 
2350
2351   if ((flgs2 & FLAGS2_32_BIT_ERROR_CODES) == FLAGS2_32_BIT_ERROR_CODES)
2352   {
2353     SIVAL(outbuf,smb_rcls,error_code);
2354     
2355     DEBUG(3,("%s 32 bit error packet at line %d cmd=%d (%s) eclass=%08x [%s]\n",
2356            timestring(), line, cmd, smb_fn_name(cmd), error_code, smb_errstr(outbuf)));
2357   }
2358   else
2359   {
2360     CVAL(outbuf,smb_rcls) = error_class;
2361     SSVAL(outbuf,smb_err,error_code);  
2362     DEBUG(3,("%s error packet at line %d cmd=%d (%s) eclass=%d ecode=%d\n",
2363            timestring(),
2364            line,
2365            (int)CVAL(inbuf,smb_com),
2366            smb_fn_name(CVAL(inbuf,smb_com)),
2367            error_class,
2368            error_code));
2369
2370   }
2371   
2372   if (errno != 0)
2373     DEBUG(3,("error string = %s\n",strerror(errno)));
2374   
2375   return(outsize);
2376 }
2377
2378
2379 #ifndef SIGCLD_IGNORE
2380 /****************************************************************************
2381 this prevents zombie child processes
2382 ****************************************************************************/
2383 static int sig_cld(void)
2384 {
2385   static int depth = 0;
2386   if (depth != 0)
2387     {
2388       DEBUG(0,("ERROR: Recursion in sig_cld? Perhaps you need `#define USE_WAITPID'?\n"));
2389       depth=0;
2390       return(0);
2391     }
2392   depth++;
2393
2394   BlockSignals(True,SIGCLD);
2395   DEBUG(5,("got SIGCLD\n"));
2396
2397 #ifdef USE_WAITPID
2398   while (sys_waitpid((pid_t)-1,(int *)NULL, WNOHANG) > 0);
2399 #endif
2400
2401   /* Stop zombies */
2402   /* Stevens, Adv. Unix Prog. says that on system V you must call
2403      wait before reinstalling the signal handler, because the kernel
2404      calls the handler from within the signal-call when there is a
2405      child that has exited. This would lead to an infinite recursion
2406      if done vice versa. */
2407         
2408 #ifndef DONT_REINSTALL_SIG
2409 #ifdef SIGCLD_IGNORE
2410   signal(SIGCLD, SIG_IGN);  
2411 #else
2412   signal(SIGCLD, SIGNAL_CAST sig_cld);
2413 #endif
2414 #endif
2415
2416 #ifndef USE_WAITPID
2417   while (wait3(WAIT3_CAST1 NULL, WNOHANG, WAIT3_CAST2 NULL) > 0);
2418 #endif
2419   depth--;
2420   BlockSignals(False,SIGCLD);
2421   return 0;
2422 }
2423 #endif
2424
2425 /****************************************************************************
2426   this is called when the client exits abruptly
2427   **************************************************************************/
2428 static int sig_pipe(void)
2429 {
2430         struct cli_state *cli;
2431         BlockSignals(True,SIGPIPE);
2432
2433         if ((cli = server_client()) && cli->initialised) {
2434                 DEBUG(3,("lost connection to password server\n"));
2435                 cli_shutdown(cli);
2436 #ifndef DONT_REINSTALL_SIG
2437                 signal(SIGPIPE, SIGNAL_CAST sig_pipe);
2438 #endif
2439                 BlockSignals(False,SIGPIPE);
2440                 return 0;
2441         }
2442
2443         exit_server("Got sigpipe\n");
2444         return(0);
2445 }
2446
2447 /****************************************************************************
2448   open the socket communication
2449 ****************************************************************************/
2450 static BOOL open_sockets(BOOL is_daemon,int port)
2451 {
2452   extern int Client;
2453
2454   if (is_daemon)
2455   {
2456     int num_interfaces = iface_count();
2457     int fd_listenset[FD_SETSIZE];
2458     fd_set listen_set;
2459     int s;
2460     int i;
2461
2462     /* Stop zombies */
2463 #ifdef SIGCLD_IGNORE
2464     signal(SIGCLD, SIG_IGN);
2465 #else
2466     signal(SIGCLD, SIGNAL_CAST sig_cld);
2467 #endif
2468
2469     if(atexit_set == 0)
2470       atexit(killkids);
2471
2472     FD_ZERO(&listen_set);
2473
2474     if(lp_interfaces() && lp_bind_interfaces_only())
2475     {
2476        /* We have been given an interfaces line, and been 
2477           told to only bind to those interfaces. Create a
2478           socket per interface and bind to only these.
2479         */
2480
2481       if(num_interfaces > FD_SETSIZE)
2482       {
2483         DEBUG(0,("open_sockets: Too many interfaces specified to bind to. Number was %d \
2484 max can be %d\n", num_interfaces, FD_SETSIZE));
2485         return False;
2486       }
2487
2488       /* Now open a listen socket for each of the interfaces. */
2489       for(i = 0; i < num_interfaces; i++)
2490       {
2491         struct in_addr *ifip = iface_n_ip(i);
2492
2493         if(ifip == NULL)
2494         {
2495           DEBUG(0,("open_sockets: interface %d has NULL IP address !\n", i));
2496           continue;
2497         }
2498         s = fd_listenset[i] = open_socket_in(SOCK_STREAM, port, 0, ifip->s_addr);
2499         if(s == -1)
2500           return False;
2501         /* ready to listen */
2502         if (listen(s, 5) == -1) 
2503         {
2504           DEBUG(0,("listen: %s\n",strerror(errno)));
2505           close(s);
2506           return False;
2507         }
2508         FD_SET(s,&listen_set);
2509       }
2510     }
2511     else
2512     {
2513       /* Just bind to 0.0.0.0 - accept connections from anywhere. */
2514       num_interfaces = 1;
2515
2516       /* open an incoming socket */
2517       s = open_socket_in(SOCK_STREAM, port, 0,interpret_addr(lp_socket_address()));
2518       if (s == -1)
2519         return(False);
2520
2521       /* ready to listen */
2522       if (listen(s, 5) == -1) 
2523       {
2524         DEBUG(0,("open_sockets: listen: %s\n",strerror(errno)));
2525         close(s);
2526         return False;
2527       }
2528
2529       fd_listenset[0] = s;
2530       FD_SET(s,&listen_set);
2531     }      
2532
2533     /* now accept incoming connections - forking a new process
2534        for each incoming connection */
2535     DEBUG(2,("waiting for a connection\n"));
2536     while (1)
2537     {
2538       fd_set lfds;
2539       int num;
2540
2541       memcpy((char *)&lfds, (char *)&listen_set, sizeof(listen_set));
2542
2543       num = sys_select(&lfds,NULL);
2544
2545       if (num == -1 && errno == EINTR)
2546         continue;
2547
2548       /* Find the sockets that are read-ready - accept on these. */
2549       for( ; num > 0; num--)
2550       {
2551         struct sockaddr addr;
2552         int in_addrlen = sizeof(addr);
2553
2554         s = -1;
2555         for(i = 0; i < num_interfaces; i++)
2556         {
2557           if(FD_ISSET(fd_listenset[i],&lfds))
2558           {
2559             s = fd_listenset[i];
2560             /* Clear this so we don't look at it again. */
2561             FD_CLR(fd_listenset[i],&lfds);
2562             break;
2563           }
2564         }
2565
2566         Client = accept(s,&addr,&in_addrlen);
2567
2568         if (Client == -1 && errno == EINTR)
2569           continue;
2570
2571         if (Client == -1)
2572         {
2573           DEBUG(0,("open_sockets: accept: %s\n",strerror(errno)));
2574           continue;
2575         }
2576
2577 #ifdef NO_FORK_DEBUG
2578 #ifndef NO_SIGNAL_TEST
2579         signal(SIGPIPE, SIGNAL_CAST sig_pipe);
2580         signal(SIGCLD, SIGNAL_CAST SIG_DFL);
2581 #endif /* NO_SIGNAL_TEST */
2582         return True;
2583 #else /* NO_FORK_DEBUG */
2584         if (Client != -1 && fork()==0)
2585         {
2586           /* Child code ... */
2587
2588 #ifndef NO_SIGNAL_TEST
2589           signal(SIGPIPE, SIGNAL_CAST sig_pipe);
2590           signal(SIGCLD, SIGNAL_CAST SIG_DFL);
2591 #endif /* NO_SIGNAL_TEST */
2592           /* close the listening socket(s) */
2593           for(i = 0; i < num_interfaces; i++)
2594             close(fd_listenset[i]);
2595
2596           /* close our standard file descriptors */
2597           close_low_fds();
2598           am_parent = 0;
2599   
2600           set_socket_options(Client,"SO_KEEPALIVE");
2601           set_socket_options(Client,user_socket_options);
2602
2603           /* Reset global variables in util.c so that
2604              client substitutions will be done correctly
2605              in the process.
2606            */
2607           reset_globals_after_fork();
2608           return True; 
2609         }
2610         close(Client); /* The parent doesn't need this socket */
2611 #endif /* NO_FORK_DEBUG */
2612       } /* end for num */
2613     } /* end while 1 */
2614   } /* end if is_daemon */
2615   else
2616   {
2617     /* Started from inetd. fd 0 is the socket. */
2618     /* We will abort gracefully when the client or remote system 
2619        goes away */
2620 #ifndef NO_SIGNAL_TEST
2621     signal(SIGPIPE, SIGNAL_CAST sig_pipe);
2622 #endif
2623     Client = dup(0);
2624
2625     /* close our standard file descriptors */
2626     close_low_fds();
2627
2628     set_socket_options(Client,"SO_KEEPALIVE");
2629     set_socket_options(Client,user_socket_options);
2630   }
2631
2632   return True;
2633 }
2634
2635 /****************************************************************************
2636   process an smb from the client - split out from the process() code so
2637   it can be used by the oplock break code.
2638 ****************************************************************************/
2639
2640 static void process_smb(char *inbuf, char *outbuf)
2641 {
2642   extern int Client;
2643   static int trans_num;
2644   int msg_type = CVAL(inbuf,0);
2645   int32 len = smb_len(inbuf);
2646   int nread = len + 4;
2647
2648   if (trans_num == 0) {
2649           /* on the first packet, check the global hosts allow/ hosts
2650              deny parameters before doing any parsing of the packet
2651              passed to us by the client.  This prevents attacks on our
2652              parsing code from hosts not in the hosts allow list */
2653           if (!check_access(-1)) {
2654                   /* send a negative session response "not listining on calling
2655                    name" */
2656                   static unsigned char buf[5] = {0x83, 0, 0, 1, 0x81};
2657                   DEBUG(1,("%s Connection denied from %s\n",
2658                            timestring(),client_addr(Client)));
2659                   send_smb(Client,(char *)buf);
2660                   exit_server("connection denied");
2661           }
2662   }
2663
2664   DEBUG(6,("got message type 0x%x of len 0x%x\n",msg_type,len));
2665   DEBUG(3,("%s Transaction %d of length %d\n",timestring(),trans_num,nread));
2666
2667 #ifdef WITH_VTP
2668   if(trans_num == 1 && VT_Check(inbuf)) 
2669   {
2670     VT_Process();
2671     return;
2672   }
2673 #endif
2674
2675   if (msg_type == 0)
2676     show_msg(inbuf);
2677   else if(msg_type == 0x85)
2678     return; /* Keepalive packet. */
2679
2680   nread = construct_reply(inbuf,outbuf,nread,max_send);
2681       
2682   if(nread > 0) 
2683   {
2684     if (CVAL(outbuf,0) == 0)
2685       show_msg(outbuf);
2686         
2687     if (nread != smb_len(outbuf) + 4) 
2688     {
2689       DEBUG(0,("ERROR: Invalid message response size! %d %d\n",
2690                  nread, smb_len(outbuf)));
2691     }
2692     else
2693       send_smb(Client,outbuf);
2694   }
2695   trans_num++;
2696 }
2697
2698 /****************************************************************************
2699   open the oplock IPC socket communication
2700 ****************************************************************************/
2701 static BOOL open_oplock_ipc(void)
2702 {
2703   struct sockaddr_in sock_name;
2704   int len = sizeof(sock_name);
2705
2706   DEBUG(3,("open_oplock_ipc: opening loopback UDP socket.\n"));
2707
2708   /* Open a lookback UDP socket on a random port. */
2709   oplock_sock = open_socket_in(SOCK_DGRAM, 0, 0, htonl(INADDR_LOOPBACK));
2710   if (oplock_sock == -1)
2711   {
2712     DEBUG(0,("open_oplock_ipc: Failed to get local UDP socket for \
2713 address %x. Error was %s\n", htonl(INADDR_LOOPBACK), strerror(errno)));
2714     oplock_port = 0;
2715     return(False);
2716   }
2717
2718   /* Find out the transient UDP port we have been allocated. */
2719   if(getsockname(oplock_sock, (struct sockaddr *)&sock_name, &len)<0)
2720   {
2721     DEBUG(0,("open_oplock_ipc: Failed to get local UDP port. Error was %s\n",
2722             strerror(errno)));
2723     close(oplock_sock);
2724     oplock_sock = -1;
2725     oplock_port = 0;
2726     return False;
2727   }
2728   oplock_port = ntohs(sock_name.sin_port);
2729
2730   DEBUG(3,("open_oplock ipc: pid = %d, oplock_port = %u\n", 
2731             getpid(), oplock_port));
2732
2733   return True;
2734 }
2735
2736 /****************************************************************************
2737   process an oplock break message.
2738 ****************************************************************************/
2739 static BOOL process_local_message(int sock, char *buffer, int buf_size)
2740 {
2741   int32 msg_len;
2742   uint16 from_port;
2743   char *msg_start;
2744
2745   msg_len = IVAL(buffer,UDP_CMD_LEN_OFFSET);
2746   from_port = SVAL(buffer,UDP_CMD_PORT_OFFSET);
2747
2748   msg_start = &buffer[UDP_CMD_HEADER_LEN];
2749
2750   DEBUG(5,("process_local_message: Got a message of length %d from port (%d)\n", 
2751             msg_len, from_port));
2752
2753   /* Switch on message command - currently OPLOCK_BREAK_CMD is the
2754      only valid request. */
2755
2756   switch(SVAL(msg_start,UDP_MESSAGE_CMD_OFFSET))
2757   {
2758     case OPLOCK_BREAK_CMD:
2759       /* Ensure that the msg length is correct. */
2760       if(msg_len != OPLOCK_BREAK_MSG_LEN)
2761       {
2762         DEBUG(0,("process_local_message: incorrect length for OPLOCK_BREAK_CMD (was %d, \
2763 should be %d).\n", msg_len, OPLOCK_BREAK_MSG_LEN));
2764         return False;
2765       }
2766       {
2767         uint32 remotepid = IVAL(msg_start,OPLOCK_BREAK_PID_OFFSET);
2768         uint32 dev = IVAL(msg_start,OPLOCK_BREAK_DEV_OFFSET);
2769         uint32 inode = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET);
2770         struct timeval tval;
2771         struct sockaddr_in toaddr;
2772
2773         tval.tv_sec = IVAL(msg_start, OPLOCK_BREAK_SEC_OFFSET);
2774         tval.tv_usec = IVAL(msg_start, OPLOCK_BREAK_USEC_OFFSET);
2775
2776         DEBUG(5,("process_local_message: oplock break request from \
2777 pid %d, port %d, dev = %x, inode = %x\n", remotepid, from_port, dev, inode));
2778
2779         /*
2780          * If we have no record of any currently open oplocks,
2781          * it's not an error, as a close command may have
2782          * just been issued on the file that was oplocked.
2783          * Just return success in this case.
2784          */
2785
2786         if(global_oplocks_open != 0)
2787         {
2788           if(oplock_break(dev, inode, &tval) == False)
2789           {
2790             DEBUG(0,("process_local_message: oplock break failed - \
2791 not returning udp message.\n"));
2792             return False;
2793           }
2794         }
2795         else
2796         {
2797           DEBUG(3,("process_local_message: oplock break requested with no outstanding \
2798 oplocks. Returning success.\n"));
2799         }
2800
2801         /* Send the message back after OR'ing in the 'REPLY' bit. */
2802         SSVAL(msg_start,UDP_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD | CMD_REPLY);
2803   
2804         bzero((char *)&toaddr,sizeof(toaddr));
2805         toaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
2806         toaddr.sin_port = htons(from_port);
2807         toaddr.sin_family = AF_INET;
2808
2809         if(sendto( sock, msg_start, OPLOCK_BREAK_MSG_LEN, 0,
2810                 (struct sockaddr *)&toaddr, sizeof(toaddr)) < 0) 
2811         {
2812           DEBUG(0,("process_local_message: sendto process %d failed. Errno was %s\n",
2813                     remotepid, strerror(errno)));
2814           return False;
2815         }
2816
2817         DEBUG(5,("process_local_message: oplock break reply sent to \
2818 pid %d, port %d, for file dev = %x, inode = %x\n", remotepid, 
2819                 from_port, dev, inode));
2820
2821       }
2822       break;
2823     /* 
2824      * Keep this as a debug case - eventually we can remove it.
2825      */
2826     case 0x8001:
2827       DEBUG(0,("process_local_message: Received unsolicited break \
2828 reply - dumping info.\n"));
2829
2830       if(msg_len != OPLOCK_BREAK_MSG_LEN)
2831       {
2832         DEBUG(0,("process_local_message: ubr: incorrect length for reply \
2833 (was %d, should be %d).\n", msg_len, OPLOCK_BREAK_MSG_LEN));
2834         return False;
2835       }
2836
2837       {
2838         uint32 remotepid = IVAL(msg_start,OPLOCK_BREAK_PID_OFFSET);
2839         uint32 dev = IVAL(msg_start,OPLOCK_BREAK_DEV_OFFSET);
2840         uint32 inode = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET);
2841
2842         DEBUG(0,("process_local_message: unsolicited oplock break reply from \
2843 pid %d, port %d, dev = %x, inode = %x\n", remotepid, from_port, dev, inode));
2844
2845        }
2846        return False;
2847
2848     default:
2849       DEBUG(0,("process_local_message: unknown UDP message command code (%x) - ignoring.\n",
2850                 (unsigned int)SVAL(msg_start,0)));
2851       return False;
2852   }
2853   return True;
2854 }
2855
2856 /****************************************************************************
2857  Process an oplock break directly.
2858 ****************************************************************************/
2859 BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval)
2860 {
2861   extern int Client;
2862   char *inbuf = NULL;
2863   char *outbuf = NULL;
2864   files_struct *fsp = NULL;
2865   int fnum;
2866   time_t start_time;
2867   BOOL shutdown_server = False;
2868
2869   DEBUG(3,("%s oplock_break: called for dev = %x, inode = %x. Current \
2870 global_oplocks_open = %d\n", timestring(), dev, inode, global_oplocks_open));
2871
2872   /* We need to search the file open table for the
2873      entry containing this dev and inode, and ensure
2874      we have an oplock on it. */
2875   for( fnum = 0; fnum < MAX_OPEN_FILES; fnum++)
2876   {
2877     if(OPEN_FNUM(fnum))
2878     {
2879       if((Files[fnum].fd_ptr->dev == dev) && (Files[fnum].fd_ptr->inode == inode) &&
2880          (Files[fnum].open_time.tv_sec == tval->tv_sec) && 
2881          (Files[fnum].open_time.tv_usec == tval->tv_usec)) {
2882               fsp = &Files[fnum];
2883               break;
2884       }
2885     }
2886   }
2887
2888   if(fsp == NULL)
2889   {
2890     /* The file could have been closed in the meantime - return success. */
2891     DEBUG(0,("%s oplock_break: cannot find open file with dev = %x, inode = %x (fnum = %d) \
2892 allowing break to succeed.\n", timestring(), dev, inode, fnum));
2893     return True;
2894   }
2895
2896   /* Ensure we have an oplock on the file */
2897
2898   /* There is a potential race condition in that an oplock could
2899      have been broken due to another udp request, and yet there are
2900      still oplock break messages being sent in the udp message
2901      queue for this file. So return true if we don't have an oplock,
2902      as we may have just freed it.
2903    */
2904
2905   if(!fsp->granted_oplock)
2906   {
2907     DEBUG(0,("%s oplock_break: file %s (fnum = %d, dev = %x, inode = %x) has no oplock. Allowing break to succeed regardless.\n", timestring(), fsp->name, fnum, dev, inode));
2908     return True;
2909   }
2910
2911   /* mark the oplock break as sent - we don't want to send twice! */
2912   if (fsp->sent_oplock_break)
2913   {
2914     DEBUG(0,("%s oplock_break: ERROR: oplock_break already sent for file %s (fnum = %d, dev = %x, inode = %x)\n", timestring(), fsp->name, fnum, dev, inode));
2915
2916     /* We have to fail the open here as we cannot send another oplock break on this
2917        file whilst we are awaiting a response from the client - neither can we
2918        allow another open to succeed while we are waiting for the client. */
2919     return False;
2920   }
2921
2922   /* Now comes the horrid part. We must send an oplock break to the client,
2923      and then process incoming messages until we get a close or oplock release.
2924      At this point we know we need a new inbuf/outbuf buffer pair.
2925      We cannot use these staticaly as we may recurse into here due to
2926      messages crossing on the wire.
2927    */
2928
2929   if((inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN))==NULL)
2930   {
2931     DEBUG(0,("oplock_break: malloc fail for input buffer.\n"));
2932     return False;
2933   }
2934
2935   if((outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN))==NULL)
2936   {
2937     DEBUG(0,("oplock_break: malloc fail for output buffer.\n"));
2938     free(inbuf);
2939     inbuf = NULL;
2940     return False;
2941   }
2942
2943   /* Prepare the SMBlockingX message. */
2944   bzero(outbuf,smb_size);
2945   set_message(outbuf,8,0,True);
2946
2947   SCVAL(outbuf,smb_com,SMBlockingX);
2948   SSVAL(outbuf,smb_tid,fsp->cnum);
2949   SSVAL(outbuf,smb_pid,0xFFFF);
2950   SSVAL(outbuf,smb_uid,0);
2951   SSVAL(outbuf,smb_mid,0xFFFF);
2952   SCVAL(outbuf,smb_vwv0,0xFF);
2953   SSVAL(outbuf,smb_vwv2,fnum);
2954   SCVAL(outbuf,smb_vwv3,LOCKING_ANDX_OPLOCK_RELEASE);
2955   /* Change this when we have level II oplocks. */
2956   SCVAL(outbuf,smb_vwv3+1,OPLOCKLEVEL_NONE);
2957  
2958   send_smb(Client, outbuf);
2959
2960   /* Remember we just sent an oplock break on this file. */
2961   fsp->sent_oplock_break = True;
2962
2963   /* We need this in case a readraw crosses on the wire. */
2964   global_oplock_break = True;
2965  
2966   /* Process incoming messages. */
2967
2968   /* JRA - If we don't get a break from the client in OPLOCK_BREAK_TIMEOUT
2969      seconds we should just die.... */
2970
2971   start_time = time(NULL);
2972
2973   while(OPEN_FNUM(fnum) && fsp->granted_oplock)
2974   {
2975     if(receive_smb(Client,inbuf,OPLOCK_BREAK_TIMEOUT * 1000) == False)
2976     {
2977       /*
2978        * Die if we got an error.
2979        */
2980
2981       if (smb_read_error == READ_EOF)
2982         DEBUG(0,("%s oplock_break: end of file from client\n", timestring()));
2983  
2984       if (smb_read_error == READ_ERROR)
2985         DEBUG(0,("%s oplock_break: receive_smb error (%s)\n",
2986                   timestring(), strerror(errno)));
2987
2988       if (smb_read_error == READ_TIMEOUT)
2989         DEBUG(0,("%s oplock_break: receive_smb timed out after %d seconds.\n",
2990                   timestring(), OPLOCK_BREAK_TIMEOUT));
2991
2992       DEBUG(0,("%s oplock_break failed for file %s (fnum = %d, dev = %x, \
2993 inode = %x).\n", timestring(), fsp->name, fnum, dev, inode));
2994       shutdown_server = True;
2995       break;
2996     }
2997
2998     /*
2999      * There are certain SMB requests that we shouldn't allow
3000      * to recurse. opens, renames and deletes are the obvious
3001      * ones. This is handled in the switch_message() function.
3002      * If global_oplock_break is set they will push the packet onto
3003      * the pending smb queue and return -1 (no reply).
3004      * JRA.
3005      */
3006
3007     process_smb(inbuf, outbuf);
3008
3009     /*
3010      * Die if we go over the time limit.
3011      */
3012
3013     if((time(NULL) - start_time) > OPLOCK_BREAK_TIMEOUT)
3014     {
3015       DEBUG(0,("%s oplock_break: no break received from client within \
3016 %d seconds.\n", timestring(), OPLOCK_BREAK_TIMEOUT));
3017       DEBUG(0,("%s oplock_break failed for file %s (fnum = %d, dev = %x, \
3018 inode = %x).\n", timestring(), fsp->name, fnum, dev, inode));
3019       shutdown_server = True;
3020       break;
3021     }
3022   }
3023
3024   /* Free the buffers we've been using to recurse. */
3025   free(inbuf);
3026   free(outbuf);
3027
3028   /* We need this in case a readraw crossed on the wire. */
3029   if(global_oplock_break)
3030     global_oplock_break = False;
3031
3032   /*
3033    * If the client did not respond we must die.
3034    */
3035
3036   if(shutdown_server)
3037   {
3038     DEBUG(0,("%s oplock_break: client failure in break - shutting down this smbd.\n",
3039           timestring()));
3040     close_sockets();
3041     close(oplock_sock);
3042     exit_server("oplock break failure");
3043   }
3044
3045   if(OPEN_FNUM(fnum))
3046   {
3047     /* The lockingX reply will have removed the oplock flag 
3048        from the sharemode. */
3049     /* Paranoia.... */
3050     fsp->granted_oplock = False;
3051     fsp->sent_oplock_break = False;
3052     global_oplocks_open--;
3053   }
3054
3055   /* Santity check - remove this later. JRA */
3056   if(global_oplocks_open < 0)
3057   {
3058     DEBUG(0,("oplock_break: global_oplocks_open < 0 (%d). PANIC ERROR\n",
3059               global_oplocks_open));
3060     exit_server("oplock_break: global_oplocks_open < 0");
3061   }
3062
3063   DEBUG(3,("%s oplock_break: returning success for fnum = %d, dev = %x, inode = %x. Current \
3064 global_oplocks_open = %d\n", timestring(), fnum, dev, inode, global_oplocks_open));
3065
3066   return True;
3067 }
3068
3069 /****************************************************************************
3070 Send an oplock break message to another smbd process. If the oplock is held 
3071 by the local smbd then call the oplock break function directly.
3072 ****************************************************************************/
3073
3074 BOOL request_oplock_break(share_mode_entry *share_entry, 
3075                           uint32 dev, uint32 inode)
3076 {
3077   char op_break_msg[OPLOCK_BREAK_MSG_LEN];
3078   struct sockaddr_in addr_out;
3079   int pid = getpid();
3080   time_t start_time;
3081   int time_left;
3082
3083   if(pid == share_entry->pid)
3084   {
3085     /* We are breaking our own oplock, make sure it's us. */
3086     if(share_entry->op_port != oplock_port)
3087     {
3088       DEBUG(0,("request_oplock_break: corrupt share mode entry - pid = %d, port = %d \
3089 should be %d\n", pid, share_entry->op_port, oplock_port));
3090       return False;
3091     }
3092
3093     DEBUG(5,("request_oplock_break: breaking our own oplock\n"));
3094
3095     /* Call oplock break direct. */
3096     return oplock_break(dev, inode, &share_entry->time);
3097   }
3098
3099   /* We need to send a OPLOCK_BREAK_CMD message to the
3100      port in the share mode entry. */
3101
3102   SSVAL(op_break_msg,UDP_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD);
3103   SIVAL(op_break_msg,OPLOCK_BREAK_PID_OFFSET,pid);
3104   SIVAL(op_break_msg,OPLOCK_BREAK_DEV_OFFSET,dev);
3105   SIVAL(op_break_msg,OPLOCK_BREAK_INODE_OFFSET,inode);
3106   SIVAL(op_break_msg,OPLOCK_BREAK_SEC_OFFSET,(uint32)share_entry->time.tv_sec);
3107   SIVAL(op_break_msg,OPLOCK_BREAK_USEC_OFFSET,(uint32)share_entry->time.tv_usec);
3108
3109   /* set the address and port */
3110   bzero((char *)&addr_out,sizeof(addr_out));
3111   addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
3112   addr_out.sin_port = htons( share_entry->op_port );
3113   addr_out.sin_family = AF_INET;
3114    
3115   DEBUG(3,("%s request_oplock_break: sending a oplock break message to pid %d on port %d \
3116 for dev = %x, inode = %x\n", timestring(), share_entry->pid, share_entry->op_port, dev, inode));
3117
3118   if(sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0,
3119          (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0)
3120   {
3121     DEBUG(0,("%s request_oplock_break: failed when sending a oplock break message \
3122 to pid %d on port %d for dev = %x, inode = %x. Error was %s\n",
3123          timestring(), share_entry->pid, share_entry->op_port, dev, inode,
3124          strerror(errno)));
3125     return False;
3126   }
3127
3128   /*
3129    * Now we must await the oplock broken message coming back
3130    * from the target smbd process. Timeout if it fails to
3131    * return in (OPLOCK_BREAK_TIMEOUT + OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR) seconds.
3132    * While we get messages that aren't ours, loop.
3133    */
3134
3135   start_time = time(NULL);
3136   time_left = OPLOCK_BREAK_TIMEOUT+OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR;
3137
3138   while(time_left >= 0)
3139   {
3140     char op_break_reply[UDP_CMD_HEADER_LEN+OPLOCK_BREAK_MSG_LEN];
3141     int32 reply_msg_len;
3142     uint16 reply_from_port;
3143     char *reply_msg_start;
3144
3145     if(receive_local_message(oplock_sock, op_break_reply, sizeof(op_break_reply),
3146                time_left ? time_left * 1000 : 1) == False)
3147     {
3148       if(smb_read_error == READ_TIMEOUT)
3149       {
3150         DEBUG(0,("%s request_oplock_break: no response received to oplock break request to \
3151 pid %d on port %d for dev = %x, inode = %x\n", timestring(), share_entry->pid, 
3152                            share_entry->op_port, dev, inode));
3153         /*
3154          * This is a hack to make handling of failing clients more robust.
3155          * If a oplock break response message is not received in the timeout
3156          * period we may assume that the smbd servicing that client holding
3157          * the oplock has died and the client changes were lost anyway, so
3158          * we should continue to try and open the file.
3159          */
3160         break;
3161       }
3162       else
3163         DEBUG(0,("%s request_oplock_break: error in response received to oplock break request to \
3164 pid %d on port %d for dev = %x, inode = %x. Error was (%s).\n", timestring, share_entry->pid, 
3165                          share_entry->op_port, dev, inode, strerror(errno)));
3166       return False;
3167     }
3168
3169     reply_msg_len = IVAL(op_break_reply,UDP_CMD_LEN_OFFSET);
3170     reply_from_port = SVAL(op_break_reply,UDP_CMD_PORT_OFFSET);
3171
3172     reply_msg_start = &op_break_reply[UDP_CMD_HEADER_LEN];
3173
3174     if(reply_msg_len != OPLOCK_BREAK_MSG_LEN)
3175     {
3176       /* Ignore it. */
3177       DEBUG(0,("%s request_oplock_break: invalid message length received. Ignoring\n",
3178              timestring()));
3179       continue;
3180     }
3181
3182     /*
3183      * Test to see if this is the reply we are awaiting.
3184      */
3185
3186     if((SVAL(reply_msg_start,UDP_MESSAGE_CMD_OFFSET) & CMD_REPLY) &&
3187        (reply_from_port == share_entry->op_port) && 
3188        (memcmp(&reply_msg_start[OPLOCK_BREAK_PID_OFFSET], 
3189                &op_break_msg[OPLOCK_BREAK_PID_OFFSET],
3190                OPLOCK_BREAK_MSG_LEN - OPLOCK_BREAK_PID_OFFSET) == 0))
3191     {
3192       /*
3193        * This is the reply we've been waiting for.
3194        */
3195       break;
3196     }
3197     else
3198     {
3199       /*
3200        * This is another message - probably a break request.
3201        * Process it to prevent potential deadlock.
3202        * Note that the code in switch_message() prevents
3203        * us from recursing into here as any SMB requests
3204        * we might process that would cause another oplock
3205        * break request to be made will be queued.
3206        * JRA.
3207        */
3208
3209       process_local_message(oplock_sock, op_break_reply, sizeof(op_break_reply));
3210     }
3211
3212     time_left -= (time(NULL) - start_time);
3213   }
3214
3215   DEBUG(3,("%s request_oplock_break: broke oplock.\n", timestring()));
3216
3217   return True;
3218 }
3219
3220 /****************************************************************************
3221 Get the next SMB packet, doing the local message processing automatically.
3222 ****************************************************************************/
3223
3224 BOOL receive_next_smb(int smbfd, int oplockfd, char *inbuf, int bufsize, int timeout)
3225 {
3226   BOOL got_smb = False;
3227   BOOL ret;
3228
3229   do
3230   {
3231     ret = receive_message_or_smb(smbfd,oplockfd,inbuf,bufsize,
3232                                  timeout,&got_smb);
3233
3234     if(ret && !got_smb)
3235     {
3236       /* Deal with oplock break requests from other smbd's. */
3237       process_local_message(oplock_sock, inbuf, bufsize);
3238       continue;
3239     }
3240
3241     if(ret && (CVAL(inbuf,0) == 0x85))
3242     {
3243       /* Keepalive packet. */
3244       got_smb = False;
3245     }
3246
3247   }
3248   while(ret && !got_smb);
3249
3250   return ret;
3251 }
3252
3253 /****************************************************************************
3254 check if a snum is in use
3255 ****************************************************************************/
3256 BOOL snum_used(int snum)
3257 {
3258   int i;
3259   for (i=0;i<MAX_CONNECTIONS;i++)
3260     if (OPEN_CNUM(i) && (SNUM(i) == snum))
3261       return(True);
3262   return(False);
3263 }
3264
3265 /****************************************************************************
3266   reload the services file
3267   **************************************************************************/
3268 BOOL reload_services(BOOL test)
3269 {
3270   BOOL ret;
3271
3272   if (lp_loaded())
3273     {
3274       pstring fname;
3275       pstrcpy(fname,lp_configfile());
3276       if (file_exist(fname,NULL) && !strcsequal(fname,servicesf))
3277         {
3278           pstrcpy(servicesf,fname);
3279           test = False;
3280         }
3281     }
3282
3283   reopen_logs();
3284
3285   if (test && !lp_file_list_changed())
3286     return(True);
3287
3288   lp_killunused(snum_used);
3289
3290   ret = lp_load(servicesf,False,False,True);
3291
3292   /* perhaps the config filename is now set */
3293   if (!test)
3294     reload_services(True);
3295
3296   reopen_logs();
3297
3298   load_interfaces();
3299
3300   {
3301     extern int Client;
3302     if (Client != -1) {      
3303       set_socket_options(Client,"SO_KEEPALIVE");
3304       set_socket_options(Client,user_socket_options);
3305     }
3306   }
3307
3308   reset_mangled_cache();
3309
3310   /* this forces service parameters to be flushed */
3311   become_service(-1,True);
3312
3313   return(ret);
3314 }
3315
3316
3317
3318 /****************************************************************************
3319 this prevents zombie child processes
3320 ****************************************************************************/
3321 static int sig_hup(void)
3322 {
3323   BlockSignals(True,SIGHUP);
3324   DEBUG(0,("Got SIGHUP\n"));
3325   reload_services(False);
3326 #ifndef DONT_REINSTALL_SIG
3327   signal(SIGHUP,SIGNAL_CAST sig_hup);
3328 #endif
3329   BlockSignals(False,SIGHUP);
3330   return(0);
3331 }
3332
3333
3334 /****************************************************************************
3335   make a connection to a service
3336 ****************************************************************************/
3337 int make_connection(char *service,char *user,char *password, int pwlen, char *dev,uint16 vuid)
3338 {
3339   int cnum;
3340   int snum;
3341   struct passwd *pass = NULL;
3342   connection_struct *pcon;
3343   BOOL guest = False;
3344   BOOL force = False;
3345
3346   strlower(service);
3347
3348   snum = find_service(service);
3349   if (snum < 0)
3350     {
3351       extern int Client;
3352       if (strequal(service,"IPC$"))
3353         {         
3354           DEBUG(3,("%s refusing IPC connection\n",timestring()));
3355           return(-3);
3356         }
3357
3358       DEBUG(0,("%s %s (%s) couldn't find service %s\n",timestring(),remote_machine,client_addr(Client),service));      
3359       return(-2);
3360     }
3361
3362   if (strequal(service,HOMES_NAME))
3363     {
3364       if (*user && Get_Pwnam(user,True))
3365         return(make_connection(user,user,password,pwlen,dev,vuid));
3366
3367       if(lp_security() != SEC_SHARE)
3368       {
3369         if (validated_username(vuid))
3370         {
3371           strcpy(user,validated_username(vuid));
3372           return(make_connection(user,user,password,pwlen,dev,vuid));
3373         }
3374       }
3375       else
3376       {
3377         /*
3378          * Security = share. Try with sesssetup_user as the username.
3379          */
3380         if(*sesssetup_user)
3381         {
3382           strcpy(user,sesssetup_user);
3383           return(make_connection(user,user,password,pwlen,dev,vuid));
3384         }
3385       }
3386     }
3387
3388   if (!lp_snum_ok(snum) || !check_access(snum)) {    
3389     return(-4);
3390   }
3391
3392   /* you can only connect to the IPC$ service as an ipc device */
3393   if (strequal(service,"IPC$"))
3394     strcpy(dev,"IPC");
3395
3396   if (*dev == '?' || !*dev)
3397     {
3398       if (lp_print_ok(snum))
3399         strcpy(dev,"LPT1:");
3400       else
3401         strcpy(dev,"A:");
3402     }
3403
3404   /* if the request is as a printer and you can't print then refuse */
3405   strupper(dev);
3406   if (!lp_print_ok(snum) && (strncmp(dev,"LPT",3) == 0)) {
3407     DEBUG(1,("Attempt to connect to non-printer as a printer\n"));
3408     return(-6);
3409   }
3410
3411   /* lowercase the user name */
3412   strlower(user);
3413
3414   /* add it as a possible user name */
3415   add_session_user(service);
3416
3417   /* shall we let them in? */
3418   if (!authorise_login(snum,user,password,pwlen,&guest,&force,vuid))
3419     {
3420       DEBUG(2,("%s invalid username/password for %s\n",timestring(),service));
3421       return(-1);
3422     }
3423   
3424   cnum = find_free_connection(str_checksum(service) + str_checksum(user));
3425   if (cnum < 0)
3426     {
3427       DEBUG(0,("%s couldn't find free connection\n",timestring()));      
3428       return(-1);
3429     }
3430
3431   pcon = &Connections[cnum];
3432   bzero((char *)pcon,sizeof(*pcon));
3433
3434   /* find out some info about the user */
3435   pass = Get_Pwnam(user,True);
3436
3437   if (pass == NULL)
3438     {
3439       DEBUG(0,("%s couldn't find account %s\n",timestring(),user)); 
3440       return(-7);
3441     }
3442
3443   pcon->read_only = lp_readonly(snum);
3444
3445   {
3446     pstring list;
3447     StrnCpy(list,lp_readlist(snum),sizeof(pstring)-1);
3448     string_sub(list,"%S",service);
3449
3450     if (user_in_list(user,list))
3451       pcon->read_only = True;
3452
3453     StrnCpy(list,lp_writelist(snum),sizeof(pstring)-1);
3454     string_sub(list,"%S",service);
3455
3456     if (user_in_list(user,list))
3457       pcon->read_only = False;    
3458   }
3459
3460   /* admin user check */
3461
3462   /* JRA - original code denied admin user if the share was
3463      marked read_only. Changed as I don't think this is needed,
3464      but old code left in case there is a problem here.
3465    */
3466   if (user_in_list(user,lp_admin_users(snum)) 
3467 #if 0
3468       && !pcon->read_only)
3469 #else
3470       )
3471 #endif
3472     {
3473       pcon->admin_user = True;
3474       DEBUG(0,("%s logged in as admin user (root privileges)\n",user));
3475     }
3476   else
3477     pcon->admin_user = False;
3478     
3479   pcon->force_user = force;
3480   pcon->vuid = vuid;
3481   pcon->uid = pass->pw_uid;
3482   pcon->gid = pass->pw_gid;
3483   pcon->num_files_open = 0;
3484   pcon->lastused = time(NULL);
3485   pcon->service = snum;
3486   pcon->used = True;
3487   pcon->printer = (strncmp(dev,"LPT",3) == 0);
3488   pcon->ipc = (strncmp(dev,"IPC",3) == 0);
3489   pcon->dirptr = NULL;
3490   pcon->veto_list = NULL;
3491   pcon->hide_list = NULL;
3492   pcon->veto_oplock_list = NULL;
3493   string_set(&pcon->dirpath,"");
3494   string_set(&pcon->user,user);
3495
3496 #if HAVE_GETGRNAM 
3497   if (*lp_force_group(snum))
3498     {
3499       struct group *gptr;
3500       pstring gname;
3501
3502       StrnCpy(gname,lp_force_group(snum),sizeof(pstring)-1);
3503       /* default service may be a group name            */
3504       string_sub(gname,"%S",service);
3505       gptr = (struct group *)getgrnam(gname);
3506
3507       if (gptr)
3508         {
3509           pcon->gid = gptr->gr_gid;
3510           DEBUG(3,("Forced group %s\n",gname));
3511         }
3512       else
3513         DEBUG(1,("Couldn't find group %s\n",gname));
3514     }
3515 #endif
3516
3517   if (*lp_force_user(snum))
3518     {
3519       struct passwd *pass2;
3520       fstring fuser;
3521       fstrcpy(fuser,lp_force_user(snum));
3522       pass2 = (struct passwd *)Get_Pwnam(fuser,True);
3523       if (pass2)
3524         {
3525           pcon->uid = pass2->pw_uid;
3526           string_set(&pcon->user,fuser);
3527           fstrcpy(user,fuser);
3528           pcon->force_user = True;
3529           DEBUG(3,("Forced user %s\n",fuser));    
3530         }
3531       else
3532         DEBUG(1,("Couldn't find user %s\n",fuser));
3533     }
3534
3535   {
3536     pstring s;
3537     pstrcpy(s,lp_pathname(snum));
3538     standard_sub(cnum,s);
3539     string_set(&pcon->connectpath,s);
3540     DEBUG(3,("Connect path is %s\n",s));
3541   }
3542
3543   /* groups stuff added by ih */
3544   pcon->ngroups = 0;
3545   pcon->igroups = NULL;
3546   pcon->groups = NULL;
3547   pcon->attrs = NULL;
3548
3549   if (!IS_IPC(cnum))
3550     {
3551       /* Find all the groups this uid is in and store them. Used by become_user() */
3552       setup_groups(pcon->user,pcon->uid,pcon->gid,
3553                   &pcon->ngroups,&pcon->igroups,&pcon->groups,&pcon->attrs);
3554       
3555       /* check number of connections */
3556       if (!claim_connection(cnum,
3557                             lp_servicename(SNUM(cnum)),
3558                             lp_max_connections(SNUM(cnum)),False))
3559         {
3560           DEBUG(1,("too many connections - rejected\n"));
3561           return(-8);
3562         }  
3563
3564       if (lp_status(SNUM(cnum)))
3565         claim_connection(cnum,"STATUS.",MAXSTATUS,False);
3566     } /* IS_IPC */
3567
3568   pcon->open = True;
3569
3570   /* execute any "root preexec = " line */
3571   if (*lp_rootpreexec(SNUM(cnum)))
3572     {
3573       pstring cmd;
3574       pstrcpy(cmd,lp_rootpreexec(SNUM(cnum)));
3575       standard_sub(cnum,cmd);
3576       DEBUG(5,("cmd=%s\n",cmd));
3577       smbrun(cmd,NULL,False);
3578     }
3579
3580   if (!become_user(&Connections[cnum], cnum,pcon->vuid))
3581     {
3582       DEBUG(0,("Can't become connected user!\n"));
3583       pcon->open = False;
3584       if (!IS_IPC(cnum)) {
3585         yield_connection(cnum,
3586                          lp_servicename(SNUM(cnum)),
3587                          lp_max_connections(SNUM(cnum)));
3588         if (lp_status(SNUM(cnum))) yield_connection(cnum,"STATUS.",MAXSTATUS);
3589       }
3590       return(-1);
3591     }
3592
3593   if (ChDir(pcon->connectpath) != 0)
3594     {
3595       DEBUG(0,("Can't change directory to %s (%s)\n",
3596                pcon->connectpath,strerror(errno)));
3597       pcon->open = False;
3598       unbecome_user();
3599       if (!IS_IPC(cnum)) {
3600         yield_connection(cnum,
3601                          lp_servicename(SNUM(cnum)),
3602                          lp_max_connections(SNUM(cnum)));
3603         if (lp_status(SNUM(cnum))) yield_connection(cnum,"STATUS.",MAXSTATUS);
3604       }
3605       return(-5);      
3606     }
3607
3608   string_set(&pcon->origpath,pcon->connectpath);
3609
3610 #if SOFTLINK_OPTIMISATION
3611   /* resolve any soft links early */
3612   {
3613     pstring s;
3614     pstrcpy(s,pcon->connectpath);
3615     GetWd(s);
3616     string_set(&pcon->connectpath,s);
3617     ChDir(pcon->connectpath);
3618   }
3619 #endif
3620
3621   num_connections_open++;
3622   add_session_user(user);
3623   
3624   /* execute any "preexec = " line */
3625   if (*lp_preexec(SNUM(cnum)))
3626     {
3627       pstring cmd;
3628       pstrcpy(cmd,lp_preexec(SNUM(cnum)));
3629       standard_sub(cnum,cmd);
3630       smbrun(cmd,NULL,False);
3631     }
3632   
3633   /* we've finished with the sensitive stuff */
3634   unbecome_user();
3635
3636   /* Add veto/hide lists */
3637   if (!IS_IPC(cnum) && !IS_PRINT(cnum))
3638   {
3639     set_namearray( &pcon->veto_list, lp_veto_files(SNUM(cnum)));
3640     set_namearray( &pcon->hide_list, lp_hide_files(SNUM(cnum)));
3641     set_namearray( &pcon->veto_oplock_list, lp_veto_oplocks(SNUM(cnum)));
3642   }
3643
3644   {
3645     extern int Client;
3646     DEBUG(IS_IPC(cnum)?3:1,("%s %s (%s) connect to service %s as user %s (uid=%d,gid=%d) (pid %d)\n",
3647                             timestring(),
3648                             remote_machine,
3649                             client_addr(Client),
3650                             lp_servicename(SNUM(cnum)),user,
3651                             pcon->uid,
3652                             pcon->gid,
3653                             (int)getpid()));
3654   }
3655
3656   return(cnum);
3657 }
3658
3659 /****************************************************************************
3660   Attempt to break an oplock on a file (if oplocked).
3661   Returns True if the file was closed as a result of
3662   the oplock break, False otherwise.
3663   Used as a last ditch attempt to free a space in the 
3664   file table when we have run out.
3665 ****************************************************************************/
3666
3667 static BOOL attempt_close_oplocked_file(files_struct *fp)
3668 {
3669
3670   DEBUG(5,("attempt_close_oplocked_file: checking file %s.\n", fp->name));
3671
3672   if (fp->open && fp->granted_oplock && !fp->sent_oplock_break) {
3673
3674     /* Try and break the oplock. */
3675     file_fd_struct *fsp = fp->fd_ptr;
3676     if(oplock_break( fsp->dev, fsp->inode, &fp->open_time)) {
3677       if(!fp->open) /* Did the oplock break close the file ? */
3678         return True;
3679     }
3680   }
3681
3682   return False;
3683 }
3684
3685 /****************************************************************************
3686   find first available file slot
3687 ****************************************************************************/
3688 int find_free_file(void )
3689 {
3690         int i;
3691         static int first_file;
3692
3693         /* we want to give out file handles differently on each new
3694            connection because of a common bug in MS clients where they try to
3695            reuse a file descriptor from an earlier smb connection. This code
3696            increases the chance that the errant client will get an error rather
3697            than causing corruption */
3698         if (first_file == 0) {
3699                 first_file = (getpid() ^ (int)time(NULL)) % MAX_OPEN_FILES;
3700                 if (first_file == 0) first_file = 1;
3701         }
3702
3703         if (first_file >= MAX_OPEN_FILES)
3704                 first_file = 1;
3705
3706         for (i=first_file;i<MAX_OPEN_FILES;i++)
3707                 if (!Files[i].open && !Files[i].reserved) {
3708                         memset(&Files[i], 0, sizeof(Files[i]));
3709                         first_file = i+1;
3710                         Files[i].reserved = True;
3711                         return(i);
3712                 }
3713
3714         /* returning a file handle of 0 is a bad idea - so we start at 1 */
3715         for (i=1;i<first_file;i++)
3716                 if (!Files[i].open && !Files[i].reserved) {
3717                         memset(&Files[i], 0, sizeof(Files[i]));
3718                         first_file = i+1;
3719                         Files[i].reserved = True;
3720                         return(i);
3721                 }
3722
3723         /* 
3724          * Before we give up, go through the open files 
3725          * and see if there are any files opened with a
3726          * batch oplock. If so break the oplock and then
3727          * re-use that entry (if it becomes closed).
3728          * This may help as NT/95 clients tend to keep
3729          * files batch oplocked for quite a long time
3730          * after they have finished with them.
3731          */
3732         for (i=first_file;i<MAX_OPEN_FILES;i++) {
3733           if(attempt_close_oplocked_file( &Files[i])) {
3734             memset(&Files[i], 0, sizeof(Files[i]));
3735             first_file = i+1;
3736             Files[i].reserved = True;
3737             return(i);
3738           }
3739         }
3740
3741         for (i=1;i<MAX_OPEN_FILES;i++) {
3742           if(attempt_close_oplocked_file( &Files[i])) {
3743             memset(&Files[i], 0, sizeof(Files[i]));
3744             first_file = i+1;
3745             Files[i].reserved = True;
3746             return(i);
3747           }
3748         }
3749
3750         DEBUG(1,("ERROR! Out of file structures - perhaps increase MAX_OPEN_FILES?\n"));
3751         return(-1);
3752 }
3753
3754 /****************************************************************************
3755   find first available connection slot, starting from a random position.
3756 The randomisation stops problems with the server dieing and clients
3757 thinking the server is still available.
3758 ****************************************************************************/
3759 static int find_free_connection(int hash )
3760 {
3761   int i;
3762   BOOL used=False;
3763   hash = (hash % (MAX_CONNECTIONS-2))+1;
3764
3765  again:
3766
3767   for (i=hash+1;i!=hash;)
3768     {
3769       if (!Connections[i].open && Connections[i].used == used) 
3770         {
3771           DEBUG(3,("found free connection number %d\n",i));
3772           return(i);
3773         }
3774       i++;
3775       if (i == MAX_CONNECTIONS)
3776         i = 1;
3777     }
3778
3779   if (!used)
3780     {
3781       used = !used;
3782       goto again;
3783     }
3784
3785   DEBUG(1,("ERROR! Out of connection structures\n"));
3786   return(-1);
3787 }
3788
3789
3790 /****************************************************************************
3791 reply for the core protocol
3792 ****************************************************************************/
3793 int reply_corep(char *outbuf)
3794 {
3795   int outsize = set_message(outbuf,1,0,True);
3796
3797   Protocol = PROTOCOL_CORE;
3798
3799   return outsize;
3800 }
3801
3802
3803 /****************************************************************************
3804 reply for the coreplus protocol
3805 ****************************************************************************/
3806 int reply_coreplus(char *outbuf)
3807 {
3808   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
3809   int outsize = set_message(outbuf,13,0,True);
3810   SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
3811                                  readbraw and writebraw (possibly) */
3812   CVAL(outbuf,smb_flg) = 0x81; /* Reply, SMBlockread, SMBwritelock supported */
3813   SSVAL(outbuf,smb_vwv1,0x1); /* user level security, don't encrypt */  
3814
3815   Protocol = PROTOCOL_COREPLUS;
3816
3817   return outsize;
3818 }
3819
3820
3821 /****************************************************************************
3822 reply for the lanman 1.0 protocol
3823 ****************************************************************************/
3824 int reply_lanman1(char *outbuf)
3825 {
3826   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
3827   int secword=0;
3828   BOOL doencrypt = SMBENCRYPT();
3829   time_t t = time(NULL);
3830
3831   if (lp_security()>=SEC_USER) secword |= 1;
3832   if (doencrypt) secword |= 2;
3833
3834   set_message(outbuf,13,doencrypt?8:0,True);
3835   SSVAL(outbuf,smb_vwv1,secword); 
3836   /* Create a token value and add it to the outgoing packet. */
3837   if (doencrypt) 
3838     generate_next_challenge(smb_buf(outbuf));
3839
3840   Protocol = PROTOCOL_LANMAN1;
3841
3842   CVAL(outbuf,smb_flg) = 0x81; /* Reply, SMBlockread, SMBwritelock supported */
3843   SSVAL(outbuf,smb_vwv2,max_recv);
3844   SSVAL(outbuf,smb_vwv3,lp_maxmux()); /* maxmux */
3845   SSVAL(outbuf,smb_vwv4,1);
3846   SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
3847                                  readbraw writebraw (possibly) */
3848   SIVAL(outbuf,smb_vwv6,getpid());
3849   SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
3850
3851   put_dos_date(outbuf,smb_vwv8,t);
3852
3853   return (smb_len(outbuf)+4);
3854 }
3855
3856
3857 /****************************************************************************
3858 reply for the lanman 2.0 protocol
3859 ****************************************************************************/
3860 int reply_lanman2(char *outbuf)
3861 {
3862   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
3863   int secword=0;
3864   BOOL doencrypt = SMBENCRYPT();
3865   time_t t = time(NULL);
3866   struct cli_state *cli = NULL;
3867   char cryptkey[8];
3868   char crypt_len = 0;
3869
3870   if (lp_security() == SEC_SERVER) {
3871           cli = server_cryptkey();
3872   }
3873
3874   if (cli) {
3875           DEBUG(3,("using password server validation\n"));
3876           doencrypt = ((cli->sec_mode & 2) != 0);
3877   }
3878
3879   if (lp_security()>=SEC_USER) secword |= 1;
3880   if (doencrypt) secword |= 2;
3881
3882   if (doencrypt) {
3883           crypt_len = 8;
3884           if (!cli) {
3885                   generate_next_challenge(cryptkey);
3886           } else {
3887                   memcpy(cryptkey, cli->cryptkey, 8);
3888                   set_challenge(cli->cryptkey);