change the default file permissions on the SHARE_MEM_FILE* to
authorAndrew Tridgell <tridge@samba.org>
Mon, 27 Oct 1997 14:27:17 +0000 (14:27 +0000)
committerAndrew Tridgell <tridge@samba.org>
Mon, 27 Oct 1997 14:27:17 +0000 (14:27 +0000)
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)
(This used to be commit c6ac10170dbba57dfebc54c50d79cb29d13bb442)

source3/include/proto.h
source3/locking/locking.c
source3/locking/locking_shm.c
source3/locking/locking_slow.c
source3/locking/shmem.c
source3/smbd/server.c
source3/utils/status.c

index f0c855c689a7957335c1a8589b71718c4ee320e6..cdecd1ec88479d797f896119db4e0b018feafa20 100644 (file)
@@ -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);
index c75497c6b920a278d032fed667758772e9af2078..ae977b0f69822a532985e631c0c9c2e81c8f7f06 100644 (file)
@@ -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;
index 8383b687e41bb3db3d9de40fab9aa86568c7229c..410fcb9760b04cbe99a8f4f973e6315179966072 100644 (file)
@@ -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;
 }
index cc646c6ca6d63512ca68f09baab444581f442537..9bd6d65aa79b47a2fcc6c93c253b47a5f8747948 100644 (file)
@@ -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;
        }
index 9daca3e48293d8c2e02f69ee523bf0f35baeda85..1f9cb8b7327ca9e89fbec142dfbf4acaf91db691 100644 (file)
@@ -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. */
index 88f7497ee532befcbea9d9fd18d48ed025cfa2b5..93042e119b000762578d06e53239976b863facab 100644 (file)
@@ -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. */
index 3e349f920a2c0be1c7a8400ee226b76a692d04b4..f124d79939cae4da8c9cb55da4fc9d6756defe83 100644 (file)
@@ -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");