From 127655cc888ac40332d4e8e5b94aab03f5120aae Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Sat, 15 Aug 1998 07:27:34 +0000 Subject: this checkin gets rid of the global Files[] array and makes it local in files.c it should now be faily easy to expand the default MAX_OPEN_FILES to many thousands. (This used to be commit b088c804f98908eb02f05ab2f2e8a61691a0a582) --- source3/Makefile.in | 4 +- source3/include/local.h | 15 +- source3/include/proto.h | 49 ++-- source3/include/smb.h | 37 +-- source3/locking/locking.c | 56 ++-- source3/locking/locking_shm.c | 38 ++- source3/locking/locking_slow.c | 68 +++-- source3/rpc_server/srv_pipe_hnd.c | 2 - source3/script/mkproto.awk | 2 +- source3/smbd/files.c | 321 +++++++++++++++++++++ source3/smbd/ipc.c | 174 ++++++------ source3/smbd/nttrans.c | 123 ++++---- source3/smbd/pipes.c | 13 +- source3/smbd/reply.c | 572 +++++++++++++++++--------------------- source3/smbd/server.c | 378 ++++++------------------- source3/smbd/trans2.c | 45 ++- source3/utils/status.c | 1 - source3/web/swat.c | 1 - 18 files changed, 957 insertions(+), 942 deletions(-) create mode 100644 source3/smbd/files.c (limited to 'source3') diff --git a/source3/Makefile.in b/source3/Makefile.in index d79873f7e8..51cf4feec1 100644 --- a/source3/Makefile.in +++ b/source3/Makefile.in @@ -120,7 +120,7 @@ LOCKING_OBJ = locking/locking.o locking/locking_shm.o locking/locking_slow.o \ PASSDB_OBJ = passdb/passdb.o passdb/smbpassfile.o passdb/smbpass.o \ passdb/pass_check.o passdb/ldap.o passdb/nispass.o -SMBD_OBJ1 = smbd/server.o smbd/chgpasswd.o smbd/connection.o \ +SMBD_OBJ1 = smbd/server.o smbd/files.o smbd/chgpasswd.o smbd/connection.o \ smbd/dfree.o smbd/dir.o smbd/password.o \ smbd/groupname.o smbd/ipc.o smbd/mangle.o \ smbd/message.o smbd/nttrans.o smbd/pipes.o smbd/predict.o \ @@ -294,7 +294,7 @@ uninstallcp: @$(SHELL) $(srcdir)/script/uninstallcp.sh $(CODEPAGEDIR) $(CODEPAGELIST) clean: - rm -f core */*.o */*~ *~ config.cache bin/[!C]* + rm -f core */*.o */*~ *~ config.cache $(PROGS) proto: @echo rebuilding include/proto.h diff --git a/source3/include/local.h b/source3/include/local.h index fb67babcda..af12f83551 100644 --- a/source3/include/local.h +++ b/source3/include/local.h @@ -29,6 +29,10 @@ /* to a maximum of 8 if old smb clients break because of long printer names. */ #define MAXPRINTERLEN 15 +/* max number of directories open at once */ +/* note that with the new directory code this no longer requires a + file handle per directory, but large numbers do use more memory */ +#define MAX_OPEN_DIRECTORIES 64 /* define what facility to use for syslog */ #ifndef SYSLOG_FACILITY @@ -40,18 +44,13 @@ MAX_CONNECTIONS services, but any number of machines may connect at one time. */ #define MAX_CONNECTIONS 127 -#define MAX_OPEN_FILES 100 - -/* max number of directories open at once */ -/* note that with the new directory code this no longer requires a - file handle per directory, but large numbers do use more memory */ -#define MAX_OPEN_DIRECTORIES 64 -#define MAX_FNUMS (MAX_OPEN_FILES+MAX_OPEN_DIRECTORIES) +/* this must be larger than the sum of the open files and directories */ +#define PIPE_HANDLE_OFFSET 0x7000 /* Default size of shared memory used for share mode locking */ #ifndef SHMEM_SIZE -#define SHMEM_SIZE (1024*(MAX_OPEN_FILES+MAX_OPEN_DIRECTORIES)) +#define SHMEM_SIZE (1024*1024) #endif /* the max number of simultanous connections to the server by all clients */ diff --git a/source3/include/proto.h b/source3/include/proto.h index 49d078b78a..9587828ea9 100644 --- a/source3/include/proto.h +++ b/source3/include/proto.h @@ -474,12 +474,12 @@ char *smb_errstr(char *inbuf); BOOL push_blocking_lock_request( char *inbuf, int length, int lock_timeout, int lock_num); void process_blocking_lock_queue(time_t t); -BOOL is_locked(int fnum,connection_struct *conn, +BOOL is_locked(files_struct *fsp,connection_struct *conn, uint32 count,uint32 offset, int lock_type); -BOOL do_lock(int fnum,connection_struct *conn, +BOOL do_lock(files_struct *fsp,connection_struct *conn, uint32 count,uint32 offset,int lock_type, int *eclass,uint32 *ecode); -BOOL do_unlock(int fnum,connection_struct *conn, +BOOL do_unlock(files_struct *fsp,connection_struct *conn, uint32 count,uint32 offset,int *eclass,uint32 *ecode); BOOL locking_init(int read_only); BOOL locking_end(void); @@ -490,9 +490,9 @@ BOOL unlock_share_entry(connection_struct *conn, int get_share_modes(connection_struct *conn, int token, uint32 dev, uint32 inode, share_mode_entry **shares); -void del_share_mode(int token, int fnum); -BOOL set_share_mode(int token, int fnum, uint16 port, uint16 op_type); -BOOL remove_share_oplock(int fnum, int token); +void del_share_mode(int token, files_struct *fsp); +BOOL set_share_mode(int token, files_struct *fsp, uint16 port, uint16 op_type); +BOOL remove_share_oplock(files_struct *fsp, int token); int share_mode_forall(void (*fn)(share_mode_entry *, char *)); void share_status(FILE *f); @@ -1941,6 +1941,20 @@ void DirCacheAdd( char *path, char *name, char *dname, int snum ); char *DirCacheCheck( char *path, char *name, int snum ); void DirCacheFlush(int snum); +/*The following definitions come from smbd/files.c */ + +files_struct *find_free_file(void ); +file_fd_struct *fd_get_already_open(struct stat *sbuf); +file_fd_struct *fd_get_new(void); +void file_close_conn(connection_struct *conn); +void file_init(void); +files_struct *file_fsp(int fnum); +void file_close_user(int vuid); +files_struct *file_find_dit(int dev, int inode, struct timeval *tval); +files_struct *file_find_print(void); +void file_sync_all(connection_struct *conn); +void file_free(files_struct *fsp); + /*The following definitions come from smbd/groupname.c */ void load_groupname_map(void); @@ -1979,7 +1993,7 @@ int reply_ntcancel(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize); int reply_nttranss(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize); -void remove_pending_change_notify_requests_by_fid(int fnum); +void remove_pending_change_notify_requests_by_fid(files_struct *fsp); void remove_pending_change_notify_requests_by_mid(int mid); void process_pending_change_notify_queue(time_t t); int reply_nttrans(connection_struct *conn, @@ -2114,22 +2128,23 @@ int file_utime(connection_struct *conn, char *fname, struct utimbuf *times); BOOL set_filetime(connection_struct *conn, char *fname, time_t mtime); BOOL unix_convert(char *name,connection_struct *conn,char *saved_last_component, BOOL *bad_path); BOOL check_name(char *name,connection_struct *conn); -void sync_file(connection_struct *conn, int fnum); -void close_file(int fnum, BOOL normal_close); -void close_directory(int fnum); -int open_directory(int fnum,connection_struct *conn, +void fd_add_to_uid_cache(file_fd_struct *fd_ptr, uid_t u); +void sync_file(connection_struct *conn, files_struct *fsp); +void close_file(files_struct *fsp, BOOL normal_close); +void close_directory(files_struct *fsp); +int open_directory(files_struct *fsp,connection_struct *conn, char *fname, int smb_ofun, int unixmode, int *action); BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op); int check_share_mode( share_mode_entry *share, int deny_mode, char *fname, BOOL fcbopen, int *flags); -void open_file_shared(int fnum,connection_struct *conn,char *fname,int share_mode,int ofun, +void open_file_shared(files_struct *fsp,connection_struct *conn,char *fname,int share_mode,int ofun, int mode,int oplock_request, int *Access,int *action); -int seek_file(int fnum,uint32 pos); -int read_file(int fnum,char *data,uint32 pos,int n); -int write_file(int fnum,char *data,int n); +int seek_file(files_struct *fsp,uint32 pos); +int read_file(files_struct *fsp,char *data,uint32 pos,int n); +int write_file(files_struct *fsp,char *data,int n); BOOL become_service(connection_struct *conn,BOOL do_chdir); int find_service(char *service); -int cached_error_packet(char *inbuf,char *outbuf,int fnum,int line); +int cached_error_packet(char *inbuf,char *outbuf,files_struct *fsp,int line); int unix_error_packet(char *inbuf,char *outbuf,int def_class,uint32 def_code,int line); int error_packet(char *inbuf,char *outbuf,int error_class,uint32 error_code,int line); BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval); @@ -2139,7 +2154,7 @@ BOOL receive_next_smb(int smbfd, int oplockfd, char *inbuf, int bufsize, int tim BOOL snum_used(int snum); BOOL reload_services(BOOL test); connection_struct *make_connection(char *service,char *user,char *password, int pwlen, char *dev,uint16 vuid, int *ecode); -int find_free_file(void ); +BOOL attempt_close_oplocked_file(files_struct *fsp); int reply_corep(char *outbuf); int reply_coreplus(char *outbuf); int reply_lanman1(char *outbuf); diff --git a/source3/include/smb.h b/source3/include/smb.h index fa5d496ceb..801e134435 100644 --- a/source3/include/smb.h +++ b/source3/include/smb.h @@ -575,6 +575,7 @@ struct current_user typedef struct { + int fnum; connection_struct *conn; file_fd_struct *fd_ptr; int pos; @@ -599,6 +600,10 @@ typedef struct char *fsp_name; } files_struct; +/* this macro should always be used to extract an fnum (smb_fid) from + a packet to ensure chaining works correctly */ +#define GETFSP(buf,where) (chain_fsp?chain_fsp:file_fsp(SVAL(buf,where))) + /* Domain controller authentication protocol info */ struct dcinfo @@ -695,9 +700,9 @@ struct share_ops { BOOL (*lock_entry)(connection_struct *, uint32 , uint32 , int *); BOOL (*unlock_entry)(connection_struct *, uint32 , uint32 , int ); int (*get_entries)(connection_struct *, int , uint32 , uint32 , share_mode_entry **); - void (*del_entry)(int , int ); - BOOL (*set_entry)(int , int , uint16 , uint16 ); - BOOL (*remove_oplock)(int , int); + void (*del_entry)(int , files_struct *); + BOOL (*set_entry)(int, files_struct *, uint16 , uint16 ); + BOOL (*remove_oplock)(files_struct *, int); int (*forall)(void (*)(share_mode_entry *, char *)); void (*status)(FILE *); }; @@ -858,22 +863,21 @@ struct parm_struct #endif /* LOCKING_VERSION */ /* these are useful macros for checking validity of handles */ -#define VALID_FNUM(fnum) (((fnum) >= 0) && ((fnum) < MAX_FNUMS)) -#define OPEN_FNUM(fnum) (VALID_FNUM(fnum) && Files[fnum].open && !Files[fnum].is_directory) +#define OPEN_FSP(fsp) ((fsp) && (fsp)->open && !(fsp)->is_directory) #define VALID_CNUM(cnum) (((cnum) >= 0) && ((cnum) < MAX_CONNECTIONS)) -#define OPEN_CNUM(conn) ((conn) && (conn)->open) +#define OPEN_CONN(conn) ((conn) && (conn)->open) #define IS_IPC(conn) ((conn) && (conn)->ipc) #define IS_PRINT(conn) ((conn) && (conn)->printer) -#define FNUM_OK(fnum,c) (OPEN_FNUM(fnum) && (c)==Files[fnum].conn) +#define FNUM_OK(fsp,c) (OPEN_FSP(fsp) && (c)==(fsp)->conn) -#define CHECK_FNUM(fnum,conn) if (!FNUM_OK(fnum,conn)) \ +#define CHECK_FSP(fsp,conn) if (!FNUM_OK(fsp,conn)) \ return(ERROR(ERRDOS,ERRbadfid)) -#define CHECK_READ(fnum) if (!Files[fnum].can_read) \ +#define CHECK_READ(fsp) if (!(fsp)->can_read) \ return(ERROR(ERRDOS,ERRbadaccess)) -#define CHECK_WRITE(fnum) if (!Files[fnum].can_write) \ +#define CHECK_WRITE(fsp) if (!(fsp)->can_write) \ return(ERROR(ERRDOS,ERRbadaccess)) -#define CHECK_ERROR(fnum) if (HAS_CACHED_ERROR(fnum)) \ - return(CACHED_ERROR(fnum)) +#define CHECK_ERROR(fsp) if (HAS_CACHED_ERROR(fsp)) \ + return(CACHED_ERROR(fsp)) /* translates a connection number into a service number */ #define SNUM(conn) ((conn)?(conn)->service:-1) @@ -883,7 +887,7 @@ struct parm_struct #define PRINTCAP (lp_printcapname()) #define PRINTCOMMAND(snum) (lp_printcommand(snum)) #define PRINTERNAME(snum) (lp_printername(snum)) -#define CAN_WRITE(conn) (OPEN_CNUM(conn) && !conn->read_only) +#define CAN_WRITE(conn) (OPEN_CONN(conn) && !conn->read_only) #define VALID_SNUM(snum) (lp_snum_ok(snum)) #define GUEST_OK(snum) (VALID_SNUM(snum) && lp_guest_ok(snum)) #define GUEST_ONLY(snum) (VALID_SNUM(snum) && lp_guest_only(snum)) @@ -1432,11 +1436,10 @@ enum ssl_version_enum {SMB_SSL_V2,SMB_SSL_V3,SMB_SSL_V23,SMB_SSL_TLS1}; #define CACHE_ERROR(w,c,e) ((w)->wr_errclass = (c), (w)->wr_error = (e), \ w->wr_discard = True, -1) /* Macro to test if an error has been cached for this fnum */ -#define HAS_CACHED_ERROR(fnum) (Files[(fnum)].open && \ - Files[(fnum)].wbmpx_ptr && \ - Files[(fnum)].wbmpx_ptr->wr_discard) +#define HAS_CACHED_ERROR(fsp) ((fsp)->open && (fsp)->wbmpx_ptr && \ + (fsp)->wbmpx_ptr->wr_discard) /* Macro to turn the cached error into an error packet */ -#define CACHED_ERROR(fnum) cached_error_packet(inbuf,outbuf,fnum,__LINE__) +#define CACHED_ERROR(fsp) cached_error_packet(inbuf,outbuf,fsp,__LINE__) /* these are the datagram types */ #define DGRAM_DIRECT_UNIQUE 0x10 diff --git a/source3/locking/locking.c b/source3/locking/locking.c index bb852b07d6..50c4af2265 100644 --- a/source3/locking/locking.c +++ b/source3/locking/locking.c @@ -33,7 +33,6 @@ #include "includes.h" extern int DEBUGLEVEL; -extern files_struct Files[]; extern int Client; static struct share_ops *share_ops; @@ -62,7 +61,7 @@ static ubi_slList blocking_lock_queue = { NULL, (ubi_slNodePtr)&blocking_lock_qu BOOL push_blocking_lock_request( char *inbuf, int length, int lock_timeout, int lock_num) { blocking_lock_record *blr; - int fnum = GETFNUM(inbuf,smb_vwv2); + files_struct *fsp = GETFSP(inbuf,smb_vwv2); /* * Now queue an entry on the blocking lock queue. We setup @@ -88,7 +87,7 @@ BOOL push_blocking_lock_request( char *inbuf, int length, int lock_timeout, int ubi_slAddTail(&blocking_lock_queue, blr); DEBUG(3,("push_blocking_lock_request: lock request blocked with expiry time %d \ -for fnum = %d, name = %s\n", blr->expire_time, fnum, Files[fnum].name )); +for fnum = %d, name = %s\n", blr->expire_time, fsp->fnum, fsp->name )); return True; } @@ -96,16 +95,15 @@ for fnum = %d, name = %s\n", blr->expire_time, fnum, Files[fnum].name )); /**************************************************************************** Return a blocking lock success SMB. *****************************************************************************/ - static void blocking_lock_reply_success(blocking_lock_record *blr) { extern int chain_size; - extern int chain_fnum; + extern files_struct *chain_fsp; extern char *OutBuffer; char *outbuf = OutBuffer; int bufsize = BUFFER_SIZE; char *inbuf = blr->inbuf; - int fnum = GETFNUM(inbuf,smb_vwv2); + files_struct *fsp = GETFSP(inbuf,smb_vwv2); int outsize = 0; construct_reply_common(inbuf, outbuf); @@ -119,7 +117,7 @@ static void blocking_lock_reply_success(blocking_lock_record *blr) * that here and must set up the chain info manually. */ - chain_fnum = fnum; + chain_fsp = fsp; chain_size = 0; outsize = chain_reply(inbuf,outbuf,blr->length,bufsize); @@ -142,7 +140,7 @@ static void blocking_lock_reply_error(blocking_lock_record *blr, int eclass, int char *outbuf = OutBuffer; int bufsize = BUFFER_SIZE; char *inbuf = blr->inbuf; - int fnum = GETFNUM(inbuf,smb_vwv2); + files_struct *fsp = GETFSP(inbuf,smb_vwv2); uint16 num_ulocks = SVAL(inbuf,smb_vwv6); uint16 num_locks = SVAL(inbuf,smb_vwv7); uint32 count, offset; @@ -160,7 +158,7 @@ static void blocking_lock_reply_error(blocking_lock_record *blr, int eclass, int for(i = blr->lock_num; i >= 0; i--) { count = IVAL(data,SMB_LKLEN_OFFSET(i)); offset = IVAL(data,SMB_LKOFF_OFFSET(i)); - do_unlock(fnum,conn,count,offset,&dummy1,&dummy2); + do_unlock(fsp,conn,count,offset,&dummy1,&dummy2); } construct_reply_common(inbuf, outbuf); @@ -177,7 +175,7 @@ static BOOL blocking_lock_record_process(blocking_lock_record *blr) { char *inbuf = blr->inbuf; unsigned char locktype = CVAL(inbuf,smb_vwv3); - int fnum = GETFNUM(inbuf,smb_vwv2); + files_struct *fsp = GETFSP(inbuf,smb_vwv2); uint16 num_ulocks = SVAL(inbuf,smb_vwv6); uint16 num_locks = SVAL(inbuf,smb_vwv7); uint32 count, offset; @@ -196,7 +194,7 @@ static BOOL blocking_lock_record_process(blocking_lock_record *blr) for(; blr->lock_num < num_locks; blr->lock_num++) { count = IVAL(data,SMB_LKLEN_OFFSET(blr->lock_num)); offset = IVAL(data,SMB_LKOFF_OFFSET(blr->lock_num)); - if(!do_lock(fnum,conn,count,offset, ((locktype & 1) ? F_RDLCK : F_WRLCK), + if(!do_lock(fsp,conn,count,offset, ((locktype & 1) ? F_RDLCK : F_WRLCK), &eclass, &ecode)) break; } @@ -208,7 +206,7 @@ static BOOL blocking_lock_record_process(blocking_lock_record *blr) */ DEBUG(3,("blocking_lock_record_process fnum=%d type=%d num_locks=%d\n", - fnum, (unsigned int)locktype, num_locks) ); + fsp->fnum, (unsigned int)locktype, num_locks) ); blocking_lock_reply_success(blr); return True; @@ -230,7 +228,7 @@ static BOOL blocking_lock_record_process(blocking_lock_record *blr) */ DEBUG(10,("blocking_lock_record_process: only got %d locks of %d needed for fnum = %d. \ -Waiting..\n", blr->lock_num, num_locks, fnum )); +Waiting..\n", blr->lock_num, num_locks, fsp->fnum)); return False; } @@ -252,13 +250,12 @@ void process_blocking_lock_queue(time_t t) */ while(blr != NULL) { - int fnum = GETFNUM(blr->inbuf,smb_vwv2); - files_struct *fsp = &Files[fnum]; + files_struct *fsp = GETFSP(blr->inbuf,smb_vwv2); uint16 vuid = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID : SVAL(blr->inbuf,smb_uid); DEBUG(5,("process_blocking_lock_queue: examining pending lock fnum = %d for file %s\n", - fnum, fsp->name )); + fsp->fnum, fsp->name )); if((blr->expire_time != -1) && (blr->expire_time > t)) { /* @@ -266,7 +263,7 @@ void process_blocking_lock_queue(time_t t) * obtained locks and return lock error. */ DEBUG(5,("process_blocking_lock_queue: pending lock fnum = %d for file %s timed out.\n", - fnum, fsp->name )); + fsp->fnum, fsp->name )); blocking_lock_reply_error(blr,ERRSRV,ERRaccess); free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev)); @@ -356,11 +353,10 @@ static int map_lock_type( files_struct *fsp, int lock_type) /**************************************************************************** Utility function called to see if a file region is locked. ****************************************************************************/ -BOOL is_locked(int fnum,connection_struct *conn, +BOOL is_locked(files_struct *fsp,connection_struct *conn, uint32 count,uint32 offset, int lock_type) { int snum = SNUM(conn); - files_struct *fsp = &Files[fnum]; if (count == 0) return(False); @@ -381,12 +377,11 @@ BOOL is_locked(int fnum,connection_struct *conn, /**************************************************************************** Utility function called by locking requests. ****************************************************************************/ -BOOL do_lock(int fnum,connection_struct *conn, +BOOL do_lock(files_struct *fsp,connection_struct *conn, uint32 count,uint32 offset,int lock_type, int *eclass,uint32 *ecode) { BOOL ok = False; - files_struct *fsp = &Files[fnum]; if (!lp_locking(SNUM(conn))) return(True); @@ -397,7 +392,7 @@ BOOL do_lock(int fnum,connection_struct *conn, return False; } - if (OPEN_FNUM(fnum) && fsp->can_lock && (fsp->conn == conn)) + if (OPEN_FSP(fsp) && fsp->can_lock && (fsp->conn == conn)) ok = fcntl_lock(fsp->fd_ptr->fd,F_SETLK,offset,count, map_lock_type(fsp,lock_type)); @@ -413,16 +408,15 @@ BOOL do_lock(int fnum,connection_struct *conn, /**************************************************************************** Utility function called by unlocking requests. ****************************************************************************/ -BOOL do_unlock(int fnum,connection_struct *conn, +BOOL do_unlock(files_struct *fsp,connection_struct *conn, uint32 count,uint32 offset,int *eclass,uint32 *ecode) { BOOL ok = False; - files_struct *fsp = &Files[fnum]; if (!lp_locking(SNUM(conn))) return(True); - if (OPEN_FNUM(fnum) && fsp->can_lock && (fsp->conn == conn)) + if (OPEN_FSP(fsp) && fsp->can_lock && (fsp->conn == conn)) ok = fcntl_lock(fsp->fd_ptr->fd,F_SETLK,offset,count,F_UNLCK); if (!ok) { @@ -501,26 +495,26 @@ int get_share_modes(connection_struct *conn, Del the share mode of a file. ********************************************************************/ -void del_share_mode(int token, int fnum) +void del_share_mode(int token, files_struct *fsp) { - share_ops->del_entry(token, fnum); + share_ops->del_entry(token, fsp); } /******************************************************************* Set the share mode of a file. Return False on fail, True on success. ********************************************************************/ -BOOL set_share_mode(int token, int fnum, uint16 port, uint16 op_type) +BOOL set_share_mode(int token, files_struct *fsp, uint16 port, uint16 op_type) { - return share_ops->set_entry(token, fnum, port, op_type); + return share_ops->set_entry(token, fsp, port, op_type); } /******************************************************************* Remove an oplock port and mode entry from a share mode. ********************************************************************/ -BOOL remove_share_oplock(int fnum, int token) +BOOL remove_share_oplock(files_struct *fsp, int token) { - return share_ops->remove_oplock(fnum, token); + return share_ops->remove_oplock(fsp, token); } /******************************************************************* diff --git a/source3/locking/locking_shm.c b/source3/locking/locking_shm.c index 84310d3a33..cded5e628d 100644 --- a/source3/locking/locking_shm.c +++ b/source3/locking/locking_shm.c @@ -37,7 +37,6 @@ #ifdef FAST_SHARE_MODES extern int DEBUGLEVEL; -extern files_struct Files[]; static struct shmem_ops *shmops; @@ -258,7 +257,7 @@ static int shm_get_share_modes(connection_struct *conn, /******************************************************************* del the share mode of a file. ********************************************************************/ -static void shm_del_share_mode(int token, int fnum) +static void shm_del_share_mode(int token, files_struct *fsp) { uint32 dev, inode; int *mode_array; @@ -270,8 +269,8 @@ static void shm_del_share_mode(int token, int fnum) BOOL found = False; int pid = getpid(); - dev = Files[fnum].fd_ptr->dev; - inode = Files[fnum].fd_ptr->inode; + dev = fsp->fd_ptr->dev; + inode = fsp->fd_ptr->inode; hash_entry = HASH_ENTRY(dev, inode); @@ -329,7 +328,7 @@ static void shm_del_share_mode(int token, int fnum) { if( (pid == entry_scanner_p->e.pid) && (memcmp(&entry_scanner_p->e.time, - &Files[fnum].open_time,sizeof(struct timeval)) == 0) ) + &fsp->open_time,sizeof(struct timeval)) == 0) ) { found = True; break; @@ -386,9 +385,8 @@ static void shm_del_share_mode(int token, int fnum) /******************************************************************* set the share mode of a file. Return False on fail, True on success. ********************************************************************/ -static BOOL shm_set_share_mode(int token, int fnum, uint16 port, uint16 op_type) +static BOOL shm_set_share_mode(int token, files_struct *fsp, uint16 port, uint16 op_type) { - files_struct *fs_p = &Files[fnum]; int32 dev, inode; int *mode_array; unsigned int hash_entry; @@ -398,8 +396,8 @@ static BOOL shm_set_share_mode(int token, int fnum, uint16 port, uint16 op_type) int new_entry_offset; BOOL found = False; - dev = fs_p->fd_ptr->dev; - inode = fs_p->fd_ptr->inode; + dev = fsp->fd_ptr->dev; + inode = fsp->fd_ptr->inode; hash_entry = HASH_ENTRY(dev, inode); @@ -428,7 +426,7 @@ static BOOL shm_set_share_mode(int token, int fnum, uint16 port, uint16 op_type) /* We must create a share_mode_record */ share_mode_record *new_mode_p = NULL; int new_offset = shmops->shm_alloc(sizeof(share_mode_record) + - strlen(fs_p->fsp_name) + 1); + strlen(fsp->fsp_name) + 1); if(new_offset == 0) { DEBUG(0,("ERROR:set_share_mode shmops->shm_alloc fail!\n")); return False; @@ -439,7 +437,7 @@ static BOOL shm_set_share_mode(int token, int fnum, uint16 port, uint16 op_type) new_mode_p->st_ino = inode; new_mode_p->num_share_mode_entries = 0; new_mode_p->share_mode_entries = 0; - pstrcpy(new_mode_p->file_name, fs_p->fsp_name); + pstrcpy(new_mode_p->file_name, fsp->fsp_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]; @@ -448,7 +446,7 @@ static BOOL shm_set_share_mode(int token, int fnum, uint16 port, uint16 op_type) file_scanner_p = new_mode_p; DEBUG(3,("set_share_mode: Created share record for %s (dev %d inode %d)\n", - fs_p->fsp_name, dev, inode)); + fsp->fsp_name, dev, inode)); } /* Now create the share mode entry */ @@ -466,10 +464,10 @@ static BOOL shm_set_share_mode(int token, int fnum, uint16 port, uint16 op_type) new_entry_p = shmops->offset2addr(new_entry_offset); new_entry_p->e.pid = getpid(); - new_entry_p->e.share_mode = fs_p->share_mode; + new_entry_p->e.share_mode = fsp->share_mode; new_entry_p->e.op_port = port; new_entry_p->e.op_type = op_type; - memcpy( (char *)&new_entry_p->e.time, (char *)&fs_p->open_time, sizeof(struct timeval)); + memcpy( (char *)&new_entry_p->e.time, (char *)&fsp->open_time, sizeof(struct timeval)); /* Chain onto the share_mode_record */ new_entry_p->next_share_mode_entry = file_scanner_p->share_mode_entries; @@ -487,7 +485,7 @@ static BOOL shm_set_share_mode(int token, int fnum, uint16 port, uint16 op_type) file_scanner_p->num_share_mode_entries += 1; DEBUG(3,("set_share_mode: Created share entry for %s with mode 0x%X pid=%d\n", - fs_p->fsp_name, fs_p->share_mode, new_entry_p->e.pid)); + fsp->fsp_name, fsp->share_mode, new_entry_p->e.pid)); return(True); } @@ -495,7 +493,7 @@ static BOOL shm_set_share_mode(int token, int fnum, uint16 port, uint16 op_type) /******************************************************************* Remove an oplock port and mode entry from a share mode. ********************************************************************/ -static BOOL shm_remove_share_oplock(int fnum, int token) +static BOOL shm_remove_share_oplock(files_struct *fsp, int token) { uint32 dev, inode; int *mode_array; @@ -507,8 +505,8 @@ static BOOL shm_remove_share_oplock(int fnum, int token) BOOL found = False; int pid = getpid(); - dev = Files[fnum].fd_ptr->dev; - inode = Files[fnum].fd_ptr->inode; + dev = fsp->fd_ptr->dev; + inode = fsp->fd_ptr->inode; hash_entry = HASH_ENTRY(dev, inode); @@ -565,9 +563,9 @@ static BOOL shm_remove_share_oplock(int fnum, int token) while(entry_scanner_p) { if( (pid == entry_scanner_p->e.pid) && - (entry_scanner_p->e.share_mode == Files[fnum].share_mode) && + (entry_scanner_p->e.share_mode == fsp->share_mode) && (memcmp(&entry_scanner_p->e.time, - &Files[fnum].open_time,sizeof(struct timeval)) == 0) ) + &fsp->open_time,sizeof(struct timeval)) == 0) ) { /* Delete the oplock info. */ entry_scanner_p->e.op_port = 0; diff --git a/source3/locking/locking_slow.c b/source3/locking/locking_slow.c index 9135ae29d2..8b56e7599b 100644 --- a/source3/locking/locking_slow.c +++ b/source3/locking/locking_slow.c @@ -37,7 +37,6 @@ #ifndef FAST_SHARE_MODES extern int DEBUGLEVEL; -extern files_struct Files[]; /* * Locking file header lengths & offsets. @@ -534,7 +533,7 @@ mode file %s to size %d (%s)\n", fname, newsize, strerror(errno))); /******************************************************************* del a share mode from a share mode file. ********************************************************************/ -static void slow_del_share_mode(int token, int fnum) +static void slow_del_share_mode(int token, files_struct *fsp) { pstring fname; int fd = (int)token; @@ -543,15 +542,14 @@ static void slow_del_share_mode(int token, int fnum) int num_entries; int newsize; int i; - files_struct *fs_p = &Files[fnum]; int pid; BOOL deleted = False; BOOL new_file; - share_name(fs_p->conn, fs_p->fd_ptr->dev, - fs_p->fd_ptr->inode, fname); + share_name(fsp->conn, fsp->fd_ptr->dev, + fsp->fd_ptr->inode, fname); - if(read_share_file( fs_p->conn, fd, fname, &buf, &new_file) != 0) + if(read_share_file( fsp->conn, fd, fname, &buf, &new_file) != 0) { DEBUG(0,("ERROR: del_share_mode: Failed to read share file %s\n", fname)); @@ -562,7 +560,7 @@ static void slow_del_share_mode(int token, int fnum) { DEBUG(0,("ERROR:del_share_mode: share file %s is new (size zero), deleting it.\n", fname)); - delete_share_file(fs_p->conn, fname); + delete_share_file(fsp->conn, fname); return; } @@ -586,7 +584,7 @@ for share file %d\n", num_entries, fname)); fname)); if(buf) free(buf); - delete_share_file(fs_p->conn, fname); + delete_share_file(fsp->conn, fname); return; } @@ -602,9 +600,9 @@ for share file %d\n", num_entries, fname)); { char *p = base + (i*SMF_ENTRY_LENGTH); - if((IVAL(p,SME_SEC_OFFSET) != fs_p->open_time.tv_sec) || - (IVAL(p,SME_USEC_OFFSET) != fs_p->open_time.tv_usec) || - (IVAL(p,SME_SHAREMODE_OFFSET) != fs_p->share_mode) || + if((IVAL(p,SME_SEC_OFFSET) != fsp->open_time.tv_sec) || + (IVAL(p,SME_USEC_OFFSET) != fsp->open_time.tv_usec) || + (IVAL(p,SME_SHAREMODE_OFFSET) != fsp->share_mode) || (IVAL(p,SME_PID_OFFSET) != pid)) continue; @@ -637,7 +635,7 @@ for share file %d\n", num_entries, fname)); fname)); if(buf) free(buf); - delete_share_file(fs_p->conn,fname); + delete_share_file(fsp->conn,fname); return; } @@ -675,9 +673,8 @@ mode file %s to size %d (%s)\n", fname, newsize, strerror(errno))); /******************************************************************* set the share mode of a file ********************************************************************/ -static BOOL slow_set_share_mode(int token,int fnum, uint16 port, uint16 op_type) +static BOOL slow_set_share_mode(int token,files_struct *fsp, uint16 port, uint16 op_type) { - files_struct *fs_p = &Files[fnum]; pstring fname; int fd = (int)token; int pid = (int)getpid(); @@ -687,8 +684,8 @@ static BOOL slow_set_share_mode(int token,int fnum, uint16 port, uint16 op_type) int header_size; char *p; - share_name(fs_p->conn, fs_p->fd_ptr->dev, - fs_p->fd_ptr->inode, fname); + share_name(fsp->conn, fsp->fd_ptr->dev, + fsp->fd_ptr->inode, fname); if(fstat(fd, &sb) != 0) { @@ -735,7 +732,7 @@ locking version (was %d, should be %d).\n",fname, IVAL(buf,SMF_VERSION_OFFSET), LOCKING_VERSION)); if(buf) free(buf); - delete_share_file(fs_p->conn, fname); + delete_share_file(fsp->conn, fname); return False; } @@ -748,7 +745,7 @@ locking version (was %d, should be %d).\n",fname, IVAL(buf,SMF_VERSION_OFFSET), deleting it.\n", fname)); if(buf) free(buf); - delete_share_file(fs_p->conn, fname); + delete_share_file(fsp->conn, fname); return False; } @@ -757,23 +754,23 @@ deleting it.\n", fname)); { /* New file - just use a single_entry. */ if((buf = (char *)malloc(SMF_HEADER_LENGTH + - strlen(fs_p->name) + 1 + SMF_ENTRY_LENGTH)) == NULL) + strlen(fsp->name) + 1 + SMF_ENTRY_LENGTH)) == NULL) { DEBUG(0,("ERROR: set_share_mode: malloc failed for single entry.\n")); return False; } SIVAL(buf,SMF_VERSION_OFFSET,LOCKING_VERSION); SIVAL(buf,SMF_NUM_ENTRIES_OFFSET,0); - SSVAL(buf,SMF_FILENAME_LEN_OFFSET,strlen(fs_p->name) + 1); - pstrcpy(buf + SMF_HEADER_LENGTH, fs_p->name); + SSVAL(buf,SMF_FILENAME_LEN_OFFSET,strlen(fsp->name) + 1); + pstrcpy(buf + SMF_HEADER_LENGTH, fsp->name); } num_entries = IVAL(buf,SMF_NUM_ENTRIES_OFFSET); header_size = SMF_HEADER_LENGTH + SVAL(buf,SMF_FILENAME_LEN_OFFSET); p = buf + header_size + (num_entries * SMF_ENTRY_LENGTH); - SIVAL(p,SME_SEC_OFFSET,fs_p->open_time.tv_sec); - SIVAL(p,SME_USEC_OFFSET,fs_p->open_time.tv_usec); - SIVAL(p,SME_SHAREMODE_OFFSET,fs_p->share_mode); + SIVAL(p,SME_SEC_OFFSET,fsp->open_time.tv_sec); + SIVAL(p,SME_USEC_OFFSET,fsp->open_time.tv_usec); + SIVAL(p,SME_SHAREMODE_OFFSET,fsp->share_mode); SIVAL(p,SME_PID_OFFSET,pid); SSVAL(p,SME_PORT_OFFSET,port); SSVAL(p,SME_OPLOCK_TYPE_OFFSET,op_type); @@ -796,7 +793,7 @@ deleting it.\n", fname)); { DEBUG(2,("ERROR: set_share_mode: Failed to write share file %s - \ deleting it (%s).\n",fname, strerror(errno))); - delete_share_file(fs_p->conn, fname); + delete_share_file(fsp->conn, fname); if(buf) free(buf); return False; @@ -818,7 +815,7 @@ mode file %s to size %d (%s)\n", fname, header_size + (SMF_ENTRY_LENGTH*num_entr free(buf); DEBUG(3,("set_share_mode: Created share file %s with \ -mode 0x%X pid=%d\n",fname,fs_p->share_mode,pid)); +mode 0x%X pid=%d\n",fname,fsp->share_mode,pid)); return True; } @@ -826,7 +823,7 @@ mode 0x%X pid=%d\n",fname,fs_p->share_mode,pid)); /******************************************************************* Remove an oplock port and mode entry from a share mode. ********************************************************************/ -static BOOL slow_remove_share_oplock(int fnum, int token) +static BOOL slow_remove_share_oplock(files_struct *fsp, int token) { pstring fname; int fd = (int)token; @@ -835,15 +832,14 @@ static BOOL slow_remove_share_oplock(int fnum, int token) int num_entries; int fsize; int i; - files_struct *fs_p = &Files[fnum]; int pid; BOOL found = False; BOOL new_file; - share_name(fs_p->conn, fs_p->fd_ptr->dev, - fs_p->fd_ptr->inode, fname); + share_name(fsp->conn, fsp->fd_ptr->dev, + fsp->fd_ptr->inode, fname); - if(read_share_file( fs_p->conn, fd, fname, &buf, &new_file) != 0) + if(read_share_file( fsp->conn, fd, fname, &buf, &new_file) != 0) { DEBUG(0,("ERROR: remove_share_oplock: Failed to read share file %s\n", fname)); @@ -854,7 +850,7 @@ static BOOL slow_remove_share_oplock(int fnum, int token) { DEBUG(0,("ERROR: remove_share_oplock: share file %s is new (size zero), \ deleting it.\n", fname)); - delete_share_file(fs_p->conn, fname); + delete_share_file(fsp->conn, fname); return False; } @@ -878,7 +874,7 @@ for share file %d\n", num_entries, fname)); fname)); if(buf) free(buf); - delete_share_file(fs_p->conn, fname); + delete_share_file(fsp->conn, fname); return False; } @@ -894,9 +890,9 @@ for share file %d\n", num_entries, fname)); { char *p = base + (i*SMF_ENTRY_LENGTH); - if((IVAL(p,SME_SEC_OFFSET) != fs_p->open_time.tv_sec) || - (IVAL(p,SME_USEC_OFFSET) != fs_p->open_time.tv_usec) || - (IVAL(p,SME_SHAREMODE_OFFSET) != fs_p->share_mode) || + if((IVAL(p,SME_SEC_OFFSET) != fsp->open_time.tv_sec) || + (IVAL(p,SME_USEC_OFFSET) != fsp->open_time.tv_usec) || + (IVAL(p,SME_SHAREMODE_OFFSET) != fsp->share_mode) || (IVAL(p,SME_PID_OFFSET) != pid)) continue; diff --git a/source3/rpc_server/srv_pipe_hnd.c b/source3/rpc_server/srv_pipe_hnd.c index d792a16426..bd29578f0e 100644 --- a/source3/rpc_server/srv_pipe_hnd.c +++ b/source3/rpc_server/srv_pipe_hnd.c @@ -35,8 +35,6 @@ static int chain_pnum = -1; #define MAX_OPEN_PIPES 50 #endif -#define PIPE_HANDLE_OFFSET 0x800 - pipes_struct Pipes[MAX_OPEN_PIPES]; #define P_OPEN(p) ((p)->open) diff --git a/source3/script/mkproto.awk b/source3/script/mkproto.awk index 28a68e29e2..0b963cbc80 100644 --- a/source3/script/mkproto.awk +++ b/source3/script/mkproto.awk @@ -80,7 +80,7 @@ END { next; } -!/^connection_struct|^uid_t|^gid_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time|^smb_shm_offset_t|^shm_offset_t|^enum remote_arch_types|^FILE/ { +!/^file_fd_struct|^files_struct|^connection_struct|^uid_t|^gid_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time|^smb_shm_offset_t|^shm_offset_t|^enum remote_arch_types|^FILE/ { next; } diff --git a/source3/smbd/files.c b/source3/smbd/files.c new file mode 100644 index 0000000000..a37d190f01 --- /dev/null +++ b/source3/smbd/files.c @@ -0,0 +1,321 @@ +/* + Unix SMB/Netbios implementation. + Version 1.9. + Files[] structure handling + Copyright (C) Andrew Tridgell 1998 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include "includes.h" + +extern int DEBUGLEVEL; + +#define MAX_OPEN_FILES 100 + +#define MAX_FNUMS (MAX_OPEN_FILES+MAX_OPEN_DIRECTORIES) +#define VALID_FNUM(fnum) (((fnum) >= 0) && ((fnum) < MAX_FNUMS)) + +static files_struct Files[MAX_FNUMS]; + +/* + * Indirection for file fd's. Needed as POSIX locking + * is based on file/process, not fd/process. + */ +static file_fd_struct FileFd[MAX_OPEN_FILES]; +static int max_file_fd_used = 0; + + +/**************************************************************************** + find first available file slot +****************************************************************************/ +files_struct *find_free_file(void ) +{ + int i; + static int first_file; + + /* we want to give out file handles differently on each new + connection because of a common bug in MS clients where they try to + reuse a file descriptor from an earlier smb connection. This code + increases the chance that the errant client will get an error rather + than causing corruption */ + if (first_file == 0) { + first_file = (getpid() ^ (int)time(NULL)) % MAX_FNUMS; + if (first_file == 0) first_file = 1; + } + + if (first_file >= MAX_FNUMS) + first_file = 1; + + for (i=first_file;iref_count > 0) && + (((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", + 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(void) +{ + extern struct current_user current_user; + 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 = (uint32)-1; + fd_ptr->inode = (uint32)-1; + fd_ptr->fd = -1; + fd_ptr->fd_readonly = -1; + fd_ptr->fd_writeonly = -1; + fd_ptr->real_open_flags = -1; + fd_ptr->uid_cache_count = 0; + fd_add_to_uid_cache(fd_ptr, (uid_t)current_user.uid); + 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; +} + + +/**************************************************************************** +close all open files for a connection +****************************************************************************/ +void file_close_conn(connection_struct *conn) +{ + int i; + for (i=0;irlp.rlim_max)? + rlp.rlim_max:MAX_FNUMS+10; + setrlimit(RLIMIT_NOFILE, &rlp); + getrlimit(RLIMIT_NOFILE, &rlp); + DEBUG(3,("Maximum number of open files per session is %d\n", + (int)rlp.rlim_cur)); + } +#endif +#endif + + + + 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; + } +} + +/**************************************************************************** +find a fsp given a fnum +****************************************************************************/ +files_struct *file_fsp(int fnum) +{ + if (!VALID_FNUM(fnum)) return NULL; + return &Files[fnum]; +} + + +/**************************************************************************** +close files open by a specified vuid +****************************************************************************/ +void file_close_user(int vuid) +{ + int i; + for (i=0;ivuid == vuid) && fsp->open) { + if(!fsp->is_directory) + close_file(fsp,False); + else + close_directory(fsp); + } + } +} + + +/**************************************************************************** +find a fsp given a device, inode and timevalue +****************************************************************************/ +files_struct *file_find_dit(int dev, int inode, struct timeval *tval) +{ + int i; + for (i=0;iopen && + fsp->fd_ptr->dev == dev && + fsp->fd_ptr->inode == inode && + fsp->open_time.tv_sec == tval->tv_sec && + fsp->open_time.tv_usec == tval->tv_usec) { + return fsp; + } + } + return NULL; +} + +/**************************************************************************** +find a fsp that is open for printing +****************************************************************************/ +files_struct *file_find_print(void) +{ + int i; + + for (i=0;iopen && fsp->print_file) { + return fsp; + } + } + return NULL; +} + + +/**************************************************************************** +sync open files on a connection +****************************************************************************/ +void file_sync_all(connection_struct *conn) +{ + int i; + for (i=0;iopen && conn == fsp->conn) { + sync_file(conn,fsp); + } + } +} + + +void file_free(files_struct *fsp) +{ + memset(fsp, 0, sizeof(*fsp)); +} diff --git a/source3/smbd/ipc.c b/source3/smbd/ipc.c index 63495f0479..ae225956a2 100644 --- a/source3/smbd/ipc.c +++ b/source3/smbd/ipc.c @@ -36,7 +36,6 @@ extern int DEBUGLEVEL; extern int max_send; -extern files_struct Files[]; extern fstring local_machine; extern fstring global_myworkgroup; @@ -1913,108 +1912,105 @@ static BOOL api_PrintJobInfo(connection_struct *conn,uint16 vuid,char *param,cha char **rdata,char **rparam, int *rdata_len,int *rparam_len) { - struct pack_desc desc; - char *str1 = param+2; - char *str2 = skip_string(str1,1); - char *p = skip_string(str2,1); - int jobid, snum; - int uLevel = SVAL(p,2); - int function = SVAL(p,4); /* what is this ?? */ - int i; - char *s = data; + struct pack_desc desc; + char *str1 = param+2; + char *str2 = skip_string(str1,1); + char *p = skip_string(str2,1); + int jobid, snum; + int uLevel = SVAL(p,2); + int function = SVAL(p,4); /* what is this ?? */ + int i; + char *s = data; + files_struct *fsp; - printjob_decode(SVAL(p,0), &snum, &jobid); + printjob_decode(SVAL(p,0), &snum, &jobid); - *rparam_len = 4; - *rparam = REALLOC(*rparam,*rparam_len); + *rparam_len = 4; + *rparam = REALLOC(*rparam,*rparam_len); - *rdata_len = 0; - - /* check it's a supported varient */ - if ((strcmp(str1,"WWsTP")) || (!check_printjob_info(&desc,uLevel,str2))) - return(False); + *rdata_len = 0; + + /* check it's a supported varient */ + if ((strcmp(str1,"WWsTP")) || + (!check_printjob_info(&desc,uLevel,str2))) + return(False); - switch (function) { - case 0x6: /* change job place in the queue, data gives the new place */ - if (snum >= 0 && VALID_SNUM(snum)) - { - print_queue_struct *queue=NULL; - int count; + switch (function) { + case 0x6: /* change job place in the queue, + data gives the new place */ + if (snum >= 0 && VALID_SNUM(snum)) { + print_queue_struct *queue=NULL; + int count; - lpq_reset(snum); - count = get_printqueue(snum,conn,&queue,NULL); - for (i=0;i place ) /* move up */; - } + { + int place= SVAL(data,0); + /* we currently have no way of + doing this. Can any unix do it? */ + if (i < place) /* move down */; + else if (i > place ) /* move up */; + } #endif - desc.errcode=NERR_notsupported; /* not yet supported */ - if (queue) free(queue); - } - } - else desc.errcode=NERR_JobNotFound; - break; - case 0xb: /* change print job name, data gives the name */ - /* jobid, snum should be zero */ - if (isalpha((int)*s)) - { - pstring name; - int l = 0; - while (l<64 && *s) - { - if (issafe(*s)) name[l++] = *s; - s++; - } - name[l] = 0; + desc.errcode=NERR_notsupported; /* not yet + supported */ + if (queue) free(queue); + } + } else { + desc.errcode=NERR_JobNotFound; + } + break; + + case 0xb: /* change print job name, data gives the name */ + /* jobid, snum should be zero */ + if (isalpha((int)*s)) { + pstring name; + int l = 0; + while (l<64 && *s) { + if (issafe(*s)) name[l++] = *s; + s++; + } + name[l] = 0; - DEBUG(3,("Setting print name to %s\n",name)); + DEBUG(3,("Setting print name to %s\n",name)); - become_root(True); - - for (i=0;iconn; + unbecome_user(); - if (!become_user(fconn,vuid) || - !become_service(fconn,True)) - break; + if (!become_user(fconn,vuid) || + !become_service(fconn,True)) + break; - if (sys_rename(Files[i].fsp_name,name) == 0) { - string_set(&Files[i].fsp_name,name); - } - break; - } + if (sys_rename(fsp->fsp_name,name) == 0) { + string_set(&fsp->fsp_name,name); + } + break; + } + } + desc.errcode=NERR_Success; + break; - unbecome_root(True); - } - desc.errcode=NERR_Success; - - break; - default: /* not implemented */ - return False; - } + default: /* not implemented */ + return False; + } - SSVALS(*rparam,0,desc.errcode); - SSVAL(*rparam,2,0); /* converter word */ - - return(True); + SSVALS(*rparam,0,desc.errcode); + SSVAL(*rparam,2,0); /* converter word */ + + return(True); } diff --git a/source3/smbd/nttrans.c b/source3/smbd/nttrans.c index 94ecbfea49..d396b05a62 100644 --- a/source3/smbd/nttrans.c +++ b/source3/smbd/nttrans.c @@ -24,8 +24,7 @@ extern int DEBUGLEVEL; extern int Protocol; -extern int chain_fnum; -extern files_struct Files[]; +extern files_struct *chain_fsp; extern int Client; extern int oplock_sock; extern int smb_read_error; @@ -388,7 +387,8 @@ static int nt_open_pipe(char *fname, connection_struct *conn, if (pnum < 0) return(ERROR(ERRSRV,ERRnofids)); - *ppnum = pnum + 0x800; /* Mark file handle up into high range. */ + *ppnum = pnum + PIPE_HANDLE_OFFSET; /* Mark file handle up into high + range. */ return 0; } @@ -399,7 +399,6 @@ int reply_ntcreate_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize) { pstring fname; - int fnum = -1; uint32 flags = IVAL(inbuf,smb_ntcreate_Flags); uint32 desired_access = IVAL(inbuf,smb_ntcreate_DesiredAccess); uint32 file_attributes = IVAL(inbuf,smb_ntcreate_FileAttributes); @@ -413,7 +412,7 @@ int reply_ntcreate_and_X(connection_struct *conn, /* Breakout the oplock request bits so we can set the reply bits separately. */ int oplock_request = 0; - int unixmode; + int unixmode, pnum = -1; int fmode=0,mtime=0,rmode=0; off_t file_len = 0; struct stat sbuf; @@ -449,10 +448,9 @@ int reply_ntcreate_and_X(connection_struct *conn, /* If it's an IPC, use the pipe handler. */ if (IS_IPC(conn)) { - int ret = nt_open_pipe(fname, conn, inbuf, outbuf, &fnum); + int ret = nt_open_pipe(fname, conn, inbuf, outbuf, &pnum); if(ret != 0) return ret; - fsp = &Files[fnum]; smb_action = FILE_WAS_OPENED; } else { @@ -468,20 +466,18 @@ int reply_ntcreate_and_X(connection_struct *conn, unix_convert(fname,conn,0,&bad_path); - fnum = find_free_file(); - if (fnum < 0) { + fsp = find_free_file(); + if (!fsp) { restore_case_semantics(file_attributes); return(ERROR(ERRSRV,ERRnofids)); } - fsp = &Files[fnum]; - if (!check_name(fname,conn)) { if((errno == ENOENT) && bad_path) { unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); restore_case_semantics(file_attributes); @@ -500,13 +496,13 @@ int reply_ntcreate_and_X(connection_struct *conn, if(flags & OPEN_DIRECTORY) { oplock_request = 0; - open_directory(fnum, conn, fname, smb_ofun, + open_directory(fsp, conn, fname, smb_ofun, unixmode, &smb_action); restore_case_semantics(file_attributes); if(!fsp->open) { - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } } else { @@ -527,7 +523,7 @@ int reply_ntcreate_and_X(connection_struct *conn, * before issuing an oplock break request to * our client. JRA. */ - open_file_shared(fnum,conn,fname,smb_open_mode, + open_file_shared(fsp,conn,fname,smb_open_mode, smb_ofun,unixmode, oplock_request,&rmode,&smb_action); @@ -551,10 +547,10 @@ int reply_ntcreate_and_X(connection_struct *conn, if(errno == EISDIR) { oplock_request = 0; - open_directory(fnum, conn, fname, smb_ofun, unixmode, &smb_action); + open_directory(fsp, conn, fname, smb_ofun, unixmode, &smb_action); if(!fsp->open) { - fsp->reserved = False; + file_free(fsp); restore_case_semantics(file_attributes); return(UNIXERROR(ERRDOS,ERRnoaccess)); } @@ -564,7 +560,7 @@ int reply_ntcreate_and_X(connection_struct *conn, unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); restore_case_semantics(file_attributes); @@ -575,13 +571,13 @@ int reply_ntcreate_and_X(connection_struct *conn, if(fsp->is_directory) { if(sys_stat(fsp->fsp_name, &sbuf) != 0) { - close_directory(fnum); + close_directory(fsp); restore_case_semantics(file_attributes); return(ERROR(ERRDOS,ERRnoaccess)); } } else { if (fstat(fsp->fd_ptr->fd,&sbuf) != 0) { - close_file(fnum,False); + close_file(fsp,False); restore_case_semantics(file_attributes); return(ERROR(ERRDOS,ERRnoaccess)); } @@ -595,7 +591,7 @@ int reply_ntcreate_and_X(connection_struct *conn, fmode = FILE_ATTRIBUTE_NORMAL; mtime = sbuf.st_mtime; if (!fsp->is_directory && (fmode & aDIR)) { - close_file(fnum,False); + close_file(fsp,False); return(ERROR(ERRDOS,ERRnoaccess)); } @@ -623,7 +619,11 @@ int reply_ntcreate_and_X(connection_struct *conn, SCVAL(p,0, (smb_action & EXTENDED_OPLOCK_GRANTED ? 1 : 0)); p++; - SSVAL(p,0,fnum); + if (IS_IPC(conn)) { + SSVAL(p,0,pnum); + } else { + SSVAL(p,0,fsp->fnum); + } p += 2; SIVAL(p,0,smb_action); p += 4; @@ -664,11 +664,10 @@ int reply_ntcreate_and_X(connection_struct *conn, SCVAL(p,0,fsp->is_directory ? 1 : 0); } - chain_fnum = fnum; + chain_fsp = fsp; - - DEBUG(5,("reply_ntcreate_and_X: open fnum = %d, name = %s\n", - fnum, fsp->fsp_name)); + DEBUG(5,("reply_ntcreate_and_X: open name = %s\n", + fsp->fsp_name)); return chain_reply(inbuf,outbuf,length,bufsize); } @@ -683,7 +682,6 @@ static int call_nt_transact_create(connection_struct *conn, char **ppdata) { pstring fname; - int fnum = -1; char *params = *ppparams; uint32 flags = IVAL(params,0); uint32 desired_access = IVAL(params,8); @@ -698,7 +696,7 @@ static int call_nt_transact_create(connection_struct *conn, /* Breakout the oplock request bits so we can set the reply bits separately. */ int oplock_request = 0; - int unixmode; + int unixmode, pnum = -1; int fmode=0,mtime=0,rmode=0; off_t file_len = 0; struct stat sbuf; @@ -732,7 +730,7 @@ static int call_nt_transact_create(connection_struct *conn, /* If it's an IPC, use the pipe handler. */ if (IS_IPC(conn)) { - int ret = nt_open_pipe(fname, conn, inbuf, outbuf, &fnum); + int ret = nt_open_pipe(fname, conn, inbuf, outbuf, &pnum); if(ret != 0) return ret; smb_action = FILE_WAS_OPENED; @@ -745,14 +743,12 @@ static int call_nt_transact_create(connection_struct *conn, unix_convert(fname,conn,0,&bad_path); - fnum = find_free_file(); - if (fnum < 0) { - restore_case_semantics(file_attributes); - return(ERROR(ERRSRV,ERRnofids)); + fsp = find_free_file(); + if (!fsp) { + restore_case_semantics(file_attributes); + return(ERROR(ERRSRV,ERRnofids)); } - fsp = &Files[fnum]; - if (!check_name(fname,conn)) { if((errno == ENOENT) && bad_path) { unix_ERR_class = ERRDOS; @@ -784,10 +780,10 @@ static int call_nt_transact_create(connection_struct *conn, * CreateDirectory() call. */ - open_directory(fnum, conn, fname, smb_ofun, unixmode, &smb_action); + open_directory(fsp, conn, fname, smb_ofun, unixmode, &smb_action); if(!fsp->open) { - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } } else { @@ -796,7 +792,7 @@ static int call_nt_transact_create(connection_struct *conn, * Ordinary file case. */ - open_file_shared(fnum,conn,fname,smb_open_mode,smb_ofun,unixmode, + open_file_shared(fsp,conn,fname,smb_open_mode,smb_ofun,unixmode, oplock_request,&rmode,&smb_action); if (!fsp->open) { @@ -804,7 +800,7 @@ static int call_nt_transact_create(connection_struct *conn, unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); restore_case_semantics(file_attributes); @@ -812,7 +808,7 @@ static int call_nt_transact_create(connection_struct *conn, } if (fstat(fsp->fd_ptr->fd,&sbuf) != 0) { - close_file(fnum,False); + close_file(fsp,False); restore_case_semantics(file_attributes); @@ -826,7 +822,7 @@ static int call_nt_transact_create(connection_struct *conn, mtime = sbuf.st_mtime; if (fmode & aDIR) { - close_file(fnum,False); + close_file(fsp,False); restore_case_semantics(file_attributes); return(ERROR(ERRDOS,ERRnoaccess)); } @@ -855,7 +851,11 @@ static int call_nt_transact_create(connection_struct *conn, p = params; SCVAL(p,0, (smb_action & EXTENDED_OPLOCK_GRANTED ? 1 : 0)); p += 2; - SSVAL(p,0,fnum); + if (IS_IPC(conn)) { + SSVAL(p,0,pnum); + } else { + SSVAL(p,0,fsp->fnum); + } p += 2; SIVAL(p,0,smb_action); p += 8; @@ -940,17 +940,17 @@ static int call_nt_transact_rename(connection_struct *conn, { char *params = *ppparams; pstring new_name; - int fnum = SVAL(params, 0); + files_struct *fsp = GETFSP(params, 0); BOOL replace_if_exists = (SVAL(params,2) & RENAME_REPLACE_IF_EXISTS) ? True : False; uint32 fname_len = MIN((((uint32)IVAL(inbuf,smb_nt_TotalParameterCount)-4)), ((uint32)sizeof(new_name)-1)); int outsize = 0; - CHECK_FNUM(fnum, conn); + CHECK_FSP(fsp, conn); StrnCpy(new_name,params+4,fname_len); new_name[fname_len] = '\0'; - outsize = rename_internals(conn, inbuf, outbuf, Files[fnum].fsp_name, + outsize = rename_internals(conn, inbuf, outbuf, fsp->fsp_name, new_name, replace_if_exists); if(outsize == 0) { /* @@ -959,7 +959,7 @@ static int call_nt_transact_rename(connection_struct *conn, send_nt_replies(outbuf, bufsize, NULL, 0, NULL, 0); DEBUG(3,("nt transact rename from = %s, to = %s succeeded.\n", - Files[fnum].fsp_name, new_name)); + fsp->fsp_name, new_name)); outsize = -1; } @@ -976,7 +976,7 @@ static int call_nt_transact_rename(connection_struct *conn, typedef struct { ubi_slNode msg_next; - int fnum; + files_struct *fsp; connection_struct *conn; time_t next_check_time; time_t modify_time; /* Info from the directory we're monitoring. */ @@ -1023,14 +1023,13 @@ static void change_notify_reply_packet(char *inbuf, int error_class, uint32 erro /**************************************************************************** Delete entries by fnum from the change notify pending queue. *****************************************************************************/ - -void remove_pending_change_notify_requests_by_fid(int fnum) +void remove_pending_change_notify_requests_by_fid(files_struct *fsp) { change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue ); change_notify_buf *prev = NULL; while(cnbp != NULL) { - if(cnbp->fnum == fnum) { + if(cnbp->fsp == fsp) { free((char *)ubi_slRemNext( &change_notify_queue, prev)); cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue)); continue; @@ -1085,9 +1084,8 @@ void process_pending_change_notify_queue(time_t t) while((cnbp != NULL) && (cnbp->next_check_time <= t)) { struct stat st; - int fnum = cnbp->fnum; + files_struct *fsp = cnbp->fsp; connection_struct *conn = cnbp->conn; - files_struct *fsp = &Files[fnum]; uint16 vuid = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID : SVAL(cnbp->request_buf,smb_uid); @@ -1133,8 +1131,8 @@ Error was %s.\n", fsp->fsp_name, strerror(errno) )); /* * Remove the entry and return a change notify to the client. */ - DEBUG(5,("process_pending_change_notify_queue: directory fnum = %d, name = %s changed\n", - fnum, fsp->fsp_name )); + DEBUG(5,("process_pending_change_notify_queue: directory name = %s changed\n", + fsp->fsp_name )); change_notify_reply_packet(cnbp->request_buf,0,NT_STATUS_NOTIFY_ENUM_DIR); free((char *)ubi_slRemNext( &change_notify_queue, prev)); cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue)); @@ -1164,19 +1162,16 @@ static int call_nt_transact_notify_change(connection_struct *conn, { char *setup = *ppsetup; files_struct *fsp; - int fnum = -1; change_notify_buf *cnbp; struct stat st; - fnum = SVAL(setup,4); + fsp = GETFSP(setup,4); - DEBUG(3,("call_nt_transact_notify_change: fnum = %d.\n", fnum)); + DEBUG(3,("call_nt_transact_notify_change\n")); - if(!VALID_FNUM(fnum)) + if(!fsp) return(ERROR(ERRDOS,ERRbadfid)); - fsp = &Files[fnum]; - if((!fsp->open) || (!fsp->is_directory) || (conn != fsp->conn)) return(ERROR(ERRDOS,ERRbadfid)); @@ -1198,14 +1193,14 @@ static int call_nt_transact_notify_change(connection_struct *conn, */ if(sys_stat(fsp->fsp_name, &st) < 0) { - DEBUG(0,("call_nt_transact_notify_change: Unable to stat fnum = %d, name = %s. \ -Error was %s\n", fnum, fsp->fsp_name, strerror(errno) )); + DEBUG(0,("call_nt_transact_notify_change: Unable to stat name = %s. \ +Error was %s\n", fsp->fsp_name, strerror(errno) )); free((char *)cnbp); return(UNIXERROR(ERRDOS,ERRbadfid)); } memcpy(cnbp->request_buf, inbuf, smb_size); - cnbp->fnum = fnum; + cnbp->fsp = fsp; cnbp->conn = conn; cnbp->modify_time = st.st_mtime; cnbp->status_time = st.st_ctime; @@ -1221,7 +1216,7 @@ Error was %s\n", fnum, fsp->fsp_name, strerror(errno) )); ubi_slAddTail(&change_notify_queue, cnbp); DEBUG(3,("call_nt_transact_notify_change: notify change called on directory \ -fid=%d, name = %s\n", fnum, fsp->fsp_name )); +name = %s\n", fsp->fsp_name )); return -1; } diff --git a/source3/smbd/pipes.c b/source3/smbd/pipes.c index 2a51e83946..9ec77c08ca 100644 --- a/source3/smbd/pipes.c +++ b/source3/smbd/pipes.c @@ -44,7 +44,6 @@ extern int Client; #define VALID_PNUM(pnum) (((pnum) >= 0) && ((pnum) < MAX_OPEN_PIPES)) #define OPEN_PNUM(pnum) (VALID_PNUM(pnum) && Pipes[pnum].open) -#define PNUM_OK(pnum,c) (OPEN_PNUM(pnum) && (c)==Pipes[pnum].cnum) /* this macro should always be used to extract an pnum (smb_fid) from a packet to ensure chaining works correctly */ @@ -84,7 +83,7 @@ int reply_open_pipe_and_X(connection_struct *conn, if( strequal(fname,pipe_names[i].client_pipe) ) break; - if ( pipe_names[i].client_pipe == NULL ) + if (pipe_names[i].client_pipe == NULL) return(ERROR(ERRSRV,ERRaccess)); /* Strip \PIPE\ off the name. */ @@ -111,7 +110,9 @@ int reply_open_pipe_and_X(connection_struct *conn, rmode = 1; } - SSVAL(outbuf,smb_vwv2, pnum + 0x800); /* mark file handle up into high range */ + SSVAL(outbuf,smb_vwv2, pnum + PIPE_HANDLE_OFFSET); /* mark file + handle up into + high range */ SSVAL(outbuf,smb_vwv3,fmode); put_dos_date3(outbuf,smb_vwv4,mtime); SIVAL(outbuf,smb_vwv6,size); @@ -138,12 +139,6 @@ int reply_pipe_read_and_X(char *inbuf,char *outbuf,int length,int bufsize) char *data; BOOL ok = False; -/* - CHECK_FNUM(fnum,cnum); - CHECK_READ(fnum); - CHECK_ERROR(fnum); -*/ - set_message(outbuf,12,0,True); data = smb_buf(outbuf); diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c index 626d2e9617..e9a25ea79a 100644 --- a/source3/smbd/reply.c +++ b/source3/smbd/reply.c @@ -33,9 +33,8 @@ extern int Protocol; extern int DEBUGLEVEL; extern int max_send; extern int max_recv; -extern int chain_fnum; +extern files_struct *chain_fsp; extern char magic_char; -extern files_struct Files[]; extern BOOL case_sensitive; extern BOOL case_preserve; extern BOOL short_case_preserve; @@ -44,11 +43,6 @@ extern fstring global_myworkgroup; extern int Client; extern int global_oplock_break; -/* this macro should always be used to extract an fnum (smb_fid) from -a packet to ensure chaining works correctly */ -#define GETFNUM(buf,where) (chain_fnum!= -1?chain_fnum:SVAL(buf,where)) - - /**************************************************************************** report a possible attack via the password buffer overflow bug ****************************************************************************/ @@ -1232,7 +1226,6 @@ int reply_fclose(connection_struct *conn, char *inbuf,char *outbuf, int dum_size int reply_open(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { pstring fname; - int fnum = -1; int outsize = 0; int fmode=0; int share_mode; @@ -1250,12 +1243,10 @@ int reply_open(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, pstrcpy(fname,smb_buf(inbuf)+1); unix_convert(fname,conn,0,&bad_path); - fnum = find_free_file(); - if (fnum < 0) + fsp = find_free_file(); + if (!fsp) return(ERROR(ERRSRV,ERRnofids)); - fsp = &Files[fnum]; - if (!check_name(fname,conn)) { if((errno == ENOENT) && bad_path) @@ -1263,13 +1254,13 @@ int reply_open(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } unixmode = unix_mode(conn,aARCH); - open_file_shared(fnum,conn,fname,share_mode,3,unixmode, + open_file_shared(fsp,conn,fname,share_mode,3,unixmode, oplock_request,&rmode,NULL); if (!fsp->open) @@ -1279,12 +1270,12 @@ int reply_open(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } if (fstat(fsp->fd_ptr->fd,&sbuf) != 0) { - close_file(fnum,False); + close_file(fsp,False); return(ERROR(ERRDOS,ERRnoaccess)); } @@ -1294,12 +1285,12 @@ int reply_open(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, if (fmode & aDIR) { DEBUG(3,("attempt to open a directory %s\n",fname)); - close_file(fnum,False); + close_file(fsp,False); return(ERROR(ERRDOS,ERRnoaccess)); } outsize = set_message(outbuf,7,0,True); - SSVAL(outbuf,smb_vwv0,fnum); + SSVAL(outbuf,smb_vwv0,fsp->fnum); SSVAL(outbuf,smb_vwv1,fmode); if(lp_dos_filetime_resolution(SNUM(conn)) ) put_dos_date3(outbuf,smb_vwv2,mtime & ~1); @@ -1324,7 +1315,6 @@ int reply_open(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int reply_open_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize) { pstring fname; - int fnum = -1; int smb_mode = SVAL(inbuf,smb_vwv3); int smb_attr = SVAL(inbuf,smb_vwv5); /* Breakout the oplock request bits so we can set the @@ -1354,12 +1344,10 @@ int reply_open_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt pstrcpy(fname,smb_buf(inbuf)); unix_convert(fname,conn,0,&bad_path); - fnum = find_free_file(); - if (fnum < 0) + fsp = find_free_file(); + if (!fsp) return(ERROR(ERRSRV,ERRnofids)); - fsp = &Files[fnum]; - if (!check_name(fname,conn)) { if((errno == ENOENT) && bad_path) @@ -1367,13 +1355,13 @@ int reply_open_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } unixmode = unix_mode(conn,smb_attr | aARCH); - open_file_shared(fnum,conn,fname,smb_mode,smb_ofun,unixmode, + open_file_shared(fsp,conn,fname,smb_mode,smb_ofun,unixmode, oplock_request, &rmode,&smb_action); if (!fsp->open) @@ -1383,12 +1371,12 @@ int reply_open_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } if (fstat(fsp->fd_ptr->fd,&sbuf) != 0) { - close_file(fnum,False); + close_file(fsp,False); return(ERROR(ERRDOS,ERRnoaccess)); } @@ -1396,7 +1384,7 @@ int reply_open_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt fmode = dos_mode(conn,fname,&sbuf); mtime = sbuf.st_mtime; if (fmode & aDIR) { - close_file(fnum,False); + close_file(fsp,False); return(ERROR(ERRDOS,ERRnoaccess)); } @@ -1427,7 +1415,7 @@ int reply_open_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt } set_message(outbuf,15,0,True); - SSVAL(outbuf,smb_vwv2,fnum); + SSVAL(outbuf,smb_vwv2,fsp->fnum); SSVAL(outbuf,smb_vwv3,fmode); if(lp_dos_filetime_resolution(SNUM(conn)) ) put_dos_date3(outbuf,smb_vwv4,mtime & ~1); @@ -1437,7 +1425,7 @@ int reply_open_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt SSVAL(outbuf,smb_vwv8,rmode); SSVAL(outbuf,smb_vwv11,smb_action); - chain_fnum = fnum; + chain_fsp = fsp; return chain_reply(inbuf,outbuf,length,bufsize); } @@ -1458,16 +1446,7 @@ int reply_ulogoffX(connection_struct *conn, char *inbuf,char *outbuf,int length, /* in user level security we are supposed to close any files open by this user */ if ((vuser != 0) && (lp_security() != SEC_SHARE)) { - int i; - for (i=0;ivuid == vuid) && fsp->open) { - if(!fsp->is_directory) - close_file(i,False); - else - close_directory(i); - } - } + file_close_user(vuid); } invalidate_vuid(vuid); @@ -1487,7 +1466,6 @@ int reply_mknew(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, { pstring fname; int com; - int fnum = -1; int outsize = 0; int createmode; mode_t unixmode; @@ -1509,12 +1487,10 @@ int reply_mknew(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, unixmode = unix_mode(conn,createmode); - fnum = find_free_file(); - if (fnum < 0) + fsp = find_free_file(); + if (!fsp) return(ERROR(ERRSRV,ERRnofids)); - fsp = &Files[fnum]; - if (!check_name(fname,conn)) { if((errno == ENOENT) && bad_path) @@ -1522,7 +1498,7 @@ int reply_mknew(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } @@ -1538,7 +1514,7 @@ int reply_mknew(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, } /* Open file in dos compatibility share mode. */ - open_file_shared(fnum,conn,fname,(DENY_FCB<<4)|0xF, ofun, unixmode, + open_file_shared(fsp,conn,fname,(DENY_FCB<<4)|0xF, ofun, unixmode, oplock_request, NULL, NULL); if (!fsp->open) @@ -1548,12 +1524,12 @@ int reply_mknew(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } outsize = set_message(outbuf,1,0,True); - SSVAL(outbuf,smb_vwv0,fnum); + SSVAL(outbuf,smb_vwv0,fsp->fnum); if (oplock_request && lp_fake_oplocks(SNUM(conn))) { CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED; @@ -1563,8 +1539,8 @@ int reply_mknew(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED; DEBUG( 2, ( "new file %s\n", fname ) ); - DEBUG( 3, ( "mknew %s fd=%d fnum=%d dmode=%d umode=%o\n", - fname, fsp->fd_ptr->fd, fnum, createmode, (int)unixmode ) ); + DEBUG( 3, ( "mknew %s fd=%d dmode=%d umode=%o\n", + fname, fsp->fd_ptr->fd, createmode, (int)unixmode ) ); return(outsize); } @@ -1577,7 +1553,6 @@ int reply_ctemp(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, { pstring fname; pstring fname2; - int fnum = -1; int outsize = 0; int createmode; mode_t unixmode; @@ -1592,12 +1567,10 @@ int reply_ctemp(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, unixmode = unix_mode(conn,createmode); - fnum = find_free_file(); - if (fnum < 0) + fsp = find_free_file(); + if (fsp) return(ERROR(ERRSRV,ERRnofids)); - fsp = &Files[fnum]; - if (!check_name(fname,conn)) { if((errno == ENOENT) && bad_path) @@ -1605,7 +1578,7 @@ int reply_ctemp(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } @@ -1613,7 +1586,7 @@ int reply_ctemp(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, /* Open file in dos compatibility share mode. */ /* We should fail if file exists. */ - open_file_shared(fnum,conn,fname2,(DENY_FCB<<4)|0xF, 0x10, unixmode, + open_file_shared(fsp,conn,fname2,(DENY_FCB<<4)|0xF, 0x10, unixmode, oplock_request, NULL, NULL); if (!fsp->open) @@ -1623,12 +1596,12 @@ int reply_ctemp(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } outsize = set_message(outbuf,1,2 + strlen(fname2),True); - SSVAL(outbuf,smb_vwv0,fnum); + SSVAL(outbuf,smb_vwv0,fsp->fnum); CVAL(smb_buf(outbuf),0) = 4; pstrcpy(smb_buf(outbuf) + 1,fname2); @@ -1640,8 +1613,8 @@ int reply_ctemp(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED; DEBUG( 2, ( "created temp file %s\n", fname2 ) ); - DEBUG( 3, ( "ctemp %s fd=%d fnum=%d dmode=%d umode=%o\n", - fname2, fsp->fd_ptr->fd, fnum, createmode, (int)unixmode ) ); + DEBUG( 3, ( "ctemp %s fd=%d dmode=%d umode=%o\n", + fname2, fsp->fd_ptr->fd, createmode, (int)unixmode ) ); return(outsize); } @@ -1777,7 +1750,7 @@ int reply_unlink(connection_struct *conn, char *inbuf,char *outbuf, int dum_size ****************************************************************************/ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_size, int dum_buffsize) { - int maxcount,mincount,fnum; + int maxcount,mincount; int nread = 0; uint32 startpos; char *header = outbuf; @@ -1800,7 +1773,7 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s return -1; } - fnum = GETFNUM(inbuf,smb_vwv0); + fsp = GETFSP(inbuf,smb_vwv0); startpos = IVAL(inbuf,smb_vwv1); maxcount = SVAL(inbuf,smb_vwv3); @@ -1810,23 +1783,18 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s maxcount = MIN(65535,maxcount); maxcount = MAX(mincount,maxcount); - if (!FNUM_OK(fnum,conn) || !Files[fnum].can_read) - { - DEBUG(3,("fnum %d not open in readbraw - cache prime?\n",fnum)); - _smb_setlen(header,0); - transfer_file(0,Client,0,header,4,0); - return(-1); - } - else - { - fsp = &Files[fnum]; - - fd = fsp->fd_ptr->fd; - fname = fsp->fsp_name; + if (!FNUM_OK(fsp,conn) || !fsp->can_read) { + DEBUG(3,("fnum %d not open in readbraw - cache prime?\n",fsp->fnum)); + _smb_setlen(header,0); + transfer_file(0,Client,0,header,4,0); + return(-1); + } else { + fd = fsp->fd_ptr->fd; + fname = fsp->fsp_name; } - if (!is_locked(fnum,conn,maxcount,startpos, F_RDLCK)) + if (!is_locked(fsp,conn,maxcount,startpos, F_RDLCK)) { int size = fsp->size; int sizeneeded = startpos + maxcount; @@ -1846,7 +1814,7 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s nread = 0; DEBUG( 3, ( "readbraw fnum=%d start=%d max=%d min=%d nread=%d\n", - fnum, startpos, + fsp->fnum, startpos, maxcount, mincount, nread ) ); #if UNSAFE_READRAW @@ -1860,7 +1828,7 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s #endif if ((nread-predict) > 0) - seek_file(fnum,startpos + predict); + seek_file(fsp,startpos + predict); ret = transfer_file(fd,Client,nread-predict,header,4+predict, startpos+predict); @@ -1871,7 +1839,7 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s fname,startpos,nread,ret)); #else - ret = read_file(fnum,header+4,startpos,nread); + ret = read_file(fsp,header+4,startpos,nread); if (ret < mincount) ret = 0; _smb_setlen(header,ret); @@ -1888,19 +1856,17 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s ****************************************************************************/ int reply_lockread(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsiz) { - int fnum; int nread = -1; char *data; int outsize = 0; uint32 startpos, numtoread; int eclass; uint32 ecode; - - fnum = GETFNUM(inbuf,smb_vwv0); + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - CHECK_FNUM(fnum,conn); - CHECK_READ(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_READ(fsp); + CHECK_ERROR(fsp); numtoread = SVAL(inbuf,smb_vwv1); startpos = IVAL(inbuf,smb_vwv2); @@ -1909,10 +1875,10 @@ int reply_lockread(connection_struct *conn, char *inbuf,char *outbuf, int dum_si numtoread = MIN(BUFFER_SIZE-outsize,numtoread); data = smb_buf(outbuf) + 3; - if(!do_lock( fnum, conn, numtoread, startpos, F_RDLCK, &eclass, &ecode)) + if(!do_lock( fsp, conn, numtoread, startpos, F_RDLCK, &eclass, &ecode)) return (ERROR(eclass,ecode)); - nread = read_file(fnum,data,startpos,numtoread); + nread = read_file(fsp,data,startpos,numtoread); if (nread < 0) return(UNIXERROR(ERRDOS,ERRnoaccess)); @@ -1923,7 +1889,7 @@ int reply_lockread(connection_struct *conn, char *inbuf,char *outbuf, int dum_si SSVAL(smb_buf(outbuf),1,nread); DEBUG( 3, ( "lockread fnum=%d num=%d nread=%d\n", - fnum, numtoread, nread ) ); + fsp->fnum, numtoread, nread ) ); return(outsize); } @@ -1934,17 +1900,16 @@ int reply_lockread(connection_struct *conn, char *inbuf,char *outbuf, int dum_si ****************************************************************************/ int reply_read(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int numtoread,fnum; + int numtoread; int nread = 0; char *data; uint32 startpos; int outsize = 0; - - fnum = GETFNUM(inbuf,smb_vwv0); + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - CHECK_FNUM(fnum,conn); - CHECK_READ(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_READ(fsp); + CHECK_ERROR(fsp); numtoread = SVAL(inbuf,smb_vwv1); startpos = IVAL(inbuf,smb_vwv2); @@ -1953,11 +1918,11 @@ int reply_read(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, numtoread = MIN(BUFFER_SIZE-outsize,numtoread); data = smb_buf(outbuf) + 3; - if (is_locked(fnum,conn,numtoread,startpos, F_RDLCK)) + if (is_locked(fsp,conn,numtoread,startpos, F_RDLCK)) return(ERROR(ERRDOS,ERRlock)); if (numtoread > 0) - nread = read_file(fnum,data,startpos,numtoread); + nread = read_file(fsp,data,startpos,numtoread); if (nread < 0) return(UNIXERROR(ERRDOS,ERRnoaccess)); @@ -1969,7 +1934,7 @@ int reply_read(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, SSVAL(smb_buf(outbuf),1,nread); DEBUG( 3, ( "read fnum=%d num=%d nread=%d\n", - fnum, numtoread, nread ) ); + fsp->fnum, numtoread, nread ) ); return(outsize); } @@ -1980,7 +1945,7 @@ int reply_read(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, ****************************************************************************/ int reply_read_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize) { - int fnum = GETFNUM(inbuf,smb_vwv2); + files_struct *fsp = GETFSP(inbuf,smb_vwv2); uint32 smb_offs = IVAL(inbuf,smb_vwv3); int smb_maxcnt = SVAL(inbuf,smb_vwv5); int smb_mincnt = SVAL(inbuf,smb_vwv6); @@ -1992,16 +1957,16 @@ int reply_read_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt if (IS_IPC(conn)) return reply_pipe_read_and_X(inbuf,outbuf,length,bufsize); - CHECK_FNUM(fnum,conn); - CHECK_READ(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_READ(fsp); + CHECK_ERROR(fsp); set_message(outbuf,12,0,True); data = smb_buf(outbuf); - if (is_locked(fnum,conn,smb_maxcnt,smb_offs, F_RDLCK)) + if (is_locked(fsp,conn,smb_maxcnt,smb_offs, F_RDLCK)) return(ERROR(ERRDOS,ERRlock)); - nread = read_file(fnum,data,smb_offs,smb_maxcnt); + nread = read_file(fsp,data,smb_offs,smb_maxcnt); ok = True; if (nread < 0) @@ -2012,9 +1977,9 @@ int reply_read_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt SSVAL(smb_buf(outbuf),-2,nread); DEBUG( 3, ( "readX fnum=%d min=%d max=%d nread=%d\n", - fnum, smb_mincnt, smb_maxcnt, nread ) ); + fsp->fnum, smb_mincnt, smb_maxcnt, nread ) ); - chain_fnum = fnum; + chain_fsp = fsp; return chain_reply(inbuf,outbuf,length,bufsize); } @@ -2028,18 +1993,16 @@ int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_s int nwritten=0; int total_written=0; int numtowrite=0; - int fnum; int outsize = 0; long startpos; char *data=NULL; BOOL write_through; int tcount; + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - fnum = GETFNUM(inbuf,smb_vwv0); - - CHECK_FNUM(fnum,conn); - CHECK_WRITE(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_WRITE(fsp); + CHECK_ERROR(fsp); tcount = IVAL(inbuf,smb_vwv1); startpos = IVAL(inbuf,smb_vwv3); @@ -2059,17 +2022,17 @@ int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_s CVAL(inbuf,smb_com) = SMBwritec; CVAL(outbuf,smb_com) = SMBwritec; - if (is_locked(fnum,conn,tcount,startpos, F_WRLCK)) + if (is_locked(fsp,conn,tcount,startpos, F_WRLCK)) return(ERROR(ERRDOS,ERRlock)); - if (seek_file(fnum,startpos) != startpos) + if (seek_file(fsp,startpos) != startpos) DEBUG(0,("couldn't seek to %ld in writebraw\n",startpos)); if (numtowrite>0) - nwritten = write_file(fnum,data,numtowrite); + nwritten = write_file(fsp,data,numtowrite); DEBUG(3,("writebraw1 fnum=%d start=%ld num=%d wrote=%d sync=%d\n", - fnum, startpos, numtowrite, nwritten, write_through)); + fsp->fnum, startpos, numtowrite, nwritten, write_through)); if (nwritten < numtowrite) return(UNIXERROR(ERRHRD,ERRdiskfull)); @@ -2097,7 +2060,7 @@ int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_s tcount,nwritten,numtowrite)); } - nwritten = transfer_file(Client,Files[fnum].fd_ptr->fd,numtowrite,NULL,0, + nwritten = transfer_file(Client,fsp->fd_ptr->fd,numtowrite,NULL,0, startpos+nwritten); total_written += nwritten; @@ -2112,10 +2075,10 @@ int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_s } if (lp_syncalways(SNUM(conn)) || write_through) - sync_file(conn,fnum); + sync_file(conn,fsp); DEBUG(3,("writebraw2 fnum=%d start=%ld num=%d wrote=%d\n", - fnum, startpos, numtowrite, total_written)); + fsp->fnum, startpos, numtowrite, total_written)); /* we won't return a status if write through is not selected - this follows what WfWg does */ @@ -2131,28 +2094,26 @@ int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_s ****************************************************************************/ int reply_writeunlock(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int fnum; int nwritten = -1; int outsize = 0; char *data; uint32 numtowrite,startpos; int eclass; uint32 ecode; - - fnum = GETFNUM(inbuf,smb_vwv0); + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - CHECK_FNUM(fnum,conn); - CHECK_WRITE(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_WRITE(fsp); + CHECK_ERROR(fsp); numtowrite = SVAL(inbuf,smb_vwv1); startpos = IVAL(inbuf,smb_vwv2); data = smb_buf(inbuf) + 3; - if (is_locked(fnum,conn,numtowrite,startpos, F_WRLCK)) + if (is_locked(fsp,conn,numtowrite,startpos, F_WRLCK)) return(ERROR(ERRDOS,ERRlock)); - seek_file(fnum,startpos); + seek_file(fsp,startpos); /* The special X/Open SMB protocol handling of zero length writes is *NOT* done for @@ -2160,15 +2121,15 @@ int reply_writeunlock(connection_struct *conn, char *inbuf,char *outbuf, int dum if(numtowrite == 0) nwritten = 0; else - nwritten = write_file(fnum,data,numtowrite); + nwritten = write_file(fsp,data,numtowrite); if (lp_syncalways(SNUM(conn))) - sync_file(conn,fnum); + sync_file(conn,fsp); if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0)) return(UNIXERROR(ERRDOS,ERRnoaccess)); - if(!do_unlock(fnum, conn, numtowrite, startpos, &eclass, &ecode)) + if(!do_unlock(fsp, conn, numtowrite, startpos, &eclass, &ecode)) return(ERROR(eclass,ecode)); outsize = set_message(outbuf,1,0,True); @@ -2176,7 +2137,7 @@ int reply_writeunlock(connection_struct *conn, char *inbuf,char *outbuf, int dum SSVAL(outbuf,smb_vwv0,nwritten); DEBUG( 3, ( "writeunlock fnum=%d num=%d wrote=%d\n", - fnum, numtowrite, nwritten ) ); + fsp->fnum, numtowrite, nwritten ) ); return(outsize); } @@ -2187,37 +2148,36 @@ int reply_writeunlock(connection_struct *conn, char *inbuf,char *outbuf, int dum ****************************************************************************/ int reply_write(connection_struct *conn, char *inbuf,char *outbuf,int dum_size,int dum_buffsize) { - int numtowrite,fnum; + int numtowrite; int nwritten = -1; int outsize = 0; int startpos; char *data; + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - fnum = GETFNUM(inbuf,smb_vwv0); - - CHECK_FNUM(fnum,conn); - CHECK_WRITE(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_WRITE(fsp); + CHECK_ERROR(fsp); numtowrite = SVAL(inbuf,smb_vwv1); startpos = IVAL(inbuf,smb_vwv2); data = smb_buf(inbuf) + 3; - if (is_locked(fnum,conn,numtowrite,startpos, F_WRLCK)) + if (is_locked(fsp,conn,numtowrite,startpos, F_WRLCK)) return(ERROR(ERRDOS,ERRlock)); - seek_file(fnum,startpos); + seek_file(fsp,startpos); /* X/Open SMB protocol says that if smb_vwv1 is zero then the file size should be extended or truncated to the size given in smb_vwv[2-3] */ if(numtowrite == 0) - nwritten = set_filelen(Files[fnum].fd_ptr->fd, startpos); + nwritten = set_filelen(fsp->fd_ptr->fd, startpos); else - nwritten = write_file(fnum,data,numtowrite); + nwritten = write_file(fsp,data,numtowrite); if (lp_syncalways(SNUM(conn))) - sync_file(conn,fnum); + sync_file(conn,fsp); if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0)) return(UNIXERROR(ERRDOS,ERRnoaccess)); @@ -2232,7 +2192,7 @@ int reply_write(connection_struct *conn, char *inbuf,char *outbuf,int dum_size,i } DEBUG(3,("write fnum=%d num=%d wrote=%d\n", - fnum, numtowrite, nwritten)); + fsp->fnum, numtowrite, nwritten)); return(outsize); } @@ -2243,7 +2203,7 @@ int reply_write(connection_struct *conn, char *inbuf,char *outbuf,int dum_size,i ****************************************************************************/ int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize) { - int fnum = GETFNUM(inbuf,smb_vwv2); + files_struct *fsp = GETFSP(inbuf,smb_vwv2); uint32 smb_offs = IVAL(inbuf,smb_vwv3); int smb_dsize = SVAL(inbuf,smb_vwv10); int smb_doff = SVAL(inbuf,smb_vwv11); @@ -2251,16 +2211,16 @@ int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int leng int nwritten = -1; char *data; - CHECK_FNUM(fnum,conn); - CHECK_WRITE(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_WRITE(fsp); + CHECK_ERROR(fsp); data = smb_base(inbuf) + smb_doff; - if (is_locked(fnum,conn,smb_dsize,smb_offs, F_WRLCK)) + if (is_locked(fsp,conn,smb_dsize,smb_offs, F_WRLCK)) return(ERROR(ERRDOS,ERRlock)); - seek_file(fnum,smb_offs); + seek_file(fsp,smb_offs); /* X/Open SMB protocol says that, unlike SMBwrite if the length is zero then NO truncation is @@ -2269,7 +2229,7 @@ int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int leng if(smb_dsize == 0) nwritten = 0; else - nwritten = write_file(fnum,data,smb_dsize); + nwritten = write_file(fsp,data,smb_dsize); if(((nwritten == 0) && (smb_dsize != 0))||(nwritten < 0)) return(UNIXERROR(ERRDOS,ERRnoaccess)); @@ -2284,12 +2244,12 @@ int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int leng } DEBUG(3,("writeX fnum=%d num=%d wrote=%d\n", - fnum, smb_dsize, nwritten)); + fsp->fnum, smb_dsize, nwritten)); - chain_fnum = fnum; + chain_fsp = fsp; if (lp_syncalways(SNUM(conn)) || write_through) - sync_file(conn,fnum); + sync_file(conn,fsp); return chain_reply(inbuf,outbuf,length,bufsize); } @@ -2300,17 +2260,14 @@ int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int leng ****************************************************************************/ int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int fnum; uint32 startpos; int32 res= -1; int mode,umode; int outsize = 0; - files_struct *fsp; - - fnum = GETFNUM(inbuf,smb_vwv0); + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - CHECK_FNUM(fnum,conn); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_ERROR(fsp); mode = SVAL(inbuf,smb_vwv1) & 3; startpos = IVAL(inbuf,smb_vwv2); @@ -2324,8 +2281,6 @@ int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, umode = SEEK_SET; break; } - fsp = &Files[fnum]; - res = lseek(fsp->fd_ptr->fd,startpos,umode); fsp->pos = res; @@ -2333,7 +2288,7 @@ int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, SIVALS(outbuf,smb_vwv0,res); DEBUG(3,("lseek fnum=%d ofs=%d mode=%d\n", - fnum, startpos, mode)); + fsp->fnum, startpos, mode)); return(outsize); } @@ -2344,28 +2299,21 @@ int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, ****************************************************************************/ int reply_flush(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int fnum; int outsize = set_message(outbuf,0,0,True); + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - fnum = GETFNUM(inbuf,smb_vwv0); - - if (fnum != 0xFFFF) { - CHECK_FNUM(fnum,conn); - CHECK_ERROR(fnum); + if (fsp) { + CHECK_FSP(fsp,conn); + CHECK_ERROR(fsp); } - if (fnum == 0xFFFF) { - int i; - for (i=0;iopen && fsp->is_directory)) + CHECK_FSP(fsp,conn); - fsp = &Files[fnum]; - - if(HAS_CACHED_ERROR(fnum)) { + if(HAS_CACHED_ERROR(fsp)) { eclass = fsp->wbmpx_ptr->wr_errclass; err = fsp->wbmpx_ptr->wr_error; } @@ -2423,8 +2368,8 @@ int reply_close(connection_struct *conn, * Special case - close NT SMB directory * handle. */ - DEBUG(3,("close directory fnum=%d\n", fnum)); - close_directory(fnum); + DEBUG(3,("close directory fnum=%d\n", fsp->fnum)); + close_directory(fsp); } else { /* * Close ordinary file. @@ -2435,10 +2380,10 @@ int reply_close(connection_struct *conn, set_filetime(conn, fsp->fsp_name,mtime); DEBUG(3,("close fd=%d fnum=%d (numopen=%d)\n", - fsp->fd_ptr->fd, fnum, + fsp->fd_ptr->fd, fsp->fnum, conn->num_files_open)); - close_file(fnum,True); + close_file(fsp,True); } /* We have a cached error */ @@ -2455,37 +2400,36 @@ int reply_close(connection_struct *conn, int reply_writeclose(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int numtowrite,fnum; + int numtowrite; int nwritten = -1; int outsize = 0; int startpos; char *data; time_t mtime; - - fnum = GETFNUM(inbuf,smb_vwv0); + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - CHECK_FNUM(fnum,conn); - CHECK_WRITE(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_WRITE(fsp); + CHECK_ERROR(fsp); numtowrite = SVAL(inbuf,smb_vwv1); startpos = IVAL(inbuf,smb_vwv2); mtime = make_unix_date3(inbuf+smb_vwv4); data = smb_buf(inbuf) + 1; - if (is_locked(fnum,conn,numtowrite,startpos, F_WRLCK)) + if (is_locked(fsp,conn,numtowrite,startpos, F_WRLCK)) return(ERROR(ERRDOS,ERRlock)); - seek_file(fnum,startpos); + seek_file(fsp,startpos); - nwritten = write_file(fnum,data,numtowrite); + nwritten = write_file(fsp,data,numtowrite); - set_filetime(conn, Files[fnum].fsp_name,mtime); + set_filetime(conn, fsp->fsp_name,mtime); - close_file(fnum,True); + close_file(fsp,True); DEBUG(3,("writeclose fnum=%d num=%d wrote=%d (numopen=%d)\n", - fnum, numtowrite, nwritten, + fsp->fnum, numtowrite, nwritten, conn->num_files_open)); if (nwritten <= 0) @@ -2504,24 +2448,22 @@ int reply_writeclose(connection_struct *conn, int reply_lock(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int fnum; int outsize = set_message(outbuf,0,0,True); uint32 count,offset; int eclass; uint32 ecode; + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - fnum = GETFNUM(inbuf,smb_vwv0); - - CHECK_FNUM(fnum,conn); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_ERROR(fsp); count = IVAL(inbuf,smb_vwv1); offset = IVAL(inbuf,smb_vwv3); DEBUG(3,("lock fd=%d fnum=%d ofs=%d cnt=%d\n", - Files[fnum].fd_ptr->fd, fnum, offset, count)); + fsp->fd_ptr->fd, fsp->fnum, offset, count)); - if (!do_lock(fnum, conn, count, offset, F_WRLCK, &eclass, &ecode)) + if (!do_lock(fsp, conn, count, offset, F_WRLCK, &eclass, &ecode)) return (ERROR(eclass,ecode)); return(outsize); @@ -2533,25 +2475,23 @@ int reply_lock(connection_struct *conn, ****************************************************************************/ int reply_unlock(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int fnum; int outsize = set_message(outbuf,0,0,True); uint32 count,offset; int eclass; uint32 ecode; - - fnum = GETFNUM(inbuf,smb_vwv0); + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - CHECK_FNUM(fnum,conn); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_ERROR(fsp); count = IVAL(inbuf,smb_vwv1); offset = IVAL(inbuf,smb_vwv3); - if(!do_unlock(fnum, conn, count, offset, &eclass, &ecode)) + if(!do_unlock(fsp, conn, count, offset, &eclass, &ecode)) return (ERROR(eclass,ecode)); DEBUG( 3, ( "unlock fd=%d fnum=%d ofs=%d cnt=%d\n", - Files[fnum].fd_ptr->fd, fnum, offset, count ) ); + fsp->fd_ptr->fd, fsp->fnum, offset, count ) ); return(outsize); } @@ -2624,7 +2564,6 @@ int reply_printopen(connection_struct *conn, { pstring fname; pstring fname2; - int fnum = -1; int outsize = 0; files_struct *fsp; @@ -2649,26 +2588,24 @@ int reply_printopen(connection_struct *conn, slprintf(fname,sizeof(fname)-1, "%s.XXXXXX",s); } - fnum = find_free_file(); - if (fnum < 0) + fsp = find_free_file(); + if (!fsp) return(ERROR(ERRSRV,ERRnofids)); - - fsp = &Files[fnum]; pstrcpy(fname2,(char *)mktemp(fname)); if (!check_name(fname2,conn)) { - fsp->reserved = False; + file_free(fsp); return(ERROR(ERRDOS,ERRnoaccess)); } /* Open for exclusive use, write only. */ - open_file_shared(fnum,conn,fname2, + open_file_shared(fsp,conn,fname2, (DENY_ALL<<4)|1, 0x12, unix_mode(conn,0), 0, NULL, NULL); if (!fsp->open) { - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } @@ -2676,10 +2613,10 @@ int reply_printopen(connection_struct *conn, fsp->print_file = True; outsize = set_message(outbuf,1,0,True); - SSVAL(outbuf,smb_vwv0,fnum); + SSVAL(outbuf,smb_vwv0,fsp->fnum); DEBUG(3,("openprint %s fd=%d fnum=%d\n", - fname2, fsp->fd_ptr->fd, fnum)); + fname2, fsp->fd_ptr->fd, fsp->fnum)); return(outsize); } @@ -2691,21 +2628,19 @@ int reply_printopen(connection_struct *conn, int reply_printclose(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int fnum; int outsize = set_message(outbuf,0,0,True); - - fnum = GETFNUM(inbuf,smb_vwv0); + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - CHECK_FNUM(fnum,conn); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_ERROR(fsp); if (!CAN_PRINT(conn)) return(ERROR(ERRDOS,ERRnoaccess)); DEBUG(3,("printclose fd=%d fnum=%d\n", - Files[fnum].fd_ptr->fd,fnum)); + fsp->fd_ptr->fd,fsp->fnum)); - close_file(fnum,True); + close_file(fsp,True); return(outsize); } @@ -2786,26 +2721,25 @@ int reply_printqueue(connection_struct *conn, ****************************************************************************/ int reply_printwrite(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int numtowrite,fnum; + int numtowrite; int outsize = set_message(outbuf,0,0,True); char *data; + files_struct *fsp = GETFSP(inbuf,smb_vwv0); if (!CAN_PRINT(conn)) return(ERROR(ERRDOS,ERRnoaccess)); - fnum = GETFNUM(inbuf,smb_vwv0); - - CHECK_FNUM(fnum,conn); - CHECK_WRITE(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_WRITE(fsp); + CHECK_ERROR(fsp); numtowrite = SVAL(smb_buf(inbuf),1); data = smb_buf(inbuf) + 3; - if (write_file(fnum,data,numtowrite) != numtowrite) + if (write_file(fsp,data,numtowrite) != numtowrite) return(UNIXERROR(ERRDOS,ERRnoaccess)); - DEBUG( 3, ( "printwrite fnum=%d num=%d\n", fnum, numtowrite ) ); + DEBUG( 3, ( "printwrite fnum=%d num=%d\n", fsp->fnum, numtowrite ) ); return(outsize); } @@ -3323,7 +3257,7 @@ static BOOL copy_file(char *src,char *dest1,connection_struct *conn, int ofun, int Access,action; struct stat st; int ret=0; - int fnum1,fnum2; + files_struct *fsp1,*fsp2; pstring dest; pstrcpy(dest,dest1); @@ -3339,43 +3273,43 @@ static BOOL copy_file(char *src,char *dest1,connection_struct *conn, int ofun, if (!file_exist(src,&st)) return(False); - fnum1 = find_free_file(); - if (fnum1<0) return(False); - open_file_shared(fnum1,conn,src,(DENY_NONE<<4), + fsp1 = find_free_file(); + if (!fsp1) return(False); + open_file_shared(fsp1,conn,src,(DENY_NONE<<4), 1,0,0,&Access,&action); - if (!Files[fnum1].open) { - Files[fnum1].reserved = False; + if (!fsp1->open) { + fsp1->reserved = False; return(False); } if (!target_is_directory && count) ofun = 1; - fnum2 = find_free_file(); - if (fnum2<0) { - close_file(fnum1,False); - return(False); + fsp2 = find_free_file(); + if (!fsp2) { + close_file(fsp1,False); + return(False); } - open_file_shared(fnum2,conn,dest,(DENY_NONE<<4)|1, + open_file_shared(fsp2,conn,dest,(DENY_NONE<<4)|1, ofun,st.st_mode,0,&Access,&action); - if (!Files[fnum2].open) { - close_file(fnum1,False); - Files[fnum2].reserved = False; + if (!fsp2->open) { + close_file(fsp1,False); + fsp2->reserved = False; return(False); } if ((ofun&3) == 1) { - lseek(Files[fnum2].fd_ptr->fd,0,SEEK_END); + lseek(fsp2->fd_ptr->fd,0,SEEK_END); } if (st.st_size) - ret = transfer_file(Files[fnum1].fd_ptr->fd, - Files[fnum2].fd_ptr->fd,st.st_size,NULL,0,0); + ret = transfer_file(fsp1->fd_ptr->fd, + fsp2->fd_ptr->fd,st.st_size,NULL,0,0); - close_file(fnum1,False); - close_file(fnum2,False); + close_file(fsp1,False); + close_file(fsp2,False); return(ret == st.st_size); } @@ -3556,7 +3490,7 @@ int reply_setdir(connection_struct *conn, char *inbuf,char *outbuf, int dum_size ****************************************************************************/ int reply_lockingX(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize) { - int fnum = GETFNUM(inbuf,smb_vwv2); + files_struct *fsp = GETFSP(inbuf,smb_vwv2); unsigned char locktype = CVAL(inbuf,smb_vwv3); #if 0 unsigned char oplocklevel = CVAL(inbuf,smb_vwv3+1); @@ -3570,8 +3504,8 @@ int reply_lockingX(connection_struct *conn, char *inbuf,char *outbuf,int length, uint32 ecode=0, dummy2; int eclass=0, dummy1; - CHECK_FNUM(fnum,conn); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_ERROR(fsp); data = smb_buf(inbuf); @@ -3581,28 +3515,27 @@ int reply_lockingX(connection_struct *conn, char *inbuf,char *outbuf,int length, if ((locktype & LOCKING_ANDX_OPLOCK_RELEASE)) { int token; - files_struct *fsp = &Files[fnum]; uint32 dev = fsp->fd_ptr->dev; uint32 inode = fsp->fd_ptr->inode; DEBUG(5,("reply_lockingX: oplock break reply from client for fnum = %d\n", - fnum)); + fsp->fnum)); /* * Make sure we have granted an oplock on this file. */ if(!fsp->granted_oplock) { DEBUG(0,("reply_lockingX: Error : oplock break from client for fnum = %d and \ -no oplock granted on this file.\n", fnum)); +no oplock granted on this file.\n", fsp->fnum)); return ERROR(ERRDOS,ERRlock); } /* Remove the oplock flag from the sharemode. */ lock_share_entry(fsp->conn, dev, inode, &token); - if(remove_share_oplock( fnum, token)==False) { + if(remove_share_oplock(fsp, token)==False) { DEBUG(0,("reply_lockingX: failed to remove share oplock for fnum %d, \ dev = %x, inode = %x\n", - fnum, dev, inode)); + fsp->fnum, dev, inode)); unlock_share_entry(fsp->conn, dev, inode, token); } else { unlock_share_entry(fsp->conn, dev, inode, token); @@ -3628,7 +3561,7 @@ dev = %x, inode = %x\n", for(i = 0; i < (int)num_ulocks; i++) { count = IVAL(data,SMB_LKLEN_OFFSET(i)); offset = IVAL(data,SMB_LKOFF_OFFSET(i)); - if(!do_unlock(fnum,conn,count,offset,&eclass, &ecode)) + if(!do_unlock(fsp,conn,count,offset,&eclass, &ecode)) return ERROR(eclass,ecode); } @@ -3642,7 +3575,7 @@ dev = %x, inode = %x\n", for(i = 0; i < (int)num_locks; i++) { count = IVAL(data,SMB_LKLEN_OFFSET(i)); offset = IVAL(data,SMB_LKOFF_OFFSET(i)); - if(!do_lock(fnum,conn,count,offset, ((locktype & 1) ? F_RDLCK : F_WRLCK), + if(!do_lock(fsp,conn,count,offset, ((locktype & 1) ? F_RDLCK : F_WRLCK), &eclass, &ecode)) #if 0 /* JRATEST - blocking lock code. */ if((ecode == ERRlock) && (lock_timeout != 0)) { @@ -3663,7 +3596,7 @@ dev = %x, inode = %x\n", for(; i >= 0; i--) { count = IVAL(data,SMB_LKLEN_OFFSET(i)); offset = IVAL(data,SMB_LKOFF_OFFSET(i)); - do_unlock(fnum,conn,count,offset,&dummy1,&dummy2); + do_unlock(fsp,conn,count,offset,&dummy1,&dummy2); } return ERROR(eclass,ecode); } @@ -3671,9 +3604,9 @@ dev = %x, inode = %x\n", set_message(outbuf,2,0,True); DEBUG( 3, ( "lockingX fnum=%d type=%d num_locks=%d num_ulocks=%d\n", - fnum, (unsigned int)locktype, num_locks, num_ulocks ) ); + fsp->fnum, (unsigned int)locktype, num_locks, num_ulocks ) ); - chain_fnum = fnum; + chain_fsp = fsp; return chain_reply(inbuf,outbuf,length,bufsize); } @@ -3684,7 +3617,6 @@ dev = %x, inode = %x\n", ****************************************************************************/ int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize) { - int fnum; int nread = -1; int total_read; char *data; @@ -3693,6 +3625,7 @@ int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length, int max_per_packet; int tcount; int pad; + files_struct *fsp = GETFSP(inbuf,smb_vwv0); /* this function doesn't seem to work - disable by default */ if (!lp_readbmpx()) @@ -3700,11 +3633,9 @@ int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length, outsize = set_message(outbuf,8,0,True); - fnum = GETFNUM(inbuf,smb_vwv0); - - CHECK_FNUM(fnum,conn); - CHECK_READ(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_READ(fsp); + CHECK_ERROR(fsp); startpos = IVAL(inbuf,smb_vwv1); maxcount = SVAL(inbuf,smb_vwv3); @@ -3719,14 +3650,14 @@ int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length, tcount = maxcount; total_read = 0; - if (is_locked(fnum,conn,maxcount,startpos, F_RDLCK)) + if (is_locked(fsp,conn,maxcount,startpos, F_RDLCK)) return(ERROR(ERRDOS,ERRlock)); do { int N = MIN(max_per_packet,tcount-total_read); - nread = read_file(fnum,data,startpos,N); + nread = read_file(fsp,data,startpos,N); if (nread <= 0) nread = 0; @@ -3755,18 +3686,17 @@ int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length, ****************************************************************************/ int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int numtowrite,fnum; + int numtowrite; int nwritten = -1; int outsize = 0; uint32 startpos; int tcount, write_through, smb_doff; char *data; - - fnum = GETFNUM(inbuf,smb_vwv0); + files_struct *fsp = GETFSP(inbuf,smb_vwv0); - CHECK_FNUM(fnum,conn); - CHECK_WRITE(fnum); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_WRITE(fsp); + CHECK_ERROR(fsp); tcount = SVAL(inbuf,smb_vwv1); startpos = IVAL(inbuf,smb_vwv3); @@ -3780,14 +3710,14 @@ int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int dum_s not an SMBwritebmpx - set this up now so we don't forget */ CVAL(outbuf,smb_com) = SMBwritec; - if (is_locked(fnum,conn,tcount,startpos,F_WRLCK)) + if (is_locked(fsp,conn,tcount,startpos,F_WRLCK)) return(ERROR(ERRDOS,ERRlock)); - seek_file(fnum,startpos); - nwritten = write_file(fnum,data,numtowrite); + seek_file(fsp,startpos); + nwritten = write_file(fsp,data,numtowrite); if(lp_syncalways(SNUM(conn)) || write_through) - sync_file(conn,fnum); + sync_file(conn,fsp); if(nwritten < numtowrite) return(UNIXERROR(ERRHRD,ERRdiskfull)); @@ -3799,8 +3729,8 @@ int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int dum_s if(tcount > nwritten) { write_bmpx_struct *wbms; - if(Files[fnum].wbmpx_ptr != NULL) - wbms = Files[fnum].wbmpx_ptr; /* Use an existing struct */ + if(fsp->wbmpx_ptr != NULL) + wbms = fsp->wbmpx_ptr; /* Use an existing struct */ else wbms = (write_bmpx_struct *)malloc(sizeof(write_bmpx_struct)); if(!wbms) @@ -3813,7 +3743,7 @@ int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int dum_s wbms->wr_total_written = nwritten; wbms->wr_errclass = 0; wbms->wr_error = 0; - Files[fnum].wbmpx_ptr = wbms; + fsp->wbmpx_ptr = wbms; } /* We are returning successfully, set the message type back to @@ -3825,7 +3755,7 @@ int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int dum_s SSVALS(outbuf,smb_vwv0,-1); /* We don't support smb_remaining */ DEBUG( 3, ( "writebmpx fnum=%d num=%d wrote=%d\n", - fnum, numtowrite, nwritten ) ); + fsp->fnum, numtowrite, nwritten ) ); if (write_through && tcount==nwritten) { /* we need to send both a primary and a secondary response */ @@ -3847,18 +3777,18 @@ int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int dum_s ****************************************************************************/ int reply_writebs(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int numtowrite,fnum; + int numtowrite; int nwritten = -1; int outsize = 0; int32 startpos; int tcount, write_through, smb_doff; char *data; write_bmpx_struct *wbms; - BOOL send_response = False; - - fnum = GETFNUM(inbuf,smb_vwv0); - CHECK_FNUM(fnum,conn); - CHECK_WRITE(fnum); + BOOL send_response = False; + files_struct *fsp = GETFSP(inbuf,smb_vwv0); + + CHECK_FSP(fsp,conn); + CHECK_WRITE(fsp); tcount = SVAL(inbuf,smb_vwv1); startpos = IVAL(inbuf,smb_vwv2); @@ -3872,7 +3802,7 @@ int reply_writebs(connection_struct *conn, char *inbuf,char *outbuf, int dum_siz /* This fd should have an auxiliary struct attached, check that it does */ - wbms = Files[fnum].wbmpx_ptr; + wbms = fsp->wbmpx_ptr; if(!wbms) return(-1); /* If write through is set we can return errors, else we must @@ -3883,18 +3813,18 @@ int reply_writebs(connection_struct *conn, char *inbuf,char *outbuf, int dum_siz if(wbms->wr_discard) return -1; /* Just discard the packet */ - seek_file(fnum,startpos); - nwritten = write_file(fnum,data,numtowrite); + seek_file(fsp,startpos); + nwritten = write_file(fsp,data,numtowrite); if(lp_syncalways(SNUM(conn)) || write_through) - sync_file(conn,fnum); + sync_file(conn,fsp); if (nwritten < numtowrite) { if(write_through) { /* We are returning an error - we can delete the aux struct */ if (wbms) free((char *)wbms); - Files[fnum].wbmpx_ptr = NULL; + fsp->wbmpx_ptr = NULL; return(ERROR(ERRHRD,ERRdiskfull)); } return(CACHE_ERROR(wbms,ERRHRD,ERRdiskfull)); @@ -3912,7 +3842,7 @@ int reply_writebs(connection_struct *conn, char *inbuf,char *outbuf, int dum_siz } free((char *)wbms); - Files[fnum].wbmpx_ptr = NULL; + fsp->wbmpx_ptr = NULL; } if(send_response) @@ -3927,16 +3857,14 @@ int reply_writebs(connection_struct *conn, char *inbuf,char *outbuf, int dum_siz ****************************************************************************/ int reply_setattrE(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int fnum; struct utimbuf unix_times; int outsize = 0; + files_struct *fsp = GETFSP(inbuf,smb_vwv0); outsize = set_message(outbuf,0,0,True); - fnum = GETFNUM(inbuf,smb_vwv0); - - CHECK_FNUM(fnum,conn); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_ERROR(fsp); /* Convert the DOS times into unix times. Ignore create time as UNIX can't set this. @@ -3954,7 +3882,7 @@ int reply_setattrE(connection_struct *conn, char *inbuf,char *outbuf, int dum_si /* Ignore request */ if( DEBUGLVL( 3 ) ) { - dbgtext( "reply_setattrE fnum=%d ", fnum); + dbgtext( "reply_setattrE fnum=%d ", fsp->fnum); dbgtext( "ignoring zero request - not setting timestamps of 0\n" ); } return(outsize); @@ -3966,11 +3894,11 @@ int reply_setattrE(connection_struct *conn, char *inbuf,char *outbuf, int dum_si } /* Set the date on this file */ - if(file_utime(conn, Files[fnum].fsp_name, &unix_times)) + if(file_utime(conn, fsp->fsp_name, &unix_times)) return(ERROR(ERRDOS,ERRnoaccess)); DEBUG( 3, ( "reply_setattrE fnum=%d actime=%d modtime=%d\n", - fnum, (int)unix_times.actime, (int)unix_times.modtime ) ); + fsp->fnum, (int)unix_times.actime, (int)unix_times.modtime ) ); return(outsize); } @@ -3981,23 +3909,21 @@ int reply_setattrE(connection_struct *conn, char *inbuf,char *outbuf, int dum_si ****************************************************************************/ int reply_getattrE(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { - int fnum; struct stat sbuf; int outsize = 0; int mode; + files_struct *fsp = GETFSP(inbuf,smb_vwv0); outsize = set_message(outbuf,11,0,True); - fnum = GETFNUM(inbuf,smb_vwv0); - - CHECK_FNUM(fnum,conn); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_ERROR(fsp); /* Do an fstat on this file */ - if(fstat(Files[fnum].fd_ptr->fd, &sbuf)) + if(fstat(fsp->fd_ptr->fd, &sbuf)) return(UNIXERROR(ERRDOS,ERRnoaccess)); - mode = dos_mode(conn,Files[fnum].fsp_name,&sbuf); + mode = dos_mode(conn,fsp->fsp_name,&sbuf); /* Convert the times into dos times. Set create date to be last modify date as UNIX doesn't save @@ -4017,7 +3943,7 @@ int reply_getattrE(connection_struct *conn, char *inbuf,char *outbuf, int dum_si } SSVAL(outbuf,smb_vwv10, mode); - DEBUG( 3, ( "reply_getattrE fnum=%d\n", fnum)); + DEBUG( 3, ( "reply_getattrE fnum=%d\n", fsp->fnum)); return(outsize); } diff --git a/source3/smbd/server.c b/source3/smbd/server.c index ba93ceaa16..8b656ab264 100644 --- a/source3/smbd/server.c +++ b/source3/smbd/server.c @@ -66,14 +66,6 @@ extern int dcelogin_atmost_once; extern DOM_SID global_machine_sid; static connection_struct Connections[MAX_CONNECTIONS]; -files_struct Files[MAX_FNUMS]; - -/* - * 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; @@ -89,8 +81,8 @@ int max_send = BUFFER_SIZE; */ int max_recv = BUFFER_SIZE; -/* a fnum to use when chaining */ -int chain_fnum = -1; +/* a fsp to use when chaining */ +files_struct *chain_fsp = NULL; /* number of open connections */ static int num_connections_open = 0; @@ -807,7 +799,7 @@ static int fd_attempt_open(char *fname, int flags, int mode) Cache a uid_t currently with this file open. This is an optimization only used when multiple sessionsetup's have been done to one smbd. ****************************************************************************/ -static void fd_add_to_uid_cache(file_fd_struct *fd_ptr, uid_t u) +void fd_add_to_uid_cache(file_fd_struct *fd_ptr, uid_t u) { if(fd_ptr->uid_cache_count >= sizeof(fd_ptr->uid_users_cache)/sizeof(uid_t)) return; @@ -844,67 +836,6 @@ static BOOL fd_is_in_uid_cache(file_fd_struct *fd_ptr, uid_t u) return False; } -/**************************************************************************** -fd support routines - attempt to find an already open file by dev -and inode - increments the ref_count of the returned file_fd_struct *. -****************************************************************************/ -static 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) && - (((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", - 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. -****************************************************************************/ -static file_fd_struct *fd_get_new(void) -{ - extern struct current_user current_user; - 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 = (uint32)-1; - fd_ptr->inode = (uint32)-1; - fd_ptr->fd = -1; - fd_ptr->fd_readonly = -1; - fd_ptr->fd_writeonly = -1; - fd_ptr->real_open_flags = -1; - fd_ptr->uid_cache_count = 0; - fd_add_to_uid_cache(fd_ptr, (uid_t)current_user.uid); - 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. @@ -934,8 +865,7 @@ static int fd_attempt_close(file_fd_struct *fd_ptr) { extern struct current_user current_user; - 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], + DEBUG(3,("fd_attempt_close fd = %d, dev = %x, inode = %x, open_flags = %d, ref_count = %d.\n", fd_ptr->fd, fd_ptr->dev, fd_ptr->inode, fd_ptr->real_open_flags, fd_ptr->ref_count)); @@ -1034,14 +964,13 @@ static BOOL check_access_allowed_for_current_user( char *fname, int accmode ) /**************************************************************************** open a file ****************************************************************************/ -static void open_file(int fnum,connection_struct *conn, +static void open_file(files_struct *fsp,connection_struct *conn, 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_struct *fsp = &Files[fnum]; int accmode = (flags & (O_RDONLY | O_WRONLY | O_RDWR)); fsp->open = False; @@ -1296,13 +1225,13 @@ static void open_file(int fnum,connection_struct *conn, */ if (fsp->print_file && lp_postscript(SNUM(conn)) && fsp->can_write) { DEBUG(3,("Writing postscript line\n")); - write_file(fnum,"%!\n",3); + write_file(fsp,"%!\n",3); } - DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d fnum=%d)\n", + DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n", *sesssetup_user ? sesssetup_user : conn->user,fname, BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write), - conn->num_files_open,fnum)); + conn->num_files_open)); } @@ -1325,28 +1254,28 @@ static void open_file(int fnum,connection_struct *conn, /******************************************************************* sync a file ********************************************************************/ -void sync_file(connection_struct *conn, int fnum) +void sync_file(connection_struct *conn, files_struct *fsp) { #ifdef HAVE_FSYNC if(lp_strict_sync(SNUM(conn))) - fsync(Files[fnum].fd_ptr->fd); + fsync(fsp->fd_ptr->fd); #endif } /**************************************************************************** run a file if it is a magic script ****************************************************************************/ -static void check_magic(int fnum,connection_struct *conn) +static void check_magic(files_struct *fsp,connection_struct *conn) { if (!*lp_magicscript(SNUM(conn))) return; - DEBUG(5,("checking magic for %s\n",Files[fnum].fsp_name)); + DEBUG(5,("checking magic for %s\n",fsp->fsp_name)); { char *p; - if (!(p = strrchr(Files[fnum].fsp_name,'/'))) - p = Files[fnum].fsp_name; + if (!(p = strrchr(fsp->fsp_name,'/'))) + p = fsp->fsp_name; else p++; @@ -1358,7 +1287,7 @@ static void check_magic(int fnum,connection_struct *conn) int ret; pstring magic_output; pstring fname; - pstrcpy(fname,Files[fnum].fsp_name); + pstrcpy(fname,fsp->fsp_name); if (*lp_magicoutput(SNUM(conn))) pstrcpy(magic_output,lp_magicoutput(SNUM(conn))); @@ -1379,7 +1308,7 @@ static void close_filestruct(files_struct *fsp) { connection_struct *conn = fsp->conn; - fsp->reserved = False; + file_free(fsp); fsp->open = False; fsp->is_directory = False; @@ -1405,69 +1334,66 @@ static void close_filestruct(files_struct *fsp) the closing of the connection. In the latter case printing and magic scripts are not run. ****************************************************************************/ -void close_file(int fnum, BOOL normal_close) +void close_file(files_struct *fsp, BOOL normal_close) { - files_struct *fs_p = &Files[fnum]; - uint32 dev = fs_p->fd_ptr->dev; - uint32 inode = fs_p->fd_ptr->inode; + uint32 dev = fsp->fd_ptr->dev; + uint32 inode = fsp->fd_ptr->inode; int token; - connection_struct *conn = fs_p->conn; + connection_struct *conn = fsp->conn; - close_filestruct(fs_p); + close_filestruct(fsp); #if USE_READ_PREDICTION - invalidate_read_prediction(fs_p->fd_ptr->fd); + invalidate_read_prediction(fsp->fd_ptr->fd); #endif if (lp_share_modes(SNUM(conn))) { lock_share_entry(conn, dev, inode, &token); - del_share_mode(token, fnum); + del_share_mode(token, fsp); } - fd_attempt_close(fs_p->fd_ptr); + fd_attempt_close(fsp->fd_ptr); if (lp_share_modes(SNUM(conn))) unlock_share_entry(conn, dev, inode, token); /* NT uses smbclose to start a print - weird */ - if (normal_close && fs_p->print_file) - print_file(conn, fs_p); + if (normal_close && fsp->print_file) + print_file(conn, fsp); /* check for magic scripts */ if (normal_close) { - check_magic(fnum,conn); + check_magic(fsp,conn); } - if(fs_p->granted_oplock == True) + if(fsp->granted_oplock == True) global_oplocks_open--; - fs_p->sent_oplock_break = False; + fsp->sent_oplock_break = False; DEBUG(2,("%s closed file %s (numopen=%d)\n", - conn->user,fs_p->fsp_name, + conn->user,fsp->fsp_name, conn->num_files_open)); - if (fs_p->fsp_name) { - string_free(&fs_p->fsp_name); + if (fsp->fsp_name) { + string_free(&fsp->fsp_name); } - /* we will catch bugs faster by zeroing this structure */ - memset(fs_p, 0, sizeof(*fs_p)); + file_free(fsp); } /**************************************************************************** Close a directory opened by an NT SMB call. ****************************************************************************/ -void close_directory(int fnum) +void close_directory(files_struct *fsp) { - files_struct *fsp = &Files[fnum]; /* TODO - walk the list of pending change notify requests and free - any pertaining to this fnum. */ + any pertaining to this fsp. */ - remove_pending_change_notify_requests_by_fid(fnum); + remove_pending_change_notify_requests_by_fid(fsp); /* * Do the code common to files and directories. @@ -1477,18 +1403,16 @@ void close_directory(int fnum) if (fsp->fsp_name) string_free(&fsp->fsp_name); - /* we will catch bugs faster by zeroing this structure */ - memset(fsp, 0, sizeof(*fsp)); + file_free(fsp); } /**************************************************************************** Open a directory from an NT SMB call. ****************************************************************************/ -int open_directory(int fnum,connection_struct *conn, +int open_directory(files_struct *fsp,connection_struct *conn, char *fname, int smb_ofun, int unixmode, int *action) { extern struct current_user current_user; - files_struct *fsp = &Files[fnum]; struct stat st; if (smb_ofun & 0x10) { @@ -1521,8 +1445,8 @@ int open_directory(int fnum,connection_struct *conn, *action = FILE_WAS_OPENED; } - DEBUG(5,("open_directory: opening directory %s, fnum = %d\n", - fname, fnum )); + DEBUG(5,("open_directory: opening directory %s\n", + fname)); /* * Setup the files_struct for it. @@ -1745,19 +1669,17 @@ free_and_exit: Helper for open_file_shared. Truncate a file after checking locking; close file if locked. **************************************************************************/ -static void truncate_unless_locked(int fnum, connection_struct *conn, int token, +static void truncate_unless_locked(files_struct *fsp, connection_struct *conn, int token, BOOL *share_locked) { - files_struct *fsp = &Files[fnum]; - if (fsp->can_write){ - if (is_locked(fnum,conn,0x3FFFFFFF,0,F_WRLCK)){ + if (is_locked(fsp,conn,0x3FFFFFFF,0,F_WRLCK)){ /* If share modes are in force for this connection we have the share entry locked. Unlock it before closing. */ if (*share_locked && lp_share_modes(SNUM(conn))) unlock_share_entry( conn, fsp->fd_ptr->dev, fsp->fd_ptr->inode, token); - close_file(fnum,False); + close_file(fsp,False); /* Share mode no longer locked. */ *share_locked = False; errno = EACCES; @@ -1813,10 +1735,9 @@ int check_share_mode( share_mode_entry *share, int deny_mode, char *fname, /**************************************************************************** open a file with a share mode ****************************************************************************/ -void open_file_shared(int fnum,connection_struct *conn,char *fname,int share_mode,int ofun, +void open_file_shared(files_struct *fsp,connection_struct *conn,char *fname,int share_mode,int ofun, int mode,int oplock_request, int *Access,int *action) { - files_struct *fs_p = &Files[fnum]; int flags=0; int flags2=0; int deny_mode = (share_mode>>4)&7; @@ -1829,8 +1750,8 @@ void open_file_shared(int fnum,connection_struct *conn,char *fname,int share_mod uint32 inode = 0; int num_share_modes = 0; - fs_p->open = False; - fs_p->fd_ptr = 0; + fsp->open = False; + fsp->fd_ptr = 0; /* this is for OS/2 EAs - try and say we don't support them */ if (strstr(fname,".+,;=[].")) @@ -1992,22 +1913,22 @@ dev = %x, inode = %x\n", old_shares[i].op_type, fname, dev, inode)); DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n", flags,flags2,mode)); - open_file(fnum,conn,fname,flags|(flags2&~(O_TRUNC)),mode,file_existed ? &sbuf : 0); - if (!fs_p->open && flags==O_RDWR && errno!=ENOENT && fcbopen) + open_file(fsp,conn,fname,flags|(flags2&~(O_TRUNC)),mode,file_existed ? &sbuf : 0); + if (!fsp->open && flags==O_RDWR && errno!=ENOENT && fcbopen) { flags = O_RDONLY; - open_file(fnum,conn,fname,flags,mode,file_existed ? &sbuf : 0 ); + open_file(fsp,conn,fname,flags,mode,file_existed ? &sbuf : 0 ); } - if (fs_p->open) + if (fsp->open) { int open_mode=0; if((share_locked == False) && lp_share_modes(SNUM(conn))) { /* 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; + dev = fsp->fd_ptr->dev; + inode = fsp->fd_ptr->inode; lock_share_entry(conn, dev, inode, &token); share_locked = True; } @@ -2025,7 +1946,7 @@ dev = %x, inode = %x\n", old_shares[i].op_type, fname, dev, inode)); break; } - fs_p->share_mode = (deny_mode<<4) | open_mode; + fsp->share_mode = (deny_mode<<4) | open_mode; if (Access) (*Access) = open_mode; @@ -2051,8 +1972,8 @@ dev = %x, inode = %x\n", old_shares[i].op_type, fname, dev, inode)); if(oplock_request && (num_share_modes == 0) && lp_oplocks(SNUM(conn)) && !IS_VETO_OPLOCK_PATH(conn,fname)) { - fs_p->granted_oplock = True; - fs_p->sent_oplock_break = False; + fsp->granted_oplock = True; + fsp->sent_oplock_break = False; global_oplocks_open++; port = oplock_port; @@ -2065,11 +1986,11 @@ dev = %x, inode = %x\n", oplock_request, fname, dev, inode)); port = 0; oplock_request = 0; } - set_share_mode(token, fnum, port, oplock_request); + set_share_mode(token, fsp, port, oplock_request); } if ((flags2&O_TRUNC) && file_existed) - truncate_unless_locked(fnum,conn,token,&share_locked); + truncate_unless_locked(fsp,conn,token,&share_locked); } if (share_locked && lp_share_modes(SNUM(conn))) @@ -2079,10 +2000,9 @@ dev = %x, inode = %x\n", oplock_request, fname, dev, inode)); /**************************************************************************** seek a file. Try to avoid the seek if possible ****************************************************************************/ -int seek_file(int fnum,uint32 pos) +int seek_file(files_struct *fsp,uint32 pos) { uint32 offset = 0; - files_struct *fsp = &Files[fnum]; if (fsp->print_file && lp_postscript(fsp->conn->service)) offset = 3; @@ -2094,10 +2014,9 @@ int seek_file(int fnum,uint32 pos) /**************************************************************************** read from a file ****************************************************************************/ -int read_file(int fnum,char *data,uint32 pos,int n) +int read_file(files_struct *fsp,char *data,uint32 pos,int n) { int ret=0,readret; - files_struct *fsp = &Files[fnum]; #if USE_READ_PREDICTION if (!fsp->can_write) @@ -2129,7 +2048,7 @@ int read_file(int fnum,char *data,uint32 pos,int n) if (n <= 0) return(ret); - if (seek_file(fnum,pos) != pos) + if (seek_file(fsp,pos) != pos) { DEBUG(3,("Failed to seek to %d\n",pos)); return(ret); @@ -2147,9 +2066,8 @@ int read_file(int fnum,char *data,uint32 pos,int n) /**************************************************************************** write to a file ****************************************************************************/ -int write_file(int fnum,char *data,int n) +int write_file(files_struct *fsp,char *data,int n) { - files_struct *fsp = &Files[fnum]; if (!fsp->can_write) { errno = EPERM; @@ -2318,16 +2236,16 @@ int find_service(char *service) /**************************************************************************** create an error packet from a cached error. ****************************************************************************/ -int cached_error_packet(char *inbuf,char *outbuf,int fnum,int line) +int cached_error_packet(char *inbuf,char *outbuf,files_struct *fsp,int line) { - write_bmpx_struct *wbmpx = Files[fnum].wbmpx_ptr; + write_bmpx_struct *wbmpx = fsp->wbmpx_ptr; int32 eclass = wbmpx->wr_errclass; int32 err = wbmpx->wr_error; /* We can now delete the auxiliary struct */ free((char *)wbmpx); - Files[fnum].wbmpx_ptr = NULL; + fsp->wbmpx_ptr = NULL; return error_packet(inbuf,outbuf,eclass,err,line); } @@ -2890,7 +2808,6 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) char *inbuf = NULL; char *outbuf = NULL; files_struct *fsp = NULL; - int fnum; time_t start_time; BOOL shutdown_server = False; connection_struct *saved_conn; @@ -2906,18 +2823,7 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) /* We need to search the file open table for the entry containing this dev and inode, and ensure we have an oplock on it. */ - for( fnum = 0; fnum < MAX_FNUMS; fnum++) - { - if(OPEN_FNUM(fnum)) - { - if((Files[fnum].fd_ptr->dev == dev) && (Files[fnum].fd_ptr->inode == inode) && - (Files[fnum].open_time.tv_sec == tval->tv_sec) && - (Files[fnum].open_time.tv_usec == tval->tv_usec)) { - fsp = &Files[fnum]; - break; - } - } - } + fsp = file_find_dit(dev, inode, tval); if(fsp == NULL) { @@ -2925,7 +2831,7 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) if( DEBUGLVL( 0 ) ) { dbgtext( "oplock_break: cannot find open file with " ); - dbgtext( "dev = %x, inode = %x (fnum = %d) ", dev, inode, fnum ); + dbgtext( "dev = %x, inode = %x ", dev, inode); dbgtext( "allowing break to succeed.\n" ); } return True; @@ -2944,8 +2850,8 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) { if( DEBUGLVL( 0 ) ) { - dbgtext( "oplock_break: file %s (fnum = %d, ", fsp->fsp_name, fnum ); - dbgtext( "dev = %x, inode = %x) has no oplock.\n", dev, inode ); + dbgtext( "oplock_break: file %s ", fsp->fsp_name ); + dbgtext( "(dev = %x, inode = %x) has no oplock.\n", dev, inode ); dbgtext( "Allowing break to succeed regardless.\n" ); } return True; @@ -2957,8 +2863,8 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) if( DEBUGLVL( 0 ) ) { dbgtext( "oplock_break: ERROR: oplock_break already sent for " ); - dbgtext( "file %s (fnum = %d, ", fsp->fsp_name, fnum ); - dbgtext( "dev = %x, inode = %x)\n", dev, inode ); + dbgtext( "file %s ", fsp->fsp_name); + dbgtext( "(dev = %x, inode = %x)\n", dev, inode ); } /* We have to fail the open here as we cannot send another oplock break on @@ -3000,7 +2906,7 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) SSVAL(outbuf,smb_uid,0); SSVAL(outbuf,smb_mid,0xFFFF); SCVAL(outbuf,smb_vwv0,0xFF); - SSVAL(outbuf,smb_vwv2,fnum); + SSVAL(outbuf,smb_vwv2,fsp->fnum); SCVAL(outbuf,smb_vwv3,LOCKING_ANDX_OPLOCK_RELEASE); /* Change this when we have level II oplocks. */ SCVAL(outbuf,smb_vwv3+1,OPLOCKLEVEL_NONE); @@ -3029,7 +2935,7 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) GetWd(saved_dir); unbecome_user(); - while(OPEN_FNUM(fnum) && fsp->granted_oplock) + while(OPEN_FSP(fsp) && fsp->granted_oplock) { if(receive_smb(Client,inbuf,OPLOCK_BREAK_TIMEOUT * 1000) == False) { @@ -3048,7 +2954,7 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) OPLOCK_BREAK_TIMEOUT ) ); DEBUGADD( 0, ( "oplock_break failed for file %s ", fsp->fsp_name ) ); - DEBUGADD( 0, ( "(fnum = %d, dev = %x, inode = %x).\n", fnum, dev, inode)); + DEBUGADD( 0, ( "(dev = %x, inode = %x).\n", dev, inode)); shutdown_server = True; break; } @@ -3075,7 +2981,7 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) dbgtext( "oplock_break: no break received from client " ); dbgtext( "within %d seconds.\n", OPLOCK_BREAK_TIMEOUT ); dbgtext( "oplock_break failed for file %s ", fsp->fsp_name ); - dbgtext( "(fnum = %d, dev = %x, inode = %x).\n", fnum, dev, inode ); + dbgtext( "(dev = %x, inode = %x).\n", dev, inode ); } shutdown_server = True; break; @@ -3118,7 +3024,7 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) exit_server("oplock break failure"); } - if(OPEN_FNUM(fnum)) + if(OPEN_FSP(fsp)) { /* The lockingX reply will have removed the oplock flag from the sharemode. */ @@ -3139,7 +3045,7 @@ BOOL oplock_break(uint32 dev, uint32 inode, struct timeval *tval) if( DEBUGLVL( 3 ) ) { dbgtext( "oplock_break: returning success for " ); - dbgtext( "fnum = %d, dev = %x, inode = %x.\n", fnum, dev, inode ); + dbgtext( "dev = %x, inode = %x.\n", dev, inode ); dbgtext( "Current global_oplocks_open = %d\n", global_oplocks_open ); } @@ -3791,8 +3697,7 @@ connection_struct *make_connection(char *service,char *user,char *password, int Used as a last ditch attempt to free a space in the file table when we have run out. ****************************************************************************/ - -static BOOL attempt_close_oplocked_file(files_struct *fsp) +BOOL attempt_close_oplocked_file(files_struct *fsp) { DEBUG(5,("attempt_close_oplocked_file: checking file %s.\n", fsp->fsp_name)); @@ -3810,75 +3715,6 @@ static BOOL attempt_close_oplocked_file(files_struct *fsp) return False; } -/**************************************************************************** - find first available file slot -****************************************************************************/ -int find_free_file(void ) -{ - int i; - static int first_file; - - /* we want to give out file handles differently on each new - connection because of a common bug in MS clients where they try to - reuse a file descriptor from an earlier smb connection. This code - increases the chance that the errant client will get an error rather - than causing corruption */ - if (first_file == 0) { - first_file = (getpid() ^ (int)time(NULL)) % MAX_FNUMS; - if (first_file == 0) first_file = 1; - } - - if (first_file >= MAX_FNUMS) - first_file = 1; - - for (i=first_file;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; - } + file_init(); /* for RPC pipes */ init_rpc_pipe_hnd(); @@ -5297,25 +5100,6 @@ static void usage(char *pname) DEBUG( 1, ( "smbd version %s started.\n", VERSION ) ); DEBUGADD( 1, ( "Copyright Andrew Tridgell 1992-1997\n" ) ); -#ifdef HAVE_GETRLIMIT -#ifdef RLIMIT_NOFILE - { - struct rlimit rlp; - getrlimit(RLIMIT_NOFILE, &rlp); - /* - * Set the fd limit to be MAX_OPEN_FILES + 10 to account for the - * extra fd we need to read directories, as well as the log files - * and standard handles etc. - */ - rlp.rlim_cur = (MAX_OPEN_FILES+10>rlp.rlim_max)? rlp.rlim_max:MAX_OPEN_FILES+10; - setrlimit(RLIMIT_NOFILE, &rlp); - getrlimit(RLIMIT_NOFILE, &rlp); - DEBUG(3,("Maximum number of open files per session is %d\n",(int)rlp.rlim_cur)); - } -#endif -#endif - - DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n", (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid())); diff --git a/source3/smbd/trans2.c b/source3/smbd/trans2.c index 992d8cd616..67db3aeb2a 100644 --- a/source3/smbd/trans2.c +++ b/source3/smbd/trans2.c @@ -26,13 +26,13 @@ extern int DEBUGLEVEL; extern int Protocol; -extern files_struct Files[]; extern BOOL case_sensitive; extern int Client; extern int oplock_sock; extern int smb_read_error; extern fstring local_machine; extern int global_oplock_break; +extern files_struct *chain_fsp; /**************************************************************************** Send the required number of replies back. @@ -200,7 +200,6 @@ static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, int16 namelen = strlen(pname)+1; pstring fname; - int fnum = -1; int unixmode; int size=0,fmode=0,mtime=0,rmode; int32 inode = 0; @@ -218,12 +217,10 @@ static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, unix_convert(fname,conn,0,&bad_path); - fnum = find_free_file(); - if (fnum < 0) + fsp = find_free_file(); + if (!fsp) return(ERROR(ERRSRV,ERRnofids)); - fsp = &Files[fnum]; - if (!check_name(fname,conn)) { if((errno == ENOENT) && bad_path) @@ -231,13 +228,13 @@ static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } unixmode = unix_mode(conn,open_attr | aARCH); - open_file_shared(fnum,conn,fname,open_mode,open_ofun,unixmode, + open_file_shared(fsp,conn,fname,open_mode,open_ofun,unixmode, oplock_request, &rmode,&smb_action); if (!fsp->open) @@ -247,12 +244,12 @@ static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, unix_ERR_class = ERRDOS; unix_ERR_code = ERRbadpath; } - fsp->reserved = False; + file_free(fsp); return(UNIXERROR(ERRDOS,ERRnoaccess)); } if (fstat(fsp->fd_ptr->fd,&sbuf) != 0) { - close_file(fnum,False); + close_file(fsp,False); return(ERROR(ERRDOS,ERRnoaccess)); } @@ -261,7 +258,7 @@ static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, mtime = sbuf.st_mtime; inode = sbuf.st_ino; if (fmode & aDIR) { - close_file(fnum,False); + close_file(fsp,False); return(ERROR(ERRDOS,ERRnoaccess)); } @@ -271,7 +268,7 @@ static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, return(ERROR(ERRDOS,ERRnomem)); bzero(params,28); - SSVAL(params,0,fnum); + SSVAL(params,0,fsp->fnum); SSVAL(params,2,fmode); put_dos_date2(params,4, mtime); SIVAL(params,8, size); @@ -1212,18 +1209,18 @@ static int call_trans2qfilepathinfo(connection_struct *conn, BOOL bad_path = False; if (tran_call == TRANSACT2_QFILEINFO) { - int16 fnum = SVALS(params,0); + files_struct *fsp = GETFSP(params,0); info_level = SVAL(params,2); - CHECK_FNUM(fnum,conn); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_ERROR(fsp); - fname = Files[fnum].fsp_name; - if (fstat(Files[fnum].fd_ptr->fd,&sbuf) != 0) { - DEBUG(3,("fstat of fnum %d failed (%s)\n",fnum, strerror(errno))); + fname = fsp->fsp_name; + if (fstat(fsp->fd_ptr->fd,&sbuf) != 0) { + DEBUG(3,("fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno))); return(UNIXERROR(ERRDOS,ERRbadfid)); } - pos = lseek(Files[fnum].fd_ptr->fd,0,SEEK_CUR); + pos = lseek(fsp->fd_ptr->fd,0,SEEK_CUR); } else { /* qpathinfo */ info_level = SVAL(params,0); @@ -1437,14 +1434,14 @@ static int call_trans2setfilepathinfo(connection_struct *conn, return(ERROR(ERRSRV,ERRaccess)); if (tran_call == TRANSACT2_SETFILEINFO) { - int16 fnum = SVALS(params,0); + files_struct *fsp = GETFSP(params,0); info_level = SVAL(params,2); - CHECK_FNUM(fnum,conn); - CHECK_ERROR(fnum); + CHECK_FSP(fsp,conn); + CHECK_ERROR(fsp); - fname = Files[fnum].fsp_name; - fd = Files[fnum].fd_ptr->fd; + fname = fsp->fsp_name; + fd = fsp->fd_ptr->fd; if(fstat(fd,&st)!=0) { DEBUG(3,("fstat of %s failed (%s)\n", fname, strerror(errno))); diff --git a/source3/utils/status.c b/source3/utils/status.c index 848f87623e..737700639b 100644 --- a/source3/utils/status.c +++ b/source3/utils/status.c @@ -61,7 +61,6 @@ int locks_only = 0; /* Added by RJS */ /* we need these because we link to locking*.o */ void become_root(BOOL save_dir) {} void unbecome_root(BOOL restore_dir) {} -files_struct Files[MAX_OPEN_FILES]; /* added by OH */ diff --git a/source3/web/swat.c b/source3/web/swat.c index 7c7a2ef205..3a56c82229 100644 --- a/source3/web/swat.c +++ b/source3/web/swat.c @@ -36,7 +36,6 @@ static pstring servicesf = CONFIGFILE; void unbecome_root(BOOL restore_dir) {} /* We need this because we link to password.o */ BOOL change_oem_password(struct smb_passwd *smbpw, char *new_passwd, BOOL override) {return False;} -files_struct Files[MAX_OPEN_FILES]; static int enum_index(int value, struct enum_list *enumlist) { -- cgit