From 8bc7d6bebd4fcf8c95cb6d58da14404a5e46de91 Mon Sep 17 00:00:00 2001 From: Samba Release Account Date: Thu, 9 Jan 1997 18:02:17 +0000 Subject: Makefile: Changes to split Solaris into Solaris2.3 and previous, and 2.4 and after from Paul Eggert. Makefile: Added AMIGA changes from Rask Ingemann Lambertsen . charset.c: Patch for Western European Languages from Josef Hinteregger charset.h: Patch for Western European Languages from Josef Hinteregger clitar.c: Patch to re-sync after read fail from (lost contributor name, sorry). includes.h: Patch for AMIGA from Rask Ingemann Lambertsen includes.h: Patch for SunOS atexit by Jeremy (jra@cygnus.com) interface.c: Patch for AMIGA from Rask Ingemann Lambertsen kanji.h: Patch for Western European Languages from Josef Hinteregger locking.c: Patch to fix file locking from Jeremy (jra@cygnus.com) locking.c: Patch to add granularity of lock files to usec by Jeremy (jra@cygnus.com) pipes.c: Patch to fix file locking from Jeremy (jra@cygnus.com) proto.h: Patch to fix file locking from Jeremy (jra@cygnus.com) reply.c: Patch to fix file locking from Jeremy (jra@cygnus.com) server.c: Patch to fix file locking from Jeremy (jra@cygnus.com) server.c: Patch for FAST_SHARE_MODE fix from (lost contributor name, sorry). smb.h: Patch to fix file locking from Jeremy (jra@cygnus.com) smb.h: Patch to add granularity of lock files to usec by Jeremy (jra@cygnus.com) status.c: Patch to fix file locking from Jeremy (jra@cygnus.com) statuc.c: Patch to add granularity of lock files to usec by Jeremy (jra@cygnus.com) system.c: Patch for Western European Languages from Josef Hinteregger trans2.c: Patch to fix file locking from Jeremy (jra@cygnus.com) trans2.c: Patch to fix volume name reported to Win95 from Jeremy (jra@cygnus.com) util.c: Patch for Western European Languages from Josef Hinteregger util.c: Patch to fix client_name from continuously returning UNKNOWN (from various contributors). version.h: Update to 1.9.16p10. (This used to be commit 03d28fa32eb094affa33133ebe2602fdb70f6361) --- source3/smbd/server.c | 412 +++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 337 insertions(+), 75 deletions(-) (limited to 'source3/smbd/server.c') diff --git a/source3/smbd/server.c b/source3/smbd/server.c index 29360c40b3..75e7279e6d 100644 --- a/source3/smbd/server.c +++ b/source3/smbd/server.c @@ -58,6 +58,13 @@ extern pstring user_socket_options; connection_struct Connections[MAX_CONNECTIONS]; files_struct Files[MAX_OPEN_FILES]; +/* + * Indirection for file fd's. Needed as POSIX locking + * is based on file/process, not fd/process. + */ +file_fd_struct FileFd[MAX_OPEN_FILES]; +int max_file_fd_used = 0; + extern int Protocol; int maxxmit = BUFFER_SIZE; @@ -731,17 +738,182 @@ static void check_for_pipe(char *fname) } } +/**************************************************************************** +fd support routines - attempt to do a sys_open +****************************************************************************/ + +int fd_attempt_open(char *fname, int flags, int mode) +{ + int fd = sys_open(fname,flags,mode); + + /* Fix for files ending in '.' */ + if((fd == -1) && (errno == ENOENT) && + (strchr(fname,'.')==NULL)) + { + strcat(fname,"."); + fd = sys_open(fname,flags,mode); + } + +#if (defined(ENAMETOOLONG) && defined(HAVE_PATHCONF)) + if ((fd == -1) && (errno == ENAMETOOLONG)) + { + int max_len; + char *p = strrchr(fname, '/'); + + if (p == fname) /* name is "/xxx" */ + { + max_len = pathconf("/", _PC_NAME_MAX); + p++; + } + else if ((p == NULL) || (p == fname)) + { + p = fname; + max_len = pathconf(".", _PC_NAME_MAX); + } + else + { + *p = '\0'; + max_len = pathconf(fname, _PC_NAME_MAX); + *p = '/'; + p++; + } + if (strlen(p) > max_len) + { + char tmp = p[max_len]; + + p[max_len] = '\0'; + if ((fd = sys_open(fname,flags,mode)) == -1) + p[max_len] = tmp; + } + } +#endif + return fd; +} + +/**************************************************************************** +fd support routines - attempt to find an already open file by dev +and inode - increments the ref_count of the returned file_fd_struct *. +****************************************************************************/ +file_fd_struct *fd_get_already_open(struct stat *sbuf) +{ + int i; + file_fd_struct *fd_ptr; + + if(sbuf == 0) + return 0; + + 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)) { + fd_ptr->ref_count++; + DEBUG(3, + ("Re-used file_fd_struct %d, dev = %x, inode = %x, ref_count = %d\n", + i, fd_ptr->dev, fd_ptr->inode, fd_ptr->ref_count)); + return fd_ptr; + } + } + return 0; +} + +/**************************************************************************** +fd support routines - attempt to find a empty slot in the FileFd array. +Increments the ref_count of the returned entry. +****************************************************************************/ +file_fd_struct *fd_get_new() +{ + int i; + file_fd_struct *fd_ptr; + + 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->fd = -1; + fd_ptr->fd_readonly = -1; + fd_ptr->fd_writeonly = -1; + fd_ptr->real_open_flags = -1; + fd_ptr->ref_count++; + /* Increment max used counter if neccessary, cuts down + on search time when re-using */ + if(i > max_file_fd_used) + max_file_fd_used = i; + DEBUG(3,("Allocated new file_fd_struct %d, dev = %x, inode = %x\n", + i, fd_ptr->dev, fd_ptr->inode)); + return fd_ptr; + } + } + DEBUG(1,("ERROR! Out of file_fd structures - perhaps increase MAX_OPEN_FILES?\ +n")); + return 0; +} + +/**************************************************************************** +fd support routines - attempt to re-open an already open fd as O_RDWR. +Save the already open fd (we cannot close due to POSIX file locking braindamage. +****************************************************************************/ + +void fd_attempt_reopen(char *fname, int mode, file_fd_struct *fd_ptr) +{ + int fd = sys_open( fname, O_RDWR, mode); + + if(fd == -1) + return; + + if(fd_ptr->real_open_flags == O_RDONLY) + fd_ptr->fd_readonly = fd_ptr->fd; + if(fd_ptr->real_open_flags == O_WRONLY) + fd_ptr->fd_writeonly = fd_ptr->fd; + + fd_ptr->fd = fd; + fd_ptr->real_open_flags = O_RDWR; +} + +/**************************************************************************** +fd support routines - attempt to close the file referenced by this fd. +Decrements the ref_count and returns it. +****************************************************************************/ +int fd_attempt_close(file_fd_struct *fd_ptr) +{ + DEBUG(3,("fd_attempt_close on file_fd_struct %d, fd = %d, dev = %x, inode = %x, open_flags = %d, ref_count = %d.\n", + fd_ptr - &FileFd[0], + fd_ptr->fd, fd_ptr->dev, fd_ptr->inode, + fd_ptr->real_open_flags, + fd_ptr->ref_count)); + if(fd_ptr->ref_count > 0) { + fd_ptr->ref_count--; + if(fd_ptr->ref_count == 0) { + if(fd_ptr->fd != -1) + close(fd_ptr->fd); + if(fd_ptr->fd_readonly != -1) + close(fd_ptr->fd_readonly); + if(fd_ptr->fd_writeonly != -1) + close(fd_ptr->fd_writeonly); + fd_ptr->fd = -1; + fd_ptr->fd_readonly = -1; + fd_ptr->fd_writeonly = -1; + fd_ptr->real_open_flags = -1; + fd_ptr->dev = -1; + fd_ptr->inode = -1; + } + } + return fd_ptr->ref_count; +} /**************************************************************************** open a file ****************************************************************************/ -void open_file(int fnum,int cnum,char *fname1,int flags,int mode) +void open_file(int fnum,int cnum,char *fname1,int flags,int mode, struct stat *sbuf) { extern struct current_user current_user; pstring fname; + struct stat statbuf; + file_fd_struct *fd_ptr; Files[fnum].open = False; - Files[fnum].fd = -1; + Files[fnum].fd_ptr = 0; errno = EPERM; strcpy(fname,fname1); @@ -771,10 +943,104 @@ void open_file(int fnum,int cnum,char *fname1,int flags,int mode) sys_unlink(fname); #endif + /* + * Ensure we have a valid struct stat so we can search the + * open fd table. + */ + if(sbuf == 0) { + if(stat(fname, &statbuf) < 0) { + if(errno != ENOENT) { + DEBUG(3,("Error doing stat on file %s (%s)\n", + fname,strerror(errno))); + + check_for_pipe(fname); + return; + } + sbuf = 0; + } else { + sbuf = &statbuf; + } + } - Files[fnum].fd = sys_open(fname,flags,mode); + /* + * Check to see if we have this file already + * open. If we do, just use the already open fd and increment the + * reference count (fd_get_already_open increments the ref_count). + */ + if((fd_ptr = fd_get_already_open(sbuf))!= 0) { + + int accmode = (flags & (O_RDONLY | O_WRONLY | O_RDWR)); + + /* File was already open. */ + if((flags & O_CREAT) && (flags & O_EXCL)) { + fd_ptr->ref_count--; + errno = EEXIST; + return; + } + + /* + * If not opened O_RDWR try + * and do that here - a chmod may have been done + * between the last open and now. + */ + if(fd_ptr->real_open_flags != O_RDWR) + fd_attempt_reopen(fname, mode, fd_ptr); + + /* + * Ensure that if we wanted write access + * it has been opened for write, and if we wanted read it + * was open for read. + */ + if(((accmode == O_WRONLY) && (fd_ptr->real_open_flags == O_RDONLY)) || + ((accmode == O_RDONLY) && (fd_ptr->real_open_flags == O_WRONLY)) || + ((accmode == O_RDWR) && (fd_ptr->real_open_flags != O_RDWR))) { + DEBUG(3,("Error opening (already open for flags=%d) file %s (%s) (flags=%d)\n", + fd_ptr->real_open_flags, fname,strerror(EACCES),flags)); + check_for_pipe(fname); + fd_ptr->ref_count--; + return; + } + + /* + * If O_TRUNC was set, ensure we truncate the file. + * open_file_shared explicitly clears this flag before + * calling open_file, so we can safely do this here. + */ + if(flags & O_TRUNC) + ftruncate(fd_ptr->fd, 0); + + } else { + int open_flags; + /* We need to allocate a new file_fd_struct (this increments the + ref_count). */ + if((fd_ptr = fd_get_new()) == 0) + return; + /* + * Whatever the requested flags, attempt read/write access, + * as we don't know what flags future file opens may require. + * If this fails, try again with the required flags. + * Even if we open read/write when only read access was + * requested the setting of the can_write flag in + * the file_struct will protect us from errant + * write requests. We never need to worry about O_APPEND + * as this is not set anywhere in Samba. + */ + fd_ptr->real_open_flags = O_RDWR; + /* Set the flags as needed without the read/write modes. */ + open_flags = flags & ~(O_RDWR|O_WRONLY|O_RDONLY); + fd_ptr->fd = fd_attempt_open(fname, open_flags|O_RDWR, mode); + if((fd_ptr->fd == -1) && (errno == EACCES)) { + if(flags & O_WRONLY) { + fd_ptr->fd = fd_attempt_open(fname, open_flags|O_WRONLY, mode); + fd_ptr->real_open_flags = O_WRONLY; + } else { + fd_ptr->fd = fd_attempt_open(fname, open_flags|O_RDONLY, mode); + fd_ptr->real_open_flags = O_RDONLY; + } + } + } - if ((Files[fnum].fd>=0) && + if ((fd_ptr->fd >=0) && Connections[cnum].printer && lp_minprintspace(SNUM(cnum))) { pstring dname; int dum1,dum2,dum3; @@ -784,72 +1050,47 @@ void open_file(int fnum,int cnum,char *fname1,int flags,int mode) if (p) *p = 0; if (sys_disk_free(dname,&dum1,&dum2,&dum3) < lp_minprintspace(SNUM(cnum))) { - close(Files[fnum].fd); - Files[fnum].fd = -1; - sys_unlink(fname); + fd_attempt_close(fd_ptr); + Files[fnum].fd_ptr = 0; + if(fd_ptr->ref_count == 0) + sys_unlink(fname); errno = ENOSPC; return; } } - - /* Fix for files ending in '.' */ - if((Files[fnum].fd == -1) && (errno == ENOENT) && - (strchr(fname,'.')==NULL)) - { - strcat(fname,"."); - Files[fnum].fd = sys_open(fname,flags,mode); - } - -#if (defined(ENAMETOOLONG) && defined(HAVE_PATHCONF)) - if ((Files[fnum].fd == -1) && (errno == ENAMETOOLONG)) - { - int max_len; - char *p = strrchr(fname, '/'); - - if (p == fname) /* name is "/xxx" */ - { - max_len = pathconf("/", _PC_NAME_MAX); - p++; - } - else if ((p == NULL) || (p == fname)) - { - p = fname; - max_len = pathconf(".", _PC_NAME_MAX); - } - else - { - *p = '\0'; - max_len = pathconf(fname, _PC_NAME_MAX); - *p = '/'; - p++; - } - if (strlen(p) > max_len) - { - char tmp = p[max_len]; - - p[max_len] = '\0'; - if ((Files[fnum].fd = sys_open(fname,flags,mode)) == -1) - p[max_len] = tmp; - } - } -#endif - - if (Files[fnum].fd < 0) + if (fd_ptr->fd < 0) { DEBUG(3,("Error opening file %s (%s) (flags=%d)\n", fname,strerror(errno),flags)); + /* Ensure the ref_count is decremented. */ + fd_attempt_close(fd_ptr); check_for_pipe(fname); return; } - if (Files[fnum].fd >= 0) + if (fd_ptr->fd >= 0) { - struct stat st; + if(sbuf == 0) { + /* Do the fstat */ + if(fstat(fd_ptr->fd, &statbuf) == -1) { + /* Error - backout !! */ + DEBUG(3,("Error doing fstat on fd %d, file %s (%s)\n", + fd_ptr->fd, fname,strerror(errno))); + /* Ensure the ref_count is decremented. */ + fd_attempt_close(fd_ptr); + return; + } + sbuf = &statbuf; + } + /* Set the correct entries in fd_ptr. */ + fd_ptr->dev = (int32)sbuf->st_dev; + fd_ptr->inode = (int32)sbuf->st_ino; + + Files[fnum].fd_ptr = fd_ptr; Connections[cnum].num_files_open++; - fstat(Files[fnum].fd,&st); - Files[fnum].mode = st.st_mode; - Files[fnum].open_time = time(NULL); + Files[fnum].mode = sbuf->st_mode; + GetTimeOfDay(&Files[fnum].open_time); Files[fnum].uid = current_user.id; Files[fnum].size = 0; Files[fnum].pos = -1; @@ -911,7 +1152,7 @@ sync a file void sync_file(int fnum) { #ifndef NO_FSYNC - fsync(Files[fnum].fd); + fsync(Files[fnum].fd_ptr->fd); #endif } @@ -961,7 +1202,7 @@ close a file - possibly invalidating the read prediction void close_file(int fnum) { int cnum = Files[fnum].cnum; - invalidate_read_prediction(Files[fnum].fd); + invalidate_read_prediction(Files[fnum].fd_ptr->fd); Files[fnum].open = False; Connections[cnum].num_files_open--; if(Files[fnum].wbmpx_ptr) @@ -981,7 +1222,7 @@ void close_file(int fnum) if (lp_share_modes(SNUM(cnum))) del_share_mode(fnum); - close(Files[fnum].fd); + fd_attempt_close(Files[fnum].fd_ptr); /* NT uses smbclose to start a print - weird */ if (Files[fnum].print_file) @@ -1081,7 +1322,7 @@ static void truncate_unless_locked(int fnum, int cnum) unix_ERR_code = ERRlock; } else - ftruncate(Files[fnum].fd,0); + ftruncate(Files[fnum].fd_ptr->fd,0); } } @@ -1101,7 +1342,7 @@ void open_file_shared(int fnum,int cnum,char *fname,int share_mode,int ofun, int share_pid=0; Files[fnum].open = False; - Files[fnum].fd = -1; + Files[fnum].fd_ptr = 0; /* this is for OS/2 EAs - try and say we don't support them */ if (strstr(fname,".+,;=[].")) { @@ -1208,10 +1449,10 @@ void open_file_shared(int fnum,int cnum,char *fname,int share_mode,int ofun, 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); + open_file(fnum,cnum,fname,flags|(flags2&~(O_TRUNC)),mode,&sbuf); if (!Files[fnum].open && flags==O_RDWR && errno!=ENOENT && fcbopen) { flags = O_RDONLY; - open_file(fnum,cnum,fname,flags,mode); + open_file(fnum,cnum,fname,flags,mode,&sbuf); } if (Files[fnum].open) { @@ -1282,7 +1523,7 @@ int seek_file(int fnum,int pos) if (Files[fnum].print_file && POSTSCRIPT(Files[fnum].cnum)) offset = 3; - Files[fnum].pos = lseek(Files[fnum].fd,pos+offset,SEEK_SET) - offset; + Files[fnum].pos = lseek(Files[fnum].fd_ptr->fd,pos+offset,SEEK_SET) - offset; return(Files[fnum].pos); } @@ -1295,7 +1536,7 @@ int read_file(int fnum,char *data,int pos,int n) if (!Files[fnum].can_write) { - ret = read_predict(Files[fnum].fd,pos,data,NULL,n); + ret = read_predict(Files[fnum].fd_ptr->fd,pos,data,NULL,n); data += ret; n -= ret; @@ -1327,7 +1568,7 @@ int read_file(int fnum,char *data,int pos,int n) } if (n > 0) { - readret = read(Files[fnum].fd,data,n); + readret = read(Files[fnum].fd_ptr->fd,data,n); if (readret > 0) ret += readret; } @@ -1348,7 +1589,7 @@ int write_file(int fnum,char *data,int n) if (!Files[fnum].modified) { struct stat st; Files[fnum].modified = True; - if (fstat(Files[fnum].fd,&st) == 0) { + if (fstat(Files[fnum].fd_ptr->fd,&st) == 0) { int dosmode = dos_mode(Files[fnum].cnum,Files[fnum].name,&st); if (MAP_ARCHIVE(Files[fnum].cnum) && !IS_DOS_ARCHIVE(dosmode)) { dos_chmod(Files[fnum].cnum,Files[fnum].name,dosmode | aARCH,&st); @@ -1356,7 +1597,7 @@ int write_file(int fnum,char *data,int n) } } - return(write_data(Files[fnum].fd,data,n)); + return(write_data(Files[fnum].fd_ptr->fd,data,n)); } @@ -2057,14 +2298,21 @@ int make_connection(char *service,char *user,char *password, int pwlen, char *de #if HAVE_GETGRNAM if (*lp_force_group(snum)) { - struct group *gptr = (struct group *)getgrnam(lp_force_group(snum)); + struct group *gptr; + pstring gname; + + StrnCpy(gname,lp_force_group(snum),sizeof(pstring)-1); + /* default service may be a group name */ + string_sub(gname,"%S",service); + gptr = (struct group *)getgrnam(gname); + if (gptr) { pcon->gid = gptr->gr_gid; - DEBUG(3,("Forced group %s\n",lp_force_group(snum))); + DEBUG(3,("Forced group %s\n",gname)); } else - DEBUG(1,("Couldn't find group %s\n",lp_force_group(snum))); + DEBUG(1,("Couldn't find group %s\n",gname)); } #endif @@ -2936,6 +3184,11 @@ void exit_server(char *reason) if (dump_core()) return; #endif } + +#if FAST_SHARE_MODES + stop_share_mode_mgmt(); +#endif + DEBUG(3,("%s Server exit (%s)\n",timestring(),reason?reason:"")); exit(0); } @@ -3574,6 +3827,19 @@ static void init_structs(void ) { Files[i].open = False; string_init(&Files[i].name,""); + + } + + for (i=0;iref_count = 0; + fd_ptr->dev = (int32)-1; + fd_ptr->inode = (int32)-1; + fd_ptr->fd = -1; + fd_ptr->fd_readonly = -1; + fd_ptr->fd_writeonly = -1; + fd_ptr->real_open_flags = -1; } init_dptrs(); @@ -3808,10 +4074,6 @@ static void usage(char *pname) process(); close_sockets(); -#if FAST_SHARE_MODES - stop_share_mode_mgmt(); -#endif - exit_server("normal exit"); return(0); } -- cgit