change the default file permissions on the SHARE_MEM_FILE* to

0644. smbstatus now gets only read permission on the share files and
does no locking.

also get rid of some unnecessary umask(0) calls. smbd always runs with
umask(0)

7 files changed, 76 insertions, 47 deletions

diff --git a/source/include/proto.h b/source/include/proto.h
index f0c855c689a..cdecd1ec884 100644
--- a/source/include/proto.h
+++ b/source/include/proto.h
@@ -351,7 +351,7 @@ int lp_minor_announce_version(void);
 BOOL is_locked(int fnum,int cnum,uint32 count,uint32 offset);
 BOOL do_lock(int fnum,int cnum,uint32 count,uint32 offset,int *eclass,uint32 *ecode);
 BOOL do_unlock(int fnum,int cnum,uint32 count,uint32 offset,int *eclass,uint32 *ecode);
-BOOL locking_init(void);
+BOOL locking_init(int read_only);
 BOOL locking_end(void);
 BOOL lock_share_entry(int cnum, uint32 dev, uint32 inode, int *ptok);
 BOOL unlock_share_entry(int cnum, uint32 dev, uint32 inode, int token);
@@ -365,11 +365,11 @@ void share_status(FILE *f);
 
 /*The following definitions come from  locking_shm.c  */
 
-struct share_ops *locking_shm_init(void);
+struct share_ops *locking_shm_init(int ronly);
 
 /*The following definitions come from  locking_slow.c  */
 
-struct share_ops *locking_slow_init(void);
+struct share_ops *locking_slow_init(int ronly);
 
 /*The following definitions come from  lsaparse.c  */
 
@@ -869,7 +869,7 @@ int construct_reply(char *inbuf,char *outbuf,int size,int bufsize);
 
 /*The following definitions come from  shmem.c  */
 
-BOOL smb_shm_open(char *file_name, int size);
+BOOL smb_shm_open(char *file_name, int size, int ronly);
 BOOL smb_shm_close( void );
 int smb_shm_alloc(int size);
 BOOL smb_shm_free(int offset);
diff --git a/source/locking/locking.c b/source/locking/locking.c
index c75497c6b92..ae977b0f698 100644
--- a/source/locking/locking.c
+++ b/source/locking/locking.c
@@ -111,17 +111,17 @@ BOOL do_unlock(int fnum,int cnum,uint32 count,uint32 offset,int *eclass,uint32 *
 /****************************************************************************
   initialise the locking functions
 ****************************************************************************/
-BOOL locking_init(void)
+BOOL locking_init(int read_only)
 {
 #ifdef FAST_SHARE_MODES
-	share_ops = locking_shm_init();
+	share_ops = locking_shm_init(read_only);
 	if (!share_ops) {
 		DEBUG(0,("ERROR: Failed to initialise fast share modes - trying slow code\n"));
 	}
 	if (share_ops) return True;
 #endif	
 
-	share_ops = locking_slow_init();
+	share_ops = locking_slow_init(read_only);
 	if (!share_ops) {
 		DEBUG(0,("ERROR: Failed to initialise share modes!\n"));
 		return False;
diff --git a/source/locking/locking_shm.c b/source/locking/locking_shm.c
index 8383b687e41..410fcb9760b 100644
--- a/source/locking/locking_shm.c
+++ b/source/locking/locking_shm.c
@@ -58,6 +58,7 @@ typedef struct
 	share_mode_entry e;
 } shm_share_mode_entry;
 
+static int read_only;
 
 /*******************************************************************
   deinitialize the shared memory for share_mode management 
@@ -715,17 +716,21 @@ static struct share_ops share_ops = {
 /*******************************************************************
   initialize the shared memory for share_mode management 
   ******************************************************************/
-struct share_ops *locking_shm_init(void)
+struct share_ops *locking_shm_init(int ronly)
 {
 	pstring shmem_file_name;
+
+	read_only = ronly;
    
 	pstrcpy(shmem_file_name,lp_lockdir());
-	if (!directory_exist(shmem_file_name,NULL))
+	if (!directory_exist(shmem_file_name,NULL)) {
+		if (read_only) return NULL;
 		mkdir(shmem_file_name,0755);
+	}
 	trim_string(shmem_file_name,"","/");
 	if (!*shmem_file_name) return(False);
 	strcat(shmem_file_name, "/SHARE_MEM_FILE");
-	if (smb_shm_open(shmem_file_name, lp_shmem_size()))
+	if (smb_shm_open(shmem_file_name, lp_shmem_size(), read_only))
 		return &share_ops;
 	return NULL;
 }
diff --git a/source/locking/locking_slow.c b/source/locking/locking_slow.c
index cc646c6ca6d..9bd6d65aa79 100644
--- a/source/locking/locking_slow.c
+++ b/source/locking/locking_slow.c
@@ -58,6 +58,14 @@ extern files_struct Files[];
 #define SME_PORT_OFFSET 16
 #define SME_OPLOCK_TYPE_OFFSET 18
 
+/* we need world read for smbstatus to function correctly */
+#ifdef SECURE_SHARE_MODES
+#define SHARE_FILE_MODE 0600
+#else
+#define SHARE_FILE_MODE 0644
+#endif
+
+static int read_only;
 
 /*******************************************************************
   deinitialize share_mode management 
@@ -87,6 +95,8 @@ Force a share file to be deleted.
 ********************************************************************/
 static int delete_share_file( int cnum, char *fname )
 {
+  if (read_only) return -1;
+
   /* the share file could be owned by anyone, so do this as root */
   become_root(False);
 
@@ -120,14 +130,13 @@ static BOOL slow_lock_share_entry(int cnum, uint32 dev, uint32 inode, int *ptok)
   if(!share_name(cnum, dev, inode, fname))
     return False;
 
+  if (read_only) return True;
+
   /* we need to do this as root */
   become_root(False);
 
   {
-    int old_umask;
     BOOL gotlock = False;
-    old_umask = umask(0);
-
     /*
      * There was a race condition in the original slow share mode code.
      * A smbd could open a share mode file, and before getting
@@ -147,11 +156,8 @@ static BOOL slow_lock_share_entry(int cnum, uint32 dev, uint32 inode, int *ptok)
     {
       struct stat dummy_stat;
 
-#ifdef SECURE_SHARE_MODES
-      fd = (int)open(fname,O_RDWR|O_CREAT,0600);
-#else /* SECURE_SHARE_MODES */
-      fd = (int)open(fname,O_RDWR|O_CREAT,0666);
-#endif /* SECURE_SHARE_MODES */
+      fd = (int)open(fname,read_only?O_RDONLY:(O_RDWR|O_CREAT),
+		     SHARE_FILE_MODE);
 
       if(fd < 0)
       {
@@ -192,8 +198,6 @@ static BOOL slow_lock_share_entry(int cnum, uint32 dev, uint32 inode, int *ptok)
      * as we don't want to return and leave ourselves running
      * as root !
      */
-
-    umask(old_umask);
   }
 
   *ptok = (int)fd;
@@ -214,6 +218,8 @@ static BOOL slow_unlock_share_entry(int cnum, uint32 dev, uint32 inode, int toke
   struct stat sb;
   pstring fname;
 
+  if (read_only) return True;
+
   /* Fix for zero length share files from
      Gerald Werner <wernerg@mfldclin.edu> */
     
@@ -959,13 +965,14 @@ static int slow_share_forall(void (*fn)(share_mode_entry *, char *))
 		strcat(lname,"/");
 		strcat(lname,s);
        
-		fd = open(lname,O_RDWR,0);
+		fd = open(lname,read_only?O_RDONLY:O_RDWR,0);
 		if (fd < 0) {
 			continue;
 		}
 
 		/* Lock the share mode file while we read it. */
-		if(fcntl_lock(fd, F_SETLKW, 0, 1, F_WRLCK) == False) {
+		if(!read_only &&
+		   fcntl_lock(fd, F_SETLKW, 0, 1, F_WRLCK) == False) {
 			close(fd);
 			continue;
 		}
@@ -1027,10 +1034,14 @@ static struct share_ops share_ops = {
 /*******************************************************************
   initialize the slow share_mode management 
   ******************************************************************/
-struct share_ops *locking_slow_init(void)
+struct share_ops *locking_slow_init(int ronly)
 {
+
+	read_only = ronly;
+
 	if (!directory_exist(lp_lockdir(),NULL)) {
-		mkdir(lp_lockdir(),0755);
+		if (!read_only)
+			mkdir(lp_lockdir(),0755);
 		if (!directory_exist(lp_lockdir(),NULL))
 			return NULL;
 	}
diff --git a/source/locking/shmem.c b/source/locking/shmem.c
index 9daca3e4829..1f9cb8b7327 100644
--- a/source/locking/shmem.c
+++ b/source/locking/shmem.c
@@ -34,6 +34,13 @@ extern int DEBUGLEVEL;
 
 #define SMB_SHM_VERSION 2
 
+/* we need world read for smbstatus to function correctly */
+#ifdef SECURE_SHARE_MODES
+#define SHM_FILE_MODE 0600
+#else
+#define SHM_FILE_MODE 0644
+#endif
+
 /* WARNING : offsets are used because mmap() does not guarantee that all processes have the 
    shared memory mapped to the same address */
 
@@ -75,6 +82,8 @@ static int smb_shm_times_locked = 0;
 
 static BOOL smb_shm_initialize_called = False;
 
+static int read_only;
+
 static BOOL smb_shm_global_lock(void)
 {
    if (smb_shm_fd < 0)
@@ -90,6 +99,9 @@ static BOOL smb_shm_global_lock(void)
       DEBUG(5,("smb_shm_global_lock : locked %d times\n",smb_shm_times_locked));
       return True;
    }
+
+   if (read_only)
+	   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)
@@ -124,6 +136,9 @@ static BOOL smb_shm_global_unlock(void)
       DEBUG(5,("smb_shm_global_unlock : still locked %d times\n",smb_shm_times_locked));
       return True;
    }
+
+   if (read_only)
+	   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)
@@ -170,11 +185,10 @@ static BOOL smb_shm_register_process(char *processreg_file, pid_t pid, BOOL *oth
    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 */
+   smb_shm_processes_fd = open(processreg_file, 
+			       read_only?O_RDONLY:(O_RDWR|O_CREAT), 
+			       SHM_FILE_MODE);
+
    if ( smb_shm_processes_fd < 0 )
    {
       DEBUG(0,("ERROR smb_shm_register_process : processreg_file open failed with code %s\n",strerror(errno)));
@@ -231,7 +245,6 @@ static BOOL smb_shm_register_process(char *processreg_file, pid_t pid, BOOL *oth
 
 static BOOL smb_shm_unregister_process(char *processreg_file, pid_t pid)
 {
-   int old_umask;
    int smb_shm_processes_fd = -1;
    int nb_read;
    pid_t other_pid;
@@ -240,9 +253,7 @@ static BOOL smb_shm_unregister_process(char *processreg_file, pid_t pid)
    BOOL found = False;
    
    
-   old_umask = umask(0);
    smb_shm_processes_fd = open(processreg_file, O_RDWR);
-   umask(old_umask);
    if ( smb_shm_processes_fd < 0 )
    {
       DEBUG(0,("ERROR smb_shm_unregister_process : processreg_file open failed with code %s\n",strerror(errno)));
@@ -380,22 +391,19 @@ static void smb_shm_solve_neighbors(struct SmbShmBlockDesc *head_p )
 
 
 
-BOOL smb_shm_open(char *file_name, int size)
+BOOL smb_shm_open(char *file_name, int size, int ronly)
 {
    int filesize;
    BOOL created_new = False;
    BOOL other_processes = True;
-   int old_umask;
+
+   read_only = ronly;
    
    DEBUG(5,("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);
+   smb_shm_fd = open(file_name, read_only?O_RDONLY:(O_RDWR|O_CREAT),
+		     SHM_FILE_MODE);
+
    if ( smb_shm_fd < 0 )
    {
       DEBUG(0,("ERROR smb_shm_open : open failed with code %s\n",strerror(errno)));
@@ -433,14 +441,15 @@ BOOL smb_shm_open(char *file_name, int size)
    strcpy(smb_shm_processreg_name, file_name);
    strcat(smb_shm_processreg_name, ".processes");
 
-   if (! smb_shm_register_process(smb_shm_processreg_name, getpid(), &other_processes))
+   if (!read_only && 
+       !smb_shm_register_process(smb_shm_processreg_name, getpid(), &other_processes))
    {
       smb_shm_global_unlock();
       close(smb_shm_fd);
       return False;
    }
 
-   if (created_new || !other_processes)
+   if (!read_only && (created_new || !other_processes))
    {
       /* we just created a new one, or are the first opener, lets set it size */
       if( ftruncate(smb_shm_fd, size) <0)
@@ -466,7 +475,11 @@ BOOL smb_shm_open(char *file_name, int size)
       size = filesize;
    }
    
-   smb_shm_header_p = (struct SmbShmHeader *)mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, smb_shm_fd, 0);
+   smb_shm_header_p = (struct SmbShmHeader *)mmap(NULL, size, 
+						  read_only?PROT_READ:
+						  (PROT_READ | PROT_WRITE), 
+						  MAP_FILE | MAP_SHARED, 
+						  smb_shm_fd, 0);
    /* WARNING, smb_shm_header_p can be different for different processes mapping the same file ! */
    if (smb_shm_header_p  == (struct SmbShmHeader *)(-1))
    {
@@ -478,7 +491,7 @@ BOOL smb_shm_open(char *file_name, int size)
    }      
    
       
-   if (created_new || !other_processes)
+   if (!read_only && (created_new || !other_processes))
    {
       smb_shm_initialize(size);
       /* Create the hash buckets for the share file entries. */
diff --git a/source/smbd/server.c b/source/smbd/server.c
index 88f7497ee53..93042e119b0 100644
--- a/source/smbd/server.c
+++ b/source/smbd/server.c
@@ -5145,7 +5145,7 @@ static void usage(char *pname)
   if (!open_sockets(is_daemon,port))
     exit(1);
 
-  if (!locking_init())
+  if (!locking_init(0))
     exit(1);
 
   /* possibly reload the services file. */
diff --git a/source/utils/status.c b/source/utils/status.c
index 3e349f920a2..f124d79939c 100644
--- a/source/utils/status.c
+++ b/source/utils/status.c
@@ -262,7 +262,7 @@ static void print_share_mode(share_mode_entry *e, char *fname)
 
   printf("\n");
 
-  locking_init();
+  locking_init(1);
 
   if (share_mode_forall(print_share_mode) <= 0)
     printf("No locked files\n");