dir.c: Fixed double slash issue.

includes.h: Changed to ifdef FAST_SHARE_MODES.
ipc.c:  Changed lp_workgroup() to myworkgroup.
loadparm.c:  Added new shared mem parameters. Added Luke's fix.
locking.c: Rewrite to do share modes better (both fast and slow modes).
nameannounce.c:  Changed lp_workgroup() to myworkgroup. Added Luke's fix.
nameconf.c:  Changed lp_workgroup() to myworkgroup.
namedbname.c:  Improved debug.
namedbserver.c:  Changed lp_workgroup() to myworkgroup.
namedbsubnet.c:  Added Luke's fix - rewritten somewhat.
namedbwork.c:  Changed lp_workgroup() to myworkgroup.
nameelect.c:  Added Luke's fix - rewritten somewhat.
nameresp.c:  Stoped shadowing global.
nameserv.c:  Added Luke's fix - Improved debug.
nameservreply.c:  Improved debug.
namework.c:  Changed lp_workgroup() to myworkgroup.
nmbd.c:  Added Luke's fix - Changed lp_workgroup() to myworkgroup.
pipes.c:   Changed lp_workgroup() to myworkgroup.
proto.h:   Added Luke's fix, added smb_shm_ proto's.
reply.c:  Changed lp_workgroup() to myworkgroup.
server.c:  Rewrite to do share modes better (both fast and slow modes).
shmem.c:  Rewrite to do share modes better (both fast and slow modes).
smb.h:  Rewrite to do share modes better (both fast and slow modes).
status.c:  Rewrite to do share modes better (both fast and slow modes).
trans2.c:  Fixed double slash issue.
util.c:  Tidied up, created myworkgroup.
Jeremy Allison (jallison@whistle.com).

26 files changed, 1925 insertions, 916 deletions

diff --git a/source/include/includes.h b/source/include/includes.h
index e1ed3a58168..265e838be0d 100644
--- a/source/include/includes.h
+++ b/source/include/includes.h
@@ -481,6 +481,7 @@ char *mktemp(char *); /* No standard include */
 
 
 #ifdef FreeBSD
+#include <arpa/inet.h>
 #include <strings.h>
 #include <netinet/tcp.h>
 #include <netinet/in_systm.h>
@@ -970,7 +971,7 @@ typedef int mode_t;
 end of the platform specific sections
 ********************************************************************/
 
-#if defined(USE_MMAP) || FAST_SHARE_MODES
+#if defined(USE_MMAP) || defined(FAST_SHARE_MODES)
 #include <sys/mman.h>
 #endif
 
diff --git a/source/include/proto.h b/source/include/proto.h
index 973b1a15f39..1fa8c1d95e1 100644
--- a/source/include/proto.h
+++ b/source/include/proto.h
@@ -149,6 +149,7 @@ char *lp_socket_address(void);
 char *lp_nis_home_map_name(void);
 BOOL lp_wins_support(void);
 BOOL lp_wins_proxy(void);
+BOOL lp_local_master(void);
 BOOL lp_domain_master(void);
 BOOL lp_domain_logons(void);
 BOOL lp_preferred_master(void);
@@ -176,6 +177,8 @@ int lp_maxpacket(void);
 int lp_keepalive(void);
 int lp_passwordlevel(void);
 int lp_readsize(void);
+int lp_shmem_size(void);
+int lp_shmem_hash_size(void);
 int lp_deadtime(void);
 int lp_maxprotocol(void);
 int lp_security(void);
@@ -266,12 +269,12 @@ BOOL do_lock(int fnum,int cnum,uint32 count,uint32 offset,int *eclass,uint32 *ec
 BOOL do_unlock(int fnum,int cnum,uint32 count,uint32 offset,int *eclass,uint32 *ecode);
 BOOL start_share_mode_mgmt(void);
 BOOL stop_share_mode_mgmt(void);
-int get_share_mode_by_fnum(int cnum,int fnum,int *pid);
-int get_share_mode_byname(int cnum,char *fname,int *pid);
-int get_share_mode(int cnum,struct stat *sbuf,int *pid);
-void del_share_mode(int fnum);
-BOOL set_share_mode(int fnum,int mode);
-void clean_share_modes(void);
+BOOL lock_share_entry(int cnum, uint32 dev, uint32 inode, share_lock_token *);
+BOOL unlock_share_entry(int cnum, uint32 dev, uint32 inode, share_lock_token);
+int get_share_modes(int cnum, share_lock_token token, uint32 dev, uint32 inode, 
+                    min_share_mode_entry **old_shares);
+void del_share_mode(share_lock_token token, int fnum);
+BOOL set_share_mode(share_lock_token token, int fnum);
 
 /*The following definitions come from  mangle.c  */
 
@@ -309,7 +312,7 @@ void do_announce_host(int command,
 		char *to_name  , int to_type  , struct in_addr to_ip,
 		time_t announce_interval,
 		char *server_name, int server_type, char *server_comment);
-void remove_my_servers(void);
+void announce_my_servers_removed(void);
 void announce_server(struct subnet_record *d, struct work_record *work,
 		     char *name, char *comment, time_t ttl, int server_type);
 void announce_host(time_t t);
@@ -394,7 +397,7 @@ void expire_servers(time_t t);
 struct subnet_record *find_subnet(struct in_addr bcast_ip);
 struct subnet_record *find_req_subnet(struct in_addr ip, BOOL bcast);
 struct subnet_record *find_subnet_all(struct in_addr bcast_ip);
-void add_subnet_interfaces(void);
+void add_workgroup_to_subnet( struct subnet_record *d, char *group);
 void add_my_subnets(char *group);
 void write_browse_list(time_t t);
 
@@ -406,7 +409,6 @@ struct work_record *remove_workgroup(struct subnet_record *d,
 struct work_record *find_workgroupstruct(struct subnet_record *d, 
 					 fstring name, BOOL add);
 void dump_workgroups(void);
-int check_work_servertype(const char *work_name, int type_mask);
 
 /*The following definitions come from  nameelect.c  */
 
@@ -724,6 +726,11 @@ BOOL smb_shm_set_userdef_off(smb_shm_offset_t userdef_off);
 void * smb_shm_offset2addr(smb_shm_offset_t offset);
 BOOL smb_shm_lock(void);
 BOOL smb_shm_unlock(void);
+smb_shm_offset_t smb_shm_alloc(int size);
+smb_shm_offset_t smb_shm_addr2offset(void *addr);
+smb_shm_offset_t smb_shm_get_userdef_off(void);
+BOOL smb_shm_lock_hash_entry( unsigned int entry);
+BOOL smb_shm_unlock_hash_entry( unsigned int entry );
 BOOL smb_shm_get_usage(int *bytes_free,
 		   int *bytes_used,
 		   int *bytes_overhead);
diff --git a/source/include/smb.h b/source/include/smb.h
index 7cd2f5b0fef..e0c08183dbe 100644
--- a/source/include/smb.h
+++ b/source/include/smb.h
@@ -36,11 +36,16 @@
 #define BUFFER_SIZE (0xFFFF)
 #define SAFETY_MARGIN 1024
 
-/* size of shared memory used for share mode locking */
+/* Default size of shared memory used for share mode locking */
 #ifndef SHMEM_SIZE
 #define SHMEM_SIZE 102400
 #endif
 
+/* Default number of hash buckets used in shared memory share mode */
+#ifndef SHMEM_HASH_SIZE
+#define SHMEM_HASH_SIZE 113
+#endif
+
 #define NMB_PORT 137
 #define DGRAM_PORT 138
 #define SMB_PORT 139
@@ -295,8 +300,8 @@ typedef struct
 typedef struct
 {
   uint16 ref_count;
-  int32 dev;
-  int32 inode;
+  uint32 dev;
+  uint32 inode;
   int fd;
   int fd_readonly;
   int fd_writeonly;
@@ -320,7 +325,6 @@ typedef struct
   BOOL can_read;
   BOOL can_write;
   BOOL share_mode;
-  BOOL share_pending;
   BOOL print_file;
   BOOL modified;
   char *name;
@@ -420,19 +424,40 @@ struct interface
 	struct in_addr nmask;
 };
 
-/* share mode record in shared memory */
+/* share mode record pointed to in shared memory hash bucket */
 typedef struct
 {
-  smb_shm_offset_t next_offset; /* offset of next record in list in shared mem */
+  smb_shm_offset_t next_offset; /* offset of next record in chain from hash bucket */
   int locking_version;
+  int32 st_dev;
+  int32 st_ino;
+  int num_share_mode_entries;
+  smb_shm_offset_t share_mode_entries; /* Chain of share mode entries for this file */
+  char file_name[1];
+} share_mode_record;
+
+/* share mode entry pointed to by share_mode_record struct */
+typedef struct
+{
+  smb_shm_offset_t next_share_mode_entry;
+  int pid;
   int share_mode;
   struct timeval time;
+} share_mode_entry;
+
+/* struct returned by get_share_modes */
+typedef struct
+{
   int pid;
-  dev_t st_dev;
-  ino_t st_ino;
-  char file_name[1];   /* dynamically allocated with correct size */
-} share_mode_record;
+  int share_mode;
+  struct timeval time;
+} min_share_mode_entry;
+
+/* Token returned by lock_share_entry (actually ignored by FAST_SHARE_MODES code) */
+typedef int share_lock_token;
 
+/* Conversion to hash entry index from device and inode numbers. */
+#define HASH_ENTRY(dev,ino) ((( (uint32)(dev) )* ( (uint32)(ino) )) % lp_shmem_hash_size())
 
 /* this is used for smbstatus */
 struct connect_record
@@ -798,12 +823,15 @@ char *Strstr(char *s, char *p);
 #define SV_TYPE_DOMAIN_ENUM         0x80000000
 #define SV_TYPE_ALL                 0xFFFFFFFF  
 
-/* What server type are we currently  - JHT Says we ARE 4.20 */
+/* what server type are we currently  - JHT Says we ARE 4.20 */
+/* this was set by JHT in liaison with Jeremy Allison early 1997 */
+/* setting to 4.20 at same time as announcing ourselves as NT Server */
 /* History: */
 /* Version 4.0 - never made public */
 /* Version 4.10 - New to 1.9.16p2, lost in space 1.9.16p3 to 1.9.16p9 */
 /*		- Reappeared in 1.9.16p11 with fixed smbd services */
 /* Version 4.20 - To indicate that nmbd and browsing now works better */
+
 #define MAJOR_VERSION 0x04
 #define MINOR_VERSION 0x02
 
diff --git a/source/lib/util.c b/source/lib/util.c
index 3315f1a41a1..0ed08405ba7 100644
--- a/source/lib/util.c
+++ b/source/lib/util.c
@@ -73,6 +73,7 @@ pstring myhostname="";
 pstring user_socket_options="";   
 pstring sesssetup_user="";
 pstring myname = "";
+fstring myworkgroup = "";
 
 int smb_read_error = 0;
 
@@ -3431,7 +3432,7 @@ BOOL is_vetoed_name(char *name)
           nameptr++;
           continue;
         }
-      if(name_end = strchr(nameptr,'/')) 
+      if((name_end = strchr(nameptr,'/'))!=NULL) 
         {
           *name_end = 0;
         }
@@ -3472,7 +3473,7 @@ BOOL is_vetoed_path(char *name)
           nameptr++;
           continue;
         }
-      if(name_end = strchr(nameptr,'/')) 
+      if((name_end = strchr(nameptr,'/'))!=NULL) 
         {
           *name_end = 0;
         }
diff --git a/source/locking/locking.c b/source/locking/locking.c
index 7c23e5b3cab..e63e347a262 100644
--- a/source/locking/locking.c
+++ b/source/locking/locking.c
@@ -22,6 +22,9 @@
 
    12 aug 96: Erik.Devriendt@te6.siemens.be
    added support for shared memory implementation of share mode locking
+
+   May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
+   locking to deal with multiple share modes per open file.
 */
 
 #include "includes.h"
@@ -29,9 +32,6 @@ extern int DEBUGLEVEL;
 extern connection_struct Connections[];
 extern files_struct Files[];
 
-pstring share_del_pending="";
-
-
 /****************************************************************************
   utility function called to see if a file region is locked
 ****************************************************************************/
@@ -100,7 +100,7 @@ BOOL do_unlock(int fnum,int cnum,uint32 count,uint32 offset,int *eclass,uint32 *
   return True; /* Did unlock */
 }
 
-#if FAST_SHARE_MODES
+#ifdef FAST_SHARE_MODES
 /*******************************************************************
   initialize the shared memory for share_mode management 
   ******************************************************************/
@@ -114,7 +114,7 @@ BOOL start_share_mode_mgmt(void)
   trim_string(shmem_file_name,"","/");
   if (!*shmem_file_name) return(False);
   strcat(shmem_file_name, "/SHARE_MEM_FILE");
-  return smb_shm_open(shmem_file_name, SHMEM_SIZE);
+  return smb_shm_open(shmem_file_name, lp_shmem_size());
 }
 
 
@@ -126,459 +126,1118 @@ BOOL stop_share_mode_mgmt(void)
    return smb_shm_close();
 }
 
-#else
-
-/* SHARE MODE LOCKS USING SLOW DESCRIPTION FILES */
-
-/*******************************************************************
-  name a share file
-  ******************************************************************/
-static BOOL share_name(int cnum,struct stat *st,char *name)
-{
-  strcpy(name,lp_lockdir());
-  standard_sub(cnum,name);
-  trim_string(name,"","/");
-  if (!*name) return(False);
-  name += strlen(name);
-  
-  sprintf(name,"/share.%d.%d",(int)st->st_dev,(int)st->st_ino);
-  return(True);
-}
-
 /*******************************************************************
-  use the fnum to get the share file name
+  lock a hash bucket entry in shared memory for share_mode management 
   ******************************************************************/
-static BOOL share_name_fnum(int fnum,char *name)
+BOOL lock_share_entry(int cnum, uint32 dev, uint32 inode, share_lock_token *ptok)
 {
-  struct stat st;
-  if (fstat(Files[fnum].fd_ptr->fd,&st) != 0) return(False);
-  return(share_name(Files[fnum].cnum,&st,name));
+  return smb_shm_lock_hash_entry(HASH_ENTRY(dev, inode));
 }
 
-#endif
-
 /*******************************************************************
-  get the share mode of a file using the fnum
+  unlock a hash bucket entry in shared memory for share_mode management 
   ******************************************************************/
-int get_share_mode_by_fnum(int cnum,int fnum,int *pid)
+BOOL unlock_share_entry(int cnum, uint32 dev, uint32 inode, share_lock_token token)
 {
-  struct stat sbuf;
-  if (fstat(Files[fnum].fd_ptr->fd,&sbuf) == -1) return(0);
-  return(get_share_mode(cnum,&sbuf,pid));
+  return smb_shm_unlock_hash_entry(HASH_ENTRY(dev, inode));
 }
 
 /*******************************************************************
-  get the share mode of a file using the files name
-  ******************************************************************/
-int get_share_mode_byname(int cnum,char *fname,int *pid)
-{
-  struct stat sbuf;
-  if (stat(fname,&sbuf) == -1) return(0);
-  return(get_share_mode(cnum,&sbuf,pid));
-}  
-
-
-/*******************************************************************
-get the share mode of a file
+get all share mode entries in shared memory for a dev/inode pair.
 ********************************************************************/
-int get_share_mode(int cnum,struct stat *sbuf,int *pid)
+int get_share_modes(int cnum, share_lock_token token, uint32 dev, uint32 inode, 
+                    min_share_mode_entry **old_shares)
 {
-#if FAST_SHARE_MODES
-  share_mode_record *scanner_p;
-  share_mode_record *prev_p;
-  int ret;
+  smb_shm_offset_t *mode_array;
+  unsigned int hash_entry = HASH_ENTRY(dev, inode); 
+  share_mode_record *file_scanner_p;
+  share_mode_record *file_prev_p;
+  share_mode_entry *entry_scanner_p;
+  share_mode_entry *entry_prev_p;
+  int num_entries;
+  int num_entries_copied;
   BOOL found = False;
+  min_share_mode_entry *share_array = (min_share_mode_entry *)0;
 
-  *pid = 0;
+  *old_shares = 0;
 
-  if(!smb_shm_lock()) return (0);
+  if(hash_entry > lp_shmem_hash_size() )
+  {
+    DEBUG(0, 
+      ("PANIC ERROR : get_share_modes (FAST_SHARE_MODES): hash_entry %d too large \
+(max = %d)\n",
+      hash_entry, lp_shmem_hash_size() ));
+    abort();
+  }
 
-  scanner_p = (share_mode_record *)smb_shm_offset2addr(smb_shm_get_userdef_off());
-  prev_p = scanner_p;
-  while(scanner_p)
+  mode_array = (smb_shm_offset_t *)smb_shm_offset2addr(smb_shm_get_userdef_off());
+  
+  if(mode_array[hash_entry] == NULL_OFFSET)
   {
-     if( (scanner_p->st_dev == sbuf->st_dev) && (scanner_p->st_ino == sbuf->st_ino) )
+    DEBUG(5,("get_share_modes (FAST_SHARE_MODES): hash bucket %d empty\n", hash_entry));
+    return 0;
+  }
+
+  file_scanner_p = (share_mode_record *)smb_shm_offset2addr(mode_array[hash_entry]);
+  file_prev_p = file_scanner_p;
+  while(file_scanner_p)
+  {
+     if( (file_scanner_p->st_dev == dev) && (file_scanner_p->st_ino == inode) )
      {
 	found = True;
 	break;
      }
      else
      {
-	prev_p = scanner_p ;
-	scanner_p = (share_mode_record *)smb_shm_offset2addr(scanner_p->next_offset);
+	file_prev_p = file_scanner_p ;
+	file_scanner_p = (share_mode_record *)smb_shm_offset2addr(
+                                                file_scanner_p->next_offset);
      }
   }
   
   if(!found)
   {
-     smb_shm_unlock();
+     DEBUG(5,("get_share_modes (FAST_SHARE_MODES): no entry for \
+file dev = %d, ino = %d in hash_bucket %d\n", dev, inode, hash_entry));
      return (0);
   }
   
-  if(scanner_p->locking_version != LOCKING_VERSION)
+  if(file_scanner_p->locking_version != LOCKING_VERSION)
   {
-     DEBUG(2,("Deleting old share mode record due to old locking version %d",scanner_p->locking_version));
-     if(prev_p == scanner_p)
-	smb_shm_set_userdef_off(scanner_p->next_offset);
+     DEBUG(0,("ERROR:get_share_modes (FAST_SHARE_MODES): Deleting old share mode \
+record due to old locking version %d for file dev = %d, inode = %d in hash \
+bucket %d",file_scanner_p->locking_version, dev, inode, hash_entry));
+     if(file_prev_p == file_scanner_p)
+	mode_array[hash_entry] = file_scanner_p->next_offset;
      else
-	prev_p->next_offset = scanner_p->next_offset;
-     smb_shm_free(smb_shm_addr2offset(scanner_p));
-     *pid = 0;
-	
-     smb_shm_unlock();
+	file_prev_p->next_offset = file_scanner_p->next_offset;
+     smb_shm_free(smb_shm_addr2offset(file_scanner_p));
      return (0);
   }
-  
-  *pid = scanner_p->pid;
-  ret = scanner_p->share_mode;
 
-  if (*pid && !process_exists(*pid))
+  /* Allocate the old_shares array */
+  num_entries = file_scanner_p->num_share_mode_entries;
+  if(num_entries)
   {
-    ret = 0;
-    *pid = 0;
+    *old_shares = share_array = (min_share_mode_entry *)
+                 malloc(num_entries * sizeof(min_share_mode_entry));
+    if(*old_shares == 0)
+    {
+      DEBUG(0,("get_share_modes (FAST_SHARE_MODES): malloc fail !\n"));
+      return 0;
+    }
   }
+
+  num_entries_copied = 0;
   
-  if (! *pid)
+  entry_scanner_p = (share_mode_entry*)smb_shm_offset2addr(
+                                           file_scanner_p->share_mode_entries);
+  entry_prev_p = entry_scanner_p;
+  while(entry_scanner_p)
   {
-     if(prev_p == scanner_p)
-	smb_shm_set_userdef_off(scanner_p->next_offset);
-     else
-	prev_p->next_offset = scanner_p->next_offset;
-     smb_shm_free(smb_shm_addr2offset(scanner_p));
+    int pid = entry_scanner_p->pid;
+
+    if (pid && !process_exists(pid))
+    {
+      /* Delete this share mode entry */
+      share_mode_entry *delete_entry_p = entry_scanner_p;
+
+      if(entry_prev_p == entry_scanner_p)
+      {
+        /* We are at start of list */
+        file_scanner_p->share_mode_entries = entry_scanner_p->next_share_mode_entry;
+        entry_scanner_p = (share_mode_entry*)smb_shm_offset2addr(
+                                           file_scanner_p->share_mode_entries);
+        entry_prev_p = entry_scanner_p;
+      }
+      else
+      {
+        entry_prev_p->next_share_mode_entry = entry_scanner_p->next_share_mode_entry;
+        entry_scanner_p = (share_mode_entry*)
+                           smb_shm_offset2addr(entry_scanner_p->next_share_mode_entry);
+      }
+      /* Decrement the number of share mode entries on this share mode record */
+      file_scanner_p->num_share_mode_entries -= 1;
+
+      /* PARANOIA TEST */
+      if(file_scanner_p->num_share_mode_entries < 0)
+      {
+        DEBUG(0,("PANIC ERROR:get_share_mode (FAST_SHARE_MODES): num_share_mode_entries < 0 (%d) \
+for dev = %d, ino = %d, hashbucket %d\n", file_scanner_p->num_share_mode_entries,
+             dev, inode, hash_entry));
+        abort();
+      }
+
+      DEBUG(0,("get_share_modes (FAST_SHARE_MODES): process %d no longer exists and \
+it left a share mode entry with mode 0x%X for file dev = %d, ino = %d in hash \
+bucket (number of entries now = %d)\n", 
+            pid, entry_scanner_p->share_mode, dev, inode, hash_entry,
+            file_scanner_p->num_share_mode_entries));
+
+      smb_shm_free(smb_shm_addr2offset(delete_entry_p));
+    } 
+    else
+    {
+       /* This is a valid share mode entry and the process that
+           created it still exists. Copy it into the output array.
+       */
+       share_array[num_entries_copied].pid = entry_scanner_p->pid;
+       share_array[num_entries_copied].share_mode = entry_scanner_p->share_mode;
+       memcpy(&share_array[num_entries_copied].time, &entry_scanner_p->time,
+              sizeof(struct timeval));
+       num_entries_copied++;
+       DEBUG(5,("get_share_modes (FAST_SHARE_MODES): Read share mode \
+record mode 0x%X pid=%d\n", entry_scanner_p->share_mode, entry_scanner_p->pid));
+       entry_prev_p = entry_scanner_p;
+       entry_scanner_p = (share_mode_entry *)
+                           smb_shm_offset2addr(entry_scanner_p->next_share_mode_entry);
+    }
   }
   
-  if (*pid)
-    DEBUG(5,("Read share mode record mode 0x%X pid=%d\n",ret,*pid));
+  /* If no valid share mode entries were found then this record shouldn't exist ! */
+  if(num_entries_copied == 0)
+  {
+    DEBUG(0,("get_share_modes (FAST_SHARE_MODES): file with dev %d, inode %d in \
+hash bucket %d has a share mode record but no entries - deleting\n", 
+                 dev, inode, hash_entry));
+    if(*old_shares)
+      free((char *)old_shares);
+    *old_shares = 0;
+
+    if(file_prev_p == file_scanner_p)
+      mode_array[hash_entry] = file_scanner_p->next_offset;
+    else
+      file_prev_p->next_offset = file_scanner_p->next_offset;
+    smb_shm_free(smb_shm_addr2offset(file_scanner_p));
+  }
 
-  if(!smb_shm_unlock()) return (0);
-  
-  return(ret);
-  
-#else
-  pstring fname;
-  int fd2;
-  char buf[20];
-  int ret;
-  struct timeval t;
+  DEBUG(5,("get_share_modes (FAST_SHARE_MODES): file with dev %d, inode %d in \
+hash bucket %d returning %d entries\n", dev, inode, hash_entry,
+                         num_entries_copied));
+
+  return(num_entries_copied);
+}  
 
-  *pid = 0;
+/*******************************************************************
+del the share mode of a file.
+********************************************************************/
+void del_share_mode(share_lock_token token, int fnum)
+{
+  uint32 dev, inode;
+  smb_shm_offset_t *mode_array;
+  unsigned int hash_entry;
+  share_mode_record *file_scanner_p;
+  share_mode_record *file_prev_p;
+  share_mode_entry *entry_scanner_p;
+  share_mode_entry *entry_prev_p;
+  BOOL found = False;
+  int pid = getpid();
 
-  if (!share_name(cnum,sbuf,fname)) return(0);
+  dev = Files[fnum].fd_ptr->dev;
+  inode = Files[fnum].fd_ptr->inode;
 
-  fd2 = open(fname,O_RDONLY,0);
-  if (fd2 < 0) return(0);
+  hash_entry = HASH_ENTRY(dev, inode);
 
-  if (read(fd2,buf,20) != 20) {
-    DEBUG(2,("Failed to read share file %s\n",fname));
-    close(fd2);
-    unlink(fname);
-    return(0);
+  if(hash_entry > lp_shmem_hash_size() )
+  {
+    DEBUG(0,
+      ("PANIC ERROR:del_share_mode (FAST_SHARE_MODES): hash_entry %d too large \
+(max = %d)\n",
+      hash_entry, lp_shmem_hash_size() ));
+    abort();
   }
-  close(fd2);
 
-  t.tv_sec = IVAL(buf,4);
-  t.tv_usec = IVAL(buf,8);
-  ret = IVAL(buf,12);
-  *pid = IVAL(buf,16);
+  mode_array = (smb_shm_offset_t *)smb_shm_offset2addr(smb_shm_get_userdef_off());
+ 
+  if(mode_array[hash_entry] == NULL_OFFSET)
+  {  
+    DEBUG(0,("PANIC ERROR:del_share_mode (FAST_SHARE_MODES): hash bucket %d empty\n", 
+                  hash_entry));
+    abort();
+  }  
   
-  if (IVAL(buf,0) != LOCKING_VERSION) {    
-    if (!unlink(fname)) DEBUG(2,("Deleted old locking file %s",fname));
-    *pid = 0;
-    return(0);
-  }
+  file_scanner_p = (share_mode_record *)smb_shm_offset2addr(mode_array[hash_entry]);
+  file_prev_p = file_scanner_p;
 
-  if (*pid && !process_exists(*pid)) {
-    ret=0;
-    *pid = 0;
+  while(file_scanner_p)
+  {
+     if( (file_scanner_p->st_dev == dev) && (file_scanner_p->st_ino == inode) )
+     {
+	found = True;
+	break;
+     }
+     else
+     {
+	file_prev_p = file_scanner_p ;
+	file_scanner_p = (share_mode_record *)
+                          smb_shm_offset2addr(file_scanner_p->next_offset);
+     }
+  }
+    
+  if(!found)
+  {
+     DEBUG(0,("ERROR:del_share_mode (FAST_SHARE_MODES): no entry found for dev %d, \
+inode %d in hash bucket %d\n", dev, inode, hash_entry));
+     return;
+  }
+  
+  if(file_scanner_p->locking_version != LOCKING_VERSION)
+  {
+     DEBUG(0,("ERROR: del_share_modes (FAST_SHARE_MODES): Deleting old share mode \
+record due to old locking version %d for file dev %d, inode %d hash bucket %d\n",
+       file_scanner_p->locking_version, dev, inode, hash_entry ));
+     if(file_prev_p == file_scanner_p)
+	mode_array[hash_entry] = file_scanner_p->next_offset;
+     else
+	file_prev_p->next_offset = file_scanner_p->next_offset;
+     smb_shm_free(smb_shm_addr2offset(file_scanner_p));
+     return;
   }
 
-  if (! *pid) unlink(fname); /* XXXXX race, race */
+  found = False;
+  entry_scanner_p = (share_mode_entry*)smb_shm_offset2addr(
+                                           file_scanner_p->share_mode_entries);
+  entry_prev_p = entry_scanner_p;
+  while(entry_scanner_p)
+  {
+    if( (pid == entry_scanner_p->pid) && 
+          (memcmp(&entry_scanner_p->time, 
+                 &Files[fnum].open_time,sizeof(struct timeval)) == 0) )
+    {
+      found = True;
+      break;
+    }
+    else
+    {
+      entry_prev_p = entry_scanner_p;
+      entry_scanner_p = (share_mode_entry *)
+                          smb_shm_offset2addr(entry_scanner_p->next_share_mode_entry);
+    }
+  } 
 
-  if (*pid)
-    DEBUG(5,("Read share file %s mode 0x%X pid=%d\n",fname,ret,*pid));
+  if (found)
+  {
+    /* Decrement the number of entries in the record. */
+    file_scanner_p->num_share_mode_entries -= 1;
+
+    DEBUG(2,("del_share_modes (FAST_SHARE_MODES): \
+Deleting share mode entry dev = %d, inode = %d in hash bucket %d (num entries now = %d)\n",
+              dev, inode, hash_entry, file_scanner_p->num_share_mode_entries));
+    if(entry_prev_p == entry_scanner_p)
+      /* We are at start of list */
+      file_scanner_p->share_mode_entries = entry_scanner_p->next_share_mode_entry;
+    else
+      entry_prev_p->next_share_mode_entry = entry_scanner_p->next_share_mode_entry;
+    smb_shm_free(smb_shm_addr2offset(entry_scanner_p));
+
+    /* PARANOIA TEST */
+    if(file_scanner_p->num_share_mode_entries < 0)
+    {
+      DEBUG(0,("PANIC ERROR:del_share_mode (FAST_SHARE_MODES): num_share_mode_entries < 0 (%d) \
+for dev = %d, ino = %d, hashbucket %d\n", file_scanner_p->num_share_mode_entries,
+           dev, inode, hash_entry));
+      abort();
+    }
 
-  return(ret);
-#endif
+    /* If we deleted the last share mode entry then remove the share mode record. */
+    if(file_scanner_p->num_share_mode_entries == 0)
+      {
+      DEBUG(2,("del_share_modes (FAST_SHARE_MODES): num entries = 0, deleting share_mode \
+record dev = %d, inode = %d in hash bucket %d\n", dev, inode, hash_entry));
+      if(file_prev_p == file_scanner_p)
+	mode_array[hash_entry] = file_scanner_p->next_offset;
+      else
+	file_prev_p->next_offset = file_scanner_p->next_offset;
+      smb_shm_free(smb_shm_addr2offset(file_scanner_p));
+      }
+  }
+  else
+  {
+    DEBUG(0,("ERROR: del_share_modes (FAST_SHARE_MODES): No share mode record found \
+dev = %d, inode = %d in hash bucket %d\n", dev, inode, hash_entry));
+  }
 }
 
-
 /*******************************************************************
-del the share mode of a file, if we set it last
+set the share mode of a file. Return False on fail, True on success.
 ********************************************************************/
-void del_share_mode(int fnum)
+BOOL set_share_mode(share_lock_token token, int fnum)
 {
-#if FAST_SHARE_MODES
-  struct stat st;
-  struct timeval t;
-  int pid=0;
-  BOOL del = False;
-  share_mode_record *scanner_p;
-  share_mode_record *prev_p;
+  files_struct *fs_p = &Files[fnum];
+  int32 dev, inode;
+  smb_shm_offset_t *mode_array;
+  unsigned int hash_entry;
+  share_mode_record *file_scanner_p;
+  share_mode_record *file_prev_p;
+  share_mode_entry *new_entry_p;
+  smb_shm_offset_t new_entry_offset;
   BOOL found = False;
 
-  t.tv_sec = t.tv_usec = 0;
-  
-  if (fstat(Files[fnum].fd_ptr->fd,&st) != 0) return;
-  
-  if (!smb_shm_lock()) return;
+  dev = fs_p->fd_ptr->dev;
+  inode = fs_p->fd_ptr->inode;
+
+  hash_entry = HASH_ENTRY(dev, inode);
+  if(hash_entry > lp_shmem_hash_size() )
+  {
+    DEBUG(0,
+      ("PANIC ERROR:set_share_mode (FAST_SHARE_MODES): hash_entry %d too large \
+(max = %d)\n",
+      hash_entry, lp_shmem_hash_size() ));
+    abort();
+  }
+
+  mode_array = (smb_shm_offset_t *)smb_shm_offset2addr(smb_shm_get_userdef_off());
+
+  file_scanner_p = (share_mode_record *)smb_shm_offset2addr(mode_array[hash_entry]);
+  file_prev_p = file_scanner_p;
   
-  scanner_p = (share_mode_record *)smb_shm_offset2addr(smb_shm_get_userdef_off());
-  prev_p = scanner_p;
-  while(scanner_p)
+  while(file_scanner_p)
   {
-     if( (scanner_p->st_dev == st.st_dev) && (scanner_p->st_ino == st.st_ino) )
+     if( (file_scanner_p->st_dev == dev) && (file_scanner_p->st_ino == inode) )
      {
-	found = True;
-	break;
+        found = True;
+        break;
      }
      else
      {
-	prev_p = scanner_p ;
-	scanner_p = (share_mode_record *)smb_shm_offset2addr(scanner_p->next_offset);
+        file_prev_p = file_scanner_p ;
+        file_scanner_p = (share_mode_record *)
+                          smb_shm_offset2addr(file_scanner_p->next_offset);
      }
   }
-    
+  
   if(!found)
   {
-     smb_shm_unlock();
-     return;
+    /* We must create a share_mode_record */
+    share_mode_record *new_mode_p = NULL;
+    smb_shm_offset_t new_offset = smb_shm_alloc( sizeof(share_mode_record) +
+                                        strlen(fs_p->name) + 1);
+    if(new_offset == NULL_OFFSET)
+    {
+      DEBUG(0,("ERROR:set_share_mode (FAST_SHARE_MODES): smb_shm_alloc fail !\n"));
+      return False;
+    }
+    new_mode_p = smb_shm_offset2addr(new_offset);
+    new_mode_p->locking_version = LOCKING_VERSION;
+    new_mode_p->st_dev = dev;
+    new_mode_p->st_ino = inode;
+    new_mode_p->num_share_mode_entries = 0;
+    new_mode_p->share_mode_entries = NULL_OFFSET;
+    strcpy(new_mode_p->file_name, fs_p->name);
+
+    /* Chain onto the start of the hash chain (in the hope we will be used first). */
+    new_mode_p->next_offset = mode_array[hash_entry];
+    mode_array[hash_entry] = new_offset;
+
+    file_scanner_p = new_mode_p;
+
+    DEBUG(3,("set_share_mode (FAST_SHARE_MODES): Created share record for %s (dev %d \
+inode %d in hash bucket %d\n", fs_p->name, dev, inode, hash_entry));
+  }
+ 
+  /* Now create the share mode entry */ 
+  new_entry_offset = smb_shm_alloc( sizeof(share_mode_entry));
+  if(new_entry_offset == NULL_OFFSET)
+  {
+    smb_shm_offset_t delete_offset = mode_array[hash_entry];
+    DEBUG(0,("ERROR:set_share_mode (FAST_SHARE_MODES): smb_shm_alloc fail 1!\n"));
+    /* Unlink the damaged record */
+    mode_array[hash_entry] = file_scanner_p->next_offset;
+    /* And delete it */
+    smb_shm_free( delete_offset );
+    return False;
   }
-  
-  t.tv_sec = scanner_p->time.tv_sec;
-  t.tv_usec = scanner_p->time.tv_usec;
-  pid = scanner_p->pid;
-  
-  if( (scanner_p->locking_version != LOCKING_VERSION) || !pid || !process_exists(pid))
-    del = True;
 
-  if (!del && (memcmp(&t,&Files[fnum].open_time,sizeof(t)) == 0)
-      && pid==(int)getpid())
-    del = True;
+  new_entry_p = smb_shm_offset2addr(new_entry_offset);
 
-  if (del)
+  new_entry_p->pid = getpid();
+  new_entry_p->share_mode = fs_p->share_mode;
+  memcpy( (char *)&new_entry_p->time, (char *)&fs_p->open_time, sizeof(struct timeval));
+
+  /* Chain onto the share_mode_record */
+  new_entry_p->next_share_mode_entry = file_scanner_p->share_mode_entries;
+  file_scanner_p->share_mode_entries = new_entry_offset;
+
+  /* PARANOIA TEST */
+  if(file_scanner_p->num_share_mode_entries < 0)
   {
-     DEBUG(2,("Deleting share mode record\n"));
-     if(prev_p == scanner_p)
-	smb_shm_set_userdef_off(scanner_p->next_offset);
-     else
-	prev_p->next_offset = scanner_p->next_offset;
-     smb_shm_free(smb_shm_addr2offset(scanner_p));
-	
+    DEBUG(0,("PANIC ERROR:set_share_mode (FAST_SHARE_MODES): num_share_mode_entries < 0 (%d) \
+for dev = %d, ino = %d, hashbucket %d\n", file_scanner_p->num_share_mode_entries,
+         dev, inode, hash_entry));
+    abort();
   }
 
-  smb_shm_unlock();
-  return;
+  /* Increment the share_mode_entries counter */
+  file_scanner_p->num_share_mode_entries += 1;
+
+  DEBUG(3,("set_share_mode (FAST_SHARE_MODES): Created share entry for %s with mode \
+0x%X pid=%d (num_entries now = %d)\n",fs_p->name, fs_p->share_mode, new_entry_p->pid,
+                             file_scanner_p->num_share_mode_entries));
+
+  return(True);
+}
+
+#else /* FAST_SHARE_MODES */
+
+/* SHARE MODE LOCKS USING SLOW DESCRIPTION FILES */
 
-#else
+/*******************************************************************
+  name a share file
+  ******************************************************************/
+static BOOL share_name(int cnum, uint32 dev, uint32 inode, char *name)
+{
+  strcpy(name,lp_lockdir());
+  standard_sub(cnum,name);
+  trim_string(name,"","/");
+  if (!*name) return(False);
+  name += strlen(name);
+  
+  sprintf(name,"/share.%u.%u",dev,inode);
+  return(True);
+}
+
+/*******************************************************************
+  lock a share mode file.
+  ******************************************************************/
+BOOL lock_share_entry(int cnum, uint32 dev, uint32 inode, share_lock_token *ptok)
+{
   pstring fname;
-  int fd2;
-  char buf[20];
-  struct timeval t;
-  int pid=0;
-  BOOL del = False;
-
-  t.tv_sec = t.tv_usec = 0;
-  if (!share_name_fnum(fnum,fname)) return;
-
-  fd2 = open(fname,O_RDONLY,0);
-  if (fd2 < 0) return;
-  if (read(fd2,buf,20) != 20)
-    del = True;
-  close(fd2);
-
-  if (!del) {
-    t.tv_sec = IVAL(buf,4);
-    t.tv_usec = IVAL(buf,8);
-    pid = IVAL(buf,16);
-  }
-
-  if (!del)
-    if (IVAL(buf,0) != LOCKING_VERSION || !pid || !process_exists(pid))
-      del = True;
-
-  if (!del && (memcmp(&t,&Files[fnum].open_time,sizeof(t)) == 0) && (pid==(int)getpid()))
-    del = True;
-
-  if (del) {
-    if (!unlink(fname)) 
-      DEBUG(2,("Deleted share file %s\n",fname));
-    else {
-      DEBUG(3,("Pending delete share file %s\n",fname));
-      if (*share_del_pending) DEBUG(0,("Share del clash!\n"));
-      strcpy(share_del_pending,fname);
+  int fd;
+
+  *ptok = (share_lock_token)-1;
+
+  if(!share_name(cnum, dev, inode, fname))
+    return False;
+
+  {
+    int old_umask;
+    unbecome_user();
+    old_umask = umask(0);
+#ifdef SECURE_SHARE_MODES
+    fd = (share_lock_token)open(fname,O_RDWR|O_CREAT,0600);
+#else /* SECURE_SHARE_MODES */
+    fd = (share_lock_token)open(fname,O_RDWR|O_CREAT,0644);
+#endif /* SECURE_SHARE_MODES */
+    umask(old_umask);
+    if(!become_user(cnum,Connections[cnum].vuid))
+    {
+      DEBUG(0,("lock_share_entry: Can't become connected user!\n"));
+      close(fd);
+      return False;
+    }
+    /* We need to change directory back to the connection root. */
+    if (ChDir(Connections[cnum].connectpath) != 0)
+    {
+      DEBUG(0,("lock_share_entry: Can't change directory to %s (%s)\n",
+              Connections[cnum].connectpath, strerror(errno)));
+      close(fd);
+      return False;  
     }
   }
-#endif
+
+  /* At this point we have an open fd to the share mode file. 
+     Lock the first byte exclusively to signify a lock. */
+  if(fcntl_lock(fd, F_SETLKW, 0, 1, F_WRLCK) == False)
+   {
+      DEBUG(0,("ERROR lock_share_entry: fcntl_lock failed with %s\n",
+                  strerror(errno)));   
+      close(fd);
+      return False;
+   }
+
+   *ptok = (share_lock_token)fd;
+   return True;
 }
-  
 
 /*******************************************************************
-set the share mode of a file
+  unlock a share mode file.
+  ******************************************************************/
+BOOL unlock_share_entry(int cnum, uint32 dev, uint32 inode, share_lock_token token)
+{
+  int fd = (int)token;
+  int ret = True;
+
+  /* token is the fd of the open share mode file. */
+  /* Unlock the first byte. */
+  if(fcntl_lock(fd, F_SETLKW, 0, 1, F_UNLCK) == False)
+   { 
+      DEBUG(0,("ERROR unlock_share_entry: fcntl_lock failed with %s\n",
+                      strerror(errno)));   
+      ret = False;
+   }
+ 
+  close((int)token);
+  return ret;
+}
+
+/*******************************************************************
+Force a share file to be deleted.
 ********************************************************************/
-BOOL set_share_mode(int fnum,int mode)
+
+static int delete_share_file( int cnum, char *fname )
 {
-#if FAST_SHARE_MODES
-  int pid = (int)getpid();
-  struct stat st;
-  smb_shm_offset_t new_off;
-  share_mode_record *new_p;
+  unbecome_user();
+  if(unlink(fname) != 0)
+  {
+    DEBUG(0,("delete_share_file: Can't delete share file %s (%s)\n",
+            fname, strerror(errno)));
+  }
+
+  DEBUG(5,("delete_share_file: Deleted share file %s\n", fname));
+
+  if(!become_user(cnum,Connections[cnum].vuid))
+  {
+    DEBUG(0,("delete_share_file: Can't become connected user!\n"));
+    return -1;
+  }
+  /* We need to change directory back to the connection root. */
+  if (ChDir(Connections[cnum].connectpath) != 0)
+  {
+    DEBUG(0,("delete_share_file: Can't change directory to %s (%s)\n",
+            Connections[cnum].connectpath, strerror(errno)));
+    return -1;  
+  }
+  return 0;
+}
+
+/*******************************************************************
+Read a share file into a buffer.
+********************************************************************/
+
+static int read_share_file(int cnum, int fd, char *fname, char **out, BOOL *p_new_file)
+{
+  struct stat sb;
+  char *buf;
+  int size;
+
+  *out = 0;
+  *p_new_file = False;
+
+  if(fstat(fd, &sb) != 0)
+  {
+    DEBUG(0,("ERROR: read_share_file: Failed to do stat on share file %s (%s)\n",
+                  fname, strerror(errno)));
+    return -1;
+  }
+
+  if(sb.st_size == 0)
+  {
+     *p_new_file = True;
+     return 0;
+  }
+
+  /* Allocate space for the file */
+  if((buf = (char *)malloc(sb.st_size)) == NULL)
+  {
+    DEBUG(0,("read_share_file: malloc for file size %d fail !\n", sb.st_size));
+    return -1;
+  }
   
+  if(lseek(fd, 0, SEEK_SET) != 0)
+  {
+    DEBUG(0,("ERROR: read_share_file: Failed to reset position to 0 \
+for share file %s (%s)\n", fname, strerror(errno)));
+    if(buf)
+      free(buf);
+    return -1;
+  }
   
-  if (fstat(Files[fnum].fd_ptr->fd,&st) != 0) return(False);
+  if (read(fd,buf,sb.st_size) != sb.st_size)
+  {
+    DEBUG(0,("ERROR: read_share_file: Failed to read share file %s (%s)\n",
+               fname, strerror(errno)));
+    if(buf)
+      free(buf);
+    return -1;
+  }
   
-  if (!smb_shm_lock()) return (False);
-  new_off = smb_shm_alloc(sizeof(share_mode_record) + strlen(Files[fnum].name) );
-  if (new_off == NULL_OFFSET) return (False);
-  new_p = (share_mode_record *)smb_shm_offset2addr(new_off);
-  new_p->locking_version = LOCKING_VERSION;
-  new_p->share_mode = mode;
-  new_p->time.tv_sec = Files[fnum].open_time.tv_sec;
-  new_p->time.tv_usec = Files[fnum].open_time.tv_usec;
-  new_p->pid = pid;
-  new_p->st_dev = st.st_dev;
-  new_p->st_ino = st.st_ino;
-  strcpy(new_p->file_name,Files[fnum].name);
-  new_p->next_offset = smb_shm_get_userdef_off();
-  smb_shm_set_userdef_off(new_off);
-
-
-  DEBUG(3,("Created share record for %s with mode 0x%X pid=%d\n",Files[fnum].name,mode,pid));
-
-  if (!smb_shm_unlock()) return (False);
-  return(True);
+  if (IVAL(buf,0) != LOCKING_VERSION) {
+    DEBUG(0,("ERROR: read_share_file: share file %s has incorrect \
+locking version (was %d, should be %d).\n",fname, IVAL(buf,0), LOCKING_VERSION));
+    if(buf)
+      free(buf);
+    delete_share_file(cnum, fname);
+    return -1;
+  }
+
+  /* Sanity check for file contents */
+  size = sb.st_size;
+  size -= 10; /* Remove the header */
+
+  /* Remove the filename component. */
+  size -= SVAL(buf, 8);
+
+  /* The remaining size must be a multiple of 16 - error if not. */
+  if((size % 16) != 0)
+  {
+    DEBUG(0,("ERROR: read_share_file: share file %s is an incorrect length - \
+deleting it.\n", fname));
+    if(buf)
+      free(buf);
+    delete_share_file(cnum, fname);
+    return -1;
+  }
 
-#else
+  *out = buf;
+  return 0;
+}
+
+/*******************************************************************
+get all share mode entries in a share file for a dev/inode pair.
+********************************************************************/
+int get_share_modes(int cnum, share_lock_token token, uint32 dev, uint32 inode, 
+                    min_share_mode_entry **old_shares)
+{
+  int fd = (int)token;
   pstring fname;
-  int fd2;
-  char buf[20];
-  int pid = (int)getpid();
+  int i;
+  int num_entries;
+  int num_entries_copied;
+  int newsize;
+  min_share_mode_entry *share_array;
+  char *buf = 0;
+  char *base = 0;
+  BOOL new_file;
+
+  *old_shares = 0;
+
+  /* Read the share file header - this is of the form:
+     0   -  locking version.
+     4   -  number of share mode entries.
+     8   -  2 byte name length
+     [n bytes] file name (zero terminated).
 
-  if (!share_name_fnum(fnum,fname)) return(False);
+   Followed by <n> share mode entries of the form :
 
+     0   -  tv_sec
+     4   -  tv_usec
+     8   -  share_mode
+    12   -  pid
+
+  */
+
+  share_name(cnum, dev, inode, fname);
+
+  if(read_share_file( cnum, fd, fname, &buf, &new_file) != 0)
   {
-    int old_umask = umask(0);
-    fd2 = open(fname,O_WRONLY|O_CREAT|O_TRUNC,0644);
-    umask(old_umask);
+    DEBUG(0,("ERROR: get_share_modes: Failed to read share file %s\n",
+                  fname));
+    return 0;
   }
-  if (fd2 < 0) {
-    DEBUG(2,("Failed to create share file %s\n",fname));
-    return(False);
+
+  if(new_file == True)
+    return 0;
+
+  num_entries = IVAL(buf,4);
+
+  DEBUG(5,("get_share_modes: share file %s has %d share mode entries.\n",
+            fname, num_entries));
+
+  /* PARANOIA TEST */
+  if(num_entries < 0)
+  {
+    DEBUG(0,("PANIC ERROR:get_share_mode: num_share_mode_entries < 0 (%d) \
+for share file %d\n", num_entries, fname));
+    abort();
   }
 
-  SIVAL(buf,0,LOCKING_VERSION);
-  SIVAL(buf,4,Files[fnum].open_time.tv_sec);
-  SIVAL(buf,8,Files[fnum].open_time.tv_usec);
-  SIVAL(buf,12,mode);
-  SIVAL(buf,16,pid);
+  if(num_entries)
+  {
+    *old_shares = share_array = (min_share_mode_entry *)
+                 malloc(num_entries * sizeof(min_share_mode_entry));
+    if(*old_shares == 0)
+    {
+      DEBUG(0,("get_share_modes: malloc fail !\n"));
+      return 0;
+    }
+  } 
+  else
+  {
+    /* No entries - just delete the file. */
+    DEBUG(0,("get_share_modes: share file %s has no share mode entries - deleting.\n",
+              fname));
+    if(buf)
+      free(buf);
+    delete_share_file(cnum, fname);
+    return 0;
+  }
 
-  if (write(fd2,buf,20) != 20) {
-    DEBUG(2,("Failed to write share file %s\n",fname));
-    close(fd2);
-    unlink(fname);
-    return(False);
+  num_entries_copied = 0;
+  base = buf + 10 + SVAL(buf,8);
+
+  for( i = 0; i < num_entries; i++)
+  {
+    int pid;
+    char *p = base + (i*16);
+
+    pid = IVAL(p,12);
+
+    if(!process_exists(pid))
+    {
+      DEBUG(0,("get_share_modes: process %d no longer exists and \
+it left a share mode entry with mode 0x%X in share file %s\n",
+            pid, IVAL(p,8), fname));
+      continue;
+    }
+    share_array[num_entries_copied].time.tv_sec = IVAL(p,0);
+    share_array[num_entries_copied].time.tv_usec = IVAL(p,4);
+    share_array[num_entries_copied].share_mode = IVAL(p,8);
+    share_array[num_entries_copied].pid = pid;
+
+    num_entries_copied++;
   }
 
-  write(fd2,Files[fnum].name,strlen(Files[fnum].name)+1);
+  if(num_entries_copied == 0)
+  {
+    /* Delete the whole file. */
+    DEBUG(0,("get_share_modes: share file %s had no valid entries - deleting it !\n",
+             fname));
+    if(*old_shares)
+      free((char *)old_shares);
+    if(buf)
+      free(buf);
+    delete_share_file(cnum, fname);
+    return 0;
+  }
 
-  close(fd2);
+  /* If we deleted some entries we need to re-write the whole number of
+     share mode entries back into the file. */
 
-  DEBUG(3,("Created share file %s with mode 0x%X pid=%d\n",fname,mode,pid));
+  if(num_entries_copied != num_entries)
+  {
+    if(lseek(fd, 0, SEEK_SET) != 0)
+    {
+      DEBUG(0,("ERROR: get_share_modes: lseek failed to reset to \
+position 0 for share mode file %s (%s)\n", fname, strerror(errno)));
+      if(*old_shares)
+        free((char *)old_shares);
+      if(buf)
+        free(buf);
+      return 0;
+    }
 
-  return(True);
-#endif
+    SIVAL(buf, 4, num_entries_copied);
+    for( i = 0; i < num_entries_copied; i++)
+    {
+      char *p = base + (i*16);
+
+      SIVAL(p,12,share_array[i].pid);
+      SIVAL(p,8,share_array[i].share_mode);
+      SIVAL(p,0,share_array[i].time.tv_sec);
+      SIVAL(p,4,share_array[i].time.tv_usec);
+    }
+
+    newsize = (base - buf) + (16*num_entries_copied);
+    if(write(fd, buf, newsize) != newsize)
+    {
+      DEBUG(0,("ERROR: get_share_modes: failed to re-write share \
+mode file %s (%s)\n", fname, strerror(errno)));
+      if(*old_shares)
+        free((char *)old_shares);
+      if(buf)
+        free(buf);
+      return 0;
+    }
+    /* Now truncate the file at this point. */
+    if(ftruncate(fd, newsize)!= 0)
+    {
+      DEBUG(0,("ERROR: get_share_modes: failed to ftruncate share \
+mode file %s to size %d (%s)\n", fname, newsize, strerror(errno)));
+      if(*old_shares)
+        free((char *)old_shares);
+      if(buf)
+        free(buf);
+      return 0;
+    }
+  }
+
+  if(buf)
+    free(buf);
+
+  DEBUG(5,("get_share_modes: Read share file %s returning %d entries\n",fname,
+            num_entries_copied));
+
+  return num_entries_copied;
 }
-  
 
 /*******************************************************************
-cleanup any stale share files
+del a share mode from a share mode file.
 ********************************************************************/
-void clean_share_modes(void)
+void del_share_mode(share_lock_token token, int fnum)
 {
-#ifdef USE_SHMEM
-  share_mode_record *scanner_p;
-  share_mode_record *prev_p;
+  pstring fname;
+  int fd = (int)token;
+  char *buf = 0;
+  char *base = 0;
+  int num_entries;
+  int newsize;
+  int i;
+  files_struct *fs_p = &Files[fnum];
   int pid;
-  
-  if (!smb_shm_lock()) return;
-  
-  scanner_p = (share_mode_record *)smb_shm_offset2addr(smb_shm_get_userdef_off());
-  prev_p = scanner_p;
-  while(scanner_p)
+  BOOL deleted = False;
+  BOOL new_file;
+
+  share_name(fs_p->cnum, fs_p->fd_ptr->dev, 
+                       fs_p->fd_ptr->inode, fname);
+
+  if(read_share_file( fs_p->cnum, fd, fname, &buf, &new_file) != 0)
   {
-     pid = scanner_p->pid;
-     
-     if( (scanner_p->locking_version != LOCKING_VERSION) || !process_exists(pid))
-     {
-	DEBUG(2,("Deleting stale share mode record"));
-	if(prev_p == scanner_p)
-	{
-	   smb_shm_set_userdef_off(scanner_p->next_offset);
-	   smb_shm_free(smb_shm_addr2offset(scanner_p));
-           scanner_p = (share_mode_record *)smb_shm_offset2addr(smb_shm_get_userdef_off());
-           prev_p = scanner_p;
-	}
-	else
-	{
-	   prev_p->next_offset = scanner_p->next_offset;
-  	   smb_shm_free(smb_shm_addr2offset(scanner_p));
-           scanner_p = (share_mode_record *)smb_shm_offset2addr(prev_p->next_offset);
-	}
-	
-     }
-     else
-     {
-	prev_p = scanner_p ;
-	scanner_p = (share_mode_record *)smb_shm_offset2addr(scanner_p->next_offset);
-     }
+    DEBUG(0,("ERROR: del_share_mode: Failed to read share file %s\n",
+                  fname));
+    return;
   }
-    
 
-  smb_shm_unlock();
-  return;
-  
-#else
-  char *lockdir = lp_lockdir();
-  void *dir;
-  char *s;
+  if(new_file == True)
+  {
+    DEBUG(0,("ERROR:del_share_mode: share file %s is new (size zero), deleting it.\n",
+              fname));
+    delete_share_file(fs_p->cnum, fname);
+    return;
+  }
 
-  if (!*lockdir) return;
+  num_entries = IVAL(buf,4);
 
-  dir = opendir(lockdir);
-  if (!dir) return;
+  DEBUG(5,("del_share_mode: share file %s has %d share mode entries.\n",
+            fname, num_entries));
 
-  while ((s=readdirname(dir))) {
-    char buf[20];
-    int pid;
-    int fd;
-    pstring lname;
-    int dev,inode;
+  /* PARANOIA TEST */
+  if(num_entries < 0)
+  {
+    DEBUG(0,("PANIC ERROR:del_share_mode: num_share_mode_entries < 0 (%d) \
+for share file %d\n", num_entries, fname));
+    abort();
+  }
 
-    if (sscanf(s,"share.%d.%d",&dev,&inode)!=2) continue;
+  if(num_entries == 0)
+  {
+    /* No entries - just delete the file. */
+    DEBUG(0,("del_share_mode: share file %s has no share mode entries - deleting.\n",
+              fname));
+    if(buf)
+      free(buf);
+    delete_share_file(fs_p->cnum, fname);
+    return;
+  }
 
-    strcpy(lname,lp_lockdir());
-    trim_string(lname,NULL,"/");
-    strcat(lname,"/");
-    strcat(lname,s);
+  pid = getpid();
 
-    fd = open(lname,O_RDONLY,0);
-    if (fd < 0) continue;
+  /* Go through the entries looking for the particular one
+     we have set - delete it.
+  */
 
-    if (read(fd,buf,20) != 20) {
-      close(fd);
-      if (!unlink(lname))
-	printf("Deleted corrupt share file %s\n",s);
+  base = buf + 10 + SVAL(buf,8);
+
+  for(i = 0; i < num_entries; i++)
+  {
+    char *p = base + (i*16);
+
+    if((IVAL(p,0) != fs_p->open_time.tv_sec) || (IVAL(p,4) != fs_p->open_time.tv_usec) ||
+        (IVAL(p,8) != fs_p->share_mode) || (IVAL(p,12) != pid))
       continue;
+
+    DEBUG(5,("del_share_mode: deleting entry number %d (of %d) from the share file %s\n",
+             i, num_entries, fname));
+
+    /* Remove this entry. */
+    if(i != num_entries - 1)
+      memcpy(p, p + 16, (num_entries - i - 1)*16);
+
+    deleted = True;
+    break;
+  }
+
+  if(!deleted)
+  {
+    DEBUG(0,("del_share_mode: entry not found in share file %s\n", fname));
+    if(buf)
+      free(buf);
+    return;
+  }
+
+  num_entries--;
+  SIVAL(buf,4, num_entries);
+
+  if(num_entries == 0)
+  {
+    /* Deleted the last entry - remove the file. */
+    DEBUG(5,("del_share_mode: removed last entry in share file - deleting share file %s\n",
+             fname));
+    if(buf)
+      free(buf);
+    delete_share_file(fs_p->cnum,fname);
+    return;
+  }
+
+  /* Re-write the file - and truncate it at the correct point. */
+  if(lseek(fd, 0, SEEK_SET) != 0)
+    {
+      DEBUG(0,("ERROR: del_share_mode: lseek failed to reset to \
+position 0 for share mode file %s (%s)\n", fname, strerror(errno)));
+      if(buf)
+        free(buf);
+      return;
     }
-    close(fd);
 
-    pid = IVAL(buf,16);
+  newsize = (base - buf) + (16*num_entries);
+  if(write(fd, buf, newsize) != newsize)
+    {
+      DEBUG(0,("ERROR: del_share_mode: failed to re-write share \
+mode file %s (%s)\n", fname, strerror(errno)));
+      if(buf)
+        free(buf);
+      return;
+    }
+  /* Now truncate the file at this point. */
+  if(ftruncate(fd, newsize) != 0)
+  {
+    DEBUG(0,("ERROR: del_share_mode: failed to ftruncate share \
+mode file %s to size %d (%s)\n", fname, newsize, strerror(errno)));
+    if(buf)
+      free(buf);
+    return;
+  }
+}
+  
+/*******************************************************************
+set the share mode of a file
+********************************************************************/
+BOOL set_share_mode(share_lock_token token,int fnum)
+{
+  files_struct *fs_p = &Files[fnum];
+  pstring fname;
+  int fd = (int)token;
+  int pid = (int)getpid();
+  struct stat sb;
+  char *buf;
+  int num_entries;
+  int header_size;
+  char *p;
+
+  share_name(fs_p->cnum, fs_p->fd_ptr->dev,
+                       fs_p->fd_ptr->inode, fname);
+
+  if(fstat(fd, &sb) != 0)
+  {
+    DEBUG(0,("ERROR: set_share_mode: Failed to do stat on share file %s\n",
+                  fname));
+    return False;
+  }
 
-    if (IVAL(buf,0) != LOCKING_VERSION || !process_exists(pid)) {
-      if (!unlink(lname))
-	printf("Deleted stale share file %s\n",s);
+  /* Sanity check for file contents (if it's not a new share file). */
+  if(sb.st_size != 0)
+  {
+    int size = sb.st_size;
+
+    /* Allocate space for the file plus one extra entry */
+    if((buf = (char *)malloc(sb.st_size + 16)) == NULL)
+    {
+      DEBUG(0,("set_share_mode: malloc for file size %d fail !\n", sb.st_size + 16));
+      return False;
+    }
+ 
+    if(lseek(fd, 0, SEEK_SET) != 0)
+    {
+      DEBUG(0,("ERROR: set_share_mode: Failed to reset position \
+to 0 for share file %s (%s)\n", fname, strerror(errno)));
+      if(buf)
+        free(buf);
+      return False;
     }
+
+    if (read(fd,buf,sb.st_size) != sb.st_size)
+    {
+      DEBUG(0,("ERROR: set_share_mode: Failed to read share file %s (%s)\n",
+                  fname, strerror(errno)));
+      if(buf)
+        free(buf);
+      return False;
+    }   
+  
+    if (IVAL(buf,0) != LOCKING_VERSION) 
+    {
+      DEBUG(0,("ERROR: set_share_mode: share file %s has incorrect \
+locking version (was %d, should be %d).\n",fname, IVAL(buf,0), LOCKING_VERSION));
+      if(buf)
+        free(buf);
+      delete_share_file(fs_p->cnum, fname);
+      return False;
+    }   
+
+    size -= (10 + SVAL(buf, 8)); /* Remove the header */
+
+    /* The remaining size must be a multiple of 16 - error if not. */
+    if((size % 16) != 0)
+    {
+      DEBUG(0,("ERROR: set_share_mode: share file %s is an incorrect length - \
+deleting it.\n", fname));
+      if(buf)
+        free(buf);
+      delete_share_file(fs_p->cnum, fname);
+      return False;
+    }
+
   }
+  else
+  {
+    /* New file - just use a single_entry. */
+    if((buf = (char *)malloc(10 + strlen(fs_p->name) + 1 + 16)) == NULL)
+    {
+      DEBUG(0,("ERROR: set_share_mode: malloc failed for single entry.\n"));
+      return False;
+    }
+    SIVAL(buf,0,LOCKING_VERSION);
+    SIVAL(buf,4,0);
+    SSVAL(buf,8,strlen(fs_p->name) + 1);
+    strcpy(buf + 10, fs_p->name);
+  }
+
+  num_entries = IVAL(buf,4);
+  header_size = 10 + SVAL(buf,8);
+  p = buf + header_size + (num_entries * 16);
+  SIVAL(p,0,fs_p->open_time.tv_sec);
+  SIVAL(p,4,fs_p->open_time.tv_usec);
+  SIVAL(p,8,fs_p->share_mode);
+  SIVAL(p,12,pid);
+
+  num_entries++;
+
+  SIVAL(buf,4,num_entries);
+
+  if(lseek(fd, 0, SEEK_SET) != 0)
+  {
+    DEBUG(0,("ERROR: set_share_mode: (1) Failed to reset position to \
+0 for share file %s (%s)\n", fname, strerror(errno)));
+    if(buf)
+      free(buf);
+    return False;
+  }
+
+  if (write(fd,buf,header_size + (num_entries*16)) != (header_size + (num_entries*16))) 
+  {
+    DEBUG(2,("ERROR: set_share_mode: Failed to write share file %s - \
+deleting it (%s).\n",fname, strerror(errno)));
+    delete_share_file(fs_p->cnum, fname);
+    if(buf)
+      free(buf);
+    return False;
+  }
+
+  /* Now truncate the file at this point - just for safety. */
+  if(ftruncate(fd, header_size + (16*num_entries))!= 0)
+  {
+    DEBUG(0,("ERROR: set_share_mode: failed to ftruncate share \
+mode file %s to size %d (%s)\n", fname, header_size + (16*num_entries), strerror(errno)));
+    if(buf)
+      free(buf);
+    return False;
+  }
+
+  if(buf)
+    free(buf);
+
+  DEBUG(3,("set_share_mode: Created share file %s with \
+mode 0x%X pid=%d\n",fname,fs_p->share_mode,pid));
 
-  closedir(dir);
-#endif
+  return True;
 }
+#endif /* FAST_SHARE_MODES */
diff --git a/source/locking/shmem.c b/source/locking/shmem.c
index 2c02982d04a..9d4e62bdd78 100644
--- a/source/locking/shmem.c
+++ b/source/locking/shmem.c
@@ -23,7 +23,7 @@
 #include "includes.h"
 
 
-#if FAST_SHARE_MODES
+#ifdef FAST_SHARE_MODES
 
 
 extern int DEBUGLEVEL;
@@ -32,7 +32,7 @@ extern int DEBUGLEVEL;
 #define SMB_SHM_MAGIC 0x53484100
 /* = "SHM" in hex */
 
-#define SMB_SHM_VERSION 1
+#define SMB_SHM_VERSION 2
 
 /* WARNING : offsets are used because mmap() does not guarantee that all processes have the 
    shared memory mapped to the same address */
@@ -73,15 +73,109 @@ static pstring smb_shm_processreg_name = "";
 static struct SmbShmHeader *smb_shm_header_p = (struct SmbShmHeader *)0;
 static int smb_shm_times_locked = 0;
 
+static BOOL smb_shm_initialize_called = False;
+
+static BOOL smb_shm_global_lock(void)
+{
+   if (smb_shm_fd < 0)
+   {
+      DEBUG(0,("ERROR smb_shm_global_lock : bad smb_shm_fd (%d)\n",smb_shm_fd));
+      return False;
+   }
+   
+   smb_shm_times_locked++;
+   
+   if(smb_shm_times_locked > 1)
+   {
+      DEBUG(2,("smb_shm_global_lock : locked %d times\n",smb_shm_times_locked));
+      return True;
+   }
+   
+   /* Do an exclusive wait lock on the first byte of the file */
+   if (fcntl_lock(smb_shm_fd, F_SETLKW, 0, 1, F_WRLCK) == False)
+   {
+      DEBUG(0,("ERROR smb_shm_global_lock : fcntl_lock failed with code %d\n",errno));
+      smb_shm_times_locked--;
+      return False;
+   }
+   
+   return True;
+   
+}
+
+static BOOL smb_shm_global_unlock(void)
+{
+   if (smb_shm_fd < 0)
+   {
+      DEBUG(0,("ERROR smb_shm_global_unlock : bad smb_shm_fd (%d)\n",smb_shm_fd));
+      return False;
+   }
+   
+   if(smb_shm_times_locked == 0)
+   {
+      DEBUG(0,("ERROR smb_shm_global_unlock : shmem not locked\n",smb_shm_fd));
+      return False;
+   }
+   
+   smb_shm_times_locked--;
+   
+   if(smb_shm_times_locked > 0)
+   {
+      DEBUG(2,("smb_shm_global_unlock : still locked %d times\n",smb_shm_times_locked));
+      return True;
+   }
+   
+   /* Do a wait unlock on the first byte of the file */
+   if (fcntl_lock(smb_shm_fd, F_SETLKW, 0, 1, F_UNLCK) == False)
+   {
+      DEBUG(0,("ERROR smb_shm_global_unlock : fcntl_lock failed with code %d\n",errno));
+      smb_shm_times_locked++;
+      return False;
+   }
+   
+   return True;
+   
+}
+
+/* 
+ * Function to create the hash table for the share mode entries. Called
+ * when smb shared memory is global locked.
+ */
+
+BOOL smb_shm_create_hash_table( unsigned int size )
+{
+  size *= sizeof(smb_shm_offset_t);
+
+  smb_shm_global_lock();
+  smb_shm_header_p->userdef_off = smb_shm_alloc( size );
+
+  if(smb_shm_header_p->userdef_off == NULL_OFFSET)
+    {
+      DEBUG(0,("smb_shm_create_hash_table: Failed to create hash table of size %d\n",size));
+      smb_shm_global_unlock();
+      return False;
+    }
+
+  /* Clear hash buckets. */
+  memset( smb_shm_offset2addr(smb_shm_header_p->userdef_off), '\0', size);
+  smb_shm_global_unlock();
+  return True;
+}
+
 static BOOL smb_shm_register_process(char *processreg_file, pid_t pid, BOOL *other_processes)
 {
    int smb_shm_processes_fd = -1;
    int nb_read;
    pid_t other_pid;
+   int seek_back = -sizeof(other_pid);
    int free_slot = -1;
    int erased_slot;   
    
+#ifndef SECURE_SHARE_MODES
    smb_shm_processes_fd = open(processreg_file, O_RDWR | O_CREAT, 0666);
+#else /* SECURE_SHARE_MODES */
+   smb_shm_processes_fd = open(processreg_file, O_RDWR | O_CREAT, 0600);
+#endif /* SECURE_SHARE_MODES */
    if ( smb_shm_processes_fd < 0 )
    {
       DEBUG(0,("ERROR smb_shm_register_process : processreg_file open failed with code %d\n",errno));
@@ -99,9 +193,10 @@ static BOOL smb_shm_register_process(char *processreg_file, pid_t pid, BOOL *oth
 	 else
 	 {
 	    /* erase old pid */
-            DEBUG(2,("smb_shm_register_process : erasing stale record for pid %d\n",other_pid));
+            DEBUG(2,("smb_shm_register_process : erasing stale record for pid %d (seek_back = %d)\n",
+                      other_pid, seek_back));
 	    other_pid = (pid_t)0;
-	    erased_slot = lseek(smb_shm_processes_fd, -sizeof(other_pid), SEEK_CUR);
+	    erased_slot = lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
 	    write(smb_shm_processes_fd, &other_pid, sizeof(other_pid));
 	    if(free_slot < 0)
 	       free_slot = erased_slot;
@@ -109,7 +204,7 @@ static BOOL smb_shm_register_process(char *processreg_file, pid_t pid, BOOL *oth
       }
       else 
 	 if(free_slot < 0)
-	    free_slot = lseek(smb_shm_processes_fd, -sizeof(other_pid), SEEK_CUR);
+	    free_slot = lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
    }
    if (nb_read < 0)
    {
@@ -141,6 +236,7 @@ static BOOL smb_shm_unregister_process(char *processreg_file, pid_t pid)
    int smb_shm_processes_fd = -1;
    int nb_read;
    pid_t other_pid;
+   int seek_back = -sizeof(other_pid);
    int erased_slot;
    BOOL found = False;
    
@@ -156,12 +252,14 @@ static BOOL smb_shm_unregister_process(char *processreg_file, pid_t pid)
    
    while ((nb_read = read(smb_shm_processes_fd, &other_pid, sizeof(other_pid))) > 0)
    {
+      DEBUG(2,("smb_shm_unregister_process : read record for pid %d\n",other_pid));
       if(other_pid == pid)
       {
 	 /* erase pid */
-         DEBUG(2,("smb_shm_unregister_process : erasing record for pid %d\n",other_pid));
+         DEBUG(2,("smb_shm_unregister_process : erasing record for pid %d (seek_val = %d)\n",
+                     other_pid, seek_back));
 	 other_pid = (pid_t)0;
-	 erased_slot = lseek(smb_shm_processes_fd, -sizeof(other_pid), SEEK_CUR);
+	 erased_slot = lseek(smb_shm_processes_fd, seek_back, SEEK_CUR);
 	 if(write(smb_shm_processes_fd, &other_pid, sizeof(other_pid)) < 0)
 	 {
 	    DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file write failed with code %d\n",errno));
@@ -257,6 +355,8 @@ static BOOL smb_shm_initialize(int size)
    
    smb_shm_header_p->consistent = True;
    
+   smb_shm_initialize_called = True;
+
    return True;
 }
    
@@ -291,7 +391,11 @@ BOOL smb_shm_open( char *file_name, int size)
    DEBUG(2,("smb_shm_open : using shmem file %s to be of size %d\n",file_name,size));
 
    old_umask = umask(0);
+#ifndef SECURE_SHARE_MODES
    smb_shm_fd = open(file_name, O_RDWR | O_CREAT, 0666);
+#else /* SECURE_SHARE_MODES */
+   smb_shm_fd = open(file_name, O_RDWR | O_CREAT, 0600);
+#endif /* SECURE_SHARE_MODE */
    umask(old_umask);
    if ( smb_shm_fd < 0 )
    {
@@ -299,16 +403,16 @@ BOOL smb_shm_open( char *file_name, int size)
       return False;
    }
    
-   if (!smb_shm_lock())
+   if (!smb_shm_global_lock())
    {
-      DEBUG(0,("ERROR smb_shm_open : can't do smb_shm_lock\n"));
+      DEBUG(0,("ERROR smb_shm_open : can't do smb_shm_global_lock\n"));
       return False;
    }
    
    if( (filesize = lseek(smb_shm_fd, 0, SEEK_END)) < 0)
    {
       DEBUG(0,("ERROR smb_shm_open : lseek failed with code %d\n",errno));
-      smb_shm_unlock();
+      smb_shm_global_unlock();
       close(smb_shm_fd);
       return False;
    }
@@ -332,7 +436,7 @@ BOOL smb_shm_open( char *file_name, int size)
 
    if (! smb_shm_register_process(smb_shm_processreg_name, getpid(), &other_processes))
    {
-      smb_shm_unlock();
+      smb_shm_global_unlock();
       close(smb_shm_fd);
       return False;
    }
@@ -344,7 +448,7 @@ BOOL smb_shm_open( char *file_name, int size)
       {
          DEBUG(0,("ERROR smb_shm_open : ftruncate failed with code %d\n",errno));
 	 smb_shm_unregister_process(smb_shm_processreg_name, getpid());
-	 smb_shm_unlock();
+	 smb_shm_global_unlock();
 	 close(smb_shm_fd);
 	 return False;
       }
@@ -369,7 +473,7 @@ BOOL smb_shm_open( char *file_name, int size)
    {
       DEBUG(0,("ERROR smb_shm_open : mmap failed with code %d\n",errno));
       smb_shm_unregister_process(smb_shm_processreg_name, getpid());
-      smb_shm_unlock();
+      smb_shm_global_unlock();
       close(smb_shm_fd);
       return False;
    }      
@@ -378,6 +482,8 @@ BOOL smb_shm_open( char *file_name, int size)
    if (created_new || !other_processes)
    {
       smb_shm_initialize(size);
+      /* Create the hash buckets for the share file entries. */
+      smb_shm_create_hash_table( lp_shmem_hash_size() );
    }
    else if (!smb_shm_validate_header(size) )
    {
@@ -385,12 +491,12 @@ BOOL smb_shm_open( char *file_name, int size)
       DEBUG(0,("ERROR smb_shm_open : corrupt shared mem file, remove it manually\n"));
       munmap((caddr_t)smb_shm_header_p, size);
       smb_shm_unregister_process(smb_shm_processreg_name, getpid());
-      smb_shm_unlock();
+      smb_shm_global_unlock();
       close(smb_shm_fd);
       return False;
    }
    
-   smb_shm_unlock();
+   smb_shm_global_unlock();
    return True;
       
 }
@@ -399,17 +505,22 @@ BOOL smb_shm_open( char *file_name, int size)
 BOOL smb_shm_close( void )
 {
    
+   if(smb_shm_initialize_called == False)
+     return True;
+
    DEBUG(2,("smb_shm_close\n"));
    if(smb_shm_times_locked > 0)
       DEBUG(0,("WARNING smb_shm_close : shmem was still locked %d times\n",smb_shm_times_locked));;
-   if ( munmap((caddr_t)smb_shm_header_p, smb_shm_header_p->total_size) < 0)
+   if ((smb_shm_header_p != NULL) && 
+              (munmap((caddr_t)smb_shm_header_p, smb_shm_header_p->total_size) < 0))
    {
       DEBUG(0,("ERROR smb_shm_close : munmap failed with code %d\n",errno));
    }
 
-   smb_shm_lock();
+   smb_shm_global_lock();
+   DEBUG(2,("calling smb_shm_unregister_process(%s, %d)\n", smb_shm_processreg_name, getpid()));
    smb_shm_unregister_process(smb_shm_processreg_name, getpid());
-   smb_shm_unlock();
+   smb_shm_global_unlock();
    
    close(smb_shm_fd);
    
@@ -438,9 +549,12 @@ smb_shm_offset_t smb_shm_alloc(int size)
       return NULL_OFFSET;
    }
    
+   smb_shm_global_lock();
+
    if( !smb_shm_header_p->consistent)
    {
       DEBUG(0,("ERROR smb_shm_alloc : shmem not consistent\n"));
+      smb_shm_global_unlock();
       return NULL_OFFSET;
    }
    
@@ -463,6 +577,7 @@ smb_shm_offset_t smb_shm_alloc(int size)
    if ( scanner_p == EOList_Addr )	
    {
       DEBUG(0,("ERROR smb_shm_alloc : alloc of %d bytes failed, no free space found\n",size));
+      smb_shm_global_unlock();
       return (NULL_OFFSET);
    }
    
@@ -516,6 +631,7 @@ smb_shm_offset_t smb_shm_alloc(int size)
 
    DEBUG(2,("smb_shm_alloc : request for %d bytes, allocated %d bytes at offset %d\n",size,scanner_p->size*CellSize,result_offset ));
 
+   smb_shm_global_unlock();
    return ( result_offset );
 }   
 
@@ -534,9 +650,12 @@ BOOL smb_shm_free(smb_shm_offset_t offset)
       return False;
    }
    
+   smb_shm_global_lock();
+
    if( !smb_shm_header_p->consistent)
    {
       DEBUG(0,("ERROR smb_shm_free : shmem not consistent\n"));
+      smb_shm_global_unlock();
       return False;
    }
    
@@ -545,6 +664,7 @@ BOOL smb_shm_free(smb_shm_offset_t offset)
    if (header_p->next != SMB_SHM_NOT_FREE_OFF)
    {
       DEBUG(0,("ERROR smb_shm_free : bad offset (%d)\n",offset));
+      smb_shm_global_unlock();
       return False;
    }
    
@@ -577,6 +697,7 @@ BOOL smb_shm_free(smb_shm_offset_t offset)
       smb_shm_solve_neighbors( header_p ); /* if neighbors then link them */
       
       smb_shm_header_p->consistent = True;
+      smb_shm_global_unlock();
       return True;
    } 
    else
@@ -590,6 +711,7 @@ BOOL smb_shm_free(smb_shm_offset_t offset)
       smb_shm_solve_neighbors(prev_p) ;
 
       smb_shm_header_p->consistent = True;
+      smb_shm_global_unlock();
       return True;
    }
 }
@@ -633,68 +755,71 @@ smb_shm_offset_t smb_shm_addr2offset(void *addr)
    return (smb_shm_offset_t)((char *)addr - (char *)smb_shm_header_p);
 }
 
-BOOL smb_shm_lock(void)
+/*******************************************************************
+  Lock a particular hash bucket entry.
+  ******************************************************************/
+
+BOOL smb_shm_lock_hash_entry( unsigned int entry)
 {
-   if (smb_shm_fd < 0)
-   {
-      DEBUG(0,("ERROR smb_shm_lock : bad smb_shm_fd (%d)\n",smb_shm_fd));
+  int start = (smb_shm_header_p->userdef_off + (entry * sizeof(smb_shm_offset_t)));
+
+  if (smb_shm_fd < 0)
+    {
+      DEBUG(0,("ERROR smb_shm_lock_hash_entry : bad smb_shm_fd (%d)\n",smb_shm_fd));
       return False;
-   }
-   
-   smb_shm_times_locked++;
-   
-   if(smb_shm_times_locked > 1)
-   {
-      DEBUG(2,("smb_shm_lock : locked %d times\n",smb_shm_times_locked));
-      return True;
-   }
-   
-   if (lockf(smb_shm_fd, F_LOCK, 0) < 0)
-   {
-      DEBUG(0,("ERROR smb_shm_lock : lockf failed with code %d\n",errno));
-      smb_shm_times_locked--;
+    }
+
+  if(entry >= lp_shmem_hash_size())
+    {
+      DEBUG(0,("ERROR smb_shm_lock_hash_entry : hash entry size too big (%d)\n", entry));
       return False;
-   }
-   
-   return True;
-   
+    }
+  
+  /* Do an exclusive wait lock on the 4 byte region mapping into this entry  */
+  if (fcntl_lock(smb_shm_fd, F_SETLKW, start, sizeof(smb_shm_offset_t), F_WRLCK) == False)
+    {
+      DEBUG(0,("ERROR smb_shm_lock_hash_entry : fcntl_lock failed with code %d\n",errno));
+      return False;
+    }
+  
+  DEBUG(9,("smb_shm_lock_hash_entry: locked hash bucket %d\n", entry)); 
+  return True;
 }
 
+/*******************************************************************
+  Unlock a particular hash bucket entry.
+  ******************************************************************/
 
-
-BOOL smb_shm_unlock(void)
+BOOL smb_shm_unlock_hash_entry( unsigned int entry )
 {
-   if (smb_shm_fd < 0)
-   {
-      DEBUG(0,("ERROR smb_shm_unlock : bad smb_shm_fd (%d)\n",smb_shm_fd));
+  int start = (smb_shm_header_p->userdef_off + (entry * sizeof(smb_shm_offset_t)));
+
+  if (smb_shm_fd < 0)
+    {
+      DEBUG(0,("ERROR smb_shm_unlock_hash_entry : bad smb_shm_fd (%d)\n",smb_shm_fd));
       return False;
-   }
+    }
    
-   if(smb_shm_times_locked == 0)
-   {
-      DEBUG(0,("ERROR smb_shm_unlock : shmem not locked\n",smb_shm_fd));
+  if(entry >= lp_shmem_hash_size())
+    {
+      DEBUG(0,("ERROR smb_shm_unlock_hash_entry : hash entry size too big (%d)\n", entry));
       return False;
-   }
-   
-   smb_shm_times_locked--;
-   
-   if(smb_shm_times_locked > 0)
-   {
-      DEBUG(2,("smb_shm_unlock : still locked %d times\n",smb_shm_times_locked));
-      return True;
-   }
-   
-   if (lockf(smb_shm_fd, F_ULOCK, 0) < 0)
-   {
-      DEBUG(0,("ERROR smb_shm_unlock : lockf failed with code %d\n",errno));
-      smb_shm_times_locked++;
+    }
+
+  /* Do a wait lock on the 4 byte region mapping into this entry  */
+  if (fcntl_lock(smb_shm_fd, F_SETLKW, start, sizeof(smb_shm_offset_t), F_UNLCK) == False)
+    {
+      DEBUG(0,("ERROR smb_shm_unlock_hash_entry : fcntl_lock failed with code %d\n",errno));
       return False;
-   }
-   
-   return True;
-   
+    }
+  
+  DEBUG(9,("smb_shm_unlock_hash_entry: unlocked hash bucket %d\n", entry)); 
+  return True;
 }
 
+/*******************************************************************
+  Gather statistics on shared memory usage.
+  ******************************************************************/
 
 BOOL smb_shm_get_usage(int *bytes_free,
 		   int *bytes_used,
@@ -716,4 +841,4 @@ BOOL smb_shm_get_usage(int *bytes_free,
 #else /* FAST_SHARE_MODES */
  int shmem_dummy_procedure(void)
 {return 0;}
-#endif
+#endif /* FAST_SHARE_MODES */
diff --git a/source/nameannounce.c b/source/nameannounce.c
index b46436168c3..7d7a95334c9 100644
--- a/source/nameannounce.c
+++ b/source/nameannounce.c
@@ -35,6 +35,7 @@ extern BOOL CanRecurse;
 extern struct in_addr ipzero;
 
 extern pstring myname;
+extern fstring myworkgroup;
 
 extern int ClientDGRAM;
 extern int ClientNMB;
@@ -185,9 +186,9 @@ void do_announce_host(int command,
 
 
 /****************************************************************************
-  remove all samba's server entries
-  ****************************************************************************/
-void remove_my_servers(void)
+announce all samba's server entries as 'gone'.
+****************************************************************************/
+void announce_my_servers_removed(void)
 {
 	struct subnet_record *d; 
 	for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_EXCLUDING_WINS(d))
@@ -372,7 +373,7 @@ static time_t announce_timer_last=0;
 
 void reset_announce_timer()
 {
-  announce_timer_last = 0;
+  announce_timer_last = time(NULL) - (CHECK_TIME_MST_ANNOUNCE * 60);
 }
 
 /****************************************************************************
@@ -396,7 +397,7 @@ void announce_master(time_t t)
       return;
     }
 
-  if(wins_subnet == 0)
+  if(wins_subnet == NULL)
     {
       DEBUG(10,("announce_master: no wins subnet, ignoring.\n"));
       return;
@@ -412,19 +413,19 @@ void announce_master(time_t t)
 	  if (AM_MASTER(work))
 	    {
 	      am_master = True;
+              DEBUG(4,( "announce_master: am_master = %d for \
+workgroup %s\n", am_master, work->work_group));
 	    }
 	}
     }
  
-  DEBUG(4,( "announce_master: am_master = %d for workgroup %s\n", am_master, lp_workgroup()));
-
   if (!am_master) return; /* only proceed if we are a master browser */
   
   /* Note that we don't do this if we are domain master browser
      and that we *only* do this on the WINS subnet. */
 
   /* Try and find our workgroup on the WINS subnet */
-  work = find_workgroupstruct(wins_subnet, lp_workgroup(), False);
+  work = find_workgroupstruct(wins_subnet, myworkgroup, False);
 
   if (work)
     {
@@ -488,7 +489,7 @@ in our own WINS database.\n", work->work_group));
 
            /* Check that this isn't one of our addresses (ie. we are not domain master
               ourselves) */
-           if(ismyip(nr->ip_flgs[0].ip))
+           if(ismyip(nr->ip_flgs[0].ip) || ip_equal(nr->ip_flgs[0].ip, ipzero))
              {
                DEBUG(4, ("announce_master: domain master ip found (%s) for workgroup %s \
 is one of our interfaces.\n", work->work_group, inet_ntoa(nr->ip_flgs[0].ip) ));
@@ -535,7 +536,7 @@ void announce_remote(time_t t)
   if (!*s) return;
 
   comment = lp_serverstring();
-  workgroup = lp_workgroup();
+  workgroup = myworkgroup;
 
   for (ptr=s; next_token(&ptr,s2,NULL); ) {
     /* the entries are of the form a.b.c.d/WORKGROUP with 
diff --git a/source/nameconf.c b/source/nameconf.c
index 99951a3b0ea..8f33419b9ac 100644
--- a/source/nameconf.c
+++ b/source/nameconf.c
@@ -35,6 +35,8 @@
 #include "includes.h"
 extern int DEBUGLEVEL;
 
+extern fstring myworkgroup;
+
 #if 0
 struct smbbrowse_parms
     {
@@ -104,7 +106,7 @@ static struct smbbrowse *new_workgroup(struct smbbrowse *model,
     StrnCpy(new->work_name, workgroup_name, 15);
     strupper(new->work_name);
         
-	if (strequal(lp_workgroup(), workgroup_name))
+	if (strequal(myworkgroup, workgroup_name))
       StrnCpy(new->browsing_alias, default_name, 15);
     else
       sprintf(new->browsing_alias, "%.14s%x", default_name, nexttoken);
@@ -289,7 +291,7 @@ static void default_smbbrowse_conf(char *default_name)
     struct smbbrowse *w;
     
     /* The workgroup specified in smb.conf */
-    w = new_workgroup((struct smbbrowse *)NULL, lp_workgroup(), default_name);
+    w = new_workgroup((struct smbbrowse *)NULL, myworkgroup, default_name);
     w->should_local_master = lp_preferred_master();
     w->should_domain_master = lp_domain_master();
     w->should_workgroup_member = True;
diff --git a/source/namedbname.c b/source/namedbname.c
index 2e0afc1497b..aa41726450f 100644
--- a/source/namedbname.c
+++ b/source/namedbname.c
@@ -153,11 +153,13 @@ struct name_record *find_name(struct name_record *n,
 			{
 				continue;
 	  		}
-			DEBUG(9,("find_name: found name %s\n", name->name));
+			DEBUG(9,("find_name: found name %s(%02x)\n", 
+                                  name->name, name->name_type));
 			return ret;
 		}
 	}
-    DEBUG(9,("find_name: name %s NOT FOUND\n", name->name));
+    DEBUG(9,("find_name: name %s(%02x) NOT FOUND\n", name->name, 
+              name->name_type));
     return NULL;
 }
 
@@ -528,7 +530,6 @@ struct name_record *dns_name_search(struct nmb_name *question, int Time)
 {
 	int name_type = question->name_type;
 	char *qname = question->name;
-	char *r;
 	BOOL dns_type = (name_type == 0x20 || name_type == 0);
 	struct in_addr dns_ip;
 
diff --git a/source/namedbserver.c b/source/namedbserver.c
index 9c7bb664ab2..8cad8a3a112 100644
--- a/source/namedbserver.c
+++ b/source/namedbserver.c
@@ -37,6 +37,7 @@ extern int ClientDGRAM;
 extern int DEBUGLEVEL;
 
 extern pstring myname;
+extern fstring myworkgroup;
 
 /* this is our domain/workgroup/server database */
 extern struct subnet_record *subnetlist;
@@ -161,7 +162,7 @@ struct server_record *add_server_entry(struct subnet_record *d,
   }
   
   
-  if (strequal(lp_workgroup(),work->work_group))
+  if (strequal(myworkgroup,work->work_group))
     {
 	  if (servertype)
         servertype |= SV_TYPE_LOCAL_LIST_ONLY;
diff --git a/source/namedbsubnet.c b/source/namedbsubnet.c
index 25c369ab1c8..393db363d86 100644
--- a/source/namedbsubnet.c
+++ b/source/namedbsubnet.c
@@ -40,6 +40,7 @@ extern struct in_addr wins_ip;
 extern struct in_addr ipzero;
 
 extern pstring myname;
+extern fstring myworkgroup;
 
 BOOL updatedlists = True;
 int updatecount = 0;
@@ -52,15 +53,10 @@ struct subnet_record *subnetlist = NULL;
 
 /* WINS subnet - keep this separate so enumeration code doesn't
    run onto it by mistake. */
-struct subnet_record *wins_subnet = 0;
+struct subnet_record *wins_subnet = NULL;
 
 extern uint16 nb_type; /* samba's NetBIOS name type */
 
-/* Forward references. */
-static struct subnet_record *add_subnet_entry(struct in_addr bcast_ip, 
-				       struct in_addr mask_ip,
-				       char *name, BOOL add, BOOL lmhosts);
-
 /****************************************************************************
   add a domain into the list
   **************************************************************************/
@@ -129,6 +125,7 @@ struct subnet_record *find_subnet_all(struct in_addr bcast_ip)
   struct subnet_record *d = find_subnet(bcast_ip);
   if(!d)
     return wins_subnet;
+  return d;
 }
 
 /****************************************************************************
@@ -156,121 +153,122 @@ static struct subnet_record *make_subnet(struct in_addr bcast_ip, struct in_addr
   return d;
 }
 
-
 /****************************************************************************
-  add the remote interfaces from lp_interfaces()
-  to the netbios subnet database.
+  add a domain entry. creates a workgroup, if necessary, and adds the domain
+  to the named a workgroup.
   ****************************************************************************/
-void add_subnet_interfaces(void)
+static struct subnet_record *add_subnet_entry(struct in_addr bcast_ip, 
+				       struct in_addr mask_ip, char *name, 
+                                       BOOL create_subnets, BOOL add)
 {
-  struct interface *i;
+  struct subnet_record *d = NULL;
 
-  /* loop on all local interfaces */
-  for (i = local_interfaces; i; i = i->next)
-    {
-      /* add the interface into our subnet database */
-      if (!find_subnet(i->bcast))
-	{
-	  make_subnet(i->bcast,i->nmask, True);
-	}
-    }
+  if (zero_ip(bcast_ip)) 
+    bcast_ip = *iface_bcast(bcast_ip);
+  
+  /* Note that we should also add into the WINS subnet as add_subnet_entry
+    should be called to add NetBIOS names and server entries on all
+    interfaces, including the WINS interface
+   */
 
-  /* add the pseudo-ip interface for WINS: 255.255.255.255 */
-  if (lp_wins_support() || (*lp_wins_server()))
+  if(create_subnets == True)
+  {
+    /* Create new subnets. */
+    if((d = make_subnet(bcast_ip, mask_ip, add)) == NULL)
     {
-      struct in_addr wins_bcast = wins_ip;
-      struct in_addr wins_nmask = ipzero;
-      wins_subnet = make_subnet(wins_bcast, wins_nmask, False);
+      DEBUG(0,("add_subnet_entry: Unable to create subnet %s\n",
+               inet_ntoa(bcast_ip) ));
+      return NULL;
     }
+    return d;
+  }
+  if(ip_equal(bcast_ip, wins_ip))
+    return wins_subnet;
+  return find_subnet(bcast_ip);
 }
 
-
-
 /****************************************************************************
-  add the default workgroup into the subnet lists.
-  **************************************************************************/
-void add_my_subnets(char *group)
+ Add a workgroup into a subnet, and if it's our primary workgroup,
+ add the required names to it.
+**************************************************************************/
+
+void add_workgroup_to_subnet( struct subnet_record *d, char *group)
 {
-  struct interface *i;
+  struct work_record *w = NULL;
 
-  /* add or find domain on our local subnet, in the default workgroup */
-  
-  if (*group == '*') return;
+  DEBUG(5,("add_workgroup_to_subnet: Adding workgroup %s to subnet %s\n",
+            group, inet_ntoa(d->bcast_ip)));
 
-	/* the coding choice is up to you, andrew: i can see why you don't want
-       global access to the local_interfaces structure: so it can't get
-       messed up! */
-    for (i = local_interfaces; i; i = i->next)
-    {
-      add_subnet_entry(i->bcast,i->nmask,group, True, False);
-    }
+  /* This next statement creates the workgroup struct if it doesn't
+     already exist. 
+   */
+  if((w = find_workgroupstruct(d, group, True)) == NULL)
+  {
+    DEBUG(0,("add_workgroup_to_subnet: Unable to add workgroup %s to subnet %s\n",
+              group, inet_ntoa(d->bcast_ip) ));
+    return;
+  }
 
-    /* If we are setup as a domain master browser, and are using
-       WINS, then we must add the workgroup to the WINS subnet. This
-       is used as a place to keep collated server lists. */
-
-    if(lp_domain_master() && (lp_wins_support() || lp_wins_server()))
-      if(find_workgroupstruct(wins_subnet, group, True) == 0)
-        DEBUG(0, ("add_my_subnets: Failed to add workgroup %s to \
-WINS subnet.\n", group));
-      else
-        DEBUG(3,("add_my_subnets: Added workgroup %s to WINS subnet.\n",
-                 group));
+  /* add WORKGROUP(1e) and WORKGROUP(00) entries into name database
+     or register with WINS server, if it's our workgroup 
+   */
+  if (strequal(myworkgroup, group))
+  {
+    add_my_name_entry(d,group,0x1e,nb_type|NB_ACTIVE|NB_GROUP);
+    add_my_name_entry(d,group,0x0 ,nb_type|NB_ACTIVE|NB_GROUP);
+    /* add samba server name to workgroup list. */
+    add_server_entry(d,w,myname,w->ServerType,0,lp_serverstring(),True);
+    DEBUG(3,("add_workgroup_to_subnet: Added server name entry %s to subnet %s\n",
+                myname, inet_ntoa(d->bcast_ip)));
+  }
 }
 
-
 /****************************************************************************
-  add a domain entry. creates a workgroup, if necessary, and adds the domain
-  to the named a workgroup.
-  ****************************************************************************/
-static struct subnet_record *add_subnet_entry(struct in_addr bcast_ip, 
-				       struct in_addr mask_ip,
-				       char *name, BOOL add, BOOL lmhosts)
-{
-  struct subnet_record *d;
+  create subnet / workgroup / server entries
+     
+  - add or create the subnet lists
+  - add or create the workgroup entries in each subnet entry
+  - register appropriate NetBIOS names for the workgroup entries
+     
+**************************************************************************/
+void add_my_subnets(char *group)
+{    
+  static BOOL create_subnets = True;
+  struct subnet_record *d = NULL;
+  struct interface *i = NULL;
 
-  /* XXXX andrew: struct in_addr ip appears not to be referenced at all except
-     in the DEBUG comment. i assume that the DEBUG comment below actually
-     intends to refer to bcast_ip? i don't know.
+  if (*group == '*') return;
 
-  struct in_addr ip = wins_ip;
+  /* Create subnets from all the local interfaces and thread them onto
+     the linked list. 
+   */
+  for (i = local_interfaces; i; i = i->next)
+  {
+    add_subnet_entry(i->bcast,i->nmask,group, create_subnets, True);
+  }
 
-  */
+  /* If we are using WINS, then we must add the workgroup to the WINS
+     subnet. This is used as a place to keep collated server lists.
+   */
 
-  if (zero_ip(bcast_ip)) 
-    bcast_ip = *iface_bcast(bcast_ip);
-  
-  /* add the domain into our domain database */
-  /* Note that we never add into the WINS subnet as add_subnet_entry
-     is only called to add our local interfaces. */
-  if ((d = find_subnet(bcast_ip)) ||
-      (d = make_subnet(bcast_ip, mask_ip, True)))
-    {
-      struct work_record *w = find_workgroupstruct(d, name, add);
-      
-      if (!w) return NULL;
+  /* Create the WINS subnet if we are using WINS - but don't thread it
+     onto the linked subnet list. 
+   */    
+  if (lp_wins_support() || lp_wins_server())
+  {
+    struct in_addr wins_nmask = ipzero;
+    wins_subnet = add_subnet_entry(wins_ip, wins_nmask, group, create_subnets, False);
+  }
 
-      /* add WORKGROUP(1e) and WORKGROUP(00) entries into name database
-	 or register with WINS server, if it's our workgroup */
-      if (strequal(lp_workgroup(), name))
-	{
-	  add_my_name_entry(d,name,0x1e,nb_type|NB_ACTIVE|NB_GROUP);
-	  add_my_name_entry(d,name,0x0 ,nb_type|NB_ACTIVE|NB_GROUP);
-	}
-      /* add samba server name to workgroup list. don't add
-         lmhosts server entries to local interfaces */
-      if (strequal(lp_workgroup(), name))
-      {
-	add_server_entry(d,w,myname,w->ServerType,0,lp_serverstring(),True);
-        DEBUG(3,("Added server name entry %s at %s\n",
-                  name,inet_ntoa(bcast_ip)));
-      }
-      
-      return d;
-    }
-  return NULL;
-}
+  /* Ensure we only create the subnets once. */
+  create_subnets = False;
 
+  /* Now we have created all the subnets - we can add the names
+     that make us a client member in the workgroup.
+   */
+  for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
+    add_workgroup_to_subnet(d, group);
+}
 
 /*******************************************************************
   write out browse.dat
diff --git a/source/namedbwork.c b/source/namedbwork.c
index 8c249cc82cb..d752916815f 100644
--- a/source/namedbwork.c
+++ b/source/namedbwork.c
@@ -40,6 +40,8 @@ extern struct subnet_record *subnetlist;
 
 extern struct in_addr wins_ip;
 
+extern fstring myworkgroup;
+
 int workgroup_count = 0; /* unique index key: one for each workgroup */
 
 
@@ -192,8 +194,8 @@ struct work_record *find_workgroupstruct(struct subnet_record *d,
   if ((work = make_workgroup(name)))
     {
       if (!ip_equal(d->bcast_ip, wins_ip) &&
-	  lp_preferred_master() &&
-	  strequal(lp_workgroup(), name))
+	  lp_preferred_master() && lp_local_master() &&
+	  strequal(myworkgroup, name))
 	{
 	  DEBUG(3, ("preferred master startup for %s\n", work->work_group));
 	  work->needelection = True;
diff --git a/source/nameelect.c b/source/nameelect.c
index 02fda9f817b..82cebd3e6c5 100644
--- a/source/nameelect.c
+++ b/source/nameelect.c
@@ -40,6 +40,7 @@ extern int DEBUGLEVEL;
 extern pstring scope;
 
 extern pstring myname;
+extern fstring myworkgroup;
 extern struct in_addr ipzero;
 extern struct in_addr wins_ip;
 
@@ -57,55 +58,59 @@ extern uint16 nb_type; /* samba's NetBIOS name type */
   ******************************************************************/
 void check_master_browser(time_t t)
 {
-	static time_t lastrun=0;
-	struct subnet_record *d;
+  static time_t lastrun=0;
+  struct subnet_record *d;
 
-	if (!lastrun) lastrun = t;
-	if (t < lastrun + CHECK_TIME_MST_BROWSE * 60) return;
+  if (!lastrun) lastrun = t;
+  if (t < lastrun + CHECK_TIME_MST_BROWSE * 60) return;
 
-	lastrun = t;
+  lastrun = t;
 
-	dump_workgroups();
+  dump_workgroups();
 
-	for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_EXCLUDING_WINS(d))
-	{
-		struct work_record *work;
+  for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_EXCLUDING_WINS(d))
+  {
+    struct work_record *work;
 
-		for (work = d->workgrouplist; work; work = work->next)
-		{
-			if (strequal(work->work_group, lp_workgroup()) && !AM_MASTER(work))
-			{
-				if (lp_preferred_master())
-				{
-					/* preferred master - not a master browser.  force
-					   becoming a master browser, hence the log message.
-					 */
-
-					DEBUG(0,("%s preferred master for %s %s - force election\n",
-					          timestring(), work->work_group,
-					          inet_ntoa(d->bcast_ip)));
-
-					browser_gone(work->work_group, d->bcast_ip);
-				}
-				else
-				{
-					/* if we are not the browse master of a workgroup,
-					   and we can't find a browser on the subnet, do
-					   something about it.
-					 */
-
-					queue_netbios_packet(d,ClientNMB,NMB_QUERY,NAME_QUERY_MST_CHK,
-				                     work->work_group,0x1d,0,0,0,NULL,NULL,
-				                     True,False,d->bcast_ip,d->bcast_ip);
-				}
-			}
-		}
-	}
+    for (work = d->workgrouplist; work; work = work->next)
+    {
+      if (strequal(work->work_group, myworkgroup) && !AM_MASTER(work))
+      {
+        if (lp_local_master())
+        {
+          /* potential master browser - not a master browser.  force
+             becoming a master browser, hence the log message.
+           */
+
+          DEBUG(0,("%s potential master for %s %s - force election\n",
+                   timestring(), work->work_group,
+                   inet_ntoa(d->bcast_ip)));
+
+          browser_gone(work->work_group, d->bcast_ip);
+        }
+        else
+        {
+          /* if we are not the browse master of a workgroup,
+             and we can't find a browser on the subnet, do
+             something about it.
+           */
+
+          queue_netbios_packet(d,ClientNMB,NMB_QUERY,NAME_QUERY_MST_CHK,
+                    work->work_group,0x1d,0,0,0,NULL,NULL,
+                    True,False,d->bcast_ip,d->bcast_ip);
+        }
+      }
+    }
+  }
 }
 
 
 /*******************************************************************
-  what to do if a master browser DOESN't exist
+  what to do if a master browser DOESN't exist.
+
+  option 1: force an election, and participate in it
+  option 2: force an election, and let everyone else participate.
+
   ******************************************************************/
 void browser_gone(char *work_name, struct in_addr ip)
 {
@@ -119,24 +124,37 @@ void browser_gone(char *work_name, struct in_addr ip)
   if (ip_equal(d->bcast_ip,wins_ip)) 
     return;
 
-  if (strequal(work->work_group, lp_workgroup()))
+  if (strequal(work->work_group, myworkgroup))
   {
 
+    if (lp_local_master())
+    {
+      /* we have discovered that there is no local master
+         browser, and we are configured to initiate
+         an election under exactly such circumstances.
+       */
       DEBUG(2,("Forcing election on %s %s\n",
 	       work->work_group,inet_ntoa(d->bcast_ip)));
 
       /* we can attempt to become master browser */
       work->needelection = True;
-  }
-  else
-  {
-     /* local interfaces: force an election */
-    send_election(d, work->work_group, 0, 0, myname);
-
-     /* only removes workgroup completely on a local interface 
-        persistent lmhosts entries on a local interface _will_ be removed).
-      */
-     remove_workgroup(d, work,True);
+    }
+    else
+    {
+      /* we need to force an election, because we are configured
+         not to _become_ the local master, but we still _need_ one,
+         having detected that one doesn't exist.
+       */
+
+      /* local interfaces: force an election */
+      send_election(d, work->work_group, 0, 0, myname);
+
+      /* only removes workgroup completely on a local interface 
+         persistent lmhosts entries on a local interface _will_ be removed).
+       */
+      remove_workgroup(d, work,True);
+      add_workgroup_to_subnet(d, work->work_group);
+    }
   }
 }
 
@@ -199,15 +217,15 @@ void name_unregister_work(struct subnet_record *d, char *name, int name_type)
     {
       remove_type_local |= SV_TYPE_MASTER_BROWSER;
     }
-    if (AM_MASTER(work) && strequal(name, lp_workgroup()) && name_type == 0x1d)
+    if (AM_MASTER(work) && strequal(name, myworkgroup) && name_type == 0x1d)
     {
       remove_type_local |= SV_TYPE_MASTER_BROWSER;
     }
-    if (AM_DOMMST(work) && strequal(name, lp_workgroup()) && name_type == 0x1b)
+    if (AM_DOMMST(work) && strequal(name, myworkgroup) && name_type == 0x1b)
     {
       remove_type_domain |= SV_TYPE_DOMAIN_MASTER;
     }
-    if (AM_DOMMEM(work) && strequal(name, lp_workgroup()) && name_type == 0x1c)
+    if (AM_DOMMEM(work) && strequal(name, myworkgroup) && name_type == 0x1c)
     {
       remove_type_logon|= SV_TYPE_DOMAIN_MEMBER;
     }
@@ -228,47 +246,48 @@ void name_unregister_work(struct subnet_record *d, char *name, int name_type)
 void name_register_work(struct subnet_record *d, char *name, int name_type,
 				int nb_flags, time_t ttl, struct in_addr ip, BOOL bcast)
 {
-	enum name_source source = (ismyip(ip) || ip_equal(ip, ipzero)) ?
+  enum name_source source = (ismyip(ip) || ip_equal(ip, ipzero)) ?
 	                          SELF : REGISTER;
 
-	if (source == SELF)
-	{
-		struct work_record *work = find_workgroupstruct(d, lp_workgroup(), False);
+  if (source == SELF)
+    {
+      struct work_record *work = find_workgroupstruct(d, 
+                                  myworkgroup, False);
 
-		add_netbios_entry(d,name,name_type,nb_flags,ttl,source,ip,True,!bcast);
+      add_netbios_entry(d,name,name_type,nb_flags,ttl,source,ip,True,!bcast);
 
-		if (work)
-		{
-			int add_type_local  = False;
-			int add_type_domain = False;
-			int add_type_logon  = False;
-
-			DEBUG(4,("checking next stage: name_register_work %s\n", name));
-
-			/* work out what to become, from the name type being added */
-
-			if (ms_browser_name(name, name_type))
-			{
-				add_type_local = True;
-			}
-			if (strequal(name, lp_workgroup()) && name_type == 0x1d)
-			{
-				add_type_local = True;
-			}
-			if (strequal(name, lp_workgroup()) && name_type == 0x1b)
-			{
-				add_type_domain = True;
-			}
-			if (strequal(name, lp_workgroup()) && name_type == 0x1c)
-			{
-				add_type_logon = True;
-			}
-
-			if (add_type_local ) become_local_master (d, work);
-			if (add_type_domain) become_domain_master(d, work);
-			if (add_type_logon ) become_logon_server (d, work);
-		}
-	}
+      if (work)
+      {
+        int add_type_local  = False;
+        int add_type_domain = False;
+        int add_type_logon  = False;
+
+        DEBUG(4,("checking next stage: name_register_work %s\n", name));
+
+        /* work out what to become, from the name type being added */
+
+        if (ms_browser_name(name, name_type))
+        {
+          add_type_local = True;
+        }
+        if (strequal(name, myworkgroup) && name_type == 0x1d)
+        {
+          add_type_local = True;
+        }
+        if (strequal(name, myworkgroup) && name_type == 0x1b)
+        {
+          add_type_domain = True;
+        }
+        if (strequal(name, myworkgroup) && name_type == 0x1c)
+        {
+          add_type_logon = True;
+        }
+
+        if (add_type_local ) become_local_master (d, work);
+        if (add_type_domain) become_domain_master(d, work);
+        if (add_type_logon ) become_logon_server (d, work);
+      }
+    }
 }
 
 
@@ -303,17 +322,18 @@ void become_local_master(struct subnet_record *d, struct work_record *work)
    */
   uint32 domain_type = SV_TYPE_DOMAIN_ENUM|SV_TYPE_NT;
 
-  if (!work || !d) return;
+  if (!work || !d) 
+    return;
   
   DEBUG(2,("Becoming master for %s %s (currently at stage %d)\n",
-					work->work_group,inet_ntoa(d->bcast_ip),work->mst_state));
+           work->work_group,inet_ntoa(d->bcast_ip),work->mst_state));
   
   switch (work->mst_state)
   {
     case MST_POTENTIAL: /* while we were nothing but a server... */
     {
       DEBUG(3,("go to first stage: register ^1^2__MSBROWSE__^2^1\n"));
-      work->mst_state = MST_BACK; /* ... an election win was successful */
+      work->mst_state = MST_BACK; /* an election win was successful */
 
       work->ElectionCriterion |= 0x5;
 
@@ -322,7 +342,7 @@ void become_local_master(struct subnet_record *d, struct work_record *work)
       add_server_entry(d,work,myname,work->ServerType,0,lp_serverstring(),True);
 
       /* add special browser name */
-      add_my_name_entry(d,MSBROWSE        ,0x01,nb_type|NB_ACTIVE|NB_GROUP);
+      add_my_name_entry(d,MSBROWSE,0x01,nb_type|NB_ACTIVE|NB_GROUP);
 
       /* DON'T do anything else after calling add_my_name_entry() */
       break;
@@ -331,7 +351,7 @@ void become_local_master(struct subnet_record *d, struct work_record *work)
     case MST_BACK: /* while nothing had happened except we won an election... */
     {
       DEBUG(3,("go to second stage: register as master browser\n"));
-      work->mst_state = MST_MSB; /* ... registering MSBROWSE was successful */
+      work->mst_state = MST_MSB; /* registering MSBROWSE was successful */
 
       /* add server entry on successful registration of MSBROWSE */
       add_server_entry(d,work,work->work_group,domain_type,0,myname,True);
@@ -346,49 +366,33 @@ void become_local_master(struct subnet_record *d, struct work_record *work)
     case MST_MSB: /* while we were still only registered MSBROWSE state... */
     {
       DEBUG(3,("2nd stage complete: registered as master browser\n"));
-      work->mst_state = MST_BROWSER; /* ... registering WORKGROUP(1d) succeeded */
+      work->mst_state = MST_BROWSER; /* registering WORKGROUP(1d) succeeded */
 
       /* update our server status */
       work->ServerType |= SV_TYPE_MASTER_BROWSER;
 
-      DEBUG(3,("become_local_master: updating our server %s to type %x\n", myname, work->ServerType));
+      DEBUG(3,("become_local_master: updating our server %s to type %x\n", 
+                myname, work->ServerType));
 
       add_server_entry(d,work,myname,work->ServerType,0,lp_serverstring(),True);
 
       if (work->serverlist == NULL) /* no servers! */
       {
         /* ask all servers on our local net to announce to us */
-        /* XXXX OOPS! add_server_entry will always add one entry - our own. */
+        /* XXXX OOPS! add_server_entry always adds one entry - ours. */
         announce_request(work, d->bcast_ip);
       }
 
-      /* If we have WINS support or are a WINS server we must add
-         the workgroup we just became master browser for to the 
-         WINS subnet. This is needed so we have somewhere to save
-         server lists when we do browser synchronization. */
-      if(wins_subnet != 0) 
-        {
-          if(find_workgroupstruct(wins_subnet, work->work_group, True) == 0)
-            DEBUG(0, ("become_local_master: \
-Failed to add workgroup %s to WINS subnet.\n",
-                     work->work_group));
-          else
-            DEBUG(3, ("become_local_master: Added workgroup %s to WINS subnet.\n",
-                   work->work_group));
-
-          /* Reset the announce master timer so that we do an announce as soon as possible
-             now we are a master. */
-          reset_announce_timer();
-        }
+      /* Reset the announce master timer so that we do an announce as soon as possible
+         now we are a master. */
+      reset_announce_timer();
       break;
-
     }
 
     case MST_BROWSER:
     {
       /* don't have to do anything: just report success */
       DEBUG(3,("3rd stage: become master browser!\n"));
-
       break;
     }
   }
@@ -438,7 +442,7 @@ void become_domain_master(struct subnet_record *d, struct work_record *work)
 		  work->dom_state = DOMAIN_WAIT;
 
 		  /* XXXX the 0x1b is domain master browser name */
-		  add_my_name_entry(d, lp_workgroup(),0x1b,nb_type|NB_ACTIVE|NB_GROUP);
+		  add_my_name_entry(d, myworkgroup,0x1b,nb_type|NB_ACTIVE|NB_GROUP);
 
 		  /* DON'T do anything else after calling add_my_name_entry() */
 		  break;
@@ -505,7 +509,7 @@ void become_logon_server(struct subnet_record *d, struct work_record *work)
 		  work->log_state = LOGON_WAIT;
 
           /* XXXX the 0x1c is apparently something to do with domain logons */
-          add_my_name_entry(d, lp_workgroup(),0x1c,nb_type|NB_ACTIVE|NB_GROUP);
+          add_my_name_entry(d, myworkgroup,0x1c,nb_type|NB_ACTIVE|NB_GROUP);
 
 		  /* DON'T do anything else after calling add_my_name_entry() */
 		  break;
@@ -749,7 +753,7 @@ void process_election(struct packet_struct *p,char *buf)
   
   for (work = d->workgrouplist; work; work = work->next)
     {
-      if (!strequal(work->work_group, lp_workgroup()))
+      if (!strequal(work->work_group, myworkgroup))
 	continue;
 
       if (win_election(work, version,criterion,timeup,name)) {
diff --git a/source/nameresp.c b/source/nameresp.c
index f2b3ba167ae..27796ec07c4 100644
--- a/source/nameresp.c
+++ b/source/nameresp.c
@@ -263,13 +263,13 @@ struct response_record *queue_netbios_pkt_wins(
   if ((!lp_wins_support()) && (*lp_wins_server()))
     {
       /* samba is not a WINS server, and we are using a WINS server */
-      struct in_addr wins_ip;
-      wins_ip = *interpret_addr2(lp_wins_server());
+      struct in_addr real_wins_ip;
+      real_wins_ip = *interpret_addr2(lp_wins_server());
 
-      if (!zero_ip(wins_ip))
+      if (!zero_ip(real_wins_ip))
 	{
 	  bcast = False;
-	  send_ip = wins_ip;
+	  send_ip = real_wins_ip;
 	}
       else
 	{
diff --git a/source/nameserv.c b/source/nameserv.c
index 022b5521a21..91636428961 100644
--- a/source/nameserv.c
+++ b/source/nameserv.c
@@ -37,6 +37,7 @@ extern int DEBUGLEVEL;
 
 extern pstring scope;
 extern pstring myname;
+extern fstring myworkgroup;
 extern struct in_addr ipzero;
 extern struct in_addr wins_ip;
 
@@ -141,6 +142,9 @@ void add_my_name_entry(struct subnet_record *d,char *name,int type,int nb_flags)
     }
     else
     {
+      DEBUG(4,("add_my_name_entry registering name %s with WINS server.\n",
+                name));
+      
       /* a time-to-live allows us to refresh this name with the WINS server. */
   	  queue_netbios_pkt_wins(ClientNMB,
 				 re_reg ? NMB_REG_REFRESH : NMB_REG, NAME_REGISTER,
@@ -179,33 +183,32 @@ void add_domain_names(time_t t)
 
   for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
   {
-    work = find_workgroupstruct(d, lp_workgroup(), False);
+    work = find_workgroupstruct(d, myworkgroup, False);
     if (lp_domain_logons() && work && work->log_state == LOGON_NONE)
     {
-      make_nmb_name(&n,lp_workgroup(),0x1c,scope);
+      make_nmb_name(&n,myworkgroup,0x1c,scope);
       if (!find_name(d->namelist, &n, FIND_SELF))
       {
         /* logon servers are group names - we don't expect this to fail. */
         DEBUG(0,("%s attempting to become logon server for %s %s\n",
-             timestring(), lp_workgroup(), inet_ntoa(d->bcast_ip)));
+             timestring(), myworkgroup, inet_ntoa(d->bcast_ip)));
         become_logon_server(d, work);
       }
     }
   }
 
-  if(wins_subnet != 0)
-    work = find_workgroupstruct(wins_subnet, lp_workgroup(), False);
-
-  if (lp_domain_master() && work && work->dom_state == DOMAIN_NONE)
-    {
-
-      DEBUG(0,("add_domain_names:Checking for domain master on workgroup %s\n", lp_workgroup()));
+ for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
+ { 
+   work = find_workgroupstruct(d, myworkgroup, True);
 
-      make_nmb_name(&n,lp_workgroup(),0x1b,scope);
-      if (!find_name(wins_subnet->namelist, &n, FIND_SELF))
+   if (lp_domain_master() && work && work->dom_state == DOMAIN_NONE)
+     {
+      make_nmb_name(&n,myworkgroup,0x1b,scope);
+      if (!find_name(d->namelist, &n, FIND_SELF))
       {
-        DEBUG(0,("add_domain_names: attempting to become domain master browser on workgroup %s\n",
-                  lp_workgroup()));
+        DEBUG(0,("%s add_domain_names: attempting to become domain master \
+browser on workgroup %s %s\n",
+                  timestring(), myworkgroup, inet_ntoa(d->bcast_ip)));
 
         if (lp_wins_support())
         {
@@ -216,8 +219,8 @@ void add_domain_names(time_t t)
            */
                
           DEBUG(1,("%s initiating becoming domain master for %s\n",
-          		timestring(), lp_workgroup()));
-          become_domain_master(wins_subnet, work);
+          		timestring(), myworkgroup));
+          become_domain_master(d, work);
         }
         else
         {
@@ -228,15 +231,17 @@ void add_domain_names(time_t t)
              NetBIOS name 0x1b.
            */
 
-          DEBUG(0,("add_domain_names:querying WINS for domain master on workgroup %s\n", lp_workgroup()));
+          DEBUG(0,("add_domain_names:querying WINS for domain master \
+on workgroup %s\n", myworkgroup));
 
           queue_netbios_pkt_wins(ClientNMB,NMB_QUERY,NAME_QUERY_DOMAIN,
-          			lp_workgroup(), 0x1b,
+          			myworkgroup, 0x1b,
           			0, 0,0,NULL,NULL,
           			False, False, ipzero, ipzero);
         }
       }
     }
+  }
 }
 
 
@@ -255,7 +260,6 @@ void add_my_names(void)
   for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
   {
     BOOL wins = (lp_wins_support() && (d == wins_subnet));
-    struct work_record *work = find_workgroupstruct(d, lp_workgroup(), False);
 
     add_my_name_entry(d, myname,0x20,nb_type|NB_ACTIVE);
     add_my_name_entry(d, myname,0x03,nb_type|NB_ACTIVE);
diff --git a/source/nameservreply.c b/source/nameservreply.c
index e1738007df1..00e940df671 100644
--- a/source/nameservreply.c
+++ b/source/nameservreply.c
@@ -528,7 +528,8 @@ void reply_name_query(struct packet_struct *p)
     }
   }
 
-  DEBUG(3,("Name query "));
+  DEBUG(3,("Name query from %s for name %s<0x%x>\n", 
+                  inet_ntoa(p->ip), question->name, question->name_type));
   
   if (search == 0)
   {
diff --git a/source/namework.c b/source/namework.c
index 218a7a349ef..23d48d9ced7 100644
--- a/source/namework.c
+++ b/source/namework.c
@@ -37,6 +37,7 @@ extern pstring scope;
 extern BOOL CanRecurse;
 
 extern pstring myname;
+extern fstring myworkgroup;
 
 extern int ClientNMB;
 extern int ClientDGRAM;
@@ -603,7 +604,7 @@ static void process_reset_browser(struct packet_struct *p,char *buf)
 	  struct work_record *work;
 	  for (work=d->workgrouplist;work;work=remove_workgroup(d,work,True));
 	}
-      add_my_subnets(lp_workgroup());
+      add_my_subnets(myworkgroup);
     }
   
   /* stop browsing altogether. i don't think this is a good idea! */
@@ -639,7 +640,7 @@ static void process_announce_request(struct packet_struct *p,char *buf)
      this workgroup before announcing, particularly as we only
      respond on local interfaces anyway.
 
-     if (strequal(dgram->dest_name, lp_workgroup()) return; ???
+     if (strequal(dgram->dest_name, myworkgroup) return; ???
    */
 
   if (!d) 
diff --git a/source/nmbd/nmbd.c b/source/nmbd/nmbd.c
index 550f3198f7c..11f005b7852 100644
--- a/source/nmbd/nmbd.c
+++ b/source/nmbd/nmbd.c
@@ -40,6 +40,7 @@ int ClientDGRAM = -1;
 extern pstring myhostname;
 static pstring host_file;
 extern pstring myname;
+extern fstring myworkgroup;
 
 /* are we running as a daemon ? */
 static BOOL is_daemon = False;
@@ -67,7 +68,7 @@ static int sig_term()
   
   /* announce all server entries as 0 time-to-live, 0 type */
   /* XXXX don't care if we never receive a response back... yet */
-  remove_my_servers();
+  announce_my_servers_removed();
 
   /* XXXX other things: if we are a master browser, force an election? */
   
@@ -203,9 +204,6 @@ BOOL reload_services(BOOL test)
     reload_services(True);
   }
 
-  load_interfaces();
-  add_subnet_interfaces();
-
   /* Do a sanity check for a misconfigured nmbd */
   if(lp_wins_support() && *lp_wins_server()) {
     DEBUG(0,("ERROR: both 'wins support = true' and 'wins server = <server>' \
@@ -502,6 +500,8 @@ static void usage(char *pname)
 
   reload_services(True);
 
+  strcpy(myworkgroup, lp_workgroup());
+
   set_samba_nb_type();
 
   if (!is_daemon && !is_a_socket(0)) {
@@ -549,15 +549,16 @@ static void usage(char *pname)
     DEBUG(3,("Loaded hosts file\n"));
   }
 
+  load_interfaces();
+  add_my_subnets(myworkgroup);
+
   add_my_names();
 
-  if (strequal(lp_workgroup(),"*")) {
+  if (strequal(myworkgroup,"*")) {
     DEBUG(0,("ERROR: a workgroup name of * is no longer supported\n"));
     exit(1);
   }
 
-  add_my_subnets(lp_workgroup());
-
   DEBUG(3,("Checked names\n"));
   
   load_netbios_names();
diff --git a/source/param/loadparm.c b/source/param/loadparm.c
index 40611e4c3a3..af0b05bb5d8 100644
--- a/source/param/loadparm.c
+++ b/source/param/loadparm.c
@@ -152,8 +152,11 @@ typedef struct
   int os_level;
   int max_ttl;
   int ReadSize;
+  int shmem_size;
+  int shmem_hash_size;
   BOOL bWINSsupport;
   BOOL bWINSproxy;
+  BOOL bLocalMaster;
   BOOL bPreferredMaster;
   BOOL bDomainMaster;
   BOOL bDomainLogons;
@@ -427,6 +430,8 @@ struct parm_struct
   {"deadtime",         P_INTEGER, P_GLOBAL, &Globals.deadtime,          NULL},
   {"time offset",      P_INTEGER, P_GLOBAL, &extra_time_offset,         NULL},
   {"read size",        P_INTEGER, P_GLOBAL, &Globals.ReadSize,          NULL},
+  {"shared mem size",  P_INTEGER, P_GLOBAL, &Globals.shmem_size,        NULL},
+  {"shared file entries",  P_INTEGER, P_GLOBAL, &Globals.shmem_hash_size, NULL},
 #ifdef KANJI
   {"coding system",    P_INTEGER, P_GLOBAL, &coding_system, handle_coding_system},
 #endif /* KANJI */
@@ -437,6 +442,7 @@ struct parm_struct
   {"wins server",      P_STRING,  P_GLOBAL, &Globals.szWINSserver,      NULL},
   {"preferred master", P_BOOL,    P_GLOBAL, &Globals.bPreferredMaster,  NULL},
   {"prefered master",  P_BOOL,    P_GLOBAL, &Globals.bPreferredMaster,  NULL},
+  {"local master",     P_BOOL,    P_GLOBAL, &Globals.bLocalMaster,      NULL},
   {"domain master",    P_BOOL,    P_GLOBAL, &Globals.bDomainMaster,     NULL},
   {"domain logons",    P_BOOL,    P_GLOBAL, &Globals.bDomainLogons,     NULL},
   {"browse list",      P_BOOL,    P_GLOBAL, &Globals.bBrowseList,       NULL},
@@ -601,15 +607,11 @@ static void init_globals(void)
   Globals.bSyslogOnly = False;
   Globals.os_level = 0;
   Globals.max_ttl = 60*60*4; /* 2 hours default */
-  Globals.bPreferredMaster = True;
-  Globals.bDomainMaster = False;
-  Globals.bDomainLogons = False;
-  Globals.bBrowseList = True;
-  Globals.bWINSsupport = False;
-  Globals.bWINSproxy = False;
   Globals.ReadSize = 16*1024;
+  Globals.shmem_size = SHMEM_SIZE;
+  Globals.shmem_hash_size = SHMEM_HASH_SIZE;
   Globals.bUnixRealname = False;
-#ifdef NETGROUP
+#if (defined(NETGROUP) && defined(AUTOMOUNT))
   Globals.bNISHomeMap = False;
   string_set(&Globals.szNISHomeMapName, "auto.home");
 #endif
@@ -617,6 +619,25 @@ static void init_globals(void)
   coding_system = interpret_coding_system (KANJI, SJIS_CODE);
 #endif /* KANJI */
 
+/* these parameters are set to defaults that are more appropriate
+   for the increasing samba install base:
+
+   as a member of the workgroup, that will possibly become a
+   _local_ master browser (lm = True).  this is opposed to a forced
+   local master browser startup (pm = True).
+
+   doesn't provide WINS server service by default (wsupp = False),
+   and doesn't provide domain master browser services by default, either.
+
+*/
+
+  Globals.bPreferredMaster = False;
+  Globals.bLocalMaster = True;
+  Globals.bDomainMaster = False;
+  Globals.bDomainLogons = False;
+  Globals.bBrowseList = True;
+  Globals.bWINSsupport = False;
+  Globals.bWINSproxy = False;
 }
 
 /***************************************************************************
@@ -771,6 +792,7 @@ FN_GLOBAL_STRING(lp_nis_home_map_name,&Globals.szNISHomeMapName)
 
 FN_GLOBAL_BOOL(lp_wins_support,&Globals.bWINSsupport)
 FN_GLOBAL_BOOL(lp_wins_proxy,&Globals.bWINSproxy)
+FN_GLOBAL_BOOL(lp_local_master,&Globals.bLocalMaster)
 FN_GLOBAL_BOOL(lp_domain_master,&Globals.bDomainMaster)
 FN_GLOBAL_BOOL(lp_domain_logons,&Globals.bDomainLogons)
 FN_GLOBAL_BOOL(lp_preferred_master,&Globals.bPreferredMaster)
@@ -799,6 +821,8 @@ FN_GLOBAL_INTEGER(lp_maxpacket,&Globals.max_packet)
 FN_GLOBAL_INTEGER(lp_keepalive,&keepalive)
 FN_GLOBAL_INTEGER(lp_passwordlevel,&Globals.pwordlevel)
 FN_GLOBAL_INTEGER(lp_readsize,&Globals.ReadSize)
+FN_GLOBAL_INTEGER(lp_shmem_size,&Globals.shmem_size)
+FN_GLOBAL_INTEGER(lp_shmem_hash_size,&Globals.shmem_hash_size)
 FN_GLOBAL_INTEGER(lp_deadtime,&Globals.deadtime)
 FN_GLOBAL_INTEGER(lp_maxprotocol,&Globals.maxprotocol)
 FN_GLOBAL_INTEGER(lp_security,&Globals.security)
diff --git a/source/smbd/dir.c b/source/smbd/dir.c
index 2437b8b17e8..bc099dd1e8f 100644
--- a/source/smbd/dir.c
+++ b/source/smbd/dir.c
@@ -433,6 +433,7 @@ BOOL get_dir_entry(int cnum,char *mask,int dirtype,char *fname,int *size,int *mo
   BOOL isrootdir;
   pstring filename;
   BOOL matched;
+  BOOL needslash;
 
   *path = *pathreal = *filename = 0;
 
@@ -440,6 +441,9 @@ BOOL get_dir_entry(int cnum,char *mask,int dirtype,char *fname,int *size,int *mo
 	       strequal(Connections[cnum].dirpath,".") ||
 	       strequal(Connections[cnum].dirpath,"/"));
   
+  needslash = 
+        ( Connections[cnum].dirpath[strlen(Connections[cnum].dirpath) -1] != '/');
+
   if (!Connections[cnum].dirptr)
     return(False);
   
@@ -467,7 +471,8 @@ BOOL get_dir_entry(int cnum,char *mask,int dirtype,char *fname,int *size,int *mo
 	  strcpy(fname,filename);
 	  *path = 0;
 	  strcpy(path,Connections[cnum].dirpath);
-	  strcat(path,"/");
+          if(needslash)
+  	    strcat(path,"/");
 	  strcpy(pathreal,path);
 	  strcat(path,fname);
 	  strcat(pathreal,dname);
diff --git a/source/smbd/ipc.c b/source/smbd/ipc.c
index 1f1ac8600a0..8b9fb485ae0 100644
--- a/source/smbd/ipc.c
+++ b/source/smbd/ipc.c
@@ -37,6 +37,7 @@ extern files_struct Files[];
 extern connection_struct Connections[];
 
 extern fstring local_machine;
+extern fstring myworkgroup;
 
 #define NERR_Success 0
 #define NERR_badpass 86
@@ -812,7 +813,7 @@ static int get_server_info(uint32 servertype,
     if (!next_token(&ptr,s->comment, NULL)) continue;
     if (!next_token(&ptr,s->domain , NULL)) {
       /* this allows us to cope with an old nmbd */
-      strcpy(s->domain,lp_workgroup()); 
+      strcpy(s->domain,myworkgroup); 
     }
     
     if (sscanf(stype,"%X",&s->type) != 1) { 
@@ -982,7 +983,7 @@ static BOOL api_RNetServerEnum(int cnum, uint16 vuid, char *param, char *data,
   if (strcmp(str1, "WrLehDz") == 0) {
     StrnCpy(domain, p, sizeof(fstring)-1);
   } else {
-    StrnCpy(domain, lp_workgroup(), sizeof(fstring)-1);    
+    StrnCpy(domain, myworkgroup, sizeof(fstring)-1);    
   }
 
   if (lp_browse_list())
@@ -1668,7 +1669,7 @@ static BOOL api_RNetServerGetInfo(int cnum,uint16 vuid, char *param,char *data,
 
       strcpy(comment,lp_serverstring());
 
-      if ((count=get_server_info(SV_TYPE_ALL,&servers,lp_workgroup()))>0) {
+      if ((count=get_server_info(SV_TYPE_ALL,&servers,myworkgroup))>0) {
 	for (i=0;i<count;i++)
 	  if (strequal(servers[i].name,local_machine))
       {
@@ -1754,7 +1755,7 @@ static BOOL api_NetWkstaGetInfo(int cnum,uint16 vuid, char *param,char *data,
   p += 4;
 
   SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* login domain */
-  strcpy(p2,lp_workgroup());
+  strcpy(p2,myworkgroup);
   strupper(p2);
   p2 = skip_string(p2,1);
   p += 4;
@@ -1764,7 +1765,7 @@ static BOOL api_NetWkstaGetInfo(int cnum,uint16 vuid, char *param,char *data,
   p += 2;
 
   SIVAL(p,0,PTR_DIFF(p2,*rdata));
-  strcpy(p2,lp_workgroup());	/* don't know.  login domain?? */
+  strcpy(p2,myworkgroup);	/* don't know.  login domain?? */
   p2 = skip_string(p2,1);
   p += 4;
 
@@ -2228,7 +2229,7 @@ static BOOL api_WWkstaUserLogon(int cnum,uint16 vuid, char *param,char *data,
       strupper(mypath);
       PACKS(&desc,"z",mypath); /* computer */
     }
-    PACKS(&desc,"z",lp_workgroup());/* domain */
+    PACKS(&desc,"z",myworkgroup);/* domain */
     PACKS(&desc,"z",lp_logon_script());		/* script path */
     PACKI(&desc,"D",0x00000000);		/* reserved */
   }
diff --git a/source/smbd/pipes.c b/source/smbd/pipes.c
index 634d7af7f42..a294ee4f491 100644
--- a/source/smbd/pipes.c
+++ b/source/smbd/pipes.c
@@ -42,6 +42,7 @@ extern files_struct Files[];
 extern BOOL case_sensitive;
 extern pstring sesssetup_user;
 extern int Client;
+extern fstring myworkgroup;
 
 /* this macro should always be used to extract an fnum (smb_fid) from
 a packet to ensure chaining works correctly */
@@ -250,7 +251,7 @@ static void LsarpcTNP3(char *data,char **rdata, int *rdata_len)
 {
   uint32 dword1;
   uint16 word1;
-  char * workgroup = lp_workgroup();
+  char * workgroup = myworkgroup;
   int wglen = strlen(workgroup);
   int i;
 
diff --git a/source/smbd/reply.c b/source/smbd/reply.c
index bb75211deb5..639c386c2fa 100644
--- a/source/smbd/reply.c
+++ b/source/smbd/reply.c
@@ -40,6 +40,7 @@ extern BOOL case_sensitive;
 extern BOOL case_preserve;
 extern BOOL short_case_preserve;
 extern pstring sesssetup_user;
+extern fstring myworkgroup;
 extern int Client;
 
 /* this macro should always be used to extract an fnum (smb_fid) from
@@ -480,7 +481,7 @@ int reply_sesssetup_and_X(char *inbuf,char *outbuf,int length,int bufsize)
     p = smb_buf(outbuf);
     strcpy(p,"Unix"); p = skip_string(p,1);
     strcpy(p,"Samba "); strcat(p,VERSION); p = skip_string(p,1);
-    strcpy(p,lp_workgroup()); p = skip_string(p,1);
+    strcpy(p,myworkgroup); p = skip_string(p,1);
     set_message(outbuf,3,PTR_DIFF(p,smb_buf(outbuf)),False);
     /* perhaps grab OS version here?? */
   }
diff --git a/source/smbd/server.c b/source/smbd/server.c
index 0f72efc4788..fe0868b34ac 100644
--- a/source/smbd/server.c
+++ b/source/smbd/server.c
@@ -25,6 +25,7 @@
 pstring servicesf = CONFIGFILE;
 extern pstring debugf;
 extern pstring sesssetup_user;
+extern fstring myworkgroup;
 
 char *InBuffer = NULL;
 char *OutBuffer = NULL;
@@ -33,8 +34,6 @@ char *last_inbuf = NULL;
 int am_parent = 1;
 int atexit_set = 0;
 
-BOOL share_mode_pending = False;
-
 /* the last message the was processed */
 int last_message = -1;
 
@@ -113,6 +112,7 @@ static int find_free_connection(int hash);
 void  *dflt_sig(void)
 {
   exit_server("caught signal");
+  return 0; /* Keep -Wall happy :-) */
 }
 /****************************************************************************
   Send a SIGTERM to our process group.
@@ -837,8 +837,8 @@ file_fd_struct *fd_get_already_open(struct stat *sbuf)
   for(i = 0; i <= max_file_fd_used; i++) {
     fd_ptr = &FileFd[i];
     if((fd_ptr->ref_count > 0) &&
-       (((int32)sbuf->st_dev) == fd_ptr->dev) &&
-       (((int32)sbuf->st_ino) == fd_ptr->inode)) {
+       (((uint32)sbuf->st_dev) == fd_ptr->dev) &&
+       (((uint32)sbuf->st_ino) == fd_ptr->inode)) {
       fd_ptr->ref_count++;
       DEBUG(3,
        ("Re-used file_fd_struct %d, dev = %x, inode = %x, ref_count = %d\n",
@@ -861,8 +861,8 @@ file_fd_struct *fd_get_new()
   for(i = 0; i < MAX_OPEN_FILES; i++) {
     fd_ptr = &FileFd[i];
     if(fd_ptr->ref_count == 0) {
-      fd_ptr->dev = (int32)-1;
-      fd_ptr->inode = (int32)-1;
+      fd_ptr->dev = (uint32)-1;
+      fd_ptr->inode = (uint32)-1;
       fd_ptr->fd = -1;
       fd_ptr->fd_readonly = -1;
       fd_ptr->fd_writeonly = -1;
@@ -927,8 +927,8 @@ int fd_attempt_close(file_fd_struct *fd_ptr)
       fd_ptr->fd_readonly = -1;
       fd_ptr->fd_writeonly = -1;
       fd_ptr->real_open_flags = -1;
-      fd_ptr->dev = -1;
-      fd_ptr->inode = -1;
+      fd_ptr->dev = (uint32)-1;
+      fd_ptr->inode = (uint32)-1;
     }
   } 
  return fd_ptr->ref_count;
@@ -1124,8 +1124,8 @@ void open_file(int fnum,int cnum,char *fname1,int flags,int mode, struct stat *s
         sbuf = &statbuf;
       }
       /* Set the correct entries in fd_ptr. */
-      fd_ptr->dev = (int32)sbuf->st_dev;
-      fd_ptr->inode = (int32)sbuf->st_ino;
+      fd_ptr->dev = (uint32)sbuf->st_dev;
+      fd_ptr->inode = (uint32)sbuf->st_ino;
 
       Files[fnum].fd_ptr = fd_ptr;
       Connections[cnum].num_files_open++;
@@ -1141,7 +1141,6 @@ void open_file(int fnum,int cnum,char *fname1,int flags,int mode, struct stat *s
       Files[fnum].can_read = ((flags & O_WRONLY)==0);
       Files[fnum].can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
       Files[fnum].share_mode = 0;
-      Files[fnum].share_pending = False;
       Files[fnum].print_file = Connections[cnum].printer;
       Files[fnum].modified = False;
       Files[fnum].cnum = cnum;
@@ -1241,38 +1240,49 @@ close a file - possibly invalidating the read prediction
 ****************************************************************************/
 void close_file(int fnum)
 {
-  int cnum = Files[fnum].cnum;
-  invalidate_read_prediction(Files[fnum].fd_ptr->fd);
-  Files[fnum].open = False;
+  files_struct *fs_p = &Files[fnum];
+  int cnum = fs_p->cnum;
+  uint32 dev = fs_p->fd_ptr->dev;
+  uint32 inode = fs_p->fd_ptr->inode;
+  share_lock_token token;
+
+  invalidate_read_prediction(fs_p->fd_ptr->fd);
+  fs_p->open = False;
   Connections[cnum].num_files_open--;
-  if(Files[fnum].wbmpx_ptr) 
+  if(fs_p->wbmpx_ptr) 
     {
-      free((char *)Files[fnum].wbmpx_ptr);
-      Files[fnum].wbmpx_ptr = NULL;
+      free((char *)fs_p->wbmpx_ptr);
+      fs_p->wbmpx_ptr = NULL;
     }
 
 #if USE_MMAP
-  if(Files[fnum].mmap_ptr) 
+  if(fs_p->mmap_ptr) 
     {
-      munmap(Files[fnum].mmap_ptr,Files[fnum].mmap_size);
-      Files[fnum].mmap_ptr = NULL;
+      munmap(fs_p->mmap_ptr,fs_p->mmap_size);
+      fs_p->mmap_ptr = NULL;
     }
 #endif
 
   if (lp_share_modes(SNUM(cnum)))
-    del_share_mode(fnum);
+  {
+    lock_share_entry( cnum, dev, inode, &token);
+    del_share_mode(token, fnum);
+  }
+
+  fd_attempt_close(fs_p->fd_ptr);
 
-  fd_attempt_close(Files[fnum].fd_ptr);
+  if (lp_share_modes(SNUM(cnum)))
+    unlock_share_entry( cnum, dev, inode, token);
 
   /* NT uses smbclose to start a print - weird */
-  if (Files[fnum].print_file)
+  if (fs_p->print_file)
     print_file(fnum);
 
   /* check for magic scripts */
   check_magic(fnum,cnum);
 
   DEBUG(2,("%s %s closed file %s (numopen=%d)\n",
-	   timestring(),Connections[cnum].user,Files[fnum].name,
+	   timestring(),Connections[cnum].user,fs_p->name,
 	   Connections[cnum].num_files_open));
 }
 
@@ -1334,17 +1344,44 @@ return True if sharing doesn't prevent the operation
 ********************************************************************/
 BOOL check_file_sharing(int cnum,char *fname)
 {
-  int pid=0;
-  int share_mode = get_share_mode_byname(cnum,fname,&pid);
+  int i;
+  int ret = False;
+  min_share_mode_entry *old_shares = 0;
+  int num_share_modes;
+  struct stat sbuf;
+  share_lock_token token;
+  int pid = getpid();
 
-  if (!pid || !share_mode) return(True);
- 
-  if (share_mode == DENY_DOS)
-    return(pid == getpid());
+  if(!lp_share_modes(SNUM(cnum)))
+    return True;
+
+  if (stat(fname,&sbuf) == -1) return(True);
+
+  lock_share_entry(cnum, (uint32)sbuf.st_dev, (uint32)sbuf.st_ino, &token);
+  num_share_modes = get_share_modes(cnum, token, 
+                     (uint32)sbuf.st_dev, (uint32)sbuf.st_ino, &old_shares);
+
+  for( i = 0; i < num_share_modes; i++)
+  {
+    if (old_shares[i].share_mode != DENY_DOS)
+      goto free_and_exit;
+
+    if(old_shares[i].pid != pid);
+      goto free_and_exit;
+  }
 
   /* XXXX exactly what share mode combinations should be allowed for
      deleting/renaming? */
-  return(False);
+  /* If we got here then either there were no share modes or
+     all share modes were DENY_DOS and the pid == getpid() */
+  ret = True;
+
+free_and_exit:
+
+  unlock_share_entry(cnum, (uint32)sbuf.st_dev, (uint32)sbuf.st_ino, token);
+  if(old_shares != NULL)
+    free((char *)old_shares);
+  return(ret);
 }
 
 /****************************************************************************
@@ -1373,25 +1410,31 @@ open a file with a share mode
 void open_file_shared(int fnum,int cnum,char *fname,int share_mode,int ofun,
 		      int mode,int *Access,int *action)
 {
+  files_struct *fs_p = &Files[fnum];
   int flags=0;
   int flags2=0;
   int deny_mode = (share_mode>>4)&7;
   struct stat sbuf;
   BOOL file_existed = file_exist(fname,&sbuf);
+  BOOL share_locked = False;
   BOOL fcbopen = False;
-  int share_pid=0;
+  share_lock_token token;
+  uint32 dev = 0;
+  uint32 inode = 0;
 
-  Files[fnum].open = False;
-  Files[fnum].fd_ptr = 0;
+  fs_p->open = False;
+  fs_p->fd_ptr = 0;
 
   /* this is for OS/2 EAs - try and say we don't support them */
-  if (strstr(fname,".+,;=[].")) {
+  if (strstr(fname,".+,;=[].")) 
+  {
     unix_ERR_class = ERRDOS;
     unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
     return;
   }
 
-  if ((ofun & 0x3) == 0 && file_existed) {
+  if ((ofun & 0x3) == 0 && file_existed)  
+  {
     errno = EEXIST;
     return;
   }
@@ -1405,7 +1448,7 @@ void open_file_shared(int fnum,int cnum,char *fname,int share_mode,int ofun,
      append does not mean the same thing under dos and unix */
 
   switch (share_mode&0xF)
-    {
+  {
     case 1: 
       flags = O_WRONLY; 
       break;
@@ -1419,18 +1462,21 @@ void open_file_shared(int fnum,int cnum,char *fname,int share_mode,int ofun,
     default:
       flags = O_RDONLY;
       break;
-    }
+  }
   
   if (flags != O_RDONLY && file_existed && 
-      (!CAN_WRITE(cnum) || IS_DOS_READONLY(dos_mode(cnum,fname,&sbuf)))) {
-    if (!fcbopen) {
+      (!CAN_WRITE(cnum) || IS_DOS_READONLY(dos_mode(cnum,fname,&sbuf)))) 
+  {
+    if (!fcbopen) 
+    {
       errno = EACCES;
       return;
     }
     flags = O_RDONLY;
   }
 
-  if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
+  if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) 
+  {
     DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
     errno = EINVAL;
     return;
@@ -1438,21 +1484,36 @@ void open_file_shared(int fnum,int cnum,char *fname,int share_mode,int ofun,
 
   if (deny_mode == DENY_FCB) deny_mode = DENY_DOS;
 
-  if (lp_share_modes(SNUM(cnum))) {
-    int old_share=0;
+  if (lp_share_modes(SNUM(cnum))) 
+  {
+    int num_shares = 0;
+    int i;
+    min_share_mode_entry *old_shares = 0;
+
 
     if (file_existed)
-      old_share = get_share_mode(cnum,&sbuf,&share_pid);
+    {
+      dev = (uint32)sbuf.st_dev;
+      inode = (uint32)sbuf.st_ino;
+      lock_share_entry(cnum, dev, inode, &token);
+      share_locked = True;
+      num_shares = get_share_modes(cnum, token, dev, inode, &old_shares);
+    }
 
-    if (share_pid) {
+    for(i = 0; i < num_shares; i++)
+    {
       /* someone else has a share lock on it, check to see 
 	 if we can too */
-      int old_open_mode = old_share&0xF;
-      int old_deny_mode = (old_share>>4)&7;
+      int old_open_mode = old_shares[i].share_mode &0xF;
+      int old_deny_mode = (old_shares[i].share_mode >>4)&7;
 
-      if (deny_mode > 4 || old_deny_mode > 4 || old_open_mode > 2) {
+      if (deny_mode > 4 || old_deny_mode > 4 || old_open_mode > 2) 
+      {
 	DEBUG(2,("Invalid share mode (%d,%d,%d) on file %s\n",
 		 deny_mode,old_deny_mode,old_open_mode,fname));
+        free((char *)old_shares);
+        if(share_locked)
+          unlock_share_entry(cnum, dev, inode, token);
 	errno = EACCES;
 	unix_ERR_class = ERRDOS;
 	unix_ERR_code = ERRbadshare;
@@ -1461,21 +1522,25 @@ void open_file_shared(int fnum,int cnum,char *fname,int share_mode,int ofun,
 
       {
 	int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
-					  share_pid,fname);
+					  old_shares[i].pid,fname);
 
 	if ((access_allowed == AFAIL) ||
 	    (!fcbopen && (access_allowed == AREAD && flags == O_RDWR)) ||
 	    (access_allowed == AREAD && flags == O_WRONLY) ||
-	    (access_allowed == AWRITE && flags == O_RDONLY)) {
+	    (access_allowed == AWRITE && flags == O_RDONLY)) 
+        {
 	  DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s) = %d\n",
 		   deny_mode,old_deny_mode,old_open_mode,
-		   share_pid,fname,
+		   old_shares[i].pid,fname,
 		   access_allowed));
+          free((char *)old_shares);
+          if(share_locked)
+            unlock_share_entry(cnum, dev, inode, token);
 	  errno = EACCES;
 	  unix_ERR_class = ERRDOS;
 	  unix_ERR_code = ERRbadshare;
 	  return;
-	}
+        }
 	
 	if (access_allowed == AREAD)
 	  flags = O_RDONLY;
@@ -1484,76 +1549,69 @@ void open_file_shared(int fnum,int cnum,char *fname,int share_mode,int ofun,
 	  flags = O_WRONLY;
       }
     }
+    if(old_shares != 0)
+      free((char *)old_shares);
   }
 
   DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
 	   flags,flags2,mode));
 
   open_file(fnum,cnum,fname,flags|(flags2&~(O_TRUNC)),mode,file_existed ? &sbuf : 0);
-  if (!Files[fnum].open && flags==O_RDWR && errno!=ENOENT && fcbopen) {
+  if (!fs_p->open && flags==O_RDWR && errno!=ENOENT && fcbopen) 
+  {
     flags = O_RDONLY;
     open_file(fnum,cnum,fname,flags,mode,file_existed ? &sbuf : 0 );
   }
 
-  if (Files[fnum].open) {
+  if (fs_p->open) 
+  {
     int open_mode=0;
-    switch (flags) {
-    case O_RDONLY:
-      open_mode = 0;
-      break;
-    case O_RDWR:
-      open_mode = 2;
-      break;
-    case O_WRONLY:
-      open_mode = 1;
-      break;
+
+    if((share_locked == False) && lp_share_modes(SNUM(cnum)))
+    {
+      /* We created the file - thus we must now lock the share entry before creating it. */
+      dev = fs_p->fd_ptr->dev;
+      inode = fs_p->fd_ptr->inode;
+      lock_share_entry(cnum, dev, inode, &token);
+      share_locked = True;
     }
 
-    Files[fnum].share_mode = (deny_mode<<4) | open_mode;
-    Files[fnum].share_pending = True;
+    switch (flags) 
+    {
+      case O_RDONLY:
+        open_mode = 0;
+        break;
+      case O_RDWR:
+        open_mode = 2;
+        break;
+      case O_WRONLY:
+        open_mode = 1;
+        break;
+    }
+
+    fs_p->share_mode = (deny_mode<<4) | open_mode;
 
-    if (Access) {
+    if (Access)
       (*Access) = open_mode;
-    }
-    
-    if (action) {
+
+    if (action) 
+    {
       if (file_existed && !(flags2 & O_TRUNC)) *action = 1;
       if (!file_existed) *action = 2;
       if (file_existed && (flags2 & O_TRUNC)) *action = 3;
     }
 
-    if (!share_pid)
-      share_mode_pending = True;
-
     if ((flags2&O_TRUNC) && file_existed)
       truncate_unless_locked(fnum,cnum);
-  }
-}
-
 
+    if (lp_share_modes(SNUM(cnum)))
+      set_share_mode(token, fnum);
+  }
 
-/*******************************************************************
-check for files that we should now set our share modes on
-********************************************************************/
-static void check_share_modes(void)
-{
-  int i;
-  for (i=0;i<MAX_OPEN_FILES;i++)
-    if(Files[i].open && Files[i].share_pending) {
-      if (lp_share_modes(SNUM(Files[i].cnum))) {
-	int pid=0;
-	get_share_mode_by_fnum(Files[i].cnum,i,&pid);
-	if (!pid) {
-	  set_share_mode(i,Files[i].share_mode);
-	  Files[i].share_pending = False;
-	}
-      } else {
-	Files[i].share_pending = False;	
-      }
-    }
+  if (share_locked && lp_share_modes(SNUM(cnum)))
+    unlock_share_entry( cnum, dev, inode, token);
 }
 
-
 /****************************************************************************
 seek a file. Try to avoid the seek if possible
 ****************************************************************************/
@@ -2694,18 +2752,18 @@ int reply_nt1(char *outbuf)
    */
   encrypt_len = doencrypt?challenge_len:0;
 #if UNICODE
-  data_len = encrypt_len + 2*(strlen(lp_workgroup())+1);
+  data_len = encrypt_len + 2*(strlen(myworkgroup)+1);
 #else
-  data_len = encrypt_len + strlen(lp_workgroup()) + 1;
+  data_len = encrypt_len + strlen(myworkgroup) + 1;
 #endif
 
   set_message(outbuf,17,data_len,True);
 
 #if UNICODE
   /* put the OEM'd domain name */
-  PutUniCode(smb_buf(outbuf)+encrypt_len,lp_workgroup());
+  PutUniCode(smb_buf(outbuf)+encrypt_len,myworkgroup);
 #else
-  strcpy(smb_buf(outbuf)+encrypt_len, lp_workgroup());
+  strcpy(smb_buf(outbuf)+encrypt_len, myworkgroup);
 #endif
 
   CVAL(outbuf,smb_vwv1) = secword;
@@ -3258,9 +3316,9 @@ void exit_server(char *reason)
 #endif
   }    
 
-#if FAST_SHARE_MODES
+#ifdef FAST_SHARE_MODES
   stop_share_mode_mgmt();
-#endif
+#endif /* FAST_SHARE_MODES */
 
   DEBUG(3,("%s Server exit  (%s)\n",timestring(),reason?reason:""));
   exit(0);
@@ -3738,24 +3796,6 @@ static void process(void)
       if (lp_readprediction())
 	do_read_prediction();
 
-      {
-	extern pstring share_del_pending;
-	if (*share_del_pending) {
-	  unbecome_user();
-	  if (!unlink(share_del_pending))
-	    DEBUG(3,("Share file deleted %s\n",share_del_pending));
-	  else
-	    DEBUG(2,("Share del failed of %s\n",share_del_pending));
-	  share_del_pending[0] = 0;
-	}
-      }
-
-      if (share_mode_pending) {
-	unbecome_user();
-	check_share_modes();
-	share_mode_pending=False;
-      }
-
       errno = 0;      
 
       for (counter=SMBD_SELECT_LOOP; 
@@ -3787,6 +3827,7 @@ static void process(void)
 	  if (!(counter%SMBD_RELOAD_CHECK))
 	    reload_services(True);
 
+#if 0 /* JRA */
 	  /* check the share modes every 10 secs */
 	  if (!(counter%SHARE_MODES_CHECK))
 	    check_share_modes();
@@ -3794,6 +3835,7 @@ static void process(void)
 	  /* clean the share modes every 5 minutes */
 	  if (!(counter%SHARE_MODES_CLEAN))
 	    clean_share_modes();
+#endif /* JRA */
 
 	  /* automatic timeout if all connections are closed */      
 	  if (num_connections_open==0 && counter >= IDLE_CLOSED_TIMEOUT) {
@@ -4082,6 +4124,8 @@ static void usage(char *pname)
   if (!reload_services(False))
     return(-1);	
 
+  strcpy(myworkgroup, lp_workgroup());
+
 #ifndef NO_SIGNAL_TEST
   signal(SIGHUP,SIGNAL_CAST sig_hup);
 #endif
@@ -4128,10 +4172,10 @@ static void usage(char *pname)
   if (!open_sockets(is_daemon,port))
     exit(1);
 
-#if FAST_SHARE_MODES
+#ifdef FAST_SHARE_MODES
   if (!start_share_mode_mgmt())
     exit(1);
-#endif
+#endif /* FAST_SHARE_MODES */
 
   /* possibly reload the services file. */
   reload_services(True);
diff --git a/source/smbd/trans2.c b/source/smbd/trans2.c
index 38c7031b665..1d9977c66e0 100644
--- a/source/smbd/trans2.c
+++ b/source/smbd/trans2.c
@@ -277,6 +277,7 @@ static int get_lanman2_dir_entry(int cnum,char *path_mask,int dirtype,int info_l
 		    strequal(Connections[cnum].dirpath,"/"));
   BOOL was_8_3;
   int nt_extmode; /* Used for NT connections instead of mode */
+  BOOL needslash = ( Connections[cnum].dirpath[strlen(Connections[cnum].dirpath) -1] != '/');
 
   *fname = 0;
   *out_of_space = False;
@@ -323,7 +324,8 @@ static int get_lanman2_dir_entry(int cnum,char *path_mask,int dirtype,int info_l
 	    continue;
 
 	  strcpy(pathreal,Connections[cnum].dirpath);
-	  strcat(pathreal,"/");
+          if(needslash)
+  	    strcat(pathreal,"/");
 	  strcat(pathreal,fname);
 	  if (sys_stat(pathreal,&sbuf) != 0) 
 	    {
diff --git a/source/utils/status.c b/source/utils/status.c
index e8e57b3dd7c..b439741e6c6 100644
--- a/source/utils/status.c
+++ b/source/utils/status.c
@@ -53,6 +53,81 @@ int            Ucrit_pid[100];  /* Ugly !!! */        /* added by OH */
 int            Ucrit_MaxPid=0;                        /* added by OH */
 unsigned int   Ucrit_IsActive = 0;                    /* added by OH */
 
+#ifndef FAST_SHARE_MODES
+static char *read_share_file(int fd, char *fname, char *progname)
+{
+  struct stat sb;
+  char *buf;
+  int size;
+
+  if(fstat(fd, &sb) != 0)
+  {
+    printf("%s: ERROR: read_share_file: Failed to do stat on share file %s (%s)\n",
+                  progname, fname, strerror(errno));
+    return 0;
+  }
+
+  if(sb.st_size == 0)
+  {
+     return 0;
+  }
+
+  /* Allocate space for the file */
+  if((buf = (char *)malloc(sb.st_size)) == NULL)
+  {
+    printf("%s: read_share_file: malloc for file size %d fail !\n", 
+              progname, (int)sb.st_size);
+    return 0;
+  }
+
+  if(lseek(fd, 0, SEEK_SET) != 0)
+  {
+    printf("%s: ERROR: read_share_file: Failed to reset position to 0 \
+for share file %s (%s)\n", progname, fname, strerror(errno));
+    if(buf)
+      free(buf);
+    return 0;
+  }
+
+  if (read(fd,buf,sb.st_size) != sb.st_size)
+  {
+    printf("%s: ERROR: read_share_file: Failed to read share file %s (%s)\n",
+               progname, fname, strerror(errno));
+    if(buf)
+      free(buf);
+    return 0;
+  }
+
+  if (IVAL(buf,0) != LOCKING_VERSION) {
+    printf("%s: ERROR: read_share_file: share file %s has incorrect \
+locking version (was %d, should be %d).\n",fname, 
+              progname, IVAL(buf,0), LOCKING_VERSION);
+    if(buf)
+      free(buf);
+    return 0;
+  }
+
+  /* Sanity check for file contents */
+  size = sb.st_size;
+  size -= 10; /* Remove the header */
+
+  /* Remove the filename component. */
+  size -= SVAL(buf, 8);
+
+  /* The remaining size must be a multiple of 16 - error if not. */
+  if((size % 16) != 0)
+  {
+    printf("%s: ERROR: read_share_file: share file %s is an incorrect length.\n", 
+             progname, fname);
+    if(buf)
+      free(buf);
+    return 0;
+  }
+
+  return buf;
+}
+#endif /* FAST_SHARE_MODES */
+
  int main(int argc, char *argv[])
 {
   FILE *f;
@@ -64,16 +139,16 @@ unsigned int   Ucrit_IsActive = 0;                    /* added by OH */
   BOOL firstopen=True;
   BOOL processes_only=False;
   int last_pid=0;
-#if FAST_SHARE_MODES
+#ifdef FAST_SHARE_MODES
   pstring shmem_file_name;
-  share_mode_record *scanner_p;
-  share_mode_record *prev_p;
+  share_mode_record *file_scanner_p;
+  smb_shm_offset_t *mode_array;
   int bytes_free, bytes_used, bytes_overhead, bytes_total;
-#else
-  int n;
+#else /* FAST_SHARE_MODES */
   void *dir;
   char *s;
-#endif
+#endif /* FAST_SHARE_MODES */
+  int i;
   struct session_record *ptr;
 
 
@@ -226,101 +301,110 @@ unsigned int   Ucrit_IsActive = 0;                    /* added by OH */
 
   printf("\n");
 
-#if FAST_SHARE_MODES
+#ifdef FAST_SHARE_MODES 
   /*******************************************************************
   initialize the shared memory for share_mode management 
   ******************************************************************/
-
    
   strcpy(shmem_file_name,lp_lockdir());
   trim_string(shmem_file_name,"","/");
   if (!*shmem_file_name) exit(-1);
   strcat(shmem_file_name, "/SHARE_MEM_FILE");
-  if(!smb_shm_open(shmem_file_name, SHMEM_SIZE)) exit(-1);
+  if(!smb_shm_open(shmem_file_name, lp_shmem_size())) exit(-1);
   
-  if(!smb_shm_lock())
+  mode_array = (smb_shm_offset_t *)smb_shm_offset2addr(smb_shm_get_userdef_off());
+  if(mode_array == NULL)
   {
-     smb_shm_close();
-     exit (-1);
+    printf("%s: base of shared memory hash array == 0! Exiting.\n", argv[0]);
+    smb_shm_close();
+    exit(-1);
   }
 
-  scanner_p = (share_mode_record *)smb_shm_offset2addr(smb_shm_get_userdef_off());
-  prev_p = scanner_p;
-  while(scanner_p)
+  for( i = 0; i < lp_shmem_hash_size(); i++)
   {
-     int pid,mode;
-     struct timeval t;
-     
-     pid = scanner_p->pid;
-     
-     if ( !Ucrit_checkPid(pid) )
-     {
-	prev_p = scanner_p ;
-	scanner_p = (share_mode_record *)smb_shm_offset2addr(scanner_p->next_offset);
-	continue;
-     }
+    smb_shm_lock_hash_entry(i);
+    if(mode_array[i] == NULL_OFFSET)
+    {
+      smb_shm_unlock_hash_entry(i);
+      continue;
+    }
+    file_scanner_p = (share_mode_record *)smb_shm_offset2addr(mode_array[i]);
+    while((file_scanner_p != 0) && (file_scanner_p->num_share_mode_entries != 0))
+    {
+      share_mode_entry *entry_scanner_p = 
+                 (share_mode_entry *)smb_shm_offset2addr(
+                                       file_scanner_p->share_mode_entries);
+
+      while(entry_scanner_p != 0)
+      {
+        struct timeval t;
+        int pid = entry_scanner_p->pid;
+        int mode = entry_scanner_p->share_mode;
      
-     if( (scanner_p->locking_version != LOCKING_VERSION) || !process_exists(pid))
+        t.tv_sec = entry_scanner_p->time.tv_sec;
+        t.tv_usec = entry_scanner_p->time.tv_usec;
+        strcpy(fname, file_scanner_p->file_name);
+#else /* FAST_SHARE_MODES */
+
+     /* For slow share modes go through all the files in
+        the share mode directory and read the entries in
+        each.
+      */
+
+     dir = opendir(lp_lockdir());
+     if (!dir) 
      {
-	DEBUG(2,("Deleting stale share mode record"));
-	if(prev_p == scanner_p)
-	{
-	   smb_shm_set_userdef_off(scanner_p->next_offset);
-	   smb_shm_free(smb_shm_addr2offset(scanner_p));
-           scanner_p = (share_mode_record *)smb_shm_offset2addr(smb_shm_get_userdef_off());
-           prev_p = scanner_p;
-	}
-	else
-	{
-	   prev_p->next_offset = scanner_p->next_offset;
-  	   smb_shm_free(smb_shm_addr2offset(scanner_p));
-           scanner_p = (share_mode_record *)smb_shm_offset2addr(prev_p->next_offset);
-	}
-	continue;
+       printf("%s: Unable to open lock directory %s.\n", argv[0], lp_lockdir());
+       return(0);
      }
-     t.tv_sec = scanner_p->time.tv_sec;
-     t.tv_usec = scanner_p->time.tv_usec;
-     mode = scanner_p->share_mode;
-     strcpy(fname, scanner_p->file_name);
-#else
-     dir = opendir(lp_lockdir());
-     if (!dir) return(0);
      while ((s=readdirname(dir))) {
-       char buf[20];
-       int pid,mode;
-       struct timeval t;
+       char *buf;
+       char *base;
        int fd;
        pstring lname;
-       int dev,inode;
+       uint32 dev,inode;
        
-       if (sscanf(s,"share.%d.%d",&dev,&inode)!=2) continue;
+       if (sscanf(s,"share.%u.%u",&dev,&inode)!=2) continue;
        
        strcpy(lname,lp_lockdir());
        trim_string(lname,NULL,"/");
        strcat(lname,"/");
        strcat(lname,s);
        
-       fd = open(lname,O_RDONLY,0);
-       if (fd < 0) continue;
-       if (read(fd,buf,20) != 20) continue;
-       n = read(fd,fname,sizeof(fname));
-       fname[MAX(n,0)]=0;
-       close(fd);
-       
-       t.tv_sec = IVAL(buf,4);
-       t.tv_usec = IVAL(buf,8);
-       mode = IVAL(buf,12);
-       pid = IVAL(buf,16);
-       
-       if ( !Ucrit_checkPid(pid) )             /* added by OH */
-	 continue;
-       
-       if (IVAL(buf,0) != LOCKING_VERSION || !process_exists(pid)) {
-	 if (unlink(lname)==0)
-	   printf("Deleted stale share file %s\n",s);
-	 continue;
+       fd = open(lname,O_RDWR,0);
+       if (fd < 0) 
+       {
+         printf("%s: Unable to open share file %s.\n", argv[0], lname);
+         continue;
        }
-#endif
+
+       /* Lock the share mode file while we read it. */
+       if(fcntl_lock(fd, F_SETLKW, 0, 1, F_WRLCK) == False)
+       {
+         printf("%s: Unable to lock open share file %s.\n", argv[0], lname);
+         close(fd);
+         continue;
+       }
+
+       if(( buf = read_share_file( fd, lname, argv[0] )) == NULL)
+       {
+         close(fd);
+         continue;
+       } 
+       strcpy( fname, &buf[10]);
+       close(fd);
+      
+       base = buf + 10 + SVAL(buf,8); 
+       for( i = 0; i < IVAL(buf, 4); i++)
+       {
+         char *p = base + (i*16);
+         struct timeval t;
+         int pid = IVAL(p,12);
+         int mode = IVAL(p,8);
+     
+         t.tv_sec = IVAL(p,0);
+         t.tv_usec = IVAL(p,4);
+#endif /* FAST_SHARE_MODES */
 
     fname[sizeof(fname)-1] = 0;
 
@@ -349,28 +433,38 @@ unsigned int   Ucrit_IsActive = 0;                    /* added by OH */
       }
     printf(" %s   %s",fname,asctime(LocalTime((time_t *)&t.tv_sec)));
 
-#if FAST_SHARE_MODES
-     prev_p = scanner_p ;
-     scanner_p = (share_mode_record *)smb_shm_offset2addr(scanner_p->next_offset);
-  } /* end while */
+#ifdef FAST_SHARE_MODES
+
+        entry_scanner_p = (share_mode_entry *)smb_shm_offset2addr(
+                                    entry_scanner_p->next_share_mode_entry);
+      } /* end while entry_scanner_p */
+     file_scanner_p = (share_mode_record *)smb_shm_offset2addr(
+                                    file_scanner_p->next_offset);
+    } /* end while file_scanner_p */
+    smb_shm_unlock_hash_entry(i);
+  } /* end for */
 
   smb_shm_get_usage(&bytes_free, &bytes_used, &bytes_overhead);
   bytes_total = bytes_free + bytes_used + bytes_overhead;
-  smb_shm_unlock();
 
   /*******************************************************************
   deinitialize the shared memory for share_mode management 
   ******************************************************************/
   smb_shm_close();
 
-#else
+#else /* FAST_SHARE_MODES */
+    } /* end for i */
+
+    if(buf)
+      free(buf);
+    base = 0;
   } /* end while */
   closedir(dir);
 
-#endif
+#endif /* FAST_SHARE_MODES */
   if (firstopen)
     printf("No locked files\n");
-#if FAST_SHARE_MODES
+#ifdef FAST_SHARE_MODES
   printf("\nShare mode memory usage (bytes):\n");
   printf("   %d(%d%%) free + %d(%d%%) used + %d(%d%%) overhead = %d(100%%) total\n",
 	 bytes_free, (bytes_free * 100)/bytes_total,
@@ -378,7 +472,7 @@ unsigned int   Ucrit_IsActive = 0;                    /* added by OH */
 	 bytes_overhead, (bytes_overhead * 100)/bytes_total,
 	 bytes_total);
   
-#endif
+#endif /* FAST_SHARE_MODES */
 
   return (0);
 }