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