home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / samba-1.9.18p7.tar.gz / samba-1.9.18p7.tar / samba-1.9.18p7 / source / server.c < prev    next >
C/C++ Source or Header  |  1998-05-12  |  158KB  |  5,523 lines
  1. /* 
  2.    Unix SMB/Netbios implementation.
  3.    Version 1.9.
  4.    Main SMB server routines
  5.    Copyright (C) Andrew Tridgell 1992-1998
  6.    
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2 of the License, or
  10.    (at your option) any later version.
  11.    
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.    
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. #include "includes.h"
  23. #include "trans2.h"
  24.  
  25. pstring servicesf = CONFIGFILE;
  26. extern pstring debugf;
  27. extern pstring sesssetup_user;
  28. extern fstring myworkgroup;
  29.  
  30. char *InBuffer = NULL;
  31. char *OutBuffer = NULL;
  32. char *last_inbuf = NULL;
  33.  
  34. int am_parent = 1;
  35. int atexit_set = 0;
  36.  
  37. /* the last message the was processed */
  38. int last_message = -1;
  39.  
  40. /* a useful macro to debug the last message processed */
  41. #define LAST_MESSAGE() smb_fn_name(last_message)
  42.  
  43. extern pstring scope;
  44. extern int DEBUGLEVEL;
  45. extern int case_default;
  46. extern BOOL case_sensitive;
  47. extern BOOL case_preserve;
  48. extern BOOL use_mangled_map;
  49. extern BOOL short_case_preserve;
  50. extern BOOL case_mangle;
  51. time_t smb_last_time=(time_t)0;
  52.  
  53. extern int smb_read_error;
  54.  
  55. extern pstring user_socket_options;
  56.  
  57. #ifdef DFS_AUTH
  58. extern int dcelogin_atmost_once;
  59. #endif /* DFS_AUTH */
  60.  
  61. connection_struct Connections[MAX_CONNECTIONS];
  62. files_struct Files[MAX_OPEN_FILES];
  63.  
  64. /*
  65.  * Indirection for file fd's. Needed as POSIX locking
  66.  * is based on file/process, not fd/process.
  67.  */
  68. file_fd_struct FileFd[MAX_OPEN_FILES];
  69. int max_file_fd_used = 0;
  70.  
  71. extern int Protocol;
  72.  
  73. /* 
  74.  * Size of data we can send to client. Set
  75.  *  by the client for all protocols above CORE.
  76.  *  Set by us for CORE protocol.
  77.  */
  78. int max_send = BUFFER_SIZE;
  79. /*
  80.  * Size of the data we can receive. Set by us.
  81.  * Can be modified by the max xmit parameter.
  82.  */
  83. int max_recv = BUFFER_SIZE;
  84.  
  85. /* a fnum to use when chaining */
  86. int chain_fnum = -1;
  87.  
  88. /* number of open connections */
  89. static int num_connections_open = 0;
  90.  
  91. /* Oplock ipc UDP socket. */
  92. int oplock_sock = -1;
  93. uint16 oplock_port = 0;
  94. /* Current number of oplocks we have outstanding. */
  95. int32 global_oplocks_open = 0;
  96.  
  97. BOOL global_oplock_break = False;
  98.  
  99. extern fstring remote_machine;
  100.  
  101. extern pstring OriginalDir;
  102.  
  103. /* these can be set by some functions to override the error codes */
  104. int unix_ERR_class=SMB_SUCCESS;
  105. int unix_ERR_code=0;
  106.  
  107.  
  108. extern int extra_time_offset;
  109.  
  110. extern pstring myhostname;
  111.  
  112. static int find_free_connection(int hash);
  113.  
  114. /* for readability... */
  115. #define IS_DOS_READONLY(test_mode) (((test_mode) & aRONLY) != 0)
  116. #define IS_DOS_DIR(test_mode) (((test_mode) & aDIR) != 0)
  117. #define IS_DOS_ARCHIVE(test_mode) (((test_mode) & aARCH) != 0)
  118. #define IS_DOS_SYSTEM(test_mode) (((test_mode) & aSYSTEM) != 0)
  119. #define IS_DOS_HIDDEN(test_mode) (((test_mode) & aHIDDEN) != 0)
  120.  
  121. /****************************************************************************
  122.   when exiting, take the whole family
  123. ****************************************************************************/
  124. void  *dflt_sig(void)
  125. {
  126.   exit_server("caught signal");
  127.   return 0; /* Keep -Wall happy :-) */
  128. }
  129. /****************************************************************************
  130.   Send a SIGTERM to our process group.
  131. *****************************************************************************/
  132. void  killkids(void)
  133. {
  134.   if(am_parent) kill(0,SIGTERM);
  135. }
  136.  
  137. /****************************************************************************
  138.   change a dos mode to a unix mode
  139.     base permission for files:
  140.          everybody gets read bit set
  141.          dos readonly is represented in unix by removing everyone's write bit
  142.          dos archive is represented in unix by the user's execute bit
  143.          dos system is represented in unix by the group's execute bit
  144.          dos hidden is represented in unix by the other's execute bit
  145.          Then apply create mask,
  146.          then add force bits.
  147.     base permission for directories:
  148.          dos directory is represented in unix by unix's dir bit and the exec bit
  149.          Then apply create mask,
  150.          then add force bits.
  151. ****************************************************************************/
  152. mode_t unix_mode(int cnum,int dosmode)
  153. {
  154.   mode_t result = (S_IRUSR | S_IRGRP | S_IROTH);
  155.  
  156.   if ( !IS_DOS_READONLY(dosmode) )
  157.     result |= (S_IWUSR | S_IWGRP | S_IWOTH);
  158.  
  159.   if (IS_DOS_DIR(dosmode)) {
  160.     /* We never make directories read only for the owner as under DOS a user
  161.        can always create a file in a read-only directory. */
  162.     result |= (S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH | S_IWUSR);
  163.     /* Apply directory mask */
  164.     result &= lp_dir_mode(SNUM(cnum));
  165.     /* Add in force bits */
  166.     result |= lp_force_dir_mode(SNUM(cnum));
  167.   } else { 
  168.     if (MAP_ARCHIVE(cnum) && IS_DOS_ARCHIVE(dosmode))
  169.       result |= S_IXUSR;
  170.  
  171.     if (MAP_SYSTEM(cnum) && IS_DOS_SYSTEM(dosmode))
  172.       result |= S_IXGRP;
  173.  
  174.     if (MAP_HIDDEN(cnum) && IS_DOS_HIDDEN(dosmode))
  175.       result |= S_IXOTH;  
  176.  
  177.     /* Apply mode mask */
  178.     result &= lp_create_mode(SNUM(cnum));
  179.     /* Add in force bits */
  180.     result |= lp_force_create_mode(SNUM(cnum));
  181.   }
  182.   return(result);
  183. }
  184.  
  185.  
  186. /****************************************************************************
  187.   change a unix mode to a dos mode
  188. ****************************************************************************/
  189. int dos_mode(int cnum,char *path,struct stat *sbuf)
  190. {
  191.   int result = 0;
  192.   extern struct current_user current_user;
  193.  
  194.   DEBUG(8,("dos_mode: %d %s\n", cnum, path));
  195.  
  196.   if (CAN_WRITE(cnum) && !lp_alternate_permissions(SNUM(cnum))) {
  197.     if (!((sbuf->st_mode & S_IWOTH) ||
  198.       Connections[cnum].admin_user ||
  199.       ((sbuf->st_mode & S_IWUSR) && current_user.uid==sbuf->st_uid) ||
  200.       ((sbuf->st_mode & S_IWGRP) && 
  201.        in_group(sbuf->st_gid,current_user.gid,
  202.             current_user.ngroups,current_user.igroups))))
  203.       result |= aRONLY;
  204.   } else {
  205.     if ((sbuf->st_mode & S_IWUSR) == 0)
  206.       result |= aRONLY;
  207.   }
  208.  
  209.   if (MAP_ARCHIVE(cnum) && ((sbuf->st_mode & S_IXUSR) != 0))
  210.     result |= aARCH;
  211.  
  212.   if (MAP_SYSTEM(cnum) && ((sbuf->st_mode & S_IXGRP) != 0))
  213.     result |= aSYSTEM;
  214.  
  215.   if (MAP_HIDDEN(cnum) && ((sbuf->st_mode & S_IXOTH) != 0))
  216.     result |= aHIDDEN;   
  217.   
  218.   if (S_ISDIR(sbuf->st_mode))
  219.     result = aDIR | (result & aRONLY);
  220.  
  221. #ifdef S_ISLNK
  222. #if LINKS_READ_ONLY
  223.   if (S_ISLNK(sbuf->st_mode) && S_ISDIR(sbuf->st_mode))
  224.     result |= aRONLY;
  225. #endif
  226. #endif
  227.  
  228.   /* hide files with a name starting with a . */
  229.   if (lp_hide_dot_files(SNUM(cnum)))
  230.     {
  231.       char *p = strrchr(path,'/');
  232.       if (p)
  233.     p++;
  234.       else
  235.     p = path;
  236.       
  237.       if (p[0] == '.' && p[1] != '.' && p[1] != 0)
  238.     result |= aHIDDEN;
  239.     }
  240.  
  241.   /* Optimization : Only call is_hidden_path if it's not already
  242.      hidden. */
  243.   if (!(result & aHIDDEN) && IS_HIDDEN_PATH(cnum,path))
  244.   {
  245.     result |= aHIDDEN;
  246.   }
  247.  
  248.   DEBUG(8,("dos_mode returning "));
  249.  
  250.   if (result & aHIDDEN) DEBUG(8, ("h"));
  251.   if (result & aRONLY ) DEBUG(8, ("r"));
  252.   if (result & aSYSTEM) DEBUG(8, ("s"));
  253.   if (result & aDIR   ) DEBUG(8, ("d"));
  254.   if (result & aARCH  ) DEBUG(8, ("a"));
  255.  
  256.   DEBUG(8,("\n"));
  257.  
  258.   return(result);
  259. }
  260.  
  261. /*******************************************************************
  262. chmod a file - but preserve some bits
  263. ********************************************************************/
  264. int dos_chmod(int cnum,char *fname,int dosmode,struct stat *st)
  265. {
  266.   struct stat st1;
  267.   int mask=0;
  268.   int tmp;
  269.   int unixmode;
  270.  
  271.   if (!st) {
  272.     st = &st1;
  273.     if (sys_stat(fname,st)) return(-1);
  274.   }
  275.  
  276.   if (S_ISDIR(st->st_mode)) dosmode |= aDIR;
  277.  
  278.   if (dos_mode(cnum,fname,st) == dosmode) return(0);
  279.  
  280.   unixmode = unix_mode(cnum,dosmode);
  281.  
  282.   /* preserve the s bits */
  283.   mask |= (S_ISUID | S_ISGID);
  284.  
  285.   /* preserve the t bit */
  286. #ifdef S_ISVTX
  287.   mask |= S_ISVTX;
  288. #endif
  289.  
  290.   /* possibly preserve the x bits */
  291.   if (!MAP_ARCHIVE(cnum)) mask |= S_IXUSR;
  292.   if (!MAP_SYSTEM(cnum)) mask |= S_IXGRP;
  293.   if (!MAP_HIDDEN(cnum)) mask |= S_IXOTH;
  294.  
  295.   unixmode |= (st->st_mode & mask);
  296.  
  297.   /* if we previously had any r bits set then leave them alone */
  298.   if ((tmp = st->st_mode & (S_IRUSR|S_IRGRP|S_IROTH))) {
  299.     unixmode &= ~(S_IRUSR|S_IRGRP|S_IROTH);
  300.     unixmode |= tmp;
  301.   }
  302.  
  303.   /* if we previously had any w bits set then leave them alone 
  304.    if the new mode is not rdonly */
  305.   if (!IS_DOS_READONLY(dosmode) &&
  306.       (tmp = st->st_mode & (S_IWUSR|S_IWGRP|S_IWOTH))) {
  307.     unixmode &= ~(S_IWUSR|S_IWGRP|S_IWOTH);
  308.     unixmode |= tmp;
  309.   }
  310.  
  311.   return(sys_chmod(fname,unixmode));
  312. }
  313.  
  314. /*******************************************************************
  315. Wrapper around sys_utime that possibly allows DOS semantics rather
  316. than POSIX.
  317. *******************************************************************/
  318.  
  319. int file_utime(int cnum, char *fname, struct utimbuf *times)
  320. {
  321.   extern struct current_user current_user;
  322.   struct stat sb;
  323.   int ret = -1;
  324.  
  325.   errno = 0;
  326.  
  327.   if(sys_utime(fname, times) == 0)
  328.     return 0;
  329.  
  330.   if((errno != EPERM) && (errno != EACCES))
  331.     return -1;
  332.  
  333.   if(!lp_dos_filetimes(SNUM(cnum)))
  334.     return -1;
  335.  
  336.   /* We have permission (given by the Samba admin) to
  337.      break POSIX semantics and allow a user to change
  338.      the time on a file they don't own but can write to
  339.      (as DOS does).
  340.    */
  341.  
  342.   if(sys_stat(fname,&sb) != 0)
  343.     return -1;
  344.  
  345.   /* Check if we have write access. */
  346.   if (CAN_WRITE(cnum)) {
  347.       if (((sb.st_mode & S_IWOTH) ||
  348.            Connections[cnum].admin_user ||
  349.            ((sb.st_mode & S_IWUSR) && current_user.uid==sb.st_uid) ||
  350.            ((sb.st_mode & S_IWGRP) &&
  351.         in_group(sb.st_gid,current_user.gid,
  352.              current_user.ngroups,current_user.igroups)))) {
  353.           /* We are allowed to become root and change the filetime. */
  354.           become_root(False);
  355.           ret = sys_utime(fname, times);
  356.           unbecome_root(False);
  357.       }
  358.   }
  359.  
  360.   return ret;
  361. }
  362.   
  363. /*******************************************************************
  364. Change a filetime - possibly allowing DOS semantics.
  365. *******************************************************************/
  366.  
  367. BOOL set_filetime(int cnum, char *fname, time_t mtime)
  368. {
  369.   struct utimbuf times;
  370.  
  371.   if (null_mtime(mtime)) return(True);
  372.  
  373.   times.modtime = times.actime = mtime;
  374.  
  375.   if (file_utime(cnum, fname, ×)) {
  376.     DEBUG(4,("set_filetime(%s) failed: %s\n",fname,strerror(errno)));
  377.   }
  378.   
  379.   return(True);
  380. } 
  381.  
  382. /****************************************************************************
  383. check if two filenames are equal
  384.  
  385. this needs to be careful about whether we are case sensitive
  386. ****************************************************************************/
  387. static BOOL fname_equal(char *name1, char *name2)
  388. {
  389.   int l1 = strlen(name1);
  390.   int l2 = strlen(name2);
  391.  
  392.   /* handle filenames ending in a single dot */
  393.   if (l1-l2 == 1 && name1[l1-1] == '.' && lp_strip_dot())
  394.     {
  395.       BOOL ret;
  396.       name1[l1-1] = 0;
  397.       ret = fname_equal(name1,name2);
  398.       name1[l1-1] = '.';
  399.       return(ret);
  400.     }
  401.  
  402.   if (l2-l1 == 1 && name2[l2-1] == '.' && lp_strip_dot())
  403.     {
  404.       BOOL ret;
  405.       name2[l2-1] = 0;
  406.       ret = fname_equal(name1,name2);
  407.       name2[l2-1] = '.';
  408.       return(ret);
  409.     }
  410.  
  411.   /* now normal filename handling */
  412.   if (case_sensitive)
  413.     return(strcmp(name1,name2) == 0);
  414.  
  415.   return(strequal(name1,name2));
  416. }
  417.  
  418.  
  419. /****************************************************************************
  420. mangle the 2nd name and check if it is then equal to the first name
  421. ****************************************************************************/
  422. static BOOL mangled_equal(char *name1, char *name2)
  423. {
  424.   pstring tmpname;
  425.  
  426.   if (is_8_3(name2, True))
  427.     return(False);
  428.  
  429.   pstrcpy(tmpname,name2);
  430.   mangle_name_83(tmpname,sizeof(pstring)-1);
  431.  
  432.   return(strequal(name1,tmpname));
  433. }
  434.  
  435.  
  436. /****************************************************************************
  437. scan a directory to find a filename, matching without case sensitivity
  438.  
  439. If the name looks like a mangled name then try via the mangling functions
  440. ****************************************************************************/
  441. static BOOL scan_directory(char *path, char *name,int cnum,BOOL docache)
  442. {
  443.   void *cur_dir;
  444.   char *dname;
  445.   BOOL mangled;
  446.   pstring name2;
  447.  
  448.   mangled = is_mangled(name);
  449.  
  450.   /* handle null paths */
  451.   if (*path == 0)
  452.     path = ".";
  453.  
  454.   if (docache && (dname = DirCacheCheck(path,name,SNUM(cnum)))) {
  455.     pstrcpy(name, dname);    
  456.     return(True);
  457.   }      
  458.  
  459.   /*
  460.    * The incoming name can be mangled, and if we de-mangle it
  461.    * here it will not compare correctly against the filename (name2)
  462.    * read from the directory and then mangled by the name_map_mangle()
  463.    * call. We need to mangle both names or neither.
  464.    * (JRA).
  465.    */
  466.   if (mangled)
  467.     mangled = !check_mangled_stack(name);
  468.  
  469.   /* open the directory */
  470.   if (!(cur_dir = OpenDir(cnum, path, True))) 
  471.     {
  472.       DEBUG(3,("scan dir didn't open dir [%s]\n",path));
  473.       return(False);
  474.     }
  475.  
  476.   /* now scan for matching names */
  477.   while ((dname = ReadDirName(cur_dir))) 
  478.     {
  479.       if (*dname == '.' &&
  480.       (strequal(dname,".") || strequal(dname,"..")))
  481.     continue;
  482.  
  483.       pstrcpy(name2,dname);
  484.       if (!name_map_mangle(name2,False,SNUM(cnum))) continue;
  485.  
  486.       if ((mangled && mangled_equal(name,name2))
  487.       || fname_equal(name, name2))
  488.     {
  489.       /* we've found the file, change it's name and return */
  490.       if (docache) DirCacheAdd(path,name,dname,SNUM(cnum));
  491.       pstrcpy(name, dname);
  492.       CloseDir(cur_dir);
  493.       return(True);
  494.     }
  495.     }
  496.  
  497.   CloseDir(cur_dir);
  498.   return(False);
  499. }
  500.  
  501. /****************************************************************************
  502. This routine is called to convert names from the dos namespace to unix
  503. namespace. It needs to handle any case conversions, mangling, format
  504. changes etc.
  505.  
  506. We assume that we have already done a chdir() to the right "root" directory
  507. for this service.
  508.  
  509. The function will return False if some part of the name except for the last
  510. part cannot be resolved
  511.  
  512. If the saved_last_component != 0, then the unmodified last component
  513. of the pathname is returned there. This is used in an exceptional
  514. case in reply_mv (so far). If saved_last_component == 0 then nothing
  515. is returned there.
  516.  
  517. The bad_path arg is set to True if the filename walk failed. This is
  518. used to pick the correct error code to return between ENOENT and ENOTDIR
  519. as Windows applications depend on ERRbadpath being returned if a component
  520. of a pathname does not exist.
  521. ****************************************************************************/
  522. BOOL unix_convert(char *name,int cnum,pstring saved_last_component, BOOL *bad_path)
  523. {
  524.   struct stat st;
  525.   char *start, *end;
  526.   pstring dirpath;
  527.   int saved_errno;
  528.  
  529.   *dirpath = 0;
  530.   *bad_path = False;
  531.  
  532.   if(saved_last_component)
  533.     *saved_last_component = 0;
  534.  
  535.   /* convert to basic unix format - removing \ chars and cleaning it up */
  536.   unix_format(name);
  537.   unix_clean_name(name);
  538.  
  539.   /* names must be relative to the root of the service - trim any leading /.
  540.    also trim trailing /'s */
  541.   trim_string(name,"/","/");
  542.  
  543.   /*
  544.    * Ensure saved_last_component is valid even if file exists.
  545.    */
  546.   if(saved_last_component) {
  547.     end = strrchr(name, '/');
  548.     if(end)
  549.       pstrcpy(saved_last_component, end + 1);
  550.     else
  551.       pstrcpy(saved_last_component, name);
  552.   }
  553.  
  554.   if (!case_sensitive && 
  555.       (!case_preserve || (is_8_3(name, False) && !short_case_preserve)))
  556.     strnorm(name);
  557.  
  558.   /* check if it's a printer file */
  559.   if (Connections[cnum].printer)
  560.     {
  561.       if ((! *name) || strchr(name,'/') || !is_8_3(name, True))
  562.     {
  563.       char *s;
  564.       fstring name2;
  565.       slprintf(name2,sizeof(name2)-1,"%.6s.XXXXXX",remote_machine);
  566.       /* sanitise the name */
  567.       for (s=name2 ; *s ; s++)
  568.         if (!issafe(*s)) *s = '_';
  569.       pstrcpy(name,(char *)mktemp(name2));      
  570.     }      
  571.       return(True);
  572.     }
  573.  
  574.   /* stat the name - if it exists then we are all done! */
  575.   if (sys_stat(name,&st) == 0)
  576.     return(True);
  577.  
  578.   saved_errno = errno;
  579.  
  580.   DEBUG(5,("unix_convert(%s,%d)\n",name,cnum));
  581.  
  582.   /* a special case - if we don't have any mangling chars and are case
  583.      sensitive then searching won't help */
  584.   if (case_sensitive && !is_mangled(name) && 
  585.       !lp_strip_dot() && !use_mangled_map && (saved_errno != ENOENT))
  586.     return(False);
  587.  
  588.   /* now we need to recursively match the name against the real 
  589.      directory structure */
  590.  
  591.   start = name;
  592.   while (strncmp(start,"./",2) == 0)
  593.     start += 2;
  594.  
  595.   /* now match each part of the path name separately, trying the names
  596.      as is first, then trying to scan the directory for matching names */
  597.   for (;start;start = (end?end+1:(char *)NULL)) 
  598.     {
  599.       /* pinpoint the end of this section of the filename */
  600.       end = strchr(start, '/');
  601.  
  602.       /* chop the name at this point */
  603.       if (end)     *end = 0;
  604.  
  605.       if(saved_last_component != 0)
  606.         pstrcpy(saved_last_component, end ? end + 1 : start);
  607.  
  608.       /* check if the name exists up to this point */
  609.       if (sys_stat(name, &st) == 0) 
  610.     {
  611.       /* it exists. it must either be a directory or this must be
  612.          the last part of the path for it to be OK */
  613.       if (end && !(st.st_mode & S_IFDIR)) 
  614.         {
  615.           /* an intermediate part of the name isn't a directory */
  616.           DEBUG(5,("Not a dir %s\n",start));
  617.           *end = '/';
  618.           return(False);
  619.         }
  620.     }
  621.       else 
  622.     {
  623.       pstring rest;
  624.  
  625.       *rest = 0;
  626.  
  627.       /* remember the rest of the pathname so it can be restored
  628.          later */
  629.       if (end) pstrcpy(rest,end+1);
  630.  
  631.       /* try to find this part of the path in the directory */
  632.       if (strchr(start,'?') || strchr(start,'*') ||
  633.           !scan_directory(dirpath, start, cnum, end?True:False))
  634.         {
  635.           if (end) 
  636.         {
  637.           /* an intermediate part of the name can't be found */
  638.           DEBUG(5,("Intermediate not found %s\n",start));
  639.           *end = '/';
  640.                   /* We need to return the fact that the intermediate
  641.                      name resolution failed. This is used to return an
  642.                      error of ERRbadpath rather than ERRbadfile. Some
  643.                      Windows applications depend on the difference between
  644.                      these two errors.
  645.                    */
  646.                   *bad_path = True;
  647.           return(False);
  648.         }
  649.           
  650.           /* just the last part of the name doesn't exist */
  651.           /* we may need to strupper() or strlower() it in case
  652.          this conversion is being used for file creation 
  653.          purposes */
  654.           /* if the filename is of mixed case then don't normalise it */
  655.           if (!case_preserve && 
  656.           (!strhasupper(start) || !strhaslower(start)))        
  657.         strnorm(start);
  658.  
  659.           /* check on the mangled stack to see if we can recover the 
  660.          base of the filename */
  661.           if (is_mangled(start))
  662.         check_mangled_stack(start);
  663.  
  664.           DEBUG(5,("New file %s\n",start));
  665.           return(True); 
  666.         }
  667.  
  668.       /* restore the rest of the string */
  669.       if (end) 
  670.         {
  671.           pstrcpy(start+strlen(start)+1,rest);
  672.           end = start + strlen(start);
  673.         }
  674.     }
  675.  
  676.       /* add to the dirpath that we have resolved so far */
  677.       if (*dirpath) pstrcat(dirpath,"/");
  678.       pstrcat(dirpath,start);
  679.  
  680.       /* restore the / that we wiped out earlier */
  681.       if (end) *end = '/';
  682.     }
  683.   
  684.   /* the name has been resolved */
  685.   DEBUG(5,("conversion finished %s\n",name));
  686.   return(True);
  687. }
  688.  
  689.  
  690. /****************************************************************************
  691. normalise for DOS usage 
  692. ****************************************************************************/
  693. static void disk_norm(int *bsize,int *dfree,int *dsize)
  694. {
  695.   /* check if the disk is beyond the max disk size */
  696.   int maxdisksize = lp_maxdisksize();
  697.   if (maxdisksize) {
  698.     /* convert to blocks - and don't overflow */
  699.     maxdisksize = ((maxdisksize*1024)/(*bsize))*1024;
  700.     if (*dsize > maxdisksize) *dsize = maxdisksize;
  701.     if (*dfree > maxdisksize) *dfree = maxdisksize-1; /* the -1 should stop 
  702.                              applications getting 
  703.                              div by 0 errors */
  704.   }  
  705.  
  706.   while (*dfree > WORDMAX || *dsize > WORDMAX || *bsize < 512) 
  707.     {
  708.       *dfree /= 2;
  709.       *dsize /= 2;
  710.       *bsize *= 2;
  711.       if (*bsize > WORDMAX )
  712.     {
  713.       *bsize = WORDMAX;
  714.       if (*dsize > WORDMAX)
  715.         *dsize = WORDMAX;
  716.       if (*dfree >  WORDMAX)
  717.         *dfree = WORDMAX;
  718.       break;
  719.     }
  720.     }
  721. }
  722.  
  723. /****************************************************************************
  724.   return number of 1K blocks available on a path and total number 
  725. ****************************************************************************/
  726. int disk_free(char *path,int *bsize,int *dfree,int *dsize)
  727. {
  728.   char *df_command = lp_dfree_command();
  729.   int dfree_retval;
  730. #ifdef QUOTAS
  731.   int dfreeq_retval;
  732.   int dfreeq = 0;
  733.   int bsizeq = *bsize;
  734.   int dsizeq = *dsize;
  735. #endif
  736.  
  737. #ifndef NO_STATFS
  738. #ifdef USE_STATVFS
  739.   struct statvfs fs;
  740. #else
  741. #ifdef ULTRIX
  742.   struct fs_data fs;
  743. #else
  744.   struct statfs fs;
  745. #endif
  746. #endif
  747. #endif
  748.  
  749.   /* possibly use system() to get the result */
  750.   if (df_command && *df_command)
  751.     {
  752.       int ret;
  753.       pstring syscmd;
  754.       pstring outfile;
  755.       
  756.       slprintf(outfile,sizeof(outfile)-1, "%s/dfree.smb.%d",tmpdir(),(int)getpid());
  757.       slprintf(syscmd,sizeof(syscmd)-1,"%s %s",df_command,path);
  758.       standard_sub_basic(syscmd);
  759.  
  760.       ret = smbrun(syscmd,outfile,False);
  761.       DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret));
  762.       
  763.       {
  764.         FILE *f = fopen(outfile,"r");    
  765.         *dsize = 0;
  766.         *dfree = 0;
  767.         *bsize = 1024;
  768.         if (f)
  769.           {
  770.             fscanf(f,"%d %d %d",dsize,dfree,bsize);
  771.             fclose(f);
  772.           }
  773.         else
  774.           DEBUG(0,("Can't open %s\n",outfile));
  775.       }
  776.       
  777.       unlink(outfile);
  778.       disk_norm(bsize,dfree,dsize);
  779.       dfree_retval = ((*bsize)/1024)*(*dfree);
  780. #ifdef QUOTAS
  781.       /* Ensure we return the min value between the users quota and
  782.          what's free on the disk. Thanks to Albrecht Gebhardt 
  783.          <albrecht.gebhardt@uni-klu.ac.at> for this fix.
  784.       */
  785.       if (disk_quotas(path, &bsizeq, &dfreeq, &dsizeq))
  786.         {
  787.           disk_norm(&bsizeq, &dfreeq, &dsizeq);
  788.           dfreeq_retval = ((bsizeq)/1024)*(dfreeq);
  789.           dfree_retval =  ( dfree_retval < dfreeq_retval ) ? 
  790.                            dfree_retval : dfreeq_retval ;
  791.           /* maybe dfree and dfreeq are calculated using different bsizes 
  792.              so convert dfree from bsize into bsizeq */
  793.           /* avoid overflows due to multiplication, so do not:
  794.                 *dfree = ((*dfree) * (*bsize)) / (bsizeq); 
  795.              bsize and bsizeq are powers of 2 so its better to
  796.              to divide them getting a multiplication or division factor
  797.              for dfree. Rene Nieuwenhuizen (07-10-1997) */
  798.           if (*bsize >= bsizeq) 
  799.             *dfree = *dfree * (*bsize / bsizeq);
  800.           else 
  801.             *dfree = *dfree / (bsizeq / *bsize);
  802.           *dfree = ( *dfree < dfreeq ) ? *dfree : dfreeq ; 
  803.           *bsize = bsizeq;
  804.           *dsize = dsizeq;
  805.         }
  806. #endif
  807.       return(dfree_retval);
  808.     }
  809.  
  810. #ifdef NO_STATFS
  811.   DEBUG(1,("Warning - no statfs function\n"));
  812.   return(1);
  813. #else
  814. #ifdef STATFS4
  815.   if (statfs(path,&fs,sizeof(fs),0) != 0)
  816. #else
  817. #ifdef USE_STATVFS
  818.     if (statvfs(path, &fs))
  819. #else
  820. #ifdef STATFS3
  821.       if (statfs(path,&fs,sizeof(fs)) == -1)     
  822. #else
  823.     if (statfs(path,&fs) == -1)
  824. #endif /* STATFS3 */
  825. #endif /* USE_STATVFS */
  826. #endif /* STATFS4 */
  827.       {
  828.         DEBUG(3,("dfree call failed code errno=%d\n",errno));
  829.         *bsize = 1024;
  830.         *dfree = 1;
  831.         *dsize = 1;
  832.         return(((*bsize)/1024)*(*dfree));
  833.       }
  834.  
  835. #ifdef ULTRIX
  836.   *bsize = 1024;
  837.   *dfree = fs.fd_req.bfree;
  838.   *dsize = fs.fd_req.btot;
  839. #else
  840. #ifdef USE_STATVFS
  841.   *bsize = fs.f_frsize;
  842. #else
  843. #ifdef USE_F_FSIZE
  844.   /* eg: osf1 has f_fsize = fundamental filesystem block size, 
  845.      f_bsize = optimal transfer block size (MX: 94-04-19) */
  846.   *bsize = fs.f_fsize;
  847. #else
  848.   *bsize = fs.f_bsize;
  849. #endif /* STATFS3 */
  850. #endif /* USE_STATVFS */
  851.  
  852. #ifdef STATFS4
  853.   *dfree = fs.f_bfree;
  854. #else
  855.   *dfree = fs.f_bavail;
  856. #endif /* STATFS4 */
  857.   *dsize = fs.f_blocks;
  858. #endif /* ULTRIX */
  859.  
  860. #if defined(SCO) || defined(ISC) || defined(MIPS)
  861.   *bsize = 512;
  862. #endif
  863.  
  864. /* handle rediculous bsize values - some OSes are broken */
  865. if ((*bsize) < 512 || (*bsize)>0xFFFF) *bsize = 1024;
  866.  
  867.   disk_norm(bsize,dfree,dsize);
  868.  
  869.   if (*bsize < 256)
  870.     *bsize = 512;
  871.   if ((*dsize)<1)
  872.     {
  873.       DEBUG(0,("dfree seems to be broken on your system\n"));
  874.       *dsize = 20*1024*1024/(*bsize);
  875.       *dfree = MAX(1,*dfree);
  876.     }
  877.   dfree_retval = ((*bsize)/1024)*(*dfree);
  878. #ifdef QUOTAS
  879.   /* Ensure we return the min value between the users quota and
  880.      what's free on the disk. Thanks to Albrecht Gebhardt 
  881.      <albrecht.gebhardt@uni-klu.ac.at> for this fix.
  882.   */
  883.   if (disk_quotas(path, &bsizeq, &dfreeq, &dsizeq))
  884.     {
  885.       disk_norm(&bsizeq, &dfreeq, &dsizeq);
  886.       dfreeq_retval = ((bsizeq)/1024)*(dfreeq);
  887.       dfree_retval = ( dfree_retval < dfreeq_retval ) ? 
  888.                        dfree_retval : dfreeq_retval ;
  889.       /* maybe dfree and dfreeq are calculated using different bsizes 
  890.          so convert dfree from bsize into bsizeq */
  891.       /* avoid overflows due to multiplication, so do not:
  892.               *dfree = ((*dfree) * (*bsize)) / (bsizeq); 
  893.        bsize and bsizeq are powers of 2 so its better to
  894.        to divide them getting a multiplication or division factor
  895.        for dfree. Rene Nieuwenhuizen (07-10-1997) */
  896.       if (*bsize >= bsizeq)
  897.         *dfree = *dfree * (*bsize / bsizeq);
  898.       else
  899.         *dfree = *dfree / (bsizeq / *bsize);
  900.       *dfree = ( *dfree < dfreeq ) ? *dfree : dfreeq ;
  901.       *bsize = bsizeq;
  902.       *dsize = dsizeq;
  903.     }
  904. #endif
  905.   return(dfree_retval);
  906. #endif
  907. }
  908.  
  909.  
  910. /****************************************************************************
  911. wrap it to get filenames right
  912. ****************************************************************************/
  913. int sys_disk_free(char *path,int *bsize,int *dfree,int *dsize)
  914. {
  915.   return(disk_free(dos_to_unix(path,False),bsize,dfree,dsize));
  916. }
  917.  
  918.  
  919.  
  920. /****************************************************************************
  921. check a filename - possibly caling reducename
  922.  
  923. This is called by every routine before it allows an operation on a filename.
  924. It does any final confirmation necessary to ensure that the filename is
  925. a valid one for the user to access.
  926. ****************************************************************************/
  927. BOOL check_name(char *name,int cnum)
  928. {
  929.   BOOL ret;
  930.  
  931.   errno = 0;
  932.  
  933.   if( IS_VETO_PATH(cnum, name)) 
  934.     {
  935.       DEBUG(5,("file path name %s vetoed\n",name));
  936.       return(0);
  937.     }
  938.  
  939.   ret = reduce_name(name,Connections[cnum].connectpath,lp_widelinks(SNUM(cnum)));
  940.  
  941.   /* Check if we are allowing users to follow symlinks */
  942.   /* Patch from David Clerc <David.Clerc@cui.unige.ch>
  943.      University of Geneva */
  944.  
  945. #ifdef S_ISLNK
  946.   if (!lp_symlinks(SNUM(cnum)))
  947.     {
  948.       struct stat statbuf;
  949.       if ( (sys_lstat(name,&statbuf) != -1) &&
  950.           (S_ISLNK(statbuf.st_mode)) )
  951.         {
  952.           DEBUG(3,("check_name: denied: file path name %s is a symlink\n",name));
  953.           ret=0; 
  954.         }
  955.     }
  956. #endif
  957.  
  958.   if (!ret)
  959.     DEBUG(5,("check_name on %s failed\n",name));
  960.  
  961.   return(ret);
  962. }
  963.  
  964. /****************************************************************************
  965. check a filename - possibly caling reducename
  966. ****************************************************************************/
  967. static void check_for_pipe(char *fname)
  968. {
  969.   /* special case of pipe opens */
  970.   char s[10];
  971.   StrnCpy(s,fname,9);
  972.   strlower(s);
  973.   if (strstr(s,"pipe/"))
  974.     {
  975.       DEBUG(3,("Rejecting named pipe open for %s\n",fname));
  976.       unix_ERR_class = ERRSRV;
  977.       unix_ERR_code = ERRaccess;
  978.     }
  979. }
  980.  
  981. /****************************************************************************
  982. fd support routines - attempt to do a sys_open
  983. ****************************************************************************/
  984. static int fd_attempt_open(char *fname, int flags, int mode)
  985. {
  986.   int fd = sys_open(fname,flags,mode);
  987.  
  988.   /* Fix for files ending in '.' */
  989.   if((fd == -1) && (errno == ENOENT) &&
  990.      (strchr(fname,'.')==NULL))
  991.     {
  992.       pstrcat(fname,".");
  993.       fd = sys_open(fname,flags,mode);
  994.     }
  995.  
  996. #if (defined(ENAMETOOLONG) && defined(HAVE_PATHCONF))
  997.   if ((fd == -1) && (errno == ENAMETOOLONG))
  998.     {
  999.       int max_len;
  1000.       char *p = strrchr(fname, '/');
  1001.  
  1002.       if (p == fname)   /* name is "/xxx" */
  1003.         {
  1004.           max_len = pathconf("/", _PC_NAME_MAX);
  1005.           p++;
  1006.         }
  1007.       else if ((p == NULL) || (p == fname))
  1008.         {
  1009.           p = fname;
  1010.           max_len = pathconf(".", _PC_NAME_MAX);
  1011.         }
  1012.       else
  1013.         {
  1014.           *p = '\0';
  1015.           max_len = pathconf(fname, _PC_NAME_MAX);
  1016.           *p = '/';
  1017.           p++;
  1018.         }
  1019.       if (strlen(p) > max_len)
  1020.         {
  1021.           char tmp = p[max_len];
  1022.  
  1023.           p[max_len] = '\0';
  1024.           if ((fd = sys_open(fname,flags,mode)) == -1)
  1025.             p[max_len] = tmp;
  1026.         }
  1027.     }
  1028. #endif
  1029.   return fd;
  1030. }
  1031.  
  1032. /****************************************************************************
  1033. fd support routines - attempt to find an already open file by dev
  1034. and inode - increments the ref_count of the returned file_fd_struct *.
  1035. ****************************************************************************/
  1036. static file_fd_struct *fd_get_already_open(struct stat *sbuf)
  1037. {
  1038.   int i;
  1039.   file_fd_struct *fd_ptr;
  1040.  
  1041.   if(sbuf == 0)
  1042.     return 0;
  1043.  
  1044.   for(i = 0; i <= max_file_fd_used; i++) {
  1045.     fd_ptr = &FileFd[i];
  1046.     if((fd_ptr->ref_count > 0) &&
  1047.        (((uint32)sbuf->st_dev) == fd_ptr->dev) &&
  1048.        (((uint32)sbuf->st_ino) == fd_ptr->inode)) {
  1049.       fd_ptr->ref_count++;
  1050.       DEBUG(3,
  1051.        ("Re-used file_fd_struct %d, dev = %x, inode = %x, ref_count = %d\n",
  1052.         i, fd_ptr->dev, fd_ptr->inode, fd_ptr->ref_count));
  1053.       return fd_ptr;
  1054.     }
  1055.   }
  1056.   return 0;
  1057. }
  1058.  
  1059. /****************************************************************************
  1060. fd support routines - attempt to find a empty slot in the FileFd array.
  1061. Increments the ref_count of the returned entry.
  1062. ****************************************************************************/
  1063. static file_fd_struct *fd_get_new(void)
  1064. {
  1065.   int i;
  1066.   file_fd_struct *fd_ptr;
  1067.  
  1068.   for(i = 0; i < MAX_OPEN_FILES; i++) {
  1069.     fd_ptr = &FileFd[i];
  1070.     if(fd_ptr->ref_count == 0) {
  1071.       fd_ptr->dev = (uint32)-1;
  1072.       fd_ptr->inode = (uint32)-1;
  1073.       fd_ptr->fd = -1;
  1074.       fd_ptr->fd_readonly = -1;
  1075.       fd_ptr->fd_writeonly = -1;
  1076.       fd_ptr->real_open_flags = -1;
  1077.       fd_ptr->ref_count++;
  1078.       /* Increment max used counter if neccessary, cuts down
  1079.      on search time when re-using */
  1080.       if(i > max_file_fd_used)
  1081.         max_file_fd_used = i;
  1082.       DEBUG(3,("Allocated new file_fd_struct %d, dev = %x, inode = %x\n",
  1083.                i, fd_ptr->dev, fd_ptr->inode));
  1084.       return fd_ptr;
  1085.     }
  1086.   }
  1087.   DEBUG(1,("ERROR! Out of file_fd structures - perhaps increase MAX_OPEN_FILES?\n"));
  1088.   return 0;
  1089. }
  1090.  
  1091. /****************************************************************************
  1092. fd support routines - attempt to re-open an already open fd as O_RDWR.
  1093. Save the already open fd (we cannot close due to POSIX file locking braindamage.
  1094. ****************************************************************************/
  1095. static void fd_attempt_reopen(char *fname, int mode, file_fd_struct *fd_ptr)
  1096. {
  1097.   int fd = sys_open( fname, O_RDWR, mode);
  1098.  
  1099.   if(fd == -1)
  1100.     return;
  1101.  
  1102.   if(fd_ptr->real_open_flags == O_RDONLY)
  1103.     fd_ptr->fd_readonly = fd_ptr->fd;
  1104.   if(fd_ptr->real_open_flags == O_WRONLY)
  1105.     fd_ptr->fd_writeonly = fd_ptr->fd;
  1106.  
  1107.   fd_ptr->fd = fd;
  1108.   fd_ptr->real_open_flags = O_RDWR;
  1109. }
  1110.  
  1111. /****************************************************************************
  1112. fd support routines - attempt to close the file referenced by this fd.
  1113. Decrements the ref_count and returns it.
  1114. ****************************************************************************/
  1115. static int fd_attempt_close(file_fd_struct *fd_ptr)
  1116. {
  1117.   DEBUG(3,("fd_attempt_close on file_fd_struct %d, fd = %d, dev = %x, inode = %x, open_flags = %d, ref_count = %d.\n",
  1118.        fd_ptr - &FileFd[0],
  1119.        fd_ptr->fd, fd_ptr->dev, fd_ptr->inode,
  1120.        fd_ptr->real_open_flags,
  1121.        fd_ptr->ref_count));
  1122.   if(fd_ptr->ref_count > 0) {
  1123.     fd_ptr->ref_count--;
  1124.     if(fd_ptr->ref_count == 0) {
  1125.       if(fd_ptr->fd != -1)
  1126.         close(fd_ptr->fd);
  1127.       if(fd_ptr->fd_readonly != -1)
  1128.     close(fd_ptr->fd_readonly);
  1129.       if(fd_ptr->fd_writeonly != -1)
  1130.     close(fd_ptr->fd_writeonly);
  1131.       fd_ptr->fd = -1;
  1132.       fd_ptr->fd_readonly = -1;
  1133.       fd_ptr->fd_writeonly = -1;
  1134.       fd_ptr->real_open_flags = -1;
  1135.       fd_ptr->dev = (uint32)-1;
  1136.       fd_ptr->inode = (uint32)-1;
  1137.     }
  1138.   } 
  1139.  return fd_ptr->ref_count;
  1140. }
  1141.  
  1142. /****************************************************************************
  1143. open a file
  1144. ****************************************************************************/
  1145. static void open_file(int fnum,int cnum,char *fname1,int flags,int mode, struct stat *sbuf)
  1146. {
  1147.   extern struct current_user current_user;
  1148.   pstring fname;
  1149.   struct stat statbuf;
  1150.   file_fd_struct *fd_ptr;
  1151.   files_struct *fsp = &Files[fnum];
  1152.   int accmode = (flags & (O_RDONLY | O_WRONLY | O_RDWR));
  1153.  
  1154.   fsp->open = False;
  1155.   fsp->fd_ptr = 0;
  1156.   fsp->granted_oplock = False;
  1157.   errno = EPERM;
  1158.  
  1159.   pstrcpy(fname,fname1);
  1160.  
  1161.   /* check permissions */
  1162.  
  1163.   /*
  1164.    * This code was changed after seeing a client open request 
  1165.    * containing the open mode of (DENY_WRITE/read-only) with
  1166.    * the 'create if not exist' bit set. The previous code
  1167.    * would fail to open the file read only on a read-only share
  1168.    * as it was checking the flags parameter  directly against O_RDONLY,
  1169.    * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
  1170.    * JRA.
  1171.    */
  1172.  
  1173.   if (!CAN_WRITE(cnum) && !Connections[cnum].printer) {
  1174.     /* It's a read-only share - fail if we wanted to write. */
  1175.     if(accmode != O_RDONLY) {
  1176.       DEBUG(3,("Permission denied opening %s\n",fname));
  1177.       check_for_pipe(fname);
  1178.       return;
  1179.     }
  1180.     else if(flags & O_CREAT) {
  1181.       /* We don't want to write - but we must make sure that O_CREAT
  1182.          doesn't create the file if we have write access into the
  1183.          directory.
  1184.        */
  1185.       flags &= ~O_CREAT;
  1186.     }
  1187.   }
  1188.  
  1189.   /* this handles a bug in Win95 - it doesn't say to create the file when it 
  1190.      should */
  1191.   if (Connections[cnum].printer)
  1192.     flags |= O_CREAT;
  1193.  
  1194. /*
  1195.   if (flags == O_WRONLY)
  1196.     DEBUG(3,("Bug in client? Set O_WRONLY without O_CREAT\n"));
  1197. */
  1198.  
  1199.   /*
  1200.    * Ensure we have a valid struct stat so we can search the
  1201.    * open fd table.
  1202.    */
  1203.   if(sbuf == 0) {
  1204.     if(stat(fname, &statbuf) < 0) {
  1205.       if(errno != ENOENT) {
  1206.         DEBUG(3,("Error doing stat on file %s (%s)\n",
  1207.                  fname,strerror(errno)));
  1208.  
  1209.         check_for_pipe(fname);
  1210.         return;
  1211.       }
  1212.       sbuf = 0;
  1213.     } else {
  1214.       sbuf = &statbuf;
  1215.     }
  1216.   }
  1217.  
  1218.   /*
  1219.    * Check to see if we have this file already
  1220.    * open. If we do, just use the already open fd and increment the
  1221.    * reference count (fd_get_already_open increments the ref_count).
  1222.    */
  1223.   if((fd_ptr = fd_get_already_open(sbuf))!= 0) {
  1224.  
  1225.     /* File was already open. */
  1226.     if((flags & O_CREAT) && (flags & O_EXCL)) {
  1227.       fd_ptr->ref_count--;
  1228.       errno = EEXIST;
  1229.       return;
  1230.     }
  1231.  
  1232.     /* 
  1233.      * If not opened O_RDWR try
  1234.      * and do that here - a chmod may have been done
  1235.      * between the last open and now. 
  1236.      */
  1237.     if(fd_ptr->real_open_flags != O_RDWR)
  1238.       fd_attempt_reopen(fname, mode, fd_ptr);
  1239.  
  1240.     /*
  1241.      * Ensure that if we wanted write access
  1242.      * it has been opened for write, and if we wanted read it
  1243.      * was open for read. 
  1244.      */
  1245.     if(((accmode == O_WRONLY) && (fd_ptr->real_open_flags == O_RDONLY)) ||
  1246.        ((accmode == O_RDONLY) && (fd_ptr->real_open_flags == O_WRONLY)) ||
  1247.        ((accmode == O_RDWR) && (fd_ptr->real_open_flags != O_RDWR))) {
  1248.       DEBUG(3,("Error opening (already open for flags=%d) file %s (%s) (flags=%d)\n",
  1249.                fd_ptr->real_open_flags, fname,strerror(EACCES),flags));
  1250.       check_for_pipe(fname);
  1251.       fd_ptr->ref_count--;
  1252.       return;
  1253.     }
  1254.  
  1255.   } else {
  1256.     int open_flags;
  1257.     /* We need to allocate a new file_fd_struct (this increments the
  1258.        ref_count). */
  1259.     if((fd_ptr = fd_get_new()) == 0)
  1260.       return;
  1261.     /*
  1262.      * Whatever the requested flags, attempt read/write access,
  1263.      * as we don't know what flags future file opens may require.
  1264.      * If this fails, try again with the required flags. 
  1265.      * Even if we open read/write when only read access was 
  1266.      * requested the setting of the can_write flag in
  1267.      * the file_struct will protect us from errant
  1268.      * write requests. We never need to worry about O_APPEND
  1269.      * as this is not set anywhere in Samba.
  1270.      */
  1271.     fd_ptr->real_open_flags = O_RDWR;
  1272.     /* Set the flags as needed without the read/write modes. */
  1273.     open_flags = flags & ~(O_RDWR|O_WRONLY|O_RDONLY);
  1274.     fd_ptr->fd = fd_attempt_open(fname, open_flags|O_RDWR, mode);
  1275.     /*
  1276.      * On some systems opening a file for R/W access on a read only
  1277.      * filesystems sets errno to EROFS.
  1278.      */
  1279. #ifdef EROFS
  1280.     if((fd_ptr->fd == -1) && ((errno == EACCES) || (errno == EROFS))) {
  1281. #else /* No EROFS */
  1282.     if((fd_ptr->fd == -1) && (errno == EACCES)) {
  1283. #endif /* EROFS */
  1284.       if(flags & O_WRONLY) {
  1285.         fd_ptr->fd = fd_attempt_open(fname, open_flags|O_WRONLY, mode);
  1286.         fd_ptr->real_open_flags = O_WRONLY;
  1287.       } else {
  1288.     fd_ptr->fd = fd_attempt_open(fname, open_flags|O_RDONLY, mode);
  1289.         fd_ptr->real_open_flags = O_RDONLY;
  1290.       }
  1291.     }
  1292.   }
  1293.  
  1294.   if ((fd_ptr->fd >=0) && 
  1295.       Connections[cnum].printer && lp_minprintspace(SNUM(cnum))) {
  1296.     pstring dname;
  1297.     int dum1,dum2,dum3;
  1298.     char *p;
  1299.     pstrcpy(dname,fname);
  1300.     p = strrchr(dname,'/');
  1301.     if (p) *p = 0;
  1302.     if (sys_disk_free(dname,&dum1,&dum2,&dum3) < 
  1303.     lp_minprintspace(SNUM(cnum))) {
  1304.       fd_attempt_close(fd_ptr);
  1305.       fsp->fd_ptr = 0;
  1306.       if(fd_ptr->ref_count == 0)
  1307.         sys_unlink(fname);
  1308.       errno = ENOSPC;
  1309.       return;
  1310.     }
  1311.   }
  1312.     
  1313.   if (fd_ptr->fd < 0)
  1314.     {
  1315.       DEBUG(3,("Error opening file %s (%s) (flags=%d)\n",
  1316.            fname,strerror(errno),flags));
  1317.       /* Ensure the ref_count is decremented. */
  1318.       fd_attempt_close(fd_ptr);
  1319.       check_for_pipe(fname);
  1320.       return;
  1321.     }
  1322.  
  1323.   if (fd_ptr->fd >= 0)
  1324.     {
  1325.       if(sbuf == 0) {
  1326.         /* Do the fstat */
  1327.         if(fstat(fd_ptr->fd, &statbuf) == -1) {
  1328.           /* Error - backout !! */
  1329.           DEBUG(3,("Error doing fstat on fd %d, file %s (%s)\n",
  1330.                    fd_ptr->fd, fname,strerror(errno)));
  1331.           /* Ensure the ref_count is decremented. */
  1332.           fd_attempt_close(fd_ptr);
  1333.           return;
  1334.         }
  1335.         sbuf = &statbuf;
  1336.       }
  1337.       /* Set the correct entries in fd_ptr. */
  1338.       fd_ptr->dev = (uint32)sbuf->st_dev;
  1339.       fd_ptr->inode = (uint32)sbuf->st_ino;
  1340.  
  1341.       fsp->fd_ptr = fd_ptr;
  1342.       Connections[cnum].num_files_open++;
  1343.       fsp->mode = sbuf->st_mode;
  1344.       GetTimeOfDay(&fsp->open_time);
  1345.       fsp->vuid = current_user.vuid;
  1346.       fsp->size = 0;
  1347.       fsp->pos = -1;
  1348.       fsp->open = True;
  1349.       fsp->mmap_ptr = NULL;
  1350.       fsp->mmap_size = 0;
  1351.       fsp->can_lock = True;
  1352.       fsp->can_read = ((flags & O_WRONLY)==0);
  1353.       fsp->can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
  1354.       fsp->share_mode = 0;
  1355.       fsp->print_file = Connections[cnum].printer;
  1356.       fsp->modified = False;
  1357.       fsp->granted_oplock = False;
  1358.       fsp->sent_oplock_break = False;
  1359.       fsp->cnum = cnum;
  1360.       string_set(&fsp->name,dos_to_unix(fname,False));
  1361.       fsp->wbmpx_ptr = NULL;      
  1362.  
  1363.       /*
  1364.        * If the printer is marked as postscript output a leading
  1365.        * file identifier to ensure the file is treated as a raw
  1366.        * postscript file.
  1367.        * This has a similar effect as CtrlD=0 in WIN.INI file.
  1368.        * tim@fsg.com 09/06/94
  1369.        */
  1370.       if (fsp->print_file && POSTSCRIPT(cnum) && 
  1371.       fsp->can_write) 
  1372.     {
  1373.       DEBUG(3,("Writing postscript line\n"));
  1374.       write_file(fnum,"%!\n",3);
  1375.     }
  1376.       
  1377.       DEBUG(2,("%s %s opened file %s read=%s write=%s (numopen=%d fnum=%d)\n",
  1378.            timestring(),Connections[cnum].user,fname,
  1379.            BOOLSTR(fsp->can_read),BOOLSTR(fsp->can_write),
  1380.            Connections[cnum].num_files_open,fnum));
  1381.  
  1382.     }
  1383.  
  1384. #if USE_MMAP
  1385.   /* mmap it if read-only */
  1386.   if (!fsp->can_write)
  1387.     {
  1388.       fsp->mmap_size = file_size(fname);
  1389.       fsp->mmap_ptr = (char *)mmap(NULL,fsp->mmap_size,
  1390.                       PROT_READ,MAP_SHARED,fsp->fd_ptr->fd,0);
  1391.  
  1392.       if (fsp->mmap_ptr == (char *)-1 || !fsp->mmap_ptr)
  1393.     {
  1394.       DEBUG(3,("Failed to mmap() %s - %s\n",fname,strerror(errno)));
  1395.       fsp->mmap_ptr = NULL;
  1396.     }
  1397.     }
  1398. #endif
  1399. }
  1400.  
  1401. /*******************************************************************
  1402. sync a file
  1403. ********************************************************************/
  1404. void sync_file(int fnum)
  1405. {
  1406. #ifndef NO_FSYNC
  1407.   fsync(Files[fnum].fd_ptr->fd);
  1408. #endif
  1409. }
  1410.  
  1411. /****************************************************************************
  1412. run a file if it is a magic script
  1413. ****************************************************************************/
  1414. static void check_magic(int fnum,int cnum)
  1415. {
  1416.   if (!*lp_magicscript(SNUM(cnum)))
  1417.     return;
  1418.  
  1419.   DEBUG(5,("checking magic for %s\n",Files[fnum].name));
  1420.  
  1421.   {
  1422.     char *p;
  1423.     if (!(p = strrchr(Files[fnum].name,'/')))
  1424.       p = Files[fnum].name;
  1425.     else
  1426.       p++;
  1427.  
  1428.     if (!strequal(lp_magicscript(SNUM(cnum)),p))
  1429.       return;
  1430.   }
  1431.  
  1432.   {
  1433.     int ret;
  1434.     pstring magic_output;
  1435.     pstring fname;
  1436.     pstrcpy(fname,Files[fnum].name);
  1437.  
  1438.     if (*lp_magicoutput(SNUM(cnum)))
  1439.       pstrcpy(magic_output,lp_magicoutput(SNUM(cnum)));
  1440.     else
  1441.       slprintf(magic_output,sizeof(fname)-1, "%s.out",fname);
  1442.  
  1443.     chmod(fname,0755);
  1444.     ret = smbrun(fname,magic_output,False);
  1445.     DEBUG(3,("Invoking magic command %s gave %d\n",fname,ret));
  1446.     unlink(fname);
  1447.   }
  1448. }
  1449.  
  1450.  
  1451. /****************************************************************************
  1452. close a file - possibly invalidating the read prediction
  1453.  
  1454. If normal_close is 1 then this came from a normal SMBclose (or equivalent)
  1455. operation otherwise it came as the result of some other operation such as
  1456. the closing of the connection. In the latter case printing and
  1457. magic scripts are not run
  1458. ****************************************************************************/
  1459. void close_file(int fnum, BOOL normal_close)
  1460. {
  1461.   files_struct *fs_p = &Files[fnum];
  1462.   int cnum = fs_p->cnum;
  1463.   uint32 dev = fs_p->fd_ptr->dev;
  1464.   uint32 inode = fs_p->fd_ptr->inode;
  1465.   int token;
  1466.  
  1467.   Files[fnum].reserved = False;
  1468.  
  1469. #if USE_READ_PREDICTION
  1470.   invalidate_read_prediction(fs_p->fd_ptr->fd);
  1471. #endif
  1472.  
  1473.   fs_p->open = False;
  1474.   Connections[cnum].num_files_open--;
  1475.   if(fs_p->wbmpx_ptr) 
  1476.   {
  1477.     free((char *)fs_p->wbmpx_ptr);
  1478.     fs_p->wbmpx_ptr = NULL;
  1479.   }
  1480.  
  1481. #if USE_MMAP
  1482.   if(fs_p->mmap_ptr) 
  1483.   {
  1484.     munmap(fs_p->mmap_ptr,fs_p->mmap_size);
  1485.     fs_p->mmap_ptr = NULL;
  1486.   }
  1487. #endif
  1488.  
  1489.   if (lp_share_modes(SNUM(cnum)))
  1490.   {
  1491.     lock_share_entry( cnum, dev, inode, &token);
  1492.     del_share_mode(token, fnum);
  1493.   }
  1494.  
  1495.   fd_attempt_close(fs_p->fd_ptr);
  1496.  
  1497.   if (lp_share_modes(SNUM(cnum)))
  1498.     unlock_share_entry( cnum, dev, inode, token);
  1499.  
  1500.   /* NT uses smbclose to start a print - weird */
  1501.   if (normal_close && fs_p->print_file)
  1502.     print_file(fnum);
  1503.  
  1504.   /* check for magic scripts */
  1505.   if (normal_close)
  1506.     check_magic(fnum,cnum);
  1507.  
  1508.   if(fs_p->granted_oplock == True)
  1509.     global_oplocks_open--;
  1510.  
  1511.   fs_p->sent_oplock_break = False;
  1512.  
  1513.   DEBUG(2,("%s %s closed file %s (numopen=%d)\n",
  1514.        timestring(),Connections[cnum].user,fs_p->name,
  1515.        Connections[cnum].num_files_open));
  1516.  
  1517.   if (fs_p->name) {
  1518.       string_free(&fs_p->name);
  1519.   }
  1520.  
  1521.   /* we will catch bugs faster by zeroing this structure */
  1522.   memset(fs_p, 0, sizeof(*fs_p));
  1523. }
  1524.  
  1525. enum {AFAIL,AREAD,AWRITE,AALL};
  1526.  
  1527. /*******************************************************************
  1528. reproduce the share mode access table
  1529. ********************************************************************/
  1530. static int access_table(int new_deny,int old_deny,int old_mode,
  1531.             int share_pid,char *fname)
  1532. {
  1533.   if (new_deny == DENY_ALL || old_deny == DENY_ALL) return(AFAIL);
  1534.  
  1535.   if (new_deny == DENY_DOS || old_deny == DENY_DOS) {
  1536.     int pid = getpid();
  1537.     if (old_deny == new_deny && share_pid == pid) 
  1538.     return(AALL);    
  1539.  
  1540.     if (old_mode == 0) return(AREAD);
  1541.  
  1542.     /* the new smbpub.zip spec says that if the file extension is
  1543.        .com, .dll, .exe or .sym then allow the open. I will force
  1544.        it to read-only as this seems sensible although the spec is
  1545.        a little unclear on this. */
  1546.     if ((fname = strrchr(fname,'.'))) {
  1547.       if (strequal(fname,".com") ||
  1548.       strequal(fname,".dll") ||
  1549.       strequal(fname,".exe") ||
  1550.       strequal(fname,".sym"))
  1551.     return(AREAD);
  1552.     }
  1553.  
  1554.     return(AFAIL);
  1555.   }
  1556.  
  1557.   switch (new_deny) 
  1558.     {
  1559.     case DENY_WRITE:
  1560.       if (old_deny==DENY_WRITE && old_mode==0) return(AREAD);
  1561.       if (old_deny==DENY_READ && old_mode==0) return(AWRITE);
  1562.       if (old_deny==DENY_NONE && old_mode==0) return(AALL);
  1563.       return(AFAIL);
  1564.     case DENY_READ:
  1565.       if (old_deny==DENY_WRITE && old_mode==1) return(AREAD);
  1566.       if (old_deny==DENY_READ && old_mode==1) return(AWRITE);
  1567.       if (old_deny==DENY_NONE && old_mode==1) return(AALL);
  1568.       return(AFAIL);
  1569.     case DENY_NONE:
  1570.       if (old_deny==DENY_WRITE) return(AREAD);
  1571.       if (old_deny==DENY_READ) return(AWRITE);
  1572.       if (old_deny==DENY_NONE) return(AALL);
  1573.       return(AFAIL);      
  1574.     }
  1575.   return(AFAIL);      
  1576. }
  1577.  
  1578. /*******************************************************************
  1579. check if the share mode on a file allows it to be deleted or unlinked
  1580. return True if sharing doesn't prevent the operation
  1581. ********************************************************************/
  1582. BOOL check_file_sharing(int cnum,char *fname, BOOL rename_op)
  1583. {
  1584.   int i;
  1585.   int ret = False;
  1586.   share_mode_entry *old_shares = 0;
  1587.   int num_share_modes;
  1588.   struct stat sbuf;
  1589.   int token;
  1590.   int pid = getpid();
  1591.   uint32 dev, inode;
  1592.  
  1593.   if(!lp_share_modes(SNUM(cnum)))
  1594.     return True;
  1595.  
  1596.   if (stat(fname,&sbuf) == -1) return(True);
  1597.  
  1598.   dev = (uint32)sbuf.st_dev;
  1599.   inode = (uint32)sbuf.st_ino;
  1600.  
  1601.   lock_share_entry(cnum, dev, inode, &token);
  1602.   num_share_modes = get_share_modes(cnum, token, dev, inode, &old_shares);
  1603.  
  1604.   /*
  1605.    * Check if the share modes will give us access.
  1606.    */
  1607.  
  1608.   if(num_share_modes != 0)
  1609.   {
  1610.     BOOL broke_oplock;
  1611.  
  1612.     do
  1613.     {
  1614.  
  1615.       broke_oplock = False;
  1616.       for(i = 0; i < num_share_modes; i++)
  1617.       {
  1618.         share_mode_entry *share_entry = &old_shares[i];
  1619.  
  1620.         /* 
  1621.          * Break oplocks before checking share modes. See comment in
  1622.          * open_file_shared for details. 
  1623.          * Check if someone has an oplock on this file. If so we must 
  1624.          * break it before continuing. 
  1625.          */
  1626.         if(share_entry->op_type & BATCH_OPLOCK)
  1627.         {
  1628.  
  1629.           /*
  1630.            * It appears that the NT redirector may have a bug, in that
  1631.            * it tries to do an SMBmv on a file that it has open with a
  1632.            * batch oplock, and then fails to respond to the oplock break
  1633.            * request. This only seems to occur when the client is doing an
  1634.            * SMBmv to the smbd it is using - thus we try and detect this
  1635.            * condition by checking if the file being moved is open and oplocked by
  1636.            * this smbd process, and then not sending the oplock break in this
  1637.            * special case. If the file was open with a deny mode that 
  1638.            * prevents the move the SMBmv will fail anyway with a share
  1639.            * violation error. JRA.
  1640.            */
  1641.           if(rename_op && (share_entry->pid == pid))
  1642.           {
  1643.             DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
  1644. batch oplocked file %s, dev = %x, inode = %x\n", fname, dev, inode));
  1645.             /* 
  1646.              * This next line is a test that allows the deny-mode
  1647.              * processing to be skipped. This seems to be needed as
  1648.              * NT insists on the rename succeeding (in Office 9x no less !).
  1649.              * This should be removed as soon as (a) MS fix the redirector
  1650.              * bug or (b) NT SMB support in Samba makes NT not issue the
  1651.              * call (as is my fervent hope). JRA.
  1652.              */ 
  1653.             continue;
  1654.           }
  1655.           else
  1656.           {
  1657.             DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
  1658. dev = %x, inode = %x\n", share_entry->op_type, fname, dev, inode));
  1659.  
  1660.             /* Oplock break.... */
  1661.             unlock_share_entry(cnum, dev, inode, token);
  1662.             if(request_oplock_break(share_entry, dev, inode) == False)
  1663.             {
  1664.               free((char *)old_shares);
  1665.               DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
  1666. dev = %x, inode = %x\n", old_shares[i].op_type, fname, dev, inode));
  1667.               return False;
  1668.             }
  1669.             lock_share_entry(cnum, dev, inode, &token);
  1670.             broke_oplock = True;
  1671.             break;
  1672.           }
  1673.         }
  1674.  
  1675.         /* someone else has a share lock on it, check to see 
  1676.            if we can too */
  1677.         if ((share_entry->share_mode != DENY_DOS) || (share_entry->pid != pid))
  1678.           goto free_and_exit;
  1679.  
  1680.       } /* end for */
  1681.  
  1682.       if(broke_oplock)
  1683.       {
  1684.         free((char *)old_shares);
  1685.         num_share_modes = get_share_modes(cnum, token, dev, inode, &old_shares);
  1686.       }
  1687.     } while(broke_oplock);
  1688.   }
  1689.  
  1690.   /* XXXX exactly what share mode combinations should be allowed for
  1691.      deleting/renaming? */
  1692.   /* If we got here then either there were no share modes or
  1693.      all share modes were DENY_DOS and the pid == getpid() */
  1694.   ret = True;
  1695.  
  1696. free_and_exit:
  1697.  
  1698.   unlock_share_entry(cnum, dev, inode, token);
  1699.   if(old_shares != NULL)
  1700.     free((char *)old_shares);
  1701.   return(ret);
  1702. }
  1703.  
  1704. /****************************************************************************
  1705.   C. Hoch 11/22/95
  1706.   Helper for open_file_shared. 
  1707.   Truncate a file after checking locking; close file if locked.
  1708.   **************************************************************************/
  1709. static void truncate_unless_locked(int fnum, int cnum, int token, 
  1710.                    BOOL *share_locked)
  1711. {
  1712.   if (Files[fnum].can_write){
  1713.     if (is_locked(fnum,cnum,0x3FFFFFFF,0)){
  1714.       /* If share modes are in force for this connection we
  1715.          have the share entry locked. Unlock it before closing. */
  1716.       if (*share_locked && lp_share_modes(SNUM(cnum)))
  1717.         unlock_share_entry( cnum, Files[fnum].fd_ptr->dev, 
  1718.                             Files[fnum].fd_ptr->inode, token);
  1719.       close_file(fnum,False);   
  1720.       /* Share mode no longer locked. */
  1721.       *share_locked = False;
  1722.       errno = EACCES;
  1723.       unix_ERR_class = ERRDOS;
  1724.       unix_ERR_code = ERRlock;
  1725.     }
  1726.     else
  1727.       ftruncate(Files[fnum].fd_ptr->fd,0); 
  1728.   }
  1729. }
  1730.  
  1731. /****************************************************************************
  1732. check if we can open a file with a share mode
  1733. ****************************************************************************/
  1734. int check_share_mode( share_mode_entry *share, int deny_mode, char *fname,
  1735.                       BOOL fcbopen, int *flags)
  1736. {
  1737.   int old_open_mode = share->share_mode &0xF;
  1738.   int old_deny_mode = (share->share_mode >>4)&7;
  1739.  
  1740.   if (old_deny_mode > 4 || old_open_mode > 2)
  1741.   {
  1742.     DEBUG(0,("Invalid share mode found (%d,%d,%d) on file %s\n",
  1743.                deny_mode,old_deny_mode,old_open_mode,fname));
  1744.     return False;
  1745.   }
  1746.  
  1747.   {
  1748.     int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
  1749.                                 share->pid,fname);
  1750.  
  1751.     if ((access_allowed == AFAIL) ||
  1752.         (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
  1753.         (access_allowed == AREAD && *flags == O_WRONLY) ||
  1754.         (access_allowed == AWRITE && *flags == O_RDONLY))
  1755.     {
  1756.       DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
  1757.                 deny_mode,old_deny_mode,old_open_mode,
  1758.                 share->pid,fname, fcbopen, *flags, access_allowed));
  1759.       return False;
  1760.     }
  1761.  
  1762.     if (access_allowed == AREAD)
  1763.       *flags = O_RDONLY;
  1764.  
  1765.     if (access_allowed == AWRITE)
  1766.       *flags = O_WRONLY;
  1767.  
  1768.   }
  1769.   return True;
  1770. }
  1771.  
  1772. /****************************************************************************
  1773. open a file with a share mode
  1774. ****************************************************************************/
  1775. void open_file_shared(int fnum,int cnum,char *fname,int share_mode,int ofun,
  1776.               int mode,int oplock_request, int *Access,int *action)
  1777. {
  1778.   files_struct *fs_p = &Files[fnum];
  1779.   int flags=0;
  1780.   int flags2=0;
  1781.   int deny_mode = (share_mode>>4)&7;
  1782.   struct stat sbuf;
  1783.   BOOL file_existed = file_exist(fname,&sbuf);
  1784.   BOOL share_locked = False;
  1785.   BOOL fcbopen = False;
  1786.   int token;
  1787.   uint32 dev = 0;
  1788.   uint32 inode = 0;
  1789.   int num_share_modes = 0;
  1790.  
  1791.   fs_p->open = False;
  1792.   fs_p->fd_ptr = 0;
  1793.  
  1794.   /* this is for OS/2 EAs - try and say we don't support them */
  1795.   if (strstr(fname,".+,;=[].")) 
  1796.   {
  1797.     unix_ERR_class = ERRDOS;
  1798.     /* OS/2 Workplace shell fix may be main code stream in a later release. */ 
  1799. #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
  1800.     unix_ERR_code = ERRcannotopen;
  1801. #else /* OS2_WPS_FIX */
  1802.     unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
  1803. #endif /* OS2_WPS_FIX */
  1804.  
  1805.     return;
  1806.   }
  1807.  
  1808.   if ((ofun & 0x3) == 0 && file_existed)  
  1809.   {
  1810.     errno = EEXIST;
  1811.     return;
  1812.   }
  1813.       
  1814.   if (ofun & 0x10)
  1815.     flags2 |= O_CREAT;
  1816.   if ((ofun & 0x3) == 2)
  1817.     flags2 |= O_TRUNC;
  1818.  
  1819.   /* note that we ignore the append flag as 
  1820.      append does not mean the same thing under dos and unix */
  1821.  
  1822.   switch (share_mode&0xF)
  1823.   {
  1824.     case 1: 
  1825.       flags = O_WRONLY; 
  1826.       break;
  1827.     case 0xF: 
  1828.       fcbopen = True;
  1829.       flags = O_RDWR; 
  1830.       break;
  1831.     case 2: 
  1832.       flags = O_RDWR; 
  1833.       break;
  1834.     default:
  1835.       flags = O_RDONLY;
  1836.       break;
  1837.   }
  1838.   
  1839.   if (flags != O_RDONLY && file_existed && 
  1840.       (!CAN_WRITE(cnum) || IS_DOS_READONLY(dos_mode(cnum,fname,&sbuf)))) 
  1841.   {
  1842.     if (!fcbopen) 
  1843.     {
  1844.       errno = EACCES;
  1845.       return;
  1846.     }
  1847.     flags = O_RDONLY;
  1848.   }
  1849.  
  1850.   if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) 
  1851.   {
  1852.     DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
  1853.     errno = EINVAL;
  1854.     return;
  1855.   }
  1856.  
  1857.   if (deny_mode == DENY_FCB) deny_mode = DENY_DOS;
  1858.  
  1859.   if (lp_share_modes(SNUM(cnum))) 
  1860.   {
  1861.     int i;
  1862.     share_mode_entry *old_shares = 0;
  1863.  
  1864.     if (file_existed)
  1865.     {
  1866.       dev = (uint32)sbuf.st_dev;
  1867.       inode = (uint32)sbuf.st_ino;
  1868.       lock_share_entry(cnum, dev, inode, &token);
  1869.       share_locked = True;
  1870.       num_share_modes = get_share_modes(cnum, token, dev, inode, &old_shares);
  1871.     }
  1872.  
  1873.     /*
  1874.      * Check if the share modes will give us access.
  1875.      */
  1876.  
  1877.     if(share_locked && (num_share_modes != 0))
  1878.     {
  1879.       BOOL broke_oplock;
  1880.  
  1881.       do
  1882.       {
  1883.  
  1884.         broke_oplock = False;
  1885.         for(i = 0; i < num_share_modes; i++)
  1886.         {
  1887.           share_mode_entry *share_entry = &old_shares[i];
  1888.  
  1889.           /* 
  1890.            * By observation of NetBench, oplocks are broken *before* share
  1891.            * modes are checked. This allows a file to be closed by the client
  1892.            * if the share mode would deny access and the client has an oplock. 
  1893.            * Check if someone has an oplock on this file. If so we must break 
  1894.            * it before continuing. 
  1895.            */
  1896.           if(share_entry->op_type & (EXCLUSIVE_OPLOCK|BATCH_OPLOCK))
  1897.           {
  1898.  
  1899.             DEBUG(5,("open_file_shared: breaking oplock (%x) on file %s, \
  1900. dev = %x, inode = %x\n", share_entry->op_type, fname, dev, inode));
  1901.  
  1902.             /* Oplock break.... */
  1903.             unlock_share_entry(cnum, dev, inode, token);
  1904.             if(request_oplock_break(share_entry, dev, inode) == False)
  1905.             {
  1906.               free((char *)old_shares);
  1907.               DEBUG(0,("open_file_shared: FAILED when breaking oplock (%x) on file %s, \
  1908. dev = %x, inode = %x\n", old_shares[i].op_type, fname, dev, inode));
  1909.               errno = EACCES;
  1910.               unix_ERR_class = ERRDOS;
  1911.               unix_ERR_code = ERRbadshare;
  1912.               return;
  1913.             }
  1914.             lock_share_entry(cnum, dev, inode, &token);
  1915.             broke_oplock = True;
  1916.             break;
  1917.           }
  1918.  
  1919.           /* someone else has a share lock on it, check to see 
  1920.              if we can too */
  1921.           if(check_share_mode(share_entry, deny_mode, fname, fcbopen, &flags) == False)
  1922.           {
  1923.             free((char *)old_shares);
  1924.             unlock_share_entry(cnum, dev, inode, token);
  1925.             errno = EACCES;
  1926.             unix_ERR_class = ERRDOS;
  1927.             unix_ERR_code = ERRbadshare;
  1928.             return;
  1929.           }
  1930.  
  1931.         } /* end for */
  1932.  
  1933.         if(broke_oplock)
  1934.         {
  1935.           free((char *)old_shares);
  1936.           num_share_modes = get_share_modes(cnum, token, dev, inode, &old_shares);
  1937.         }
  1938.       } while(broke_oplock);
  1939.     }
  1940.  
  1941.     if(old_shares != 0)
  1942.       free((char *)old_shares);
  1943.   }
  1944.  
  1945.   DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
  1946.        flags,flags2,mode));
  1947.  
  1948.   open_file(fnum,cnum,fname,flags|(flags2&~(O_TRUNC)),mode,file_existed ? &sbuf : 0);
  1949.   if (!fs_p->open && flags==O_RDWR && errno!=ENOENT && fcbopen) 
  1950.   {
  1951.     flags = O_RDONLY;
  1952.     open_file(fnum,cnum,fname,flags,mode,file_existed ? &sbuf : 0 );
  1953.   }
  1954.  
  1955.   if (fs_p->open) 
  1956.   {
  1957.     int open_mode=0;
  1958.  
  1959.     if((share_locked == False) && lp_share_modes(SNUM(cnum)))
  1960.     {
  1961.       /* We created the file - thus we must now lock the share entry before creating it. */
  1962.       dev = fs_p->fd_ptr->dev;
  1963.       inode = fs_p->fd_ptr->inode;
  1964.       lock_share_entry(cnum, dev, inode, &token);
  1965.       share_locked = True;
  1966.     }
  1967.  
  1968.     switch (flags) 
  1969.     {
  1970.       case O_RDONLY:
  1971.         open_mode = 0;
  1972.         break;
  1973.       case O_RDWR:
  1974.         open_mode = 2;
  1975.         break;
  1976.       case O_WRONLY:
  1977.         open_mode = 1;
  1978.         break;
  1979.     }
  1980.  
  1981.     fs_p->share_mode = (deny_mode<<4) | open_mode;
  1982.  
  1983.     if (Access)
  1984.       (*Access) = open_mode;
  1985.  
  1986.     if (action) 
  1987.     {
  1988.       if (file_existed && !(flags2 & O_TRUNC)) *action = 1;
  1989.       if (!file_existed) *action = 2;
  1990.       if (file_existed && (flags2 & O_TRUNC)) *action = 3;
  1991.     }
  1992.     /* We must create the share mode entry before truncate as
  1993.        truncate can fail due to locking and have to close the
  1994.        file (which expects the share_mode_entry to be there).
  1995.      */
  1996.     if (lp_share_modes(SNUM(cnum)))
  1997.     {
  1998.       uint16 port = 0;
  1999.       /* JRA. Currently this only services Exlcusive and batch
  2000.          oplocks (no other opens on this file). This needs to
  2001.          be extended to level II oplocks (multiple reader
  2002.          oplocks). */
  2003.  
  2004.       if(oplock_request && (num_share_modes == 0) && lp_oplocks(SNUM(cnum)) && 
  2005.           !IS_VETO_OPLOCK_PATH(cnum,fname))
  2006.       {
  2007.         fs_p->granted_oplock = True;
  2008.         fs_p->sent_oplock_break = False;
  2009.         global_oplocks_open++;
  2010.         port = oplock_port;
  2011.  
  2012.         DEBUG(5,("open_file_shared: granted oplock (%x) on file %s, \
  2013. dev = %x, inode = %x\n", oplock_request, fname, dev, inode));
  2014.  
  2015.       }
  2016.       else
  2017.       {
  2018.         port = 0;
  2019.         oplock_request = 0;
  2020.       }
  2021.       set_share_mode(token, fnum, port, oplock_request);
  2022.     }
  2023.  
  2024.     if ((flags2&O_TRUNC) && file_existed)
  2025.       truncate_unless_locked(fnum,cnum,token,&share_locked);
  2026.   }
  2027.  
  2028.   if (share_locked && lp_share_modes(SNUM(cnum)))
  2029.     unlock_share_entry( cnum, dev, inode, token);
  2030. }
  2031.  
  2032. /****************************************************************************
  2033. seek a file. Try to avoid the seek if possible
  2034. ****************************************************************************/
  2035. int seek_file(int fnum,uint32 pos)
  2036. {
  2037.   uint32 offset = 0;
  2038.   if (Files[fnum].print_file && POSTSCRIPT(Files[fnum].cnum))
  2039.     offset = 3;
  2040.  
  2041.   Files[fnum].pos = (int)(lseek(Files[fnum].fd_ptr->fd,pos+offset,SEEK_SET) 
  2042.                                   - offset);
  2043.   return(Files[fnum].pos);
  2044. }
  2045.  
  2046. /****************************************************************************
  2047. read from a file
  2048. ****************************************************************************/
  2049. int read_file(int fnum,char *data,uint32 pos,int n)
  2050. {
  2051.   int ret=0,readret;
  2052.  
  2053. #if USE_READ_PREDICTION
  2054.   if (!Files[fnum].can_write)
  2055.     {
  2056.       ret = read_predict(Files[fnum].fd_ptr->fd,pos,data,NULL,n);
  2057.  
  2058.       data += ret;
  2059.       n -= ret;
  2060.       pos += ret;
  2061.     }
  2062. #endif
  2063.  
  2064. #if USE_MMAP
  2065.   if (Files[fnum].mmap_ptr)
  2066.     {
  2067.       int num = (Files[fnum].mmap_size > pos) ? (Files[fnum].mmap_size - pos) : -1;
  2068.       num = MIN(n,num);
  2069.       if (num > 0)
  2070.     {
  2071.       memcpy(data,Files[fnum].mmap_ptr+pos,num);
  2072.       data += num;
  2073.       pos += num;
  2074.       n -= num;
  2075.       ret += num;
  2076.     }
  2077.     }
  2078. #endif
  2079.  
  2080.   if (n <= 0)
  2081.     return(ret);
  2082.  
  2083.   if (seek_file(fnum,pos) != pos)
  2084.     {
  2085.       DEBUG(3,("Failed to seek to %d\n",pos));
  2086.       return(ret);
  2087.     }
  2088.   
  2089.   if (n > 0) {
  2090.     readret = read(Files[fnum].fd_ptr->fd,data,n);
  2091.     if (readret > 0) ret += readret;
  2092.   }
  2093.  
  2094.   return(ret);
  2095. }
  2096.  
  2097.  
  2098. /****************************************************************************
  2099. write to a file
  2100. ****************************************************************************/
  2101. int write_file(int fnum,char *data,int n)
  2102. {
  2103.   if (!Files[fnum].can_write) {
  2104.     errno = EPERM;
  2105.     return(0);
  2106.   }
  2107.  
  2108.   if (!Files[fnum].modified) {
  2109.     struct stat st;
  2110.     Files[fnum].modified = True;
  2111.     if (fstat(Files[fnum].fd_ptr->fd,&st) == 0) {
  2112.       int dosmode = dos_mode(Files[fnum].cnum,Files[fnum].name,&st);
  2113.       if (MAP_ARCHIVE(Files[fnum].cnum) && !IS_DOS_ARCHIVE(dosmode)) {    
  2114.     dos_chmod(Files[fnum].cnum,Files[fnum].name,dosmode | aARCH,&st);
  2115.       }
  2116.     }  
  2117.   }
  2118.  
  2119.   return(write_data(Files[fnum].fd_ptr->fd,data,n));
  2120. }
  2121.  
  2122.  
  2123. /****************************************************************************
  2124. load parameters specific to a connection/service
  2125. ****************************************************************************/
  2126. BOOL become_service(int cnum,BOOL do_chdir)
  2127. {
  2128.   extern char magic_char;
  2129.   static int last_cnum = -1;
  2130.   int snum;
  2131.  
  2132.   if (!OPEN_CNUM(cnum))
  2133.     {
  2134.       last_cnum = -1;
  2135.       return(False);
  2136.     }
  2137.  
  2138.   Connections[cnum].lastused = smb_last_time;
  2139.  
  2140.   snum = SNUM(cnum);
  2141.   
  2142.   if (do_chdir &&
  2143.       ChDir(Connections[cnum].connectpath) != 0 &&
  2144.       ChDir(Connections[cnum].origpath) != 0)
  2145.     {
  2146.       DEBUG(0,("%s chdir (%s) failed cnum=%d\n",timestring(),
  2147.         Connections[cnum].connectpath,cnum));     
  2148.       return(False);
  2149.     }
  2150.  
  2151.   if (cnum == last_cnum)
  2152.     return(True);
  2153.  
  2154.   last_cnum = cnum;
  2155.  
  2156.   case_default = lp_defaultcase(snum);
  2157.   case_preserve = lp_preservecase(snum);
  2158.   short_case_preserve = lp_shortpreservecase(snum);
  2159.   case_mangle = lp_casemangle(snum);
  2160.   case_sensitive = lp_casesensitive(snum);
  2161.   magic_char = lp_magicchar(snum);
  2162.   use_mangled_map = (*lp_mangled_map(snum) ? True:False);
  2163.   return(True);
  2164. }
  2165.  
  2166.  
  2167. /****************************************************************************
  2168.   find a service entry
  2169. ****************************************************************************/
  2170. int find_service(char *service)
  2171. {
  2172.    int iService;
  2173.  
  2174.    string_sub(service,"\\","/");
  2175.  
  2176.    iService = lp_servicenumber(service);
  2177.  
  2178.    /* now handle the special case of a home directory */
  2179.    if (iService < 0)
  2180.    {
  2181.       char *phome_dir = get_home_dir(service);
  2182.       DEBUG(3,("checking for home directory %s gave %s\n",service,
  2183.         phome_dir?phome_dir:"(NULL)"));
  2184.       if (phome_dir)
  2185.       {   
  2186.      int iHomeService;
  2187.      if ((iHomeService = lp_servicenumber(HOMES_NAME)) >= 0)
  2188.      {
  2189.         lp_add_home(service,iHomeService,phome_dir);
  2190.         iService = lp_servicenumber(service);
  2191.      }
  2192.       }
  2193.    }
  2194.  
  2195.    /* If we still don't have a service, attempt to add it as a printer. */
  2196.    if (iService < 0)
  2197.    {
  2198.       int iPrinterService;
  2199.  
  2200.       if ((iPrinterService = lp_servicenumber(PRINTERS_NAME)) >= 0)
  2201.       {
  2202.          char *pszTemp;
  2203.  
  2204.          DEBUG(3,("checking whether %s is a valid printer name...\n", service));
  2205.          pszTemp = PRINTCAP;
  2206.          if ((pszTemp != NULL) && pcap_printername_ok(service, pszTemp))
  2207.          {
  2208.             DEBUG(3,("%s is a valid printer name\n", service));
  2209.             DEBUG(3,("adding %s as a printer service\n", service));
  2210.             lp_add_printer(service,iPrinterService);
  2211.             iService = lp_servicenumber(service);
  2212.             if (iService < 0)
  2213.                DEBUG(0,("failed to add %s as a printer service!\n", service));
  2214.          }
  2215.          else
  2216.             DEBUG(3,("%s is not a valid printer name\n", service));
  2217.       }
  2218.    }
  2219.  
  2220.    /* just possibly it's a default service? */
  2221.    if (iService < 0) 
  2222.      {
  2223.        char *pdefservice = lp_defaultservice();
  2224.        if (pdefservice && *pdefservice && !strequal(pdefservice,service)) {
  2225.          /*
  2226.           * We need to do a local copy here as lp_defaultservice() 
  2227.           * returns one of the rotating lp_string buffers that
  2228.           * could get overwritten by the recursive find_service() call
  2229.           * below. Fix from Josef Hinteregger <joehtg@joehtg.co.at>.
  2230.           */
  2231.          pstring defservice;
  2232.          pstrcpy(defservice, pdefservice);
  2233.      iService = find_service(defservice);
  2234.      if (iService >= 0) {
  2235.        string_sub(service,"_","/");
  2236.        iService = lp_add_service(service,iService);
  2237.      }
  2238.        }
  2239.      }
  2240.  
  2241.    if (iService >= 0)
  2242.       if (!VALID_SNUM(iService))
  2243.       {
  2244.          DEBUG(0,("Invalid snum %d for %s\n",iService,service));
  2245.      iService = -1;
  2246.       }
  2247.  
  2248.    if (iService < 0)
  2249.       DEBUG(3,("find_service() failed to find service %s\n", service));
  2250.  
  2251.    return (iService);
  2252. }
  2253.  
  2254.  
  2255. /****************************************************************************
  2256.   create an error packet from a cached error.
  2257. ****************************************************************************/
  2258. int cached_error_packet(char *inbuf,char *outbuf,int fnum,int line)
  2259. {
  2260.   write_bmpx_struct *wbmpx = Files[fnum].wbmpx_ptr;
  2261.  
  2262.   int32 eclass = wbmpx->wr_errclass;
  2263.   int32 err = wbmpx->wr_error;
  2264.  
  2265.   /* We can now delete the auxiliary struct */
  2266.   free((char *)wbmpx);
  2267.   Files[fnum].wbmpx_ptr = NULL;
  2268.   return error_packet(inbuf,outbuf,eclass,err,line);
  2269. }
  2270.  
  2271.  
  2272. struct
  2273. {
  2274.   int unixerror;
  2275.   int smbclass;
  2276.   int smbcode;
  2277. } unix_smb_errmap[] =
  2278. {
  2279.   {EPERM,ERRDOS,ERRnoaccess},
  2280.   {EACCES,ERRDOS,ERRnoaccess},
  2281.   {ENOENT,ERRDOS,ERRbadfile},
  2282.   {ENOTDIR,ERRDOS,ERRbadpath},
  2283.   {EIO,ERRHRD,ERRgeneral},
  2284.   {EBADF,ERRSRV,ERRsrverror},
  2285.   {EINVAL,ERRSRV,ERRsrverror},
  2286.   {EEXIST,ERRDOS,ERRfilexists},
  2287.   {ENFILE,ERRDOS,ERRnofids},
  2288.   {EMFILE,ERRDOS,ERRnofids},
  2289.   {ENOSPC,ERRHRD,ERRdiskfull},
  2290. #ifdef EDQUOT
  2291.   {EDQUOT,ERRHRD,ERRdiskfull},
  2292. #endif
  2293. #ifdef ENOTEMPTY
  2294.   {ENOTEMPTY,ERRDOS,ERRnoaccess},
  2295. #endif
  2296. #ifdef EXDEV
  2297.   {EXDEV,ERRDOS,ERRdiffdevice},
  2298. #endif
  2299.   {EROFS,ERRHRD,ERRnowrite},
  2300.   {0,0,0}
  2301. };
  2302.  
  2303. /****************************************************************************
  2304.   create an error packet from errno
  2305. ****************************************************************************/
  2306. int unix_error_packet(char *inbuf,char *outbuf,int def_class,uint32 def_code,int line)
  2307. {
  2308.   int eclass=def_class;
  2309.   int ecode=def_code;
  2310.   int i=0;
  2311.  
  2312.   if (unix_ERR_class != SMB_SUCCESS)
  2313.     {
  2314.       eclass = unix_ERR_class;
  2315.       ecode = unix_ERR_code;
  2316.       unix_ERR_class = SMB_SUCCESS;
  2317.       unix_ERR_code = 0;
  2318.     }
  2319.   else
  2320.     {
  2321.       while (unix_smb_errmap[i].smbclass != 0)
  2322.       {
  2323.         if (unix_smb_errmap[i].unixerror == errno)
  2324.         {
  2325.           eclass = unix_smb_errmap[i].smbclass;
  2326.           ecode = unix_smb_errmap[i].smbcode;
  2327.           break;
  2328.         }
  2329.       i++;
  2330.       }
  2331.     }
  2332.  
  2333.   return(error_packet(inbuf,outbuf,eclass,ecode,line));
  2334. }
  2335.  
  2336.  
  2337. /****************************************************************************
  2338.   create an error packet. Normally called using the ERROR() macro
  2339. ****************************************************************************/
  2340. int error_packet(char *inbuf,char *outbuf,int error_class,uint32 error_code,int line)
  2341. {
  2342.   int outsize = set_message(outbuf,0,0,True);
  2343.   int cmd;
  2344.   cmd = CVAL(inbuf,smb_com);
  2345.   
  2346.   CVAL(outbuf,smb_rcls) = error_class;
  2347.   SSVAL(outbuf,smb_err,error_code);  
  2348.   
  2349.   DEBUG(3,("%s error packet at line %d cmd=%d (%s) eclass=%d ecode=%d\n",
  2350.        timestring(),
  2351.        line,
  2352.        (int)CVAL(inbuf,smb_com),
  2353.        smb_fn_name(CVAL(inbuf,smb_com)),
  2354.        error_class,
  2355.        error_code));
  2356.  
  2357.   if (errno != 0)
  2358.     DEBUG(3,("error string = %s\n",strerror(errno)));
  2359.   
  2360.   return(outsize);
  2361. }
  2362.  
  2363.  
  2364. #ifndef SIGCLD_IGNORE
  2365. /****************************************************************************
  2366. this prevents zombie child processes
  2367. ****************************************************************************/
  2368. static int sig_cld(void)
  2369. {
  2370.   static int depth = 0;
  2371.   if (depth != 0)
  2372.     {
  2373.       DEBUG(0,("ERROR: Recursion in sig_cld? Perhaps you need `#define USE_WAITPID'?\n"));
  2374.       depth=0;
  2375.       return(0);
  2376.     }
  2377.   depth++;
  2378.  
  2379.   BlockSignals(True,SIGCLD);
  2380.   DEBUG(5,("got SIGCLD\n"));
  2381.  
  2382. #ifdef USE_WAITPID
  2383.   while (sys_waitpid((pid_t)-1,(int *)NULL, WNOHANG) > 0);
  2384. #endif
  2385.  
  2386.   /* Stop zombies */
  2387.   /* Stevens, Adv. Unix Prog. says that on system V you must call
  2388.      wait before reinstalling the signal handler, because the kernel
  2389.      calls the handler from within the signal-call when there is a
  2390.      child that has exited. This would lead to an infinite recursion
  2391.      if done vice versa. */
  2392.         
  2393. #ifndef DONT_REINSTALL_SIG
  2394. #ifdef SIGCLD_IGNORE
  2395.   signal(SIGCLD, SIG_IGN);  
  2396. #else
  2397.   signal(SIGCLD, SIGNAL_CAST sig_cld);
  2398. #endif
  2399. #endif
  2400.  
  2401. #ifndef USE_WAITPID
  2402.   while (wait3(WAIT3_CAST1 NULL, WNOHANG, WAIT3_CAST2 NULL) > 0);
  2403. #endif
  2404.   depth--;
  2405.   BlockSignals(False,SIGCLD);
  2406.   return 0;
  2407. }
  2408. #endif
  2409.  
  2410. /****************************************************************************
  2411.   this is called when the client exits abruptly
  2412.   **************************************************************************/
  2413. static int sig_pipe(void)
  2414. {
  2415.     struct cli_state *cli;
  2416.     BlockSignals(True,SIGPIPE);
  2417.  
  2418.     if ((cli = server_client()) && cli->initialised) {
  2419.         DEBUG(3,("lost connection to password server\n"));
  2420.         cli_shutdown(cli);
  2421. #ifndef DONT_REINSTALL_SIG
  2422.         signal(SIGPIPE, SIGNAL_CAST sig_pipe);
  2423. #endif
  2424.         BlockSignals(False,SIGPIPE);
  2425.         return 0;
  2426.     }
  2427.  
  2428.     exit_server("Got sigpipe\n");
  2429.     return(0);
  2430. }
  2431.  
  2432. /****************************************************************************
  2433.   open the socket communication
  2434. ****************************************************************************/
  2435. static BOOL open_sockets(BOOL is_daemon,int port)
  2436. {
  2437.   extern int Client;
  2438.  
  2439.   if (is_daemon)
  2440.   {
  2441.     int num_interfaces = iface_count();
  2442.     int fd_listenset[FD_SETSIZE];
  2443.     fd_set listen_set;
  2444.     int s;
  2445.     int i;
  2446.  
  2447.     /* Stop zombies */
  2448. #ifdef SIGCLD_IGNORE
  2449.     signal(SIGCLD, SIG_IGN);
  2450. #else
  2451.     signal(SIGCLD, SIGNAL_CAST sig_cld);
  2452. #endif
  2453.  
  2454.     if(atexit_set == 0)
  2455.       atexit(killkids);
  2456.  
  2457.     FD_ZERO(&listen_set);
  2458.  
  2459.     if(lp_interfaces() && lp_bind_interfaces_only())
  2460.     {
  2461.        /* We have been given an interfaces line, and been 
  2462.           told to only bind to those interfaces. Create a
  2463.           socket per interface and bind to only these.
  2464.         */
  2465.  
  2466.       if(num_interfaces > FD_SETSIZE)
  2467.       {
  2468.         DEBUG(0,("open_sockets: Too many interfaces specified to bind to. Number was %d \
  2469. max can be %d\n", num_interfaces, FD_SETSIZE));
  2470.         return False;
  2471.       }
  2472.  
  2473.       /* Now open a listen socket for each of the interfaces. */
  2474.       for(i = 0; i < num_interfaces; i++)
  2475.       {
  2476.         struct in_addr *ifip = iface_n_ip(i);
  2477.  
  2478.         if(ifip == NULL)
  2479.         {
  2480.           DEBUG(0,("open_sockets: interface %d has NULL IP address !\n", i));
  2481.           continue;
  2482.         }
  2483.         s = fd_listenset[i] = open_socket_in(SOCK_STREAM, port, 0, ifip->s_addr);
  2484.         if(s == -1)
  2485.           return False;
  2486.         /* ready to listen */
  2487.         if (listen(s, 5) == -1) 
  2488.         {
  2489.           DEBUG(0,("listen: %s\n",strerror(errno)));
  2490.           close(s);
  2491.           return False;
  2492.         }
  2493.         FD_SET(s,&listen_set);
  2494.       }
  2495.     }
  2496.     else
  2497.     {
  2498.       /* Just bind to 0.0.0.0 - accept connections from anywhere. */
  2499.       num_interfaces = 1;
  2500.  
  2501.       /* open an incoming socket */
  2502.       s = open_socket_in(SOCK_STREAM, port, 0,interpret_addr(lp_socket_address()));
  2503.       if (s == -1)
  2504.         return(False);
  2505.  
  2506.       /* ready to listen */
  2507.       if (listen(s, 5) == -1) 
  2508.       {
  2509.         DEBUG(0,("open_sockets: listen: %s\n",strerror(errno)));
  2510.         close(s);
  2511.         return False;
  2512.       }
  2513.  
  2514.       fd_listenset[0] = s;
  2515.       FD_SET(s,&listen_set);
  2516.     }      
  2517.  
  2518.     /* now accept incoming connections - forking a new process
  2519.        for each incoming connection */
  2520.     DEBUG(2,("waiting for a connection\n"));
  2521.     while (1)
  2522.     {
  2523.       fd_set lfds;
  2524.       int num;
  2525.  
  2526.       memcpy((char *)&lfds, (char *)&listen_set, sizeof(listen_set));
  2527.  
  2528.       num = sys_select(&lfds,NULL);
  2529.  
  2530.       if (num == -1 && errno == EINTR)
  2531.         continue;
  2532.  
  2533.       /* Find the sockets that are read-ready - accept on these. */
  2534.       for( ; num > 0; num--)
  2535.       {
  2536.         struct sockaddr addr;
  2537.         int in_addrlen = sizeof(addr);
  2538.  
  2539.         s = -1;
  2540.         for(i = 0; i < num_interfaces; i++)
  2541.         {
  2542.           if(FD_ISSET(fd_listenset[i],&lfds))
  2543.           {
  2544.             s = fd_listenset[i];
  2545.             /* Clear this so we don't look at it again. */
  2546.             FD_CLR(fd_listenset[i],&lfds);
  2547.             break;
  2548.           }
  2549.         }
  2550.  
  2551.         Client = accept(s,&addr,&in_addrlen);
  2552.  
  2553.         if (Client == -1 && errno == EINTR)
  2554.           continue;
  2555.  
  2556.         if (Client == -1)
  2557.         {
  2558.           DEBUG(0,("open_sockets: accept: %s\n",strerror(errno)));
  2559.           continue;
  2560.         }
  2561.  
  2562. #ifdef NO_FORK_DEBUG
  2563. #ifndef NO_SIGNAL_TEST
  2564.         signal(SIGPIPE, SIGNAL_CAST sig_pipe);
  2565.         signal(SIGCLD, SIGNAL_CAST SIG_DFL);
  2566. #endif /* NO_SIGNAL_TEST */
  2567.         return True;
  2568. #else /* NO_FORK_DEBUG */
  2569.         if (Client != -1 && fork()==0)
  2570.         {
  2571.           /* Child code ... */
  2572.  
  2573. #ifndef NO_SIGNAL_TEST
  2574.           signal(SIGPIPE, SIGNAL_CAST sig_pipe);
  2575.           signal(SIGCLD, SIGNAL_CAST SIG_DFL);
  2576. #endif /* NO_SIGNAL_TEST */
  2577.           /* close the listening socket(s) */
  2578.           for(i = 0; i < num_interfaces; i++)
  2579.             close(fd_listenset[i]);
  2580.  
  2581.           /* close our standard file descriptors */
  2582.           close_low_fds();
  2583.           am_parent = 0;
  2584.   
  2585.           set_socket_options(Client,"SO_KEEPALIVE");
  2586.           set_socket_options(Client,user_socket_options);
  2587.  
  2588.           /* Reset global variables in util.c so that
  2589.              client substitutions will be done correctly
  2590.              in the process.
  2591.            */
  2592.           reset_globals_after_fork();
  2593.           return True; 
  2594.         }
  2595.         close(Client); /* The parent doesn't need this socket */
  2596. #endif /* NO_FORK_DEBUG */
  2597.       } /* end for num */
  2598.     } /* end while 1 */
  2599.   } /* end if is_daemon */
  2600.   else
  2601.   {
  2602.     /* Started from inetd. fd 0 is the socket. */
  2603.     /* We will abort gracefully when the client or remote system 
  2604.        goes away */
  2605. #ifndef NO_SIGNAL_TEST
  2606.     signal(SIGPIPE, SIGNAL_CAST sig_pipe);
  2607. #endif
  2608.     Client = dup(0);
  2609.  
  2610.     /* close our standard file descriptors */
  2611.     close_low_fds();
  2612.  
  2613.     set_socket_options(Client,"SO_KEEPALIVE");
  2614.     set_socket_options(Client,user_socket_options);
  2615.   }
  2616.  
  2617.   return True;
  2618. }
  2619.  
  2620. /****************************************************************************
  2621.   process an smb from the client - split out from the process() code so
  2622.   it can be used by the oplock break code.
  2623. ****************************************************************************/
  2624.  
  2625. static void process_smb(char *inbuf, char *outbuf)
  2626. {
  2627.   extern int Client;
  2628.   static int trans_num;
  2629.   int msg_type = CVAL(inbuf,0);
  2630.   int32 len = smb_len(inbuf);
  2631.   int nread = len + 4;
  2632.  
  2633.   if (trans_num == 0) {
  2634.       /* on the first packet, check the global hosts allow/ hosts
  2635.          deny parameters before doing any parsing of the packet
  2636.          passed to us by the client.  This prevents attacks on our
  2637.          parsing code from hosts not in the hosts allow list */
  2638.       if (!check_access(-1)) {
  2639.           /* send a negative session response "not listining on calling
  2640.            name" */
  2641.           static unsigned char buf[5] = {0x83, 0, 0, 1, 0x81};
  2642.           DEBUG(1,("%s Connection denied from %s\n",
  2643.                timestring(),client_addr()));
  2644.           send_smb(Client,(char *)buf);
  2645.           exit_server("connection denied");
  2646.       }
  2647.   }
  2648.  
  2649.   DEBUG(6,("got message type 0x%x of len 0x%x\n",msg_type,len));
  2650.   DEBUG(3,("%s Transaction %d of length %d\n",timestring(),trans_num,nread));
  2651.  
  2652. #ifdef WITH_VTP
  2653.   if(trans_num == 1 && VT_Check(inbuf)) 
  2654.   {
  2655.     VT_Process();
  2656.     return;
  2657.   }
  2658. #endif
  2659.  
  2660.   if (msg_type == 0)
  2661.     show_msg(inbuf);
  2662.   else if(msg_type == 0x85)
  2663.     return; /* Keepalive packet. */
  2664.  
  2665.   nread = construct_reply(inbuf,outbuf,nread,max_send);
  2666.       
  2667.   if(nread > 0) 
  2668.   {
  2669.     if (CVAL(outbuf,0) == 0)
  2670.       show_msg(outbuf);
  2671.     
  2672.     if (nread != smb_len(outbuf) + 4) 
  2673.     {
  2674.       DEBUG(0,("ERROR: Invalid message response size! %d %d\n",
  2675.                  nread, smb_len(outbuf)));
  2676.     }
  2677.     else
  2678.       send_smb(Client,outbuf);
  2679.   }
  2680.   trans_num++;
  2681. }
  2682.  
  2683. /****************************************************************************
  2684.   open the oplock IPC socket communication
  2685. ****************************************************************************/
  2686. static BOOL open_oplock_ipc(void)
  2687. {
  2688.   struct sockaddr_in sock_name;
  2689.   int len = sizeof(sock_name);
  2690.  
  2691.   DEBUG(3,("open_oplock_ipc: opening loopback UDP socket.\n"));
  2692.  
  2693.   /* Open a lookback UDP socket on a random port. */
  2694.   oplock_sock = open_socket_in(SOCK_DGRAM, 0, 0, htonl(INADDR_LOOPBACK));
  2695.   if (oplock_sock == -1)
  2696.   {
  2697.     DEBUG(0,("open_oplock_ipc: Failed to get local UDP socket for \
  2698. address %x. Error was %s\n", htonl(INADDR_LOOPBACK), strerror(errno)));
  2699.     oplock_port = 0;
  2700.     return(False);
  2701.   }
  2702.  
  2703.   /* Find out the transient UDP port we have been allocated. */
  2704.   if(getsockname(oplock_sock, (struct sockaddr *)&sock_name, &len)<0)
  2705.   {
  2706.     DEBUG(0,("open_oplock_ipc: Failed to get local UDP port. Error was %s\n",
  2707.             strerror(errno)));
  2708.     close(oplock_sock);
  2709.     oplock_sock = -1;
  2710.     oplock_port = 0;
  2711.     return False;
  2712.   }
  2713.   oplock_port = ntohs(sock_name.sin_port);
  2714.  
  2715.   DEBUG(3,("open_oplock ipc: pid = %d, oplock_port = %u\n", 
  2716.             getpid(), oplock_port));
  2717.  
  2718.   return True;
  2719. }
  2720.  
  2721. /****************************************************************************
  2722.   process an oplock break message.
  2723. ****************************************************************************/
  2724. static BOOL process_local_message(int sock, char *buffer, int buf_size)
  2725. {
  2726.   int32 msg_len;
  2727.   uint16 from_port;
  2728.   char *msg_start;
  2729.  
  2730.   msg_len = IVAL(buffer,UDP_CMD_LEN_OFFSET);
  2731.   from_port = SVAL(buffer,UDP_CMD_PORT_OFFSET);
  2732.  
  2733.   msg_start = &buffer[UDP_CMD_HEADER_LEN];
  2734.  
  2735.   DEBUG(5,("process_local_message: Got a message of length %d from port (%d)\n", 
  2736.             msg_len, from_port));
  2737.  
  2738.   /* Switch on message command - currently OPLOCK_BREAK_CMD is the
  2739.      only valid request. */
  2740.  
  2741.   switch(SVAL(msg_start,UDP_MESSAGE_CMD_OFFSET))
  2742.   {
  2743.     case OPLOCK_BREAK_CMD:
  2744.       /* Ensure that the msg length is correct. */
  2745.       if(msg_len != OPLOCK_BREAK_MSG_LEN)
  2746.       {
  2747.         DEBUG(0,("process_local_message: incorrect length for OPLOCK_BREAK_CMD (was %d, \
  2748. should be %d).\n", msg_len, OPLOCK_BREAK_MSG_LEN));
  2749.         return False;
  2750.       }
  2751.       {
  2752.         uint32 remotepid = IVAL(msg_start,OPLOCK_BREAK_PID_OFFSET);
  2753.         uint32 dev = IVAL(msg_start,OPLOCK_BREAK_DEV_OFFSET);
  2754.         uint32 inode = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET);
  2755.         struct timeval tval;
  2756.         struct sockaddr_in toaddr;
  2757.  
  2758.         tval.tv_sec = IVAL(msg_start, OPLOCK_BREAK_SEC_OFFSET);
  2759.         tval.tv_usec = IVAL(msg_start, OPLOCK_BREAK_USEC_OFFSET);
  2760.  
  2761.         DEBUG(5,("process_local_message: oplock break request from \
  2762. pid %d, port %d, dev = %x, inode = %x\n", remotepid, from_port, dev, inode));
  2763.  
  2764.         /*
  2765.          * If we have no record of any currently open oplocks,
  2766.          * it's not an error, as a close command may have
  2767.          * just been issued on the file that was oplocked.
  2768.          * Just return success in this case.
  2769.          */
  2770.  
  2771.         if(global_oplocks_open != 0)
  2772.         {
  2773.           if(oplock_break(dev, inode, &tval) == False)
  2774.           {
  2775.             DEBUG(0,("process_local_message: oplock break failed - \
  2776. not returning udp message.\n"));
  2777.             return False;
  2778.           }
  2779.         }
  2780.         else
  2781.         {
  2782.           DEBUG(3,("process_local_message: oplock break requested with no outstanding \
  2783. oplocks. Returning success.\n"));
  2784.         }
  2785.  
  2786.         /* Send the message back after OR'ing in the 'REPLY' bit. */
  2787.         SSVAL(msg_start,UDP_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD | CMD_REPLY);
  2788.   
  2789.         bzero((char *)&toaddr,sizeof(toaddr));
  2790.         toaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
  2791.         toaddr.sin_port = htons(from_port);
  2792.         toaddr.sin_family = AF_INET;
  2793.  
  2794.         if(sendto( sock, msg_start, OPLOCK_BREAK_MSG_LEN, 0,
  2795.                 (struct sockaddr *)&toaddr, sizeof(toaddr)) < 0) 
  2796.         {
  2797.           DEBUG(0,("process_local_message: sendto process %d failed. Errno was %s\n",
  2798.                     remotepid, strerror(errno)));
  2799.           return False;
  2800.         }
  2801.  
  2802.         DEBUG(5,("process_local_message: oplock break reply sent to \
  2803. pid %d, port %d, for file dev = %x, inode = %x\n", remotepid, 
  2804.                 from_port, dev, inode));
  2805.  
  2806.       }
  2807.       break;
  2808.     /* 
  2809.      * Keep this as a debug case - eventually we can remove it.
  2810.      */
  2811.     case 0x8001:
  2812.       DEBUG(0,("process_local_message: Received unsolicited break \
  2813. reply - dumping info.\n"));
  2814.  
  2815.       if(msg_len != OPLOCK_BREAK_MSG_LEN)
  2816.       {
  2817.         DEBUG(0,("process_local_message: ubr: incorrect length for reply \
  2818. (was %d, should be %d).\n", msg_len, OPLOCK_BREAK_MSG_LEN));
  2819.         return False;
  2820.       }
  2821.  
  2822.       {
  2823.         uint32 remotepid = IVAL(msg_start,OPLOCK_BREAK_PID_OFFSET);
  2824.         uint32 dev = IVAL(msg_start,OPLOCK_BREAK_DEV_OFFSET);
  2825.         uint32 inode = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET);
  2826.  
  2827.         DEBUG(0,("process_local_message: unsolicited oplock break reply from \
  2828. pid %d, port %d, dev = %x, inode = %x\n", remotepid, from_port, dev, inode));
  2829.  
  2830.        }
  2831.        return False;
  2832.  
  2833.     default:
  2834.       DEBUG(0,("process_local_message: unknown UDP message command code (%x) - ignoring.\n",
  2835.                 (unsigned int)SVAL(msg_start,0)));
  2836.       return False;
  2837.   }
  2838.   return True;
  2839. }
  2840.  
  2841. /****************************************************************************
  2842.  Process an oplock break directly.
  2843. ****************************************************************************/
  2844. BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval)
  2845. {
  2846.   extern int Client;
  2847.   char *inbuf = NULL;
  2848.   char *outbuf = NULL;
  2849.   files_struct *fsp = NULL;
  2850.   int fnum;
  2851.   time_t start_time;
  2852.   BOOL shutdown_server = False;
  2853.  
  2854.   DEBUG(3,("%s oplock_break: called for dev = %x, inode = %x. Current \
  2855. global_oplocks_open = %d\n", timestring(), dev, inode, global_oplocks_open));
  2856.  
  2857.   /* We need to search the file open table for the
  2858.      entry containing this dev and inode, and ensure
  2859.      we have an oplock on it. */
  2860.   for( fnum = 0; fnum < MAX_OPEN_FILES; fnum++)
  2861.   {
  2862.     if(OPEN_FNUM(fnum))
  2863.     {
  2864.       if((Files[fnum].fd_ptr->dev == dev) && (Files[fnum].fd_ptr->inode == inode) &&
  2865.          (Files[fnum].open_time.tv_sec == tval->tv_sec) && 
  2866.          (Files[fnum].open_time.tv_usec == tval->tv_usec)) {
  2867.           fsp = &Files[fnum];
  2868.           break;
  2869.       }
  2870.     }
  2871.   }
  2872.  
  2873.   if(fsp == NULL)
  2874.   {
  2875.     /* The file could have been closed in the meantime - return success. */
  2876.     DEBUG(0,("%s oplock_break: cannot find open file with dev = %x, inode = %x (fnum = %d) \
  2877. allowing break to succeed.\n", timestring(), dev, inode, fnum));
  2878.     return True;
  2879.   }
  2880.  
  2881.   /* Ensure we have an oplock on the file */
  2882.  
  2883.   /* There is a potential race condition in that an oplock could
  2884.      have been broken due to another udp request, and yet there are
  2885.      still oplock break messages being sent in the udp message
  2886.      queue for this file. So return true if we don't have an oplock,
  2887.      as we may have just freed it.
  2888.    */
  2889.  
  2890.   if(!fsp->granted_oplock)
  2891.   {
  2892.     DEBUG(0,("%s oplock_break: file %s (fnum = %d, dev = %x, inode = %x) has no oplock. Allowing break to succeed regardless.\n", timestring(), fsp->name, fnum, dev, inode));
  2893.     return True;
  2894.   }
  2895.  
  2896.   /* mark the oplock break as sent - we don't want to send twice! */
  2897.   if (fsp->sent_oplock_break)
  2898.   {
  2899.     DEBUG(0,("%s oplock_break: ERROR: oplock_break already sent for file %s (fnum = %d, dev = %x, inode = %x)\n", timestring(), fsp->name, fnum, dev, inode));
  2900.  
  2901.     /* We have to fail the open here as we cannot send another oplock break on this
  2902.        file whilst we are awaiting a response from the client - neither can we
  2903.        allow another open to succeed while we are waiting for the client. */
  2904.     return False;
  2905.   }
  2906.  
  2907.   /* Now comes the horrid part. We must send an oplock break to the client,
  2908.      and then process incoming messages until we get a close or oplock release.
  2909.      At this point we know we need a new inbuf/outbuf buffer pair.
  2910.      We cannot use these staticaly as we may recurse into here due to
  2911.      messages crossing on the wire.
  2912.    */
  2913.  
  2914.   if((inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN))==NULL)
  2915.   {
  2916.     DEBUG(0,("oplock_break: malloc fail for input buffer.\n"));
  2917.     return False;
  2918.   }
  2919.  
  2920.   if((outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN))==NULL)
  2921.   {
  2922.     DEBUG(0,("oplock_break: malloc fail for output buffer.\n"));
  2923.     free(inbuf);
  2924.     inbuf = NULL;
  2925.     return False;
  2926.   }
  2927.  
  2928.   /* Prepare the SMBlockingX message. */
  2929.   bzero(outbuf,smb_size);
  2930.   set_message(outbuf,8,0,True);
  2931.  
  2932.   SCVAL(outbuf,smb_com,SMBlockingX);
  2933.   SSVAL(outbuf,smb_tid,fsp->cnum);
  2934.   SSVAL(outbuf,smb_pid,0xFFFF);
  2935.   SSVAL(outbuf,smb_uid,0);
  2936.   SSVAL(outbuf,smb_mid,0xFFFF);
  2937.   SCVAL(outbuf,smb_vwv0,0xFF);
  2938.   SSVAL(outbuf,smb_vwv2,fnum);
  2939.   SCVAL(outbuf,smb_vwv3,LOCKING_ANDX_OPLOCK_RELEASE);
  2940.   /* Change this when we have level II oplocks. */
  2941.   SCVAL(outbuf,smb_vwv3+1,OPLOCKLEVEL_NONE);
  2942.  
  2943.   send_smb(Client, outbuf);
  2944.  
  2945.   /* Remember we just sent an oplock break on this file. */
  2946.   fsp->sent_oplock_break = True;
  2947.  
  2948.   /* We need this in case a readraw crosses on the wire. */
  2949.   global_oplock_break = True;
  2950.  
  2951.   /* Process incoming messages. */
  2952.  
  2953.   /* JRA - If we don't get a break from the client in OPLOCK_BREAK_TIMEOUT
  2954.      seconds we should just die.... */
  2955.  
  2956.   start_time = time(NULL);
  2957.  
  2958.   while(OPEN_FNUM(fnum) && fsp->granted_oplock)
  2959.   {
  2960.     if(receive_smb(Client,inbuf,OPLOCK_BREAK_TIMEOUT * 1000) == False)
  2961.     {
  2962.       /*
  2963.        * Die if we got an error.
  2964.        */
  2965.  
  2966.       if (smb_read_error == READ_EOF)
  2967.         DEBUG(0,("%s oplock_break: end of file from client\n", timestring()));
  2968.  
  2969.       if (smb_read_error == READ_ERROR)
  2970.         DEBUG(0,("%s oplock_break: receive_smb error (%s)\n",
  2971.                   timestring(), strerror(errno)));
  2972.  
  2973.       if (smb_read_error == READ_TIMEOUT)
  2974.         DEBUG(0,("%s oplock_break: receive_smb timed out after %d seconds.\n",
  2975.                   timestring(), OPLOCK_BREAK_TIMEOUT));
  2976.  
  2977.       DEBUG(0,("%s oplock_break failed for file %s (fnum = %d, dev = %x, \
  2978. inode = %x).\n", timestring(), fsp->name, fnum, dev, inode));
  2979.       shutdown_server = True;
  2980.       break;
  2981.     }
  2982.  
  2983.     /*
  2984.      * There are certain SMB requests that we shouldn't allow
  2985.      * to recurse. opens, renames and deletes are the obvious
  2986.      * ones. This is handled in the switch_message() function.
  2987.      * If global_oplock_break is set they will push the packet onto
  2988.      * the pending smb queue and return -1 (no reply).
  2989.      * JRA.
  2990.      */
  2991.  
  2992.     process_smb(inbuf, outbuf);
  2993.  
  2994.     /*
  2995.      * Die if we go over the time limit.
  2996.      */
  2997.  
  2998.     if((time(NULL) - start_time) > OPLOCK_BREAK_TIMEOUT)
  2999.     {
  3000.       DEBUG(0,("%s oplock_break: no break received from client within \
  3001. %d seconds.\n", timestring(), OPLOCK_BREAK_TIMEOUT));
  3002.       DEBUG(0,("%s oplock_break failed for file %s (fnum = %d, dev = %x, \
  3003. inode = %x).\n", timestring(), fsp->name, fnum, dev, inode));
  3004.       shutdown_server = True;
  3005.       break;
  3006.     }
  3007.   }
  3008.  
  3009.   /* Free the buffers we've been using to recurse. */
  3010.   free(inbuf);
  3011.   free(outbuf);
  3012.  
  3013.   /* We need this in case a readraw crossed on the wire. */
  3014.   if(global_oplock_break)
  3015.     global_oplock_break = False;
  3016.  
  3017.   /*
  3018.    * If the client did not respond we must die.
  3019.    */
  3020.  
  3021.   if(shutdown_server)
  3022.   {
  3023.     DEBUG(0,("%s oplock_break: client failure in break - shutting down this smbd.\n",
  3024.           timestring()));
  3025.     close_sockets();
  3026.     close(oplock_sock);
  3027.     exit_server("oplock break failure");
  3028.   }
  3029.  
  3030.   if(OPEN_FNUM(fnum))
  3031.   {
  3032.     /* The lockingX reply will have removed the oplock flag 
  3033.        from the sharemode. */
  3034.     /* Paranoia.... */
  3035.     fsp->granted_oplock = False;
  3036.     fsp->sent_oplock_break = False;
  3037.     global_oplocks_open--;
  3038.   }
  3039.  
  3040.   /* Santity check - remove this later. JRA */
  3041.   if(global_oplocks_open < 0)
  3042.   {
  3043.     DEBUG(0,("oplock_break: global_oplocks_open < 0 (%d). PANIC ERROR\n",
  3044.               global_oplocks_open));
  3045.     exit_server("oplock_break: global_oplocks_open < 0");
  3046.   }
  3047.  
  3048.   DEBUG(3,("%s oplock_break: returning success for fnum = %d, dev = %x, inode = %x. Current \
  3049. global_oplocks_open = %d\n", timestring(), fnum, dev, inode, global_oplocks_open));
  3050.  
  3051.   return True;
  3052. }
  3053.  
  3054. /****************************************************************************
  3055. Send an oplock break message to another smbd process. If the oplock is held 
  3056. by the local smbd then call the oplock break function directly.
  3057. ****************************************************************************/
  3058.  
  3059. BOOL request_oplock_break(share_mode_entry *share_entry, 
  3060.                           uint32 dev, uint32 inode)
  3061. {
  3062.   char op_break_msg[OPLOCK_BREAK_MSG_LEN];
  3063.   struct sockaddr_in addr_out;
  3064.   int pid = getpid();
  3065.   time_t start_time;
  3066.   int time_left;
  3067.  
  3068.   if(pid == share_entry->pid)
  3069.   {
  3070.     /* We are breaking our own oplock, make sure it's us. */
  3071.     if(share_entry->op_port != oplock_port)
  3072.     {
  3073.       DEBUG(0,("request_oplock_break: corrupt share mode entry - pid = %d, port = %d \
  3074. should be %d\n", pid, share_entry->op_port, oplock_port));
  3075.       return False;
  3076.     }
  3077.  
  3078.     DEBUG(5,("request_oplock_break: breaking our own oplock\n"));
  3079.  
  3080.     /* Call oplock break direct. */
  3081.     return oplock_break(dev, inode, &share_entry->time);
  3082.   }
  3083.  
  3084.   /* We need to send a OPLOCK_BREAK_CMD message to the
  3085.      port in the share mode entry. */
  3086.  
  3087.   SSVAL(op_break_msg,UDP_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD);
  3088.   SIVAL(op_break_msg,OPLOCK_BREAK_PID_OFFSET,pid);
  3089.   SIVAL(op_break_msg,OPLOCK_BREAK_DEV_OFFSET,dev);
  3090.   SIVAL(op_break_msg,OPLOCK_BREAK_INODE_OFFSET,inode);
  3091.   SIVAL(op_break_msg,OPLOCK_BREAK_SEC_OFFSET,(uint32)share_entry->time.tv_sec);
  3092.   SIVAL(op_break_msg,OPLOCK_BREAK_USEC_OFFSET,(uint32)share_entry->time.tv_usec);
  3093.  
  3094.   /* set the address and port */
  3095.   bzero((char *)&addr_out,sizeof(addr_out));
  3096.   addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
  3097.   addr_out.sin_port = htons( share_entry->op_port );
  3098.   addr_out.sin_family = AF_INET;
  3099.    
  3100.   DEBUG(3,("%s request_oplock_break: sending a oplock break message to pid %d on port %d \
  3101. for dev = %x, inode = %x\n", timestring(), share_entry->pid, share_entry->op_port, dev, inode));
  3102.  
  3103.   if(sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0,
  3104.          (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0)
  3105.   {
  3106.     DEBUG(0,("%s request_oplock_break: failed when sending a oplock break message \
  3107. to pid %d on port %d for dev = %x, inode = %x. Error was %s\n",
  3108.          timestring(), share_entry->pid, share_entry->op_port, dev, inode,
  3109.          strerror(errno)));
  3110.     return False;
  3111.   }
  3112.  
  3113.   /*
  3114.    * Now we must await the oplock broken message coming back
  3115.    * from the target smbd process. Timeout if it fails to
  3116.    * return in (OPLOCK_BREAK_TIMEOUT + OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR) seconds.
  3117.    * While we get messages that aren't ours, loop.
  3118.    */
  3119.  
  3120.   start_time = time(NULL);
  3121.   time_left = OPLOCK_BREAK_TIMEOUT+OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR;
  3122.  
  3123.   while(time_left >= 0)
  3124.   {
  3125.     char op_break_reply[UDP_CMD_HEADER_LEN+OPLOCK_BREAK_MSG_LEN];
  3126.     int32 reply_msg_len;
  3127.     uint16 reply_from_port;
  3128.     char *reply_msg_start;
  3129.  
  3130.     if(receive_local_message(oplock_sock, op_break_reply, sizeof(op_break_reply),
  3131.                time_left ? time_left * 1000 : 1) == False)
  3132.     {
  3133.       if(smb_read_error == READ_TIMEOUT)
  3134.       {
  3135.         DEBUG(0,("%s request_oplock_break: no response received to oplock break request to \
  3136. pid %d on port %d for dev = %x, inode = %x\n", timestring(), share_entry->pid, 
  3137.                            share_entry->op_port, dev, inode));
  3138.         /*
  3139.          * This is a hack to make handling of failing clients more robust.
  3140.          * If a oplock break response message is not received in the timeout
  3141.          * period we may assume that the smbd servicing that client holding
  3142.          * the oplock has died and the client changes were lost anyway, so
  3143.          * we should continue to try and open the file.
  3144.          */
  3145.         break;
  3146.       }
  3147.       else
  3148.         DEBUG(0,("%s request_oplock_break: error in response received to oplock break request to \
  3149. pid %d on port %d for dev = %x, inode = %x. Error was (%s).\n", timestring, share_entry->pid, 
  3150.                          share_entry->op_port, dev, inode, strerror(errno)));
  3151.       return False;
  3152.     }
  3153.  
  3154.     reply_msg_len = IVAL(op_break_reply,UDP_CMD_LEN_OFFSET);
  3155.     reply_from_port = SVAL(op_break_reply,UDP_CMD_PORT_OFFSET);
  3156.  
  3157.     reply_msg_start = &op_break_reply[UDP_CMD_HEADER_LEN];
  3158.  
  3159.     if(reply_msg_len != OPLOCK_BREAK_MSG_LEN)
  3160.     {
  3161.       /* Ignore it. */
  3162.       DEBUG(0,("%s request_oplock_break: invalid message length received. Ignoring\n",
  3163.              timestring()));
  3164.       continue;
  3165.     }
  3166.  
  3167.     /*
  3168.      * Test to see if this is the reply we are awaiting.
  3169.      */
  3170.  
  3171.     if((SVAL(reply_msg_start,UDP_MESSAGE_CMD_OFFSET) & CMD_REPLY) &&
  3172.        (reply_from_port == share_entry->op_port) && 
  3173.        (memcmp(&reply_msg_start[OPLOCK_BREAK_PID_OFFSET], 
  3174.                &op_break_msg[OPLOCK_BREAK_PID_OFFSET],
  3175.                OPLOCK_BREAK_MSG_LEN - OPLOCK_BREAK_PID_OFFSET) == 0))
  3176.     {
  3177.       /*
  3178.        * This is the reply we've been waiting for.
  3179.        */
  3180.       break;
  3181.     }
  3182.     else
  3183.     {
  3184.       /*
  3185.        * This is another message - probably a break request.
  3186.        * Process it to prevent potential deadlock.
  3187.        * Note that the code in switch_message() prevents
  3188.        * us from recursing into here as any SMB requests
  3189.        * we might process that would cause another oplock
  3190.        * break request to be made will be queued.
  3191.        * JRA.
  3192.        */
  3193.  
  3194.       process_local_message(oplock_sock, op_break_reply, sizeof(op_break_reply));
  3195.     }
  3196.  
  3197.     time_left -= (time(NULL) - start_time);
  3198.   }
  3199.  
  3200.   DEBUG(3,("%s request_oplock_break: broke oplock.\n", timestring()));
  3201.  
  3202.   return True;
  3203. }
  3204.  
  3205. /****************************************************************************
  3206. Get the next SMB packet, doing the local message processing automatically.
  3207. ****************************************************************************/
  3208.  
  3209. BOOL receive_next_smb(int smbfd, int oplockfd, char *inbuf, int bufsize, int timeout)
  3210. {
  3211.   BOOL got_smb = False;
  3212.   BOOL ret;
  3213.  
  3214.   do
  3215.   {
  3216.     ret = receive_message_or_smb(smbfd,oplockfd,inbuf,bufsize,
  3217.                                  timeout,&got_smb);
  3218.  
  3219.     if(ret && !got_smb)
  3220.     {
  3221.       /* Deal with oplock break requests from other smbd's. */
  3222.       process_local_message(oplock_sock, inbuf, bufsize);
  3223.       continue;
  3224.     }
  3225.  
  3226.     if(ret && (CVAL(inbuf,0) == 0x85))
  3227.     {
  3228.       /* Keepalive packet. */
  3229.       got_smb = False;
  3230.     }
  3231.  
  3232.   }
  3233.   while(ret && !got_smb);
  3234.  
  3235.   return ret;
  3236. }
  3237.  
  3238. /****************************************************************************
  3239. check if a snum is in use
  3240. ****************************************************************************/
  3241. BOOL snum_used(int snum)
  3242. {
  3243.   int i;
  3244.   for (i=0;i<MAX_CONNECTIONS;i++)
  3245.     if (OPEN_CNUM(i) && (SNUM(i) == snum))
  3246.       return(True);
  3247.   return(False);
  3248. }
  3249.  
  3250. /****************************************************************************
  3251.   reload the services file
  3252.   **************************************************************************/
  3253. BOOL reload_services(BOOL test)
  3254. {
  3255.   BOOL ret;
  3256.  
  3257.   if (lp_loaded())
  3258.     {
  3259.       pstring fname;
  3260.       pstrcpy(fname,lp_configfile());
  3261.       if (file_exist(fname,NULL) && !strcsequal(fname,servicesf))
  3262.     {
  3263.       pstrcpy(servicesf,fname);
  3264.       test = False;
  3265.     }
  3266.     }
  3267.  
  3268.   reopen_logs();
  3269.  
  3270.   if (test && !lp_file_list_changed())
  3271.     return(True);
  3272.  
  3273.   lp_killunused(snum_used);
  3274.  
  3275.   ret = lp_load(servicesf,False);
  3276.  
  3277.   /* perhaps the config filename is now set */
  3278.   if (!test)
  3279.     reload_services(True);
  3280.  
  3281.   reopen_logs();
  3282.  
  3283.   load_interfaces();
  3284.  
  3285.   {
  3286.     extern int Client;
  3287.     if (Client != -1) {      
  3288.       set_socket_options(Client,"SO_KEEPALIVE");
  3289.       set_socket_options(Client,user_socket_options);
  3290.     }
  3291.   }
  3292.  
  3293.   reset_mangled_stack( lp_mangledstack() );
  3294.  
  3295.   /* this forces service parameters to be flushed */
  3296.   become_service(-1,True);
  3297.  
  3298.   return(ret);
  3299. }
  3300.  
  3301.  
  3302.  
  3303. /****************************************************************************
  3304. this prevents zombie child processes
  3305. ****************************************************************************/
  3306. static int sig_hup(void)
  3307. {
  3308.   BlockSignals(True,SIGHUP);
  3309.   DEBUG(0,("Got SIGHUP\n"));
  3310.   reload_services(False);
  3311. #ifndef DONT_REINSTALL_SIG
  3312.   signal(SIGHUP,SIGNAL_CAST sig_hup);
  3313. #endif
  3314.   BlockSignals(False,SIGHUP);
  3315.   return(0);
  3316. }
  3317.  
  3318. /****************************************************************************
  3319. Setup the groups a user belongs to.
  3320. ****************************************************************************/
  3321. int setup_groups(char *user, int uid, int gid, int *p_ngroups, 
  3322.          int **p_igroups, gid_t **p_groups,
  3323.          int **p_attrs)
  3324. {
  3325.   if (-1 == initgroups(user,gid))
  3326.     {
  3327.       if (getuid() == 0)
  3328.     {
  3329.       DEBUG(0,("Unable to initgroups!\n"));
  3330.       if (gid < 0 || gid > 16000 || uid < 0 || uid > 16000)
  3331.         DEBUG(0,("This is probably a problem with the account %s\n",user));
  3332.     }
  3333.     }
  3334.   else
  3335.     {
  3336.       int i,ngroups;
  3337.       int *igroups;
  3338.       int *attrs;
  3339.       gid_t grp = 0;
  3340.       ngroups = getgroups(0,&grp);
  3341.       if (ngroups <= 0)
  3342.         ngroups = 32;
  3343.       igroups = (int *)malloc(sizeof(int)*ngroups);
  3344.       attrs   = (int *)malloc(sizeof(int)*ngroups);
  3345.       for (i=0;i<ngroups;i++)
  3346.       {
  3347.         attrs  [i] = 0x7; /* XXXX don't know what NT user attributes are yet! */
  3348.         igroups[i] = 0x42424242;
  3349.       }
  3350.       ngroups = getgroups(ngroups,(gid_t *)igroups);
  3351.  
  3352.       if (igroups[0] == 0x42424242)
  3353.         ngroups = 0;
  3354.  
  3355.       *p_ngroups = ngroups;
  3356.       *p_attrs   = attrs;
  3357.  
  3358.       /* The following bit of code is very strange. It is due to the
  3359.          fact that some OSes use int* and some use gid_t* for
  3360.          getgroups, and some (like SunOS) use both, one in prototypes,
  3361.          and one in man pages and the actual code. Thus we detect it
  3362.          dynamically using some very ugly code */
  3363.       if (ngroups > 0)
  3364.         {
  3365.       /* does getgroups return ints or gid_t ?? */
  3366.       static BOOL groups_use_ints = True;
  3367.  
  3368.       if (groups_use_ints && 
  3369.           ngroups == 1 && 
  3370.           SVAL(igroups,2) == 0x4242)
  3371.         groups_use_ints = False;
  3372.       
  3373.           for (i=0;groups_use_ints && i<ngroups;i++)
  3374.             if (igroups[i] == 0x42424242)
  3375.               groups_use_ints = False;
  3376.           
  3377.           if (groups_use_ints)
  3378.           {
  3379.               *p_igroups = igroups;
  3380.               *p_groups = (gid_t *)igroups;      
  3381.           }
  3382.           else
  3383.           {
  3384.           gid_t *groups = (gid_t *)igroups;
  3385.           igroups = (int *)malloc(sizeof(int)*ngroups);
  3386.           for (i=0;i<ngroups;i++)
  3387.           {
  3388.             igroups[i] = groups[i];
  3389.           }
  3390.           *p_igroups = igroups;
  3391.           *p_groups = (gid_t *)groups;
  3392.         }
  3393.     }
  3394.       DEBUG(3,("%s is in %d groups\n",user,ngroups));
  3395.       for (i=0;i<ngroups;i++)
  3396.         DEBUG(3,("%d ",igroups[i]));
  3397.       DEBUG(3,("\n"));
  3398.     }
  3399.   return 0;
  3400. }
  3401.  
  3402. /****************************************************************************
  3403.   make a connection to a service
  3404. ****************************************************************************/
  3405. int make_connection(char *service,char *user,char *password, int pwlen, char *dev,uint16 vuid)
  3406. {
  3407.   int cnum;
  3408.   int snum;
  3409.   struct passwd *pass = NULL;
  3410.   connection_struct *pcon;
  3411.   BOOL guest = False;
  3412.   BOOL force = False;
  3413.   static BOOL first_connection = True;
  3414.  
  3415.   strlower(service);
  3416.  
  3417.   snum = find_service(service);
  3418.   if (snum < 0)
  3419.     {
  3420.       if (strequal(service,"IPC$"))
  3421.     {      
  3422.       DEBUG(3,("%s refusing IPC connection\n",timestring()));
  3423.       return(-3);
  3424.     }
  3425.  
  3426.       DEBUG(0,("%s %s (%s) couldn't find service %s\n",timestring(),remote_machine,client_addr(),service));      
  3427.       return(-2);
  3428.     }
  3429.  
  3430.   if (strequal(service,HOMES_NAME))
  3431.     {
  3432.       if (*user && Get_Pwnam(user,True))
  3433.     return(make_connection(user,user,password,pwlen,dev,vuid));
  3434.  
  3435.       if(lp_security() != SEC_SHARE)
  3436.       {
  3437.         if (validated_username(vuid))
  3438.         {
  3439.           pstrcpy(user,validated_username(vuid));
  3440.           return(make_connection(user,user,password,pwlen,dev,vuid));
  3441.         }
  3442.       }
  3443.       else
  3444.       {
  3445.         /*
  3446.          * Security = share. Try with sesssetup_user as the username.
  3447.          */
  3448.         if(*sesssetup_user)
  3449.         {
  3450.           pstrcpy(user,sesssetup_user);
  3451.           return(make_connection(user,user,password,pwlen,dev,vuid));
  3452.         }
  3453.       }
  3454.     }
  3455.  
  3456.   if (!lp_snum_ok(snum) || !check_access(snum)) {    
  3457.     return(-4);
  3458.   }
  3459.  
  3460.   /* you can only connect to the IPC$ service as an ipc device */
  3461.   if (strequal(service,"IPC$"))
  3462.     pstrcpy(dev,"IPC");
  3463.  
  3464.   if (*dev == '?' || !*dev)
  3465.     {
  3466.       if (lp_print_ok(snum))
  3467.     pstrcpy(dev,"LPT1:");
  3468.       else
  3469.     pstrcpy(dev,"A:");
  3470.     }
  3471.  
  3472.   /* if the request is as a printer and you can't print then refuse */
  3473.   strupper(dev);
  3474.   if (!lp_print_ok(snum) && (strncmp(dev,"LPT",3) == 0)) {
  3475.     DEBUG(1,("Attempt to connect to non-printer as a printer\n"));
  3476.     return(-6);
  3477.   }
  3478.  
  3479.   /* lowercase the user name */
  3480.   strlower(user);
  3481.  
  3482.   /* add it as a possible user name */
  3483.   add_session_user(service);
  3484.  
  3485.   /* shall we let them in? */
  3486.   if (!authorise_login(snum,user,password,pwlen,&guest,&force,vuid))
  3487.     {
  3488.       DEBUG(2,("%s invalid username/password for %s\n",timestring(),service));
  3489.       return(-1);
  3490.     }
  3491.   
  3492.   cnum = find_free_connection(str_checksum(service) + str_checksum(user));
  3493.   if (cnum < 0)
  3494.     {
  3495.       DEBUG(0,("%s couldn't find free connection\n",timestring()));      
  3496.       return(-1);
  3497.     }
  3498.  
  3499.   pcon = &Connections[cnum];
  3500.   bzero((char *)pcon,sizeof(*pcon));
  3501.  
  3502.   /* find out some info about the user */
  3503.   pass = Get_Pwnam(user,True);
  3504.  
  3505.   if (pass == NULL)
  3506.     {
  3507.       DEBUG(0,("%s couldn't find account %s\n",timestring(),user)); 
  3508.       return(-7);
  3509.     }
  3510.  
  3511.   pcon->read_only = lp_readonly(snum);
  3512.  
  3513.   {
  3514.     pstring list;
  3515.     StrnCpy(list,lp_readlist(snum),sizeof(pstring)-1);
  3516.     string_sub(list,"%S",service);
  3517.  
  3518.     if (user_in_list(user,list))
  3519.       pcon->read_only = True;
  3520.  
  3521.     StrnCpy(list,lp_writelist(snum),sizeof(pstring)-1);
  3522.     string_sub(list,"%S",service);
  3523.  
  3524.     if (user_in_list(user,list))
  3525.       pcon->read_only = False;    
  3526.   }
  3527.  
  3528.   /* admin user check */
  3529.  
  3530.   /* JRA - original code denied admin user if the share was
  3531.      marked read_only. Changed as I don't think this is needed,
  3532.      but old code left in case there is a problem here.
  3533.    */
  3534.   if (user_in_list(user,lp_admin_users(snum)) 
  3535. #if 0
  3536.       && !pcon->read_only)
  3537. #else
  3538.       )
  3539. #endif
  3540.     {
  3541.       pcon->admin_user = True;
  3542.       DEBUG(0,("%s logged in as admin user (root privileges)\n",user));
  3543.     }
  3544.   else
  3545.     pcon->admin_user = False;
  3546.     
  3547.   pcon->force_user = force;
  3548.   pcon->vuid = vuid;
  3549.   pcon->uid = pass->pw_uid;
  3550.   pcon->gid = pass->pw_gid;
  3551.   pcon->num_files_open = 0;
  3552.   pcon->lastused = time(NULL);
  3553.   pcon->service = snum;
  3554.   pcon->used = True;
  3555.   pcon->printer = (strncmp(dev,"LPT",3) == 0);
  3556.   pcon->ipc = (strncmp(dev,"IPC",3) == 0);
  3557.   pcon->dirptr = NULL;
  3558.   pcon->veto_list = NULL;
  3559.   pcon->hide_list = NULL;
  3560.   pcon->veto_oplock_list = NULL;
  3561.   string_set(&pcon->dirpath,"");
  3562.   string_set(&pcon->user,user);
  3563.  
  3564. #if HAVE_GETGRNAM 
  3565.   if (*lp_force_group(snum))
  3566.     {
  3567.       struct group *gptr;
  3568.       pstring gname;
  3569.  
  3570.       StrnCpy(gname,lp_force_group(snum),sizeof(pstring)-1);
  3571.       /* default service may be a group name         */
  3572.       string_sub(gname,"%S",service);
  3573.       gptr = (struct group *)getgrnam(gname);
  3574.  
  3575.       if (gptr)
  3576.     {
  3577.       pcon->gid = gptr->gr_gid;
  3578.       DEBUG(3,("Forced group %s\n",gname));
  3579.     }
  3580.       else
  3581.     DEBUG(1,("Couldn't find group %s\n",gname));
  3582.     }
  3583. #endif
  3584.  
  3585.   if (*lp_force_user(snum))
  3586.     {
  3587.       struct passwd *pass2;
  3588.       fstring fuser;
  3589.       fstrcpy(fuser,lp_force_user(snum));
  3590.       pass2 = (struct passwd *)Get_Pwnam(fuser,True);
  3591.       if (pass2)
  3592.     {
  3593.       pcon->uid = pass2->pw_uid;
  3594.       string_set(&pcon->user,fuser);
  3595.       fstrcpy(user,fuser);
  3596.       pcon->force_user = True;
  3597.       DEBUG(3,("Forced user %s\n",fuser));      
  3598.     }
  3599.       else
  3600.     DEBUG(1,("Couldn't find user %s\n",fuser));
  3601.     }
  3602.  
  3603.   {
  3604.     pstring s;
  3605.     pstrcpy(s,lp_pathname(snum));
  3606.     standard_sub(cnum,s);
  3607.     string_set(&pcon->connectpath,s);
  3608.     DEBUG(3,("Connect path is %s\n",s));
  3609.   }
  3610.  
  3611.   /* groups stuff added by ih */
  3612.   pcon->ngroups = 0;
  3613.   pcon->igroups = NULL;
  3614.   pcon->groups = NULL;
  3615.   pcon->attrs = NULL;
  3616.  
  3617.   if (!IS_IPC(cnum))
  3618.     {
  3619.       /* Find all the groups this uid is in and store them. Used by become_user() */
  3620.       setup_groups(pcon->user,pcon->uid,pcon->gid,
  3621.                   &pcon->ngroups,&pcon->igroups,&pcon->groups,&pcon->attrs);
  3622.       
  3623.       /* check number of connections */
  3624.       if (!claim_connection(cnum,
  3625.                 lp_servicename(SNUM(cnum)),
  3626.                 lp_max_connections(SNUM(cnum)),False))
  3627.     {
  3628.       DEBUG(1,("too many connections - rejected\n"));
  3629.       return(-8);
  3630.     }  
  3631.  
  3632.       if (lp_status(SNUM(cnum)))
  3633.     claim_connection(cnum,"STATUS.",MAXSTATUS,first_connection);
  3634.  
  3635.       first_connection = False;
  3636.     } /* IS_IPC */
  3637.  
  3638.   pcon->open = True;
  3639.  
  3640.   /* execute any "root preexec = " line */
  3641.   if (*lp_rootpreexec(SNUM(cnum)))
  3642.     {
  3643.       pstring cmd;
  3644.       pstrcpy(cmd,lp_rootpreexec(SNUM(cnum)));
  3645.       standard_sub(cnum,cmd);
  3646.       DEBUG(5,("cmd=%s\n",cmd));
  3647.       smbrun(cmd,NULL,False);
  3648.     }
  3649.  
  3650.   if (!become_user(&Connections[cnum], cnum,pcon->vuid))
  3651.     {
  3652.       DEBUG(0,("Can't become connected user!\n"));
  3653.       pcon->open = False;
  3654.       if (!IS_IPC(cnum)) {
  3655.     yield_connection(cnum,
  3656.              lp_servicename(SNUM(cnum)),
  3657.              lp_max_connections(SNUM(cnum)));
  3658.     if (lp_status(SNUM(cnum))) yield_connection(cnum,"STATUS.",MAXSTATUS);
  3659.       }
  3660.       return(-1);
  3661.     }
  3662.  
  3663.   if (ChDir(pcon->connectpath) != 0)
  3664.     {
  3665.       DEBUG(0,("Can't change directory to %s (%s)\n",
  3666.            pcon->connectpath,strerror(errno)));
  3667.       pcon->open = False;
  3668.       unbecome_user();
  3669.       if (!IS_IPC(cnum)) {
  3670.     yield_connection(cnum,
  3671.              lp_servicename(SNUM(cnum)),
  3672.              lp_max_connections(SNUM(cnum)));
  3673.     if (lp_status(SNUM(cnum))) yield_connection(cnum,"STATUS.",MAXSTATUS);
  3674.       }
  3675.       return(-5);      
  3676.     }
  3677.  
  3678.   string_set(&pcon->origpath,pcon->connectpath);
  3679.  
  3680. #if SOFTLINK_OPTIMISATION
  3681.   /* resolve any soft links early */
  3682.   {
  3683.     pstring s;
  3684.     pstrcpy(s,pcon->connectpath);
  3685.     GetWd(s);
  3686.     string_set(&pcon->connectpath,s);
  3687.     ChDir(pcon->connectpath);
  3688.   }
  3689. #endif
  3690.  
  3691.   num_connections_open++;
  3692.   add_session_user(user);
  3693.   
  3694.   /* execute any "preexec = " line */
  3695.   if (*lp_preexec(SNUM(cnum)))
  3696.     {
  3697.       pstring cmd;
  3698.       pstrcpy(cmd,lp_preexec(SNUM(cnum)));
  3699.       standard_sub(cnum,cmd);
  3700.       smbrun(cmd,NULL,False);
  3701.     }
  3702.   
  3703.   /* we've finished with the sensitive stuff */
  3704.   unbecome_user();
  3705.  
  3706.   /* Add veto/hide lists */
  3707.   if (!IS_IPC(cnum) && !IS_PRINT(cnum))
  3708.   {
  3709.     set_namearray( &pcon->veto_list, lp_veto_files(SNUM(cnum)));
  3710.     set_namearray( &pcon->hide_list, lp_hide_files(SNUM(cnum)));
  3711.     set_namearray( &pcon->veto_oplock_list, lp_veto_oplocks(SNUM(cnum)));
  3712.   }
  3713.  
  3714.   {
  3715.     DEBUG(IS_IPC(cnum)?3:1,("%s %s (%s) connect to service %s as user %s (uid=%d,gid=%d) (pid %d)\n",
  3716.                 timestring(),
  3717.                 remote_machine,
  3718.                 client_addr(),
  3719.                 lp_servicename(SNUM(cnum)),user,
  3720.                 pcon->uid,
  3721.                 pcon->gid,
  3722.                 (int)getpid()));
  3723.   }
  3724.  
  3725.   return(cnum);
  3726. }
  3727.  
  3728. /****************************************************************************
  3729.   Attempt to break an oplock on a file (if oplocked).
  3730.   Returns True if the file was closed as a result of
  3731.   the oplock break, False otherwise.
  3732.   Used as a last ditch attempt to free a space in the 
  3733.   file table when we have run out.
  3734. ****************************************************************************/
  3735.  
  3736. static BOOL attempt_close_oplocked_file(files_struct *fp)
  3737. {
  3738.  
  3739.   DEBUG(5,("attempt_close_oplocked_file: checking file %s.\n", fp->name));
  3740.  
  3741.   if (fp->open && fp->granted_oplock && !fp->sent_oplock_break) {
  3742.  
  3743.     /* Try and break the oplock. */
  3744.     file_fd_struct *fsp = fp->fd_ptr;
  3745.     if(oplock_break( fsp->dev, fsp->inode, &fp->open_time)) {
  3746.       if(!fp->open) /* Did the oplock break close the file ? */
  3747.         return True;
  3748.     }
  3749.   }
  3750.  
  3751.   return False;
  3752. }
  3753.  
  3754. /****************************************************************************
  3755.   find first available file slot
  3756. ****************************************************************************/
  3757. int find_free_file(void )
  3758. {
  3759.     int i;
  3760.     static int first_file;
  3761.  
  3762.     /* we want to give out file handles differently on each new
  3763.        connection because of a common bug in MS clients where they try to
  3764.        reuse a file descriptor from an earlier smb connection. This code
  3765.        increases the chance that the errant client will get an error rather
  3766.        than causing corruption */
  3767.     if (first_file == 0) {
  3768.         first_file = (getpid() ^ (int)time(NULL)) % MAX_OPEN_FILES;
  3769.         if (first_file == 0) first_file = 1;
  3770.     }
  3771.  
  3772.     if (first_file >= MAX_OPEN_FILES)
  3773.         first_file = 1;
  3774.  
  3775.     for (i=first_file;i<MAX_OPEN_FILES;i++)
  3776.         if (!Files[i].open && !Files[i].reserved) {
  3777.             memset(&Files[i], 0, sizeof(Files[i]));
  3778.             first_file = i+1;
  3779.             Files[i].reserved = True;
  3780.             return(i);
  3781.         }
  3782.  
  3783.     /* returning a file handle of 0 is a bad idea - so we start at 1 */
  3784.     for (i=1;i<first_file;i++)
  3785.         if (!Files[i].open && !Files[i].reserved) {
  3786.             memset(&Files[i], 0, sizeof(Files[i]));
  3787.             first_file = i+1;
  3788.             Files[i].reserved = True;
  3789.             return(i);
  3790.         }
  3791.  
  3792.         /* 
  3793.          * Before we give up, go through the open files 
  3794.          * and see if there are any files opened with a
  3795.          * batch oplock. If so break the oplock and then
  3796.          * re-use that entry (if it becomes closed).
  3797.          * This may help as NT/95 clients tend to keep
  3798.          * files batch oplocked for quite a long time
  3799.          * after they have finished with them.
  3800.          */
  3801.         for (i=first_file;i<MAX_OPEN_FILES;i++) {
  3802.           if(attempt_close_oplocked_file( &Files[i])) {
  3803.             memset(&Files[i], 0, sizeof(Files[i]));
  3804.             first_file = i+1;
  3805.             Files[i].reserved = True;
  3806.             return(i);
  3807.           }
  3808.         }
  3809.  
  3810.         for (i=1;i<MAX_OPEN_FILES;i++) {
  3811.           if(attempt_close_oplocked_file( &Files[i])) {
  3812.             memset(&Files[i], 0, sizeof(Files[i]));
  3813.             first_file = i+1;
  3814.             Files[i].reserved = True;
  3815.             return(i);
  3816.           }
  3817.         }
  3818.  
  3819.     DEBUG(1,("ERROR! Out of file structures - perhaps increase MAX_OPEN_FILES?\n"));
  3820.     return(-1);
  3821. }
  3822.  
  3823. /****************************************************************************
  3824.   find first available connection slot, starting from a random position.
  3825. The randomisation stops problems with the server dieing and clients
  3826. thinking the server is still available.
  3827. ****************************************************************************/
  3828. static int find_free_connection(int hash )
  3829. {
  3830.   int i;
  3831.   BOOL used=False;
  3832.   hash = (hash % (MAX_CONNECTIONS-2))+1;
  3833.  
  3834.  again:
  3835.  
  3836.   for (i=hash+1;i!=hash;)
  3837.     {
  3838.       if (!Connections[i].open && Connections[i].used == used) 
  3839.     {
  3840.       DEBUG(3,("found free connection number %d\n",i));
  3841.       return(i);
  3842.     }
  3843.       i++;
  3844.       if (i == MAX_CONNECTIONS)
  3845.     i = 1;
  3846.     }
  3847.  
  3848.   if (!used)
  3849.     {
  3850.       used = !used;
  3851.       goto again;
  3852.     }
  3853.  
  3854.   DEBUG(1,("ERROR! Out of connection structures\n"));
  3855.   return(-1);
  3856. }
  3857.  
  3858.  
  3859. /****************************************************************************
  3860. reply for the core protocol
  3861. ****************************************************************************/
  3862. int reply_corep(char *outbuf)
  3863. {
  3864.   int outsize = set_message(outbuf,1,0,True);
  3865.  
  3866.   Protocol = PROTOCOL_CORE;
  3867.  
  3868.   return outsize;
  3869. }
  3870.  
  3871.  
  3872. /****************************************************************************
  3873. reply for the coreplus protocol
  3874. ****************************************************************************/
  3875. int reply_coreplus(char *outbuf)
  3876. {
  3877.   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
  3878.   int outsize = set_message(outbuf,13,0,True);
  3879.   SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
  3880.                  readbraw and writebraw (possibly) */
  3881.   CVAL(outbuf,smb_flg) = 0x81; /* Reply, SMBlockread, SMBwritelock supported */
  3882.   SSVAL(outbuf,smb_vwv1,0x1); /* user level security, don't encrypt */    
  3883.  
  3884.   Protocol = PROTOCOL_COREPLUS;
  3885.  
  3886.   return outsize;
  3887. }
  3888.  
  3889.  
  3890. /****************************************************************************
  3891. reply for the lanman 1.0 protocol
  3892. ****************************************************************************/
  3893. int reply_lanman1(char *outbuf)
  3894. {
  3895.   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
  3896.   int secword=0;
  3897.   BOOL doencrypt = SMBENCRYPT();
  3898.   time_t t = time(NULL);
  3899.  
  3900.   if (lp_security()>=SEC_USER) secword |= 1;
  3901.   if (doencrypt) secword |= 2;
  3902.  
  3903.   set_message(outbuf,13,doencrypt?8:0,True);
  3904.   SSVAL(outbuf,smb_vwv1,secword); 
  3905.   /* Create a token value and add it to the outgoing packet. */
  3906.   if (doencrypt) 
  3907.     generate_next_challenge(smb_buf(outbuf));
  3908.  
  3909.   Protocol = PROTOCOL_LANMAN1;
  3910.  
  3911.   CVAL(outbuf,smb_flg) = 0x81; /* Reply, SMBlockread, SMBwritelock supported */
  3912.   SSVAL(outbuf,smb_vwv2,max_recv);
  3913.   SSVAL(outbuf,smb_vwv3,lp_maxmux()); /* maxmux */
  3914.   SSVAL(outbuf,smb_vwv4,1);
  3915.   SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
  3916.                  readbraw writebraw (possibly) */
  3917.   SIVAL(outbuf,smb_vwv6,getpid());
  3918.   SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
  3919.  
  3920.   put_dos_date(outbuf,smb_vwv8,t);
  3921.  
  3922.   return (smb_len(outbuf)+4);
  3923. }
  3924.  
  3925.  
  3926. /****************************************************************************
  3927. reply for the lanman 2.0 protocol
  3928. ****************************************************************************/
  3929. int reply_lanman2(char *outbuf)
  3930. {
  3931.   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
  3932.   int secword=0;
  3933.   BOOL doencrypt = SMBENCRYPT();
  3934.   time_t t = time(NULL);
  3935.   struct cli_state *cli = NULL;
  3936.   char cryptkey[8];
  3937.   char crypt_len = 0;
  3938.  
  3939.   if (lp_security() == SEC_SERVER) {
  3940.       cli = server_cryptkey();
  3941.   }
  3942.  
  3943.   if (cli) {
  3944.       DEBUG(3,("using password server validation\n"));
  3945.       doencrypt = ((cli->sec_mode & 2) != 0);
  3946.   }
  3947.  
  3948.   if (lp_security()>=SEC_USER) secword |= 1;
  3949.   if (doencrypt) secword |= 2;
  3950.  
  3951.   if (doencrypt) {
  3952.       crypt_len = 8;
  3953.       if (!cli) {
  3954.           generate_next_challenge(cryptkey);
  3955.       } else {
  3956.           memcpy(cryptkey, cli->cryptkey, 8);
  3957.           set_challenge(cli->cryptkey);
  3958.       }
  3959.   }
  3960.  
  3961.   set_message(outbuf,13,crypt_len,True);
  3962.   SSVAL(outbuf,smb_vwv1,secword); 
  3963.   SIVAL(outbuf,smb_vwv6,getpid());
  3964.   if (doencrypt) 
  3965.       memcpy(smb_buf(outbuf), cryptkey, 8);
  3966.  
  3967.   Protocol = PROTOCOL_LANMAN2;
  3968.  
  3969.   CVAL(outbuf,smb_flg) = 0x81; /* Reply, SMBlockread, SMBwritelock supported */
  3970.   SSVAL(outbuf,smb_vwv2,max_recv);
  3971.   SSVAL(outbuf,smb_vwv3,lp_maxmux()); 
  3972.   SSVAL(outbuf,smb_vwv4,1);
  3973.   SSVAL(outbuf,smb_vwv5,raw); /* readbraw and/or writebraw */
  3974.   SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
  3975.   put_dos_date(outbuf,smb_vwv8,t);
  3976.  
  3977.   return (smb_len(outbuf)+4);
  3978. }
  3979.  
  3980.  
  3981. /****************************************************************************
  3982. reply for the nt protocol
  3983. ****************************************************************************/
  3984. int reply_nt1(char *outbuf)
  3985. {
  3986.   /* dual names + lock_and_read + nt SMBs + remote API calls */
  3987.   int capabilities = CAP_NT_FIND|CAP_LOCK_AND_READ;
  3988. /*
  3989.   other valid capabilities which we may support at some time...
  3990.                      CAP_LARGE_FILES|CAP_NT_SMBS|CAP_RPC_REMOTE_APIS;
  3991.                      CAP_LARGE_READX|CAP_STATUS32|CAP_LEVEL_II_OPLOCKS;
  3992.  */
  3993.  
  3994.   int secword=0;
  3995.   BOOL doencrypt = SMBENCRYPT();
  3996.   time_t t = time(NULL);
  3997.   int data_len;
  3998.   struct cli_state *cli = NULL;
  3999.   char cryptkey[8];
  4000.   char crypt_len = 0;
  4001.  
  4002.   if (lp_security() == SEC_SERVER) {
  4003.       cli = server_cryptkey();
  4004.   }
  4005.  
  4006.   if (cli) {
  4007.       DEBUG(3,("using password server validation\n"));
  4008.       doencrypt = ((cli->sec_mode & 2) != 0);
  4009.   }
  4010.  
  4011.   if (doencrypt) {
  4012.       crypt_len = 8;
  4013.       if (!cli) {
  4014.           generate_next_challenge(cryptkey);
  4015.       } else {
  4016.           memcpy(cryptkey, cli->cryptkey, 8);
  4017.           set_challenge(cli->cryptkey);
  4018.       }
  4019.   }
  4020.  
  4021.   if (lp_readraw() && lp_writeraw()) {
  4022.       capabilities |= CAP_RAW_MODE;
  4023.   }
  4024.  
  4025.   if (lp_security() >= SEC_USER) secword |= 1;
  4026.   if (doencrypt) secword |= 2;
  4027.  
  4028.   /* decide where (if) to put the encryption challenge, and
  4029.      follow it with the OEM'd domain name
  4030.    */
  4031.   data_len = crypt_len + strlen(myworkgroup) + 1;
  4032.  
  4033.   set_message(outbuf,17,data_len,True);
  4034.   pstrcpy(smb_buf(outbuf)+crypt_len, myworkgroup);
  4035.  
  4036.   CVAL(outbuf,smb_vwv1) = secword;
  4037.   SSVALS(outbuf,smb_vwv16+1,crypt_len);
  4038.   if (doencrypt) 
  4039.       memcpy(smb_buf(outbuf), cryptkey, 8);
  4040.  
  4041.   Protocol = PROTOCOL_NT1;
  4042.  
  4043.   SSVAL(outbuf,smb_vwv1+1,lp_maxmux()); /* maxmpx */
  4044.   SSVAL(outbuf,smb_vwv2+1,1); /* num vcs */
  4045.   SIVAL(outbuf,smb_vwv3+1,0xffff); /* max buffer. LOTS! */
  4046.   SIVAL(outbuf,smb_vwv5+1,0xffff); /* raw size. LOTS! */
  4047.   SIVAL(outbuf,smb_vwv7+1,getpid()); /* session key */
  4048.   SIVAL(outbuf,smb_vwv9+1,capabilities); /* capabilities */
  4049.   put_long_date(outbuf+smb_vwv11+1,t);
  4050.   SSVALS(outbuf,smb_vwv15+1,TimeDiff(t)/60);
  4051.   SSVAL(outbuf,smb_vwv17,data_len); /* length of challenge+domain strings */
  4052.  
  4053.   return (smb_len(outbuf)+4);
  4054. }
  4055.  
  4056. /* these are the protocol lists used for auto architecture detection:
  4057.  
  4058. WinNT 3.51:
  4059. protocol [PC NETWORK PROGRAM 1.0]
  4060. protocol [XENIX CORE]
  4061. protocol [MICROSOFT NETWORKS 1.03]
  4062. protocol [LANMAN1.0]
  4063. protocol [Windows for Workgroups 3.1a]
  4064. protocol [LM1.2X002]
  4065. protocol [LANMAN2.1]
  4066. protocol [NT LM 0.12]
  4067.  
  4068. Win95:
  4069. protocol [PC NETWORK PROGRAM 1.0]
  4070. protocol [XENIX CORE]
  4071. protocol [MICROSOFT NETWORKS 1.03]
  4072. protocol [LANMAN1.0]
  4073. protocol [Windows for Workgroups 3.1a]
  4074. protocol [LM1.2X002]
  4075. protocol [LANMAN2.1]
  4076. protocol [NT LM 0.12]
  4077.  
  4078. OS/2:
  4079. protocol [PC NETWORK PROGRAM 1.0]
  4080. protocol [XENIX CORE]
  4081. protocol [LANMAN1.0]
  4082. protocol [LM1.2X002]
  4083. protocol [LANMAN2.1]
  4084. */
  4085.  
  4086. /*
  4087.   * Modified to recognize the architecture of the remote machine better.
  4088.   *
  4089.   * This appears to be the matrix of which protocol is used by which
  4090.   * MS product.
  4091.        Protocol                       WfWg    Win95   WinNT  OS/2
  4092.        PC NETWORK PROGRAM 1.0          1       1       1      1
  4093.        XENIX CORE                                      2      2
  4094.        MICROSOFT NETWORKS 3.0          2       2       
  4095.        DOS LM1.2X002                   3       3       
  4096.        MICROSOFT NETWORKS 1.03                         3
  4097.        DOS LANMAN2.1                   4       4       
  4098.        LANMAN1.0                                       4      3
  4099.        Windows for Workgroups 3.1a     5       5       5
  4100.        LM1.2X002                                       6      4
  4101.        LANMAN2.1                                       7      5
  4102.        NT LM 0.12                              6       8
  4103.   *
  4104.   *  tim@fsg.com 09/29/95
  4105.   */
  4106.   
  4107. #define ARCH_WFWG     0x3      /* This is a fudge because WfWg is like Win95 */
  4108. #define ARCH_WIN95    0x2
  4109. #define    ARCH_OS2      0xC      /* Again OS/2 is like NT */
  4110. #define ARCH_WINNT    0x8
  4111. #define ARCH_SAMBA    0x10
  4112.  
  4113. #define ARCH_ALL      0x1F
  4114.  
  4115. /* List of supported protocols, most desired first */
  4116. struct {
  4117.   char *proto_name;
  4118.   char *short_name;
  4119.   int (*proto_reply_fn)(char *);
  4120.   int protocol_level;
  4121. } supported_protocols[] = {
  4122.   {"NT LANMAN 1.0",           "NT1",      reply_nt1,      PROTOCOL_NT1},
  4123.   {"NT LM 0.12",              "NT1",      reply_nt1,      PROTOCOL_NT1},
  4124.   {"LM1.2X002",               "LANMAN2",  reply_lanman2,  PROTOCOL_LANMAN2},
  4125.   {"Samba",                   "LANMAN2",  reply_lanman2,  PROTOCOL_LANMAN2},
  4126.   {"DOS LM1.2X002",           "LANMAN2",  reply_lanman2,  PROTOCOL_LANMAN2},
  4127.   {"LANMAN1.0",               "LANMAN1",  reply_lanman1,  PROTOCOL_LANMAN1},
  4128.   {"MICROSOFT NETWORKS 3.0",  "LANMAN1",  reply_lanman1,  PROTOCOL_LANMAN1},
  4129.   {"MICROSOFT NETWORKS 1.03", "COREPLUS", reply_coreplus, PROTOCOL_COREPLUS},
  4130.   {"PC NETWORK PROGRAM 1.0",  "CORE",     reply_corep,    PROTOCOL_CORE}, 
  4131.   {NULL,NULL},
  4132. };
  4133.  
  4134.  
  4135. /****************************************************************************
  4136.   reply to a negprot
  4137. ****************************************************************************/
  4138. static int reply_negprot(char *inbuf,char *outbuf, int size, int bufsize)
  4139. {
  4140.   int outsize = set_message(outbuf,1,0,True);
  4141.   int Index=0;
  4142.   int choice= -1;
  4143.   int protocol;
  4144.   char *p;
  4145.   int bcc = SVAL(smb_buf(inbuf),-2);
  4146.   int arch = ARCH_ALL;
  4147.  
  4148.   p = smb_buf(inbuf)+1;
  4149.   while (p < (smb_buf(inbuf) + bcc))
  4150.     { 
  4151.       Index++;
  4152.       DEBUG(3,("Requested protocol [%s]\n",p));
  4153.       if (strcsequal(p,"Windows for Workgroups 3.1a"))
  4154.     arch &= ( ARCH_WFWG | ARCH_WIN95 | ARCH_WINNT );
  4155.       else if (strcsequal(p,"DOS LM1.2X002"))
  4156.     arch &= ( ARCH_WFWG | ARCH_WIN95 );
  4157.       else if (strcsequal(p,"DOS LANMAN2.1"))
  4158.     arch &= ( ARCH_WFWG | ARCH_WIN95 );
  4159.       else if (strcsequal(p,"NT LM 0.12"))
  4160.     arch &= ( ARCH_WIN95 | ARCH_WINNT );
  4161.       else if (strcsequal(p,"LANMAN2.1"))
  4162.     arch &= ( ARCH_WINNT | ARCH_OS2 );
  4163.       else if (strcsequal(p,"LM1.2X002"))
  4164.     arch &= ( ARCH_WINNT | ARCH_OS2 );
  4165.       else if (strcsequal(p,"MICROSOFT NETWORKS 1.03"))
  4166.     arch &= ARCH_WINNT;
  4167.       else if (strcsequal(p,"XENIX CORE"))
  4168.     arch &= ( ARCH_WINNT | ARCH_OS2 );
  4169.       else if (strcsequal(p,"Samba")) {
  4170.     arch = ARCH_SAMBA;
  4171.     break;
  4172.       }
  4173.  
  4174.       p += strlen(p) + 2;
  4175.     }
  4176.     
  4177.   switch ( arch ) {
  4178.   case ARCH_SAMBA:
  4179.     set_remote_arch(RA_SAMBA);
  4180.     break;
  4181.   case ARCH_WFWG:
  4182.     set_remote_arch(RA_WFWG);
  4183.     break;
  4184.   case ARCH_WIN95:
  4185.     set_remote_arch(RA_WIN95);
  4186.     break;
  4187.   case ARCH_WINNT:
  4188.     set_remote_arch(RA_WINNT);
  4189.     break;
  4190.   case ARCH_OS2:
  4191.     set_remote_arch(RA_OS2);
  4192.     break;
  4193.   default:
  4194.     set_remote_arch(RA_UNKNOWN);
  4195.     break;
  4196.   }
  4197.  
  4198.   /* possibly reload - change of architecture */
  4199.   reload_services(True);      
  4200.     
  4201.   /* a special case to stop password server loops */
  4202.   if (Index == 1 && strequal(remote_machine,myhostname) && 
  4203.       lp_security()==SEC_SERVER)
  4204.     exit_server("Password server loop!");
  4205.   
  4206.   /* Check for protocols, most desirable first */
  4207.   for (protocol = 0; supported_protocols[protocol].proto_name; protocol++)
  4208.     {
  4209.       p = smb_buf(inbuf)+1;
  4210.       Index = 0;
  4211.       if (lp_maxprotocol() >= supported_protocols[protocol].protocol_level)
  4212.     while (p < (smb_buf(inbuf) + bcc))
  4213.       { 
  4214.         if (strequal(p,supported_protocols[protocol].proto_name))
  4215.           choice = Index;
  4216.         Index++;
  4217.         p += strlen(p) + 2;
  4218.       }
  4219.       if(choice != -1)
  4220.     break;
  4221.     }
  4222.   
  4223.   SSVAL(outbuf,smb_vwv0,choice);
  4224.   if(choice != -1) {
  4225.     extern fstring remote_proto;
  4226.     fstrcpy(remote_proto,supported_protocols[protocol].short_name);
  4227.     reload_services(True);          
  4228.     outsize = supported_protocols[protocol].proto_reply_fn(outbuf);
  4229.     DEBUG(3,("Selected protocol %s\n",supported_protocols[protocol].proto_name));
  4230.   }
  4231.   else {
  4232.     DEBUG(0,("No protocol supported !\n"));
  4233.   }
  4234.   SSVAL(outbuf,smb_vwv0,choice);
  4235.   
  4236.   DEBUG(5,("%s negprot index=%d\n",timestring(),choice));
  4237.  
  4238.   return(outsize);
  4239. }
  4240.  
  4241.  
  4242. /****************************************************************************
  4243. close all open files for a connection
  4244. ****************************************************************************/
  4245. static void close_open_files(int cnum)
  4246. {
  4247.   int i;
  4248.   for (i=0;i<MAX_OPEN_FILES;i++)
  4249.     if( Files[i].cnum == cnum && Files[i].open) {
  4250.       close_file(i,False);
  4251.     }
  4252. }
  4253.  
  4254.  
  4255.  
  4256. /****************************************************************************
  4257. close a cnum
  4258. ****************************************************************************/
  4259. void close_cnum(int cnum, uint16 vuid)
  4260. {
  4261.   DirCacheFlush(SNUM(cnum));
  4262.  
  4263.   unbecome_user();
  4264.  
  4265.   if (!OPEN_CNUM(cnum))
  4266.     {
  4267.       DEBUG(0,("Can't close cnum %d\n",cnum));
  4268.       return;
  4269.     }
  4270.  
  4271.   DEBUG(IS_IPC(cnum)?3:1,("%s %s (%s) closed connection to service %s\n",
  4272.               timestring(),
  4273.               remote_machine,client_addr(),
  4274.               lp_servicename(SNUM(cnum))));
  4275.  
  4276.   yield_connection(cnum,
  4277.            lp_servicename(SNUM(cnum)),
  4278.            lp_max_connections(SNUM(cnum)));
  4279.  
  4280.   if (lp_status(SNUM(cnum)))
  4281.     yield_connection(cnum,"STATUS.",MAXSTATUS);
  4282.  
  4283.   close_open_files(cnum);
  4284.   dptr_closecnum(cnum);
  4285.  
  4286.   /* execute any "postexec = " line */
  4287.   if (*lp_postexec(SNUM(cnum)) && become_user(&Connections[cnum], cnum,vuid))
  4288.     {
  4289.       pstring cmd;
  4290.       pstrcpy(cmd,lp_postexec(SNUM(cnum)));
  4291.       standard_sub(cnum,cmd);
  4292.       smbrun(cmd,NULL,False);
  4293.       unbecome_user();
  4294.     }
  4295.  
  4296.   unbecome_user();
  4297.   /* execute any "root postexec = " line */
  4298.   if (*lp_rootpostexec(SNUM(cnum)))
  4299.     {
  4300.       pstring cmd;
  4301.       pstrcpy(cmd,lp_rootpostexec(SNUM(cnum)));
  4302.       standard_sub(cnum,cmd);
  4303.       smbrun(cmd,NULL,False);
  4304.     }
  4305.  
  4306.   Connections[cnum].open = False;
  4307.   num_connections_open--;
  4308.   if (Connections[cnum].ngroups && Connections[cnum].groups)
  4309.     {
  4310.       if (Connections[cnum].igroups != (int *)Connections[cnum].groups)
  4311.     free(Connections[cnum].groups);
  4312.       free(Connections[cnum].igroups);
  4313.       Connections[cnum].groups = NULL;
  4314.       Connections[cnum].igroups = NULL;
  4315.       Connections[cnum].ngroups = 0;
  4316.     }
  4317.  
  4318.   free_namearray(Connections[cnum].veto_list);
  4319.   free_namearray(Connections[cnum].hide_list);
  4320.   free_namearray(Connections[cnum].veto_oplock_list);
  4321.  
  4322.   string_set(&Connections[cnum].user,"");
  4323.   string_set(&Connections[cnum].dirpath,"");
  4324.   string_set(&Connections[cnum].connectpath,"");
  4325. }
  4326.  
  4327.  
  4328. /****************************************************************************
  4329. simple routines to do connection counting
  4330. ****************************************************************************/
  4331. BOOL yield_connection(int cnum,char *name,int max_connections)
  4332. {
  4333.   struct connect_record crec;
  4334.   pstring fname;
  4335.   FILE *f;
  4336.   int mypid = getpid();
  4337.   int i;
  4338.  
  4339.   DEBUG(3,("Yielding connection to %d %s\n",cnum,name));
  4340.  
  4341.   if (max_connections <= 0)
  4342.     return(True);
  4343.  
  4344.   bzero(&crec,sizeof(crec));
  4345.  
  4346.   pstrcpy(fname,lp_lockdir());
  4347.   standard_sub(cnum,fname);
  4348.   trim_string(fname,"","/");
  4349.  
  4350.   pstrcat(fname,"/");
  4351.   pstrcat(fname,name);
  4352.   pstrcat(fname,".LCK");
  4353.  
  4354.   f = fopen(fname,"r+");
  4355.   if (!f)
  4356.     {
  4357.       DEBUG(2,("Couldn't open lock file %s (%s)\n",fname,strerror(errno)));
  4358.       return(False);
  4359.     }
  4360.  
  4361.   fseek(f,0,SEEK_SET);
  4362.  
  4363.   /* find a free spot */
  4364.   for (i=0;i<max_connections;i++)
  4365.     {
  4366.       if (fread(&crec,sizeof(crec),1,f) != 1)
  4367.     {
  4368.       DEBUG(2,("Entry not found in lock file %s\n",fname));
  4369.       fclose(f);
  4370.       return(False);
  4371.     }
  4372.       if (crec.pid == mypid && crec.cnum == cnum)
  4373.     break;
  4374.     }
  4375.  
  4376.   if (crec.pid != mypid || crec.cnum != cnum)
  4377.     {
  4378.       fclose(f);
  4379.       DEBUG(2,("Entry not found in lock file %s\n",fname));
  4380.       return(False);
  4381.     }
  4382.  
  4383.   bzero((void *)&crec,sizeof(crec));
  4384.   
  4385.   /* remove our mark */
  4386.   if (fseek(f,i*sizeof(crec),SEEK_SET) != 0 ||
  4387.       fwrite(&crec,sizeof(crec),1,f) != 1)
  4388.     {
  4389.       DEBUG(2,("Couldn't update lock file %s (%s)\n",fname,strerror(errno)));
  4390.       fclose(f);
  4391.       return(False);
  4392.     }
  4393.  
  4394.   DEBUG(3,("Yield successful\n"));
  4395.  
  4396.   fclose(f);
  4397.   return(True);
  4398. }
  4399.  
  4400.  
  4401. /****************************************************************************
  4402. simple routines to do connection counting
  4403. ****************************************************************************/
  4404. BOOL claim_connection(int cnum,char *name,int max_connections,BOOL Clear)
  4405. {
  4406.   struct connect_record crec;
  4407.   pstring fname;
  4408.   FILE *f;
  4409.   int snum = SNUM(cnum);
  4410.   int i,foundi= -1;
  4411.   int total_recs;
  4412.  
  4413.   if (max_connections <= 0)
  4414.     return(True);
  4415.  
  4416.   DEBUG(5,("trying claim %s %s %d\n",lp_lockdir(),name,max_connections));
  4417.  
  4418.   pstrcpy(fname,lp_lockdir());
  4419.   standard_sub(cnum,fname);
  4420.   trim_string(fname,"","/");
  4421.  
  4422.   if (!directory_exist(fname,NULL))
  4423.     mkdir(fname,0755);
  4424.  
  4425.   pstrcat(fname,"/");
  4426.   pstrcat(fname,name);
  4427.   pstrcat(fname,".LCK");
  4428.  
  4429.   if (!file_exist(fname,NULL))
  4430.     {
  4431.       int oldmask = umask(022);
  4432.       f = fopen(fname,"w");
  4433.       if (f) fclose(f);
  4434.       umask(oldmask);
  4435.     }
  4436.  
  4437.   total_recs = file_size(fname) / sizeof(crec);
  4438.  
  4439.   f = fopen(fname,"r+");
  4440.  
  4441.   if (!f)
  4442.     {
  4443.       DEBUG(1,("couldn't open lock file %s\n",fname));
  4444.       return(False);
  4445.     }
  4446.  
  4447.   /* find a free spot */
  4448.   for (i=0;i<max_connections;i++)
  4449.     {
  4450.  
  4451.       if (i>=total_recs || 
  4452.       fseek(f,i*sizeof(crec),SEEK_SET) != 0 ||
  4453.       fread(&crec,sizeof(crec),1,f) != 1)
  4454.     {
  4455.       if (foundi < 0) foundi = i;
  4456.       break;
  4457.     }
  4458.  
  4459.       if (Clear && crec.pid && !process_exists(crec.pid))
  4460.     {
  4461.       fseek(f,i*sizeof(crec),SEEK_SET);
  4462.       bzero((void *)&crec,sizeof(crec));
  4463.       fwrite(&crec,sizeof(crec),1,f);
  4464.       if (foundi < 0) foundi = i;
  4465.       continue;
  4466.     }
  4467.       if (foundi < 0 && (!crec.pid || !process_exists(crec.pid)))
  4468.     {
  4469.       foundi=i;
  4470.       if (!Clear) break;
  4471.     }
  4472.     }  
  4473.  
  4474.   if (foundi < 0)
  4475.     {
  4476.       DEBUG(3,("no free locks in %s\n",fname));
  4477.       fclose(f);
  4478.       return(False);
  4479.     }      
  4480.  
  4481.   /* fill in the crec */
  4482.   bzero((void *)&crec,sizeof(crec));
  4483.   crec.magic = 0x280267;
  4484.   crec.pid = getpid();
  4485.   crec.cnum = cnum;
  4486.   crec.uid = Connections[cnum].uid;
  4487.   crec.gid = Connections[cnum].gid;
  4488.   StrnCpy(crec.name,lp_servicename(snum),sizeof(crec.name)-1);
  4489.   crec.start = time(NULL);
  4490.  
  4491.   StrnCpy(crec.machine,remote_machine,sizeof(crec.machine)-1);
  4492.   StrnCpy(crec.addr,client_addr(),sizeof(crec.addr)-1);
  4493.   
  4494.   /* make our mark */
  4495.   if (fseek(f,foundi*sizeof(crec),SEEK_SET) != 0 ||
  4496.       fwrite(&crec,sizeof(crec),1,f) != 1)
  4497.     {
  4498.       fclose(f);
  4499.       return(False);
  4500.     }
  4501.  
  4502.   fclose(f);
  4503.   return(True);
  4504. }
  4505.  
  4506. #if DUMP_CORE
  4507. /*******************************************************************
  4508. prepare to dump a core file - carefully!
  4509. ********************************************************************/
  4510. static BOOL dump_core(void)
  4511. {
  4512.   char *p;
  4513.   pstring dname;
  4514.   pstrcpy(dname,debugf);
  4515.   if ((p=strrchr(dname,'/'))) *p=0;
  4516.   pstrcat(dname,"/corefiles");
  4517.   mkdir(dname,0700);
  4518.   sys_chown(dname,getuid(),getgid());
  4519.   chmod(dname,0700);
  4520.   if (chdir(dname)) return(False);
  4521.   umask(~(0700));
  4522.  
  4523. #ifndef NO_GETRLIMIT
  4524. #ifdef RLIMIT_CORE
  4525.   {
  4526.     struct rlimit rlp;
  4527.     getrlimit(RLIMIT_CORE, &rlp);
  4528.     rlp.rlim_cur = MAX(4*1024*1024,rlp.rlim_cur);
  4529.     setrlimit(RLIMIT_CORE, &rlp);
  4530.     getrlimit(RLIMIT_CORE, &rlp);
  4531.     DEBUG(3,("Core limits now %d %d\n",rlp.rlim_cur,rlp.rlim_max));
  4532.   }
  4533. #endif
  4534. #endif
  4535.  
  4536.  
  4537.   DEBUG(0,("Dumping core in %s\n",dname));
  4538.   return(True);
  4539. }
  4540. #endif
  4541.  
  4542. /****************************************************************************
  4543. exit the server
  4544. ****************************************************************************/
  4545. void exit_server(char *reason)
  4546. {
  4547.   static int firsttime=1;
  4548.   int i;
  4549.  
  4550.   if (!firsttime) exit(0);
  4551.   firsttime = 0;
  4552.  
  4553.   unbecome_user();
  4554.   DEBUG(2,("Closing connections\n"));
  4555.   for (i=0;i<MAX_CONNECTIONS;i++)
  4556.     if (Connections[i].open)
  4557.       close_cnum(i,(uint16)-1);
  4558. #ifdef DFS_AUTH
  4559.   if (dcelogin_atmost_once)
  4560.     dfs_unlogin();
  4561. #endif
  4562.   if (!reason) {   
  4563.     int oldlevel = DEBUGLEVEL;
  4564.     DEBUGLEVEL = 10;
  4565.     DEBUG(0,("Last message was %s\n",smb_fn_name(last_message)));
  4566.     if (last_inbuf)
  4567.       show_msg(last_inbuf);
  4568.     DEBUGLEVEL = oldlevel;
  4569.     DEBUG(0,("===============================================================\n"));
  4570. #if DUMP_CORE
  4571.     if (dump_core()) return;
  4572. #endif
  4573.   }    
  4574.  
  4575.   locking_end();
  4576.  
  4577.   DEBUG(3,("%s Server exit  (%s)\n",timestring(),reason?reason:""));
  4578.   exit(0);
  4579. }
  4580.  
  4581. /****************************************************************************
  4582. do some standard substitutions in a string
  4583. ****************************************************************************/
  4584. void standard_sub(int cnum,char *str)
  4585. {
  4586.   if (VALID_CNUM(cnum)) {
  4587.     char *p, *s, *home;
  4588.  
  4589.     for ( s=str ; (p=strchr(s, '%')) != NULL ; s=p ) {
  4590.       switch (*(p+1)) {
  4591.         case 'H' : if ((home = get_home_dir(Connections[cnum].user))!=NULL)
  4592.                      string_sub(p,"%H",home);
  4593.                    else
  4594.                      p += 2;
  4595.                    break;
  4596.         case 'P' : string_sub(p,"%P",Connections[cnum].connectpath); break;
  4597.         case 'S' : string_sub(p,"%S",lp_servicename(Connections[cnum].service)); break;
  4598.         case 'g' : string_sub(p,"%g",gidtoname(Connections[cnum].gid)); break;
  4599.         case 'u' : string_sub(p,"%u",Connections[cnum].user); break;
  4600.     /* 
  4601.          * Patch from jkf@soton.ac.uk
  4602.          * Left the %N (NIS server name) in standard_sub_basic as it
  4603.          * is a feature for logon servers, hence uses the username.
  4604.      * The %p (NIS server path) code is here as it is used
  4605.      * instead of the default "path =" string in [homes] and so
  4606.      * needs the service name, not the username. 
  4607.          */
  4608.     case 'p' : string_sub(p,"%p",automount_path(lp_servicename(Connections[cnum].service))); break;
  4609.         case '\0' : p++; break; /* don't run off the end of the string */
  4610.         default  : p+=2; break;
  4611.       }
  4612.     }
  4613.   }
  4614.   standard_sub_basic(str);
  4615. }
  4616.  
  4617. /*
  4618. These flags determine some of the permissions required to do an operation 
  4619.  
  4620. Note that I don't set NEED_WRITE on some write operations because they
  4621. are used by some brain-dead clients when printing, and I don't want to
  4622. force write permissions on print services.
  4623. */
  4624. #define AS_USER (1<<0)
  4625. #define NEED_WRITE (1<<1)
  4626. #define TIME_INIT (1<<2)
  4627. #define CAN_IPC (1<<3)
  4628. #define AS_GUEST (1<<5)
  4629. #define QUEUE_IN_OPLOCK (1<<6)
  4630.  
  4631. /* 
  4632.    define a list of possible SMB messages and their corresponding
  4633.    functions. Any message that has a NULL function is unimplemented -
  4634.    please feel free to contribute implementations!
  4635. */
  4636.  
  4637. struct smb_message_struct
  4638. {
  4639.   int code;
  4640.   char *name;
  4641.   int (*fn)(char *, char *, int, int);
  4642.   int flags;
  4643. #if PROFILING
  4644.   unsigned long time;
  4645. #endif
  4646. }
  4647.  smb_messages[] = {
  4648.  
  4649.     /* CORE PROTOCOL */
  4650.  
  4651.    {SMBnegprot,"SMBnegprot",reply_negprot,0},
  4652.    {SMBtcon,"SMBtcon",reply_tcon,0},
  4653.    {SMBtdis,"SMBtdis",reply_tdis,0},
  4654.    {SMBexit,"SMBexit",reply_exit,0},
  4655.    {SMBioctl,"SMBioctl",reply_ioctl,0},
  4656.    {SMBecho,"SMBecho",reply_echo,0},
  4657.    {SMBsesssetupX,"SMBsesssetupX",reply_sesssetup_and_X,0},
  4658.    {SMBtconX,"SMBtconX",reply_tcon_and_X,0},
  4659.    {SMBulogoffX, "SMBulogoffX",reply_ulogoffX, 0}, /* ulogoff doesn't give a valid TID */
  4660.    {SMBgetatr,"SMBgetatr",reply_getatr,AS_USER},
  4661.    {SMBsetatr,"SMBsetatr",reply_setatr,AS_USER | NEED_WRITE},
  4662.    {SMBchkpth,"SMBchkpth",reply_chkpth,AS_USER},
  4663.    {SMBsearch,"SMBsearch",reply_search,AS_USER},
  4664.    {SMBopen,"SMBopen",reply_open,AS_USER | QUEUE_IN_OPLOCK },
  4665.  
  4666.    /* note that SMBmknew and SMBcreate are deliberately overloaded */   
  4667.    {SMBcreate,"SMBcreate",reply_mknew,AS_USER},
  4668.    {SMBmknew,"SMBmknew",reply_mknew,AS_USER}, 
  4669.  
  4670.    {SMBunlink,"SMBunlink",reply_unlink,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK},
  4671.    {SMBread,"SMBread",reply_read,AS_USER},
  4672.    {SMBwrite,"SMBwrite",reply_write,AS_USER},
  4673.    {SMBclose,"SMBclose",reply_close,AS_USER | CAN_IPC},
  4674.    {SMBmkdir,"SMBmkdir",reply_mkdir,AS_USER | NEED_WRITE},
  4675.    {SMBrmdir,"SMBrmdir",reply_rmdir,AS_USER | NEED_WRITE},
  4676.    {SMBdskattr,"SMBdskattr",reply_dskattr,AS_USER},
  4677.    {SMBmv,"SMBmv",reply_mv,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK},
  4678.  
  4679.    /* this is a Pathworks specific call, allowing the 
  4680.       changing of the root path */
  4681.    {pSETDIR,"pSETDIR",reply_setdir,AS_USER}, 
  4682.  
  4683.    {SMBlseek,"SMBlseek",reply_lseek,AS_USER},
  4684.    {SMBflush,"SMBflush",reply_flush,AS_USER},
  4685.    {SMBctemp,"SMBctemp",reply_ctemp,AS_USER | QUEUE_IN_OPLOCK },
  4686.    {SMBsplopen,"SMBsplopen",reply_printopen,AS_USER | QUEUE_IN_OPLOCK },
  4687.    {SMBsplclose,"SMBsplclose",reply_printclose,AS_USER},
  4688.    {SMBsplretq,"SMBsplretq",reply_printqueue,AS_USER|AS_GUEST},
  4689.    {SMBsplwr,"SMBsplwr",reply_printwrite,AS_USER},
  4690.    {SMBlock,"SMBlock",reply_lock,AS_USER},
  4691.    {SMBunlock,"SMBunlock",reply_unlock,AS_USER},
  4692.    
  4693.    /* CORE+ PROTOCOL FOLLOWS */
  4694.    
  4695.    {SMBreadbraw,"SMBreadbraw",reply_readbraw,AS_USER},
  4696.    {SMBwritebraw,"SMBwritebraw",reply_writebraw,AS_USER},
  4697.    {SMBwriteclose,"SMBwriteclose",reply_writeclose,AS_USER},
  4698.    {SMBlockread,"SMBlockread",reply_lockread,AS_USER},
  4699.    {SMBwriteunlock,"SMBwriteunlock",reply_writeunlock,AS_USER},
  4700.    
  4701.    /* LANMAN1.0 PROTOCOL FOLLOWS */
  4702.    
  4703.    {SMBreadBmpx,"SMBreadBmpx",reply_readbmpx,AS_USER},
  4704.    {SMBreadBs,"SMBreadBs",NULL,AS_USER},
  4705.    {SMBwriteBmpx,"SMBwriteBmpx",reply_writebmpx,AS_USER},
  4706.    {SMBwriteBs,"SMBwriteBs",reply_writebs,AS_USER},
  4707.    {SMBwritec,"SMBwritec",NULL,AS_USER},
  4708.    {SMBsetattrE,"SMBsetattrE",reply_setattrE,AS_USER | NEED_WRITE},
  4709.    {SMBgetattrE,"SMBgetattrE",reply_getattrE,AS_USER},
  4710.    {SMBtrans,"SMBtrans",reply_trans,AS_USER | CAN_IPC},
  4711.    {SMBtranss,"SMBtranss",NULL,AS_USER | CAN_IPC},
  4712.    {SMBioctls,"SMBioctls",NULL,AS_USER},
  4713.    {SMBcopy,"SMBcopy",reply_copy,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
  4714.    {SMBmove,"SMBmove",NULL,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
  4715.    
  4716.    {SMBopenX,"SMBopenX",reply_open_and_X,AS_USER | CAN_IPC | QUEUE_IN_OPLOCK },
  4717.    {SMBreadX,"SMBreadX",reply_read_and_X,AS_USER},
  4718.    {SMBwriteX,"SMBwriteX",reply_write_and_X,AS_USER},
  4719.    {SMBlockingX,"SMBlockingX",reply_lockingX,AS_USER},
  4720.    
  4721.    {SMBffirst,"SMBffirst",reply_search,AS_USER},
  4722.    {SMBfunique,"SMBfunique",reply_search,AS_USER},
  4723.    {SMBfclose,"SMBfclose",reply_fclose,AS_USER},
  4724.  
  4725.    /* LANMAN2.0 PROTOCOL FOLLOWS */
  4726.    {SMBfindnclose, "SMBfindnclose",reply_findnclose, AS_USER},
  4727.    {SMBfindclose, "SMBfindclose",reply_findclose,AS_USER},
  4728.    {SMBtrans2, "SMBtrans2",reply_trans2, AS_USER},
  4729.    {SMBtranss2, "SMBtranss2",reply_transs2, AS_USER},
  4730.  
  4731.    /* messaging routines */
  4732.    {SMBsends,"SMBsends",reply_sends,AS_GUEST},
  4733.    {SMBsendstrt,"SMBsendstrt",reply_sendstrt,AS_GUEST},
  4734.    {SMBsendend,"SMBsendend",reply_sendend,AS_GUEST},
  4735.    {SMBsendtxt,"SMBsendtxt",reply_sendtxt,AS_GUEST},
  4736.  
  4737.    /* NON-IMPLEMENTED PARTS OF THE CORE PROTOCOL */
  4738.    
  4739.    {SMBsendb,"SMBsendb",NULL,AS_GUEST},
  4740.    {SMBfwdname,"SMBfwdname",NULL,AS_GUEST},
  4741.    {SMBcancelf,"SMBcancelf",NULL,AS_GUEST},
  4742.    {SMBgetmac,"SMBgetmac",NULL,AS_GUEST}
  4743.  };
  4744.  
  4745. /****************************************************************************
  4746. return a string containing the function name of a SMB command
  4747. ****************************************************************************/
  4748. char *smb_fn_name(int type)
  4749. {
  4750.   static char *unknown_name = "SMBunknown";
  4751.   static int num_smb_messages = 
  4752.     sizeof(smb_messages) / sizeof(struct smb_message_struct);
  4753.   int match;
  4754.  
  4755.   for (match=0;match<num_smb_messages;match++)
  4756.     if (smb_messages[match].code == type)
  4757.       break;
  4758.  
  4759.   if (match == num_smb_messages)
  4760.     return(unknown_name);
  4761.  
  4762.   return(smb_messages[match].name);
  4763. }
  4764.  
  4765.  
  4766. /****************************************************************************
  4767. do a switch on the message type, and return the response size
  4768. ****************************************************************************/
  4769. static int switch_message(int type,char *inbuf,char *outbuf,int size,int bufsize)
  4770. {
  4771.   static int pid= -1;
  4772.   int outsize = 0;
  4773.   static int num_smb_messages = 
  4774.     sizeof(smb_messages) / sizeof(struct smb_message_struct);
  4775.   int match;
  4776.  
  4777. #if PROFILING
  4778.   struct timeval msg_start_time;
  4779.   struct timeval msg_end_time;
  4780.   static unsigned long total_time = 0;
  4781.  
  4782.   GetTimeOfDay(&msg_start_time);
  4783. #endif
  4784.  
  4785.   if (pid == -1)
  4786.     pid = getpid();
  4787.  
  4788.   errno = 0;
  4789.   last_message = type;
  4790.  
  4791.   /* make sure this is an SMB packet */
  4792.   if (strncmp(smb_base(inbuf),"\377SMB",4) != 0)
  4793.     {
  4794.       DEBUG(2,("Non-SMB packet of length %d\n",smb_len(inbuf)));
  4795.       return(-1);
  4796.     }
  4797.  
  4798.   for (match=0;match<num_smb_messages;match++)
  4799.     if (smb_messages[match].code == type)
  4800.       break;
  4801.  
  4802.   if (match == num_smb_messages)
  4803.     {
  4804.       DEBUG(0,("Unknown message type %d!\n",type));
  4805.       outsize = reply_unknown(inbuf,outbuf);
  4806.     }
  4807.   else
  4808.     {
  4809.       DEBUG(3,("switch message %s (pid %d)\n",smb_messages[match].name,pid));
  4810.  
  4811.       if(global_oplock_break && (smb_messages[match].flags & QUEUE_IN_OPLOCK))
  4812.       {
  4813.         /* 
  4814.          * Queue this message as we are the process of an oplock break.
  4815.          */
  4816.  
  4817.         DEBUG(2,("%s: switch_message: queueing message due to being in oplock break state.\n",
  4818.                timestring() ));
  4819.  
  4820.         push_smb_message( inbuf, size);
  4821.         return -1;
  4822.       }          
  4823.  
  4824.       if (smb_messages[match].fn)
  4825.     {
  4826.       int cnum = SVAL(inbuf,smb_tid);
  4827.       int flags = smb_messages[match].flags;
  4828.           static uint16 last_session_tag = UID_FIELD_INVALID;
  4829.           /* In share mode security we must ignore the vuid. */
  4830.       uint16 session_tag = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID : SVAL(inbuf,smb_uid);
  4831.           /* Ensure this value is replaced in the incoming packet. */
  4832.           SSVAL(inbuf,smb_uid,session_tag);
  4833.  
  4834.           /*
  4835.            * Ensure the correct username is in sesssetup_user.
  4836.            * This is a really ugly bugfix for problems with
  4837.            * multiple session_setup_and_X's being done and
  4838.            * allowing %U and %G substitutions to work correctly.
  4839.            * There is a reason this code is done here, don't
  4840.            * move it unless you know what you're doing... :-).
  4841.            * JRA.
  4842.            */
  4843.           if(session_tag != last_session_tag ) {
  4844.             user_struct *vuser = NULL;
  4845.  
  4846.             last_session_tag = session_tag;
  4847.             if(session_tag != UID_FIELD_INVALID)
  4848.               vuser = get_valid_user_struct(session_tag);
  4849.             if(vuser != NULL)
  4850.               pstrcpy( sesssetup_user, vuser->requested_name);
  4851.           }
  4852.  
  4853.       /* does this protocol need to be run as root? */
  4854.       if (!(flags & AS_USER))
  4855.         unbecome_user();
  4856.  
  4857.       /* does this protocol need to be run as the connected user? */
  4858.       if ((flags & AS_USER) && !become_user(&Connections[cnum], cnum,session_tag)) {
  4859.         if (flags & AS_GUEST) 
  4860.           flags &= ~AS_USER;
  4861.         else
  4862.           return(ERROR(ERRSRV,ERRinvnid));
  4863.       }
  4864.       /* this code is to work around a bug is MS client 3 without
  4865.          introducing a security hole - it needs to be able to do
  4866.          print queue checks as guest if it isn't logged in properly */
  4867.       if (flags & AS_USER)
  4868.         flags &= ~AS_GUEST;
  4869.  
  4870.       /* does it need write permission? */
  4871.       if ((flags & NEED_WRITE) && !CAN_WRITE(cnum))
  4872.         return(ERROR(ERRSRV,ERRaccess));
  4873.  
  4874.       /* ipc services are limited */
  4875.       if (IS_IPC(cnum) && (flags & AS_USER) && !(flags & CAN_IPC))
  4876.         return(ERROR(ERRSRV,ERRaccess));        
  4877.  
  4878.       /* load service specific parameters */
  4879.       if (OPEN_CNUM(cnum) && !become_service(cnum,(flags & AS_USER)?True:False))
  4880.         return(ERROR(ERRSRV,ERRaccess));
  4881.  
  4882.       /* does this protocol need to be run as guest? */
  4883.       if ((flags & AS_GUEST) && (!become_guest() || !check_access(-1)))
  4884.         return(ERROR(ERRSRV,ERRaccess));
  4885.  
  4886.       last_inbuf = inbuf;
  4887.  
  4888.       outsize = smb_messages[match].fn(inbuf,outbuf,size,bufsize);
  4889.     }
  4890.       else
  4891.     {
  4892.       outsize = reply_unknown(inbuf,outbuf);
  4893.     }
  4894.     }
  4895.  
  4896. #if PROFILING
  4897.   GetTimeOfDay(&msg_end_time);
  4898.   if (!(smb_messages[match].flags & TIME_INIT))
  4899.     {
  4900.       smb_messages[match].time = 0;
  4901.       smb_messages[match].flags |= TIME_INIT;
  4902.     }
  4903.   {
  4904.     unsigned long this_time =     
  4905.       (msg_end_time.tv_sec - msg_start_time.tv_sec)*1e6 +
  4906.     (msg_end_time.tv_usec - msg_start_time.tv_usec);
  4907.     smb_messages[match].time += this_time;
  4908.     total_time += this_time;
  4909.   }
  4910.   DEBUG(2,("TIME %s  %d usecs   %g pct\n",
  4911.        smb_fn_name(type),smb_messages[match].time,
  4912.     (100.0*smb_messages[match].time) / total_time));
  4913. #endif
  4914.  
  4915.   return(outsize);
  4916. }
  4917.  
  4918.  
  4919. /****************************************************************************
  4920.   construct a chained reply and add it to the already made reply
  4921.   **************************************************************************/
  4922. int chain_reply(char *inbuf,char *outbuf,int size,int bufsize)
  4923. {
  4924.   static char *orig_inbuf;
  4925.   static char *orig_outbuf;
  4926.   int smb_com1, smb_com2 = CVAL(inbuf,smb_vwv0);
  4927.   unsigned smb_off2 = SVAL(inbuf,smb_vwv1);
  4928.   char *inbuf2, *outbuf2;
  4929.   int outsize2;
  4930.   char inbuf_saved[smb_wct];
  4931.   char outbuf_saved[smb_wct];
  4932.   extern int chain_size;
  4933.   int wct = CVAL(outbuf,smb_wct);
  4934.   int outsize = smb_size + 2*wct + SVAL(outbuf,smb_vwv0+2*wct);
  4935.  
  4936.   /* maybe its not chained */
  4937.   if (smb_com2 == 0xFF) {
  4938.     CVAL(outbuf,smb_vwv0) = 0xFF;
  4939.     return outsize;
  4940.   }
  4941.  
  4942.   if (chain_size == 0) {
  4943.     /* this is the first part of the chain */
  4944.     orig_inbuf = inbuf;
  4945.     orig_outbuf = outbuf;
  4946.   }
  4947.  
  4948.   /* we need to tell the client where the next part of the reply will be */
  4949.   SSVAL(outbuf,smb_vwv1,smb_offset(outbuf+outsize,outbuf));
  4950.   CVAL(outbuf,smb_vwv0) = smb_com2;
  4951.  
  4952.   /* remember how much the caller added to the chain, only counting stuff
  4953.      after the parameter words */
  4954.   chain_size += outsize - smb_wct;
  4955.  
  4956.   /* work out pointers into the original packets. The
  4957.      headers on these need to be filled in */
  4958.   inbuf2 = orig_inbuf + smb_off2 + 4 - smb_wct;
  4959.   outbuf2 = orig_outbuf + SVAL(outbuf,smb_vwv1) + 4 - smb_wct;
  4960.  
  4961.   /* remember the original command type */
  4962.   smb_com1 = CVAL(orig_inbuf,smb_com);
  4963.  
  4964.   /* save the data which will be overwritten by the new headers */
  4965.   memcpy(inbuf_saved,inbuf2,smb_wct);
  4966.   memcpy(outbuf_saved,outbuf2,smb_wct);
  4967.  
  4968.   /* give the new packet the same header as the last part of the SMB */
  4969.   memmove(inbuf2,inbuf,smb_wct);
  4970.  
  4971.   /* create the in buffer */
  4972.   CVAL(inbuf2,smb_com) = smb_com2;
  4973.  
  4974.   /* create the out buffer */
  4975.   bzero(outbuf2,smb_size);
  4976.   set_message(outbuf2,0,0,True);
  4977.   CVAL(outbuf2,smb_com) = CVAL(inbuf2,smb_com);
  4978.   
  4979.   memcpy(outbuf2+4,inbuf2+4,4);
  4980.   CVAL(outbuf2,smb_rcls) = SMB_SUCCESS;
  4981.   CVAL(outbuf2,smb_reh) = 0;
  4982.   CVAL(outbuf2,smb_flg) = 0x80 | (CVAL(inbuf2,smb_flg) & 0x8); /* bit 7 set 
  4983.                                   means a reply */
  4984.   SSVAL(outbuf2,smb_flg2,1); /* say we support long filenames */
  4985.   SSVAL(outbuf2,smb_err,SMB_SUCCESS);
  4986.   SSVAL(outbuf2,smb_tid,SVAL(inbuf2,smb_tid));
  4987.   SSVAL(outbuf2,smb_pid,SVAL(inbuf2,smb_pid));
  4988.   SSVAL(outbuf2,smb_uid,SVAL(inbuf2,smb_uid));
  4989.   SSVAL(outbuf2,smb_mid,SVAL(inbuf2,smb_mid));
  4990.  
  4991.   DEBUG(3,("Chained message\n"));
  4992.   show_msg(inbuf2);
  4993.  
  4994.   /* process the request */
  4995.   outsize2 = switch_message(smb_com2,inbuf2,outbuf2,size-chain_size,
  4996.                 bufsize-chain_size);
  4997.  
  4998.   /* copy the new reply and request headers over the old ones, but
  4999.      preserve the smb_com field */
  5000.   memmove(orig_outbuf,outbuf2,smb_wct);
  5001.   CVAL(orig_outbuf,smb_com) = smb_com1;
  5002.  
  5003.   /* restore the saved data, being careful not to overwrite any
  5004.    data from the reply header */
  5005.   memcpy(inbuf2,inbuf_saved,smb_wct);
  5006.   {
  5007.     int ofs = smb_wct - PTR_DIFF(outbuf2,orig_outbuf);
  5008.     if (ofs < 0) ofs = 0;
  5009.     memmove(outbuf2+ofs,outbuf_saved+ofs,smb_wct-ofs);
  5010.   }
  5011.  
  5012.   return outsize2;
  5013. }
  5014.  
  5015.  
  5016.  
  5017. /****************************************************************************
  5018.   construct a reply to the incoming packet
  5019. ****************************************************************************/
  5020. int construct_reply(char *inbuf,char *outbuf,int size,int bufsize)
  5021. {
  5022.   int type = CVAL(inbuf,smb_com);
  5023.   int outsize = 0;
  5024.   int msg_type = CVAL(inbuf,0);
  5025.   extern int chain_size;
  5026.  
  5027.   smb_last_time = time(NULL);
  5028.  
  5029.   chain_size = 0;
  5030.   chain_fnum = -1;
  5031.   reset_chain_pnum();
  5032.  
  5033.   bzero(outbuf,smb_size);
  5034.  
  5035.   if (msg_type != 0)
  5036.     return(reply_special(inbuf,outbuf));  
  5037.  
  5038.   CVAL(outbuf,smb_com) = CVAL(inbuf,smb_com);
  5039.   set_message(outbuf,0,0,True);
  5040.   
  5041.   memcpy(outbuf+4,inbuf+4,4);
  5042.   CVAL(outbuf,smb_rcls) = SMB_SUCCESS;
  5043.   CVAL(outbuf,smb_reh) = 0;
  5044.   CVAL(outbuf,smb_flg) = 0x80 | (CVAL(inbuf,smb_flg) & 0x8); /* bit 7 set 
  5045.                                  means a reply */
  5046.   SSVAL(outbuf,smb_flg2,1); /* say we support long filenames */
  5047.   SSVAL(outbuf,smb_err,SMB_SUCCESS);
  5048.   SSVAL(outbuf,smb_tid,SVAL(inbuf,smb_tid));
  5049.   SSVAL(outbuf,smb_pid,SVAL(inbuf,smb_pid));
  5050.   SSVAL(outbuf,smb_uid,SVAL(inbuf,smb_uid));
  5051.   SSVAL(outbuf,smb_mid,SVAL(inbuf,smb_mid));
  5052.  
  5053.   outsize = switch_message(type,inbuf,outbuf,size,bufsize);
  5054.  
  5055.   outsize += chain_size;
  5056.  
  5057.   if(outsize > 4)
  5058.     smb_setlen(outbuf,outsize - 4);
  5059.   return(outsize);
  5060. }
  5061.  
  5062. /****************************************************************************
  5063.   process commands from the client
  5064. ****************************************************************************/
  5065. static void process(void)
  5066. {
  5067.   extern int Client;
  5068.  
  5069.   InBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
  5070.   OutBuffer = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
  5071.   if ((InBuffer == NULL) || (OutBuffer == NULL)) 
  5072.     return;
  5073.  
  5074.   InBuffer += SMB_ALIGNMENT;
  5075.   OutBuffer += SMB_ALIGNMENT;
  5076.  
  5077. #if PRIME_NMBD
  5078.   DEBUG(3,("priming nmbd\n"));
  5079.   {
  5080.     struct in_addr ip;
  5081.     ip = *interpret_addr2("localhost");
  5082.     if (zero_ip(ip)) ip = *interpret_addr2("127.0.0.1");
  5083.     *OutBuffer = 0;
  5084.     send_one_packet(OutBuffer,1,ip,NMB_PORT,SOCK_DGRAM);
  5085.   }
  5086. #endif    
  5087.  
  5088.   /* re-initialise the timezone */
  5089.   TimeInit();
  5090.  
  5091.   while (True)
  5092.   {
  5093.     int deadtime = lp_deadtime()*60;
  5094.     int counter;
  5095.     int last_keepalive=0;
  5096.     int service_load_counter = 0;
  5097.     BOOL got_smb = False;
  5098.  
  5099.     if (deadtime <= 0)
  5100.       deadtime = DEFAULT_SMBD_TIMEOUT;
  5101.  
  5102. #if USE_READ_PREDICTION
  5103.     if (lp_readprediction())
  5104.       do_read_prediction();
  5105. #endif
  5106.  
  5107.     errno = 0;      
  5108.  
  5109.     for (counter=SMBD_SELECT_LOOP; 
  5110.           !receive_message_or_smb(Client,oplock_sock,
  5111.                       InBuffer,BUFFER_SIZE,SMBD_SELECT_LOOP*1000,&got_smb); 
  5112.           counter += SMBD_SELECT_LOOP)
  5113.     {
  5114.       int i;
  5115.       time_t t;
  5116.       BOOL allidle = True;
  5117.       extern int keepalive;
  5118.  
  5119.       if (counter > 365 * 3600) /* big number of seconds. */
  5120.       {
  5121.         counter = 0;
  5122.         service_load_counter = 0;
  5123.       }
  5124.  
  5125.       if (smb_read_error == READ_EOF) 
  5126.       {
  5127.         DEBUG(3,("end of file from client\n"));
  5128.         return;
  5129.       }
  5130.  
  5131.       if (smb_read_error == READ_ERROR) 
  5132.       {
  5133.         DEBUG(3,("receive_smb error (%s) exiting\n",
  5134.                   strerror(errno)));
  5135.         return;
  5136.       }
  5137.  
  5138.       t = time(NULL);
  5139.  
  5140.       /* become root again if waiting */
  5141.       unbecome_user();
  5142.  
  5143.       /* check for smb.conf reload */
  5144.       if (counter >= service_load_counter + SMBD_RELOAD_CHECK)
  5145.       {
  5146.         service_load_counter = counter;
  5147.  
  5148.         /* reload services, if files have changed. */
  5149.         reload_services(True);
  5150.       }
  5151.  
  5152.       /* automatic timeout if all connections are closed */      
  5153.       if (num_connections_open==0 && counter >= IDLE_CLOSED_TIMEOUT) 
  5154.       {
  5155.         DEBUG(2,("%s Closing idle connection\n",timestring()));
  5156.         return;
  5157.       }
  5158.  
  5159.       if (keepalive && (counter-last_keepalive)>keepalive) 
  5160.       {
  5161.           struct cli_state *cli = server_client();
  5162.           if (!send_keepalive(Client)) { 
  5163.               DEBUG(2,("%s Keepalive failed - exiting\n",timestring()));
  5164.               return;
  5165.           }        
  5166.           /* also send a keepalive to the password server if its still
  5167.          connected */
  5168.           if (cli && cli->initialised)
  5169.               send_keepalive(cli->fd);
  5170.           last_keepalive = counter;
  5171.       }
  5172.  
  5173.       /* check for connection timeouts */
  5174.       for (i=0;i<MAX_CONNECTIONS;i++)
  5175.         if (Connections[i].open)
  5176.         {
  5177.           /* close dirptrs on connections that are idle */
  5178.           if ((t-Connections[i].lastused)>DPTR_IDLE_TIMEOUT)
  5179.             dptr_idlecnum(i);
  5180.  
  5181.           if (Connections[i].num_files_open > 0 ||
  5182.                      (t-Connections[i].lastused)<deadtime)
  5183.             allidle = False;
  5184.         }
  5185.  
  5186.       if (allidle && num_connections_open>0) 
  5187.       {
  5188.         DEBUG(2,("%s Closing idle connection 2\n",timestring()));
  5189.         return;
  5190.       }
  5191.     }
  5192.  
  5193.     if(got_smb)
  5194.       process_smb(InBuffer, OutBuffer);
  5195.     else
  5196.       process_local_message(oplock_sock, InBuffer, BUFFER_SIZE);
  5197.   }
  5198. }
  5199.  
  5200.  
  5201. /****************************************************************************
  5202.   initialise connect, service and file structs
  5203. ****************************************************************************/
  5204. static void init_structs(void )
  5205. {
  5206.   int i;
  5207.   get_myname(myhostname,NULL);
  5208.  
  5209.   for (i=0;i<MAX_CONNECTIONS;i++)
  5210.     {
  5211.       Connections[i].open = False;
  5212.       Connections[i].num_files_open=0;
  5213.       Connections[i].lastused=0;
  5214.       Connections[i].used=False;
  5215.       string_init(&Connections[i].user,"");
  5216.       string_init(&Connections[i].dirpath,"");
  5217.       string_init(&Connections[i].connectpath,"");
  5218.       string_init(&Connections[i].origpath,"");
  5219.     }
  5220.  
  5221.   for (i=0;i<MAX_OPEN_FILES;i++)
  5222.     {
  5223.       Files[i].open = False;
  5224.       string_init(&Files[i].name,"");
  5225.  
  5226.     }
  5227.  
  5228.   for (i=0;i<MAX_OPEN_FILES;i++)
  5229.     {
  5230.       file_fd_struct *fd_ptr = &FileFd[i];
  5231.       fd_ptr->ref_count = 0;
  5232.       fd_ptr->dev = (int32)-1;
  5233.       fd_ptr->inode = (int32)-1;
  5234.       fd_ptr->fd = -1;
  5235.       fd_ptr->fd_readonly = -1;
  5236.       fd_ptr->fd_writeonly = -1;
  5237.       fd_ptr->real_open_flags = -1;
  5238.     }
  5239.  
  5240.   /* for RPC pipes */
  5241.   init_rpc_pipe_hnd();
  5242.  
  5243. #ifdef NTDOMAIN
  5244.   /* for LSA handles */
  5245.   init_lsa_policy_hnd();
  5246. #endif
  5247.  
  5248.   init_dptrs();
  5249. }
  5250.  
  5251. /****************************************************************************
  5252. usage on the program
  5253. ****************************************************************************/
  5254. static void usage(char *pname)
  5255. {
  5256.   DEBUG(0,("Incorrect program usage - are you sure the command line is correct?\n"));
  5257.  
  5258.   printf("Usage: %s [-D] [-p port] [-d debuglevel] [-l log basename] [-s services file]\n",pname);
  5259.   printf("Version %s\n",VERSION);
  5260.   printf("\t-D                    become a daemon\n");
  5261.   printf("\t-p port               listen on the specified port\n");
  5262.   printf("\t-d debuglevel         set the debuglevel\n");
  5263.   printf("\t-l log basename.      Basename for log/debug files\n");
  5264.   printf("\t-s services file.     Filename of services file\n");
  5265.   printf("\t-P                    passive only\n");
  5266.   printf("\t-a                    overwrite log file, don't append\n");
  5267.   printf("\n");
  5268. }
  5269.  
  5270.  
  5271. /****************************************************************************
  5272.   main program
  5273. ****************************************************************************/
  5274.  int main(int argc,char *argv[])
  5275. {
  5276.   extern BOOL append_log;
  5277.   /* shall I run as a daemon */
  5278.   BOOL is_daemon = False;
  5279.   int port = SMB_PORT;
  5280.   int opt;
  5281.   extern char *optarg;
  5282.   char pidFile[100];
  5283.  
  5284.   *pidFile = '\0';
  5285.  
  5286. #ifdef NEED_AUTH_PARAMETERS
  5287.   set_auth_parameters(argc,argv);
  5288. #endif
  5289.  
  5290. #ifdef SecureWare
  5291.   setluid(0);
  5292. #endif
  5293.  
  5294.   append_log = True;
  5295.  
  5296.   TimeInit();
  5297.  
  5298.   pstrcpy(debugf,SMBLOGFILE);  
  5299.  
  5300.   pstrcpy(remote_machine, "smb");
  5301.  
  5302.   setup_logging(argv[0],False);
  5303.  
  5304.   charset_initialise();
  5305.  
  5306.   /* make absolutely sure we run as root - to handle cases where people
  5307.      are crazy enough to have it setuid */
  5308. #ifdef USE_SETRES
  5309.   setresuid(0,0,0);
  5310. #else
  5311.   setuid(0);
  5312.   seteuid(0);
  5313.   setuid(0);
  5314.   seteuid(0);
  5315. #endif
  5316.  
  5317.   fault_setup((void (*)(void *))exit_server);
  5318.   signal(SIGTERM , SIGNAL_CAST dflt_sig);
  5319.  
  5320.   /* we want total control over the permissions on created files,
  5321.      so set our umask to 0 */
  5322.   umask(0);
  5323.  
  5324.   GetWd(OriginalDir);
  5325.  
  5326.   init_uid();
  5327.  
  5328.   /* this is for people who can't start the program correctly */
  5329.   while (argc > 1 && (*argv[1] != '-'))
  5330.     {
  5331.       argv++;
  5332.       argc--;
  5333.     }
  5334.  
  5335.   while ((opt = getopt(argc, argv, "O:i:l:s:d:Dp:hPaf:")) != EOF)
  5336.     switch (opt)
  5337.       {
  5338.       case 'f':
  5339.         strncpy(pidFile, optarg, sizeof(pidFile));
  5340.         break;
  5341.       case 'O':
  5342.     pstrcpy(user_socket_options,optarg);
  5343.     break;
  5344.       case 'i':
  5345.     pstrcpy(scope,optarg);
  5346.     break;
  5347.       case 'P':
  5348.     {
  5349.       extern BOOL passive;
  5350.       passive = True;
  5351.     }
  5352.     break;    
  5353.       case 's':
  5354.     pstrcpy(servicesf,optarg);
  5355.     break;
  5356.       case 'l':
  5357.     pstrcpy(debugf,optarg);
  5358.     break;
  5359.       case 'a':
  5360.     {
  5361.       extern BOOL append_log;
  5362.       append_log = !append_log;
  5363.     }
  5364.     break;
  5365.       case 'D':
  5366.     is_daemon = True;
  5367.     break;
  5368.       case 'd':
  5369.     if (*optarg == 'A')
  5370.       DEBUGLEVEL = 10000;
  5371.     else
  5372.       DEBUGLEVEL = atoi(optarg);
  5373.     break;
  5374.       case 'p':
  5375.     port = atoi(optarg);
  5376.     break;
  5377.       case 'h':
  5378.     usage(argv[0]);
  5379.     exit(0);
  5380.     break;
  5381.       default:
  5382.     usage(argv[0]);
  5383.     exit(1);
  5384.       }
  5385.  
  5386.   reopen_logs();
  5387.  
  5388.   DEBUG(2,("%s smbd version %s started\n",timestring(),VERSION));
  5389.   DEBUG(2,("Copyright Andrew Tridgell 1992-1997\n"));
  5390.  
  5391. #ifndef NO_GETRLIMIT
  5392. #ifdef RLIMIT_NOFILE
  5393.   {
  5394.     struct rlimit rlp;
  5395.     getrlimit(RLIMIT_NOFILE, &rlp);
  5396.     /*
  5397.      * Set the fd limit to be MAX_OPEN_FILES + 10 to account for the
  5398.      * extra fd we need to read directories, as well as the log files
  5399.      * and standard handles etc.
  5400.      */
  5401.     rlp.rlim_cur = (MAX_OPEN_FILES+10>rlp.rlim_max)? rlp.rlim_max:MAX_OPEN_FILES+10;
  5402.     setrlimit(RLIMIT_NOFILE, &rlp);
  5403.     getrlimit(RLIMIT_NOFILE, &rlp);
  5404.     DEBUG(3,("Maximum number of open files per session is %d\n",rlp.rlim_cur));
  5405.   }
  5406. #endif
  5407. #endif
  5408.  
  5409.   
  5410.   DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
  5411.     getuid(),getgid(),geteuid(),getegid()));
  5412.  
  5413.   if (sizeof(uint16) < 2 || sizeof(uint32) < 4)
  5414.     {
  5415.       DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
  5416.       exit(1);
  5417.     }
  5418.  
  5419.   init_structs();
  5420.  
  5421.   if (!reload_services(False))
  5422.     return(-1);    
  5423.  
  5424.   codepage_initialise(lp_client_code_page());
  5425.  
  5426.   pstrcpy(myworkgroup, lp_workgroup());
  5427.  
  5428. #ifndef NO_SIGNAL_TEST
  5429.   signal(SIGHUP,SIGNAL_CAST sig_hup);
  5430. #endif
  5431.  
  5432.   /* Setup the signals that allow the debug log level
  5433.      to by dynamically changed. */
  5434.  
  5435.   /* If we are using the malloc debug code we can't use
  5436.      SIGUSR1 and SIGUSR2 to do debug level changes. */
  5437.  
  5438. #ifndef MEM_MAN
  5439. #if defined(SIGUSR1)
  5440.   signal( SIGUSR1, SIGNAL_CAST sig_usr1 );
  5441. #endif /* SIGUSR1 */
  5442.    
  5443. #if defined(SIGUSR2)
  5444.   signal( SIGUSR2, SIGNAL_CAST sig_usr2 );
  5445. #endif /* SIGUSR2 */
  5446. #endif /* MEM_MAN */
  5447.  
  5448.   DEBUG(3,("%s loaded services\n",timestring()));
  5449.  
  5450.   if (!is_daemon && !is_a_socket(0))
  5451.     {
  5452.       DEBUG(0,("standard input is not a socket, assuming -D option\n"));
  5453.       is_daemon = True;
  5454.     }
  5455.  
  5456.   if (is_daemon)
  5457.     {
  5458.       DEBUG(3,("%s becoming a daemon\n",timestring()));
  5459.       become_daemon();
  5460.     }
  5461.  
  5462.   if (!directory_exist(lp_lockdir(), NULL)) {
  5463.       mkdir(lp_lockdir(), 0755);
  5464.   }
  5465.  
  5466.   if (*pidFile)
  5467.     {
  5468.       int     fd;
  5469.       char    buf[20];
  5470.  
  5471.       if ((fd = open(pidFile,
  5472. #ifdef O_NONBLOCK
  5473.          O_NONBLOCK | 
  5474. #endif
  5475.          O_CREAT | O_WRONLY | O_TRUNC, 0644)) < 0)
  5476.         {
  5477.            DEBUG(0,("ERROR: can't open %s: %s\n", pidFile, strerror(errno)));
  5478.            exit(1);
  5479.         }
  5480.       if(fcntl_lock(fd,F_SETLK,0,1,F_WRLCK)==False)
  5481.         {
  5482.           DEBUG(0,("ERROR: smbd is already running\n"));
  5483.           exit(1);
  5484.         }
  5485.       slprintf(buf, sizeof(buf)-1, "%u\n", (unsigned int) getpid());
  5486.       if (write(fd, buf, strlen(buf)) < 0)
  5487.         {
  5488.           DEBUG(0,("ERROR: can't write to %s: %s\n", pidFile, strerror(errno)));
  5489.           exit(1);
  5490.         }
  5491.       /* Leave pid file open & locked for the duration... */
  5492.     }
  5493.  
  5494.   if (!open_sockets(is_daemon,port))
  5495.     exit(1);
  5496.  
  5497.   if (!locking_init(0))
  5498.     exit(1);
  5499.  
  5500.   /* possibly reload the services file. */
  5501.   reload_services(True);
  5502.  
  5503.   max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
  5504.  
  5505.   if (*lp_rootdir())
  5506.     {
  5507.       if (sys_chroot(lp_rootdir()) == 0)
  5508.     DEBUG(2,("%s changed root to %s\n",timestring(),lp_rootdir()));
  5509.     }
  5510.  
  5511.   /* Setup the oplock IPC socket. */
  5512.   if(!open_oplock_ipc())
  5513.     exit(1);
  5514.  
  5515.   process();
  5516.   close_sockets();
  5517.  
  5518.   exit_server("normal exit");
  5519.   return(0);
  5520. }
  5521.  
  5522.  
  5523.