From 8bf537d119be3e1823ad41b8b8af0d163251b1c5 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 28 Jun 2004 08:39:00 +0000 Subject: r1280: rename struct request_context to smbsrv_request metze (This used to be commit a85d2db5826a84b812ea5162a11f54edd25f74e3) --- source4/smb_server/negprot.c | 14 ++-- source4/smb_server/nttrans.c | 14 ++-- source4/smb_server/reply.c | 162 ++++++++++++++++++++-------------------- source4/smb_server/request.c | 48 ++++++------ source4/smb_server/search.c | 10 +-- source4/smb_server/service.c | 6 +- source4/smb_server/sesssetup.c | 10 +-- source4/smb_server/signing.c | 8 +- source4/smb_server/smb_server.c | 20 ++--- source4/smb_server/trans2.c | 48 ++++++------ 10 files changed, 170 insertions(+), 170 deletions(-) (limited to 'source4/smb_server') diff --git a/source4/smb_server/negprot.c b/source4/smb_server/negprot.c index dfeb9ef457..83b3cd75e9 100644 --- a/source4/smb_server/negprot.c +++ b/source4/smb_server/negprot.c @@ -49,7 +49,7 @@ static void get_challenge(struct smbsrv_context *smb_ctx, char buff[8]) /**************************************************************************** Reply for the core protocol. ****************************************************************************/ -static void reply_corep(struct request_context *req, uint16_t choice) +static void reply_corep(struct smbsrv_request *req, uint16_t choice) { req_setup_reply(req, 1, 0); @@ -65,7 +65,7 @@ static void reply_corep(struct request_context *req, uint16_t choice) this is quite incomplete - we only fill in a small part of the reply, but as nobody uses this any more it probably doesn't matter ****************************************************************************/ -static void reply_coreplus(struct request_context *req, uint16_t choice) +static void reply_coreplus(struct smbsrv_request *req, uint16_t choice) { uint16_t raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0); @@ -90,7 +90,7 @@ static void reply_coreplus(struct request_context *req, uint16_t choice) /**************************************************************************** Reply for the lanman 1.0 protocol. ****************************************************************************/ -static void reply_lanman1(struct request_context *req, uint16_t choice) +static void reply_lanman1(struct smbsrv_request *req, uint16_t choice) { int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0); int secword=0; @@ -134,7 +134,7 @@ static void reply_lanman1(struct request_context *req, uint16_t choice) /**************************************************************************** Reply for the lanman 2.0 protocol. ****************************************************************************/ -static void reply_lanman2(struct request_context *req, uint16_t choice) +static void reply_lanman2(struct smbsrv_request *req, uint16_t choice) { int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0); int secword=0; @@ -223,7 +223,7 @@ static DATA_BLOB negprot_spnego(struct smbsrv_context *smb_ctx) /**************************************************************************** Reply for the nt protocol. ****************************************************************************/ -static void reply_nt1(struct request_context *req, uint16_t choice) +static void reply_nt1(struct smbsrv_request *req, uint16_t choice) { /* dual names + lock_and_read + nt SMBs + remote API calls */ int capabilities; @@ -422,7 +422,7 @@ protocol [LANMAN2.1] static const struct { const char *proto_name; const char *short_name; - void (*proto_reply_fn)(struct request_context *req, uint16_t choice); + void (*proto_reply_fn)(struct smbsrv_request *req, uint16_t choice); int protocol_level; } supported_protocols[] = { {"NT LANMAN 1.0", "NT1", reply_nt1, PROTOCOL_NT1}, @@ -441,7 +441,7 @@ static const struct { Reply to a negprot. ****************************************************************************/ -void reply_negprot(struct request_context *req) +void reply_negprot(struct smbsrv_request *req) { int Index=0; int choice = -1; diff --git a/source4/smb_server/nttrans.c b/source4/smb_server/nttrans.c index 14977f9bd2..ddae725c4b 100644 --- a/source4/smb_server/nttrans.c +++ b/source4/smb_server/nttrans.c @@ -32,7 +32,7 @@ /* setup a nttrans reply, given the data and params sizes */ -static void nttrans_setup_reply(struct request_context *req, +static void nttrans_setup_reply(struct smbsrv_request *req, struct smb_nttrans *trans, uint16_t param_size, uint16_t data_size, uint16_t setup_count) @@ -48,7 +48,7 @@ static void nttrans_setup_reply(struct request_context *req, /* parse NTTRANS_CREATE request */ -static NTSTATUS nttrans_create(struct request_context *req, +static NTSTATUS nttrans_create(struct smbsrv_request *req, struct smb_nttrans *trans) { return NT_STATUS_FOOBAR; @@ -56,14 +56,14 @@ static NTSTATUS nttrans_create(struct request_context *req, /* parse NTTRANS_RENAME request */ -static NTSTATUS nttrans_rename(struct request_context *req, +static NTSTATUS nttrans_rename(struct smbsrv_request *req, struct smb_nttrans *trans) { return NT_STATUS_FOOBAR; } /* parse NTTRANS_IOCTL request */ -static NTSTATUS nttrans_ioctl(struct request_context *req, +static NTSTATUS nttrans_ioctl(struct smbsrv_request *req, struct smb_nttrans *trans) { union smb_ioctl nt; @@ -100,7 +100,7 @@ static NTSTATUS nttrans_ioctl(struct request_context *req, /* backend for nttrans requests */ -static NTSTATUS nttrans_backend(struct request_context *req, +static NTSTATUS nttrans_backend(struct smbsrv_request *req, struct smb_nttrans *trans) { DEBUG(9,("nttrans_backend: setup_count=%d function=%d\n", @@ -128,7 +128,7 @@ static NTSTATUS nttrans_backend(struct request_context *req, /**************************************************************************** Reply to an SMBnttrans request ****************************************************************************/ -void reply_nttrans(struct request_context *req) +void reply_nttrans(struct smbsrv_request *req) { struct smb_nttrans trans; int i; @@ -267,7 +267,7 @@ void reply_nttrans(struct request_context *req) /**************************************************************************** Reply to an SMBnttranss request ****************************************************************************/ -void reply_nttranss(struct request_context *req) +void reply_nttranss(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } diff --git a/source4/smb_server/reply.c b/source4/smb_server/reply.c index 3356ce9925..0715dc4075 100644 --- a/source4/smb_server/reply.c +++ b/source4/smb_server/reply.c @@ -65,7 +65,7 @@ /**************************************************************************** Reply to a simple request (async send) ****************************************************************************/ -static void reply_simple_send(struct request_context *req) +static void reply_simple_send(struct smbsrv_request *req) { CHECK_ASYNC_STATUS; @@ -77,7 +77,7 @@ static void reply_simple_send(struct request_context *req) /**************************************************************************** Reply to a tcon. ****************************************************************************/ -void reply_tcon(struct request_context *req) +void reply_tcon(struct smbsrv_request *req) { union smb_tcon con; NTSTATUS status; @@ -120,7 +120,7 @@ void reply_tcon(struct request_context *req) /**************************************************************************** Reply to a tcon and X. ****************************************************************************/ -void reply_tcon_and_X(struct request_context *req) +void reply_tcon_and_X(struct smbsrv_request *req) { NTSTATUS status; union smb_tcon con; @@ -189,7 +189,7 @@ void reply_tcon_and_X(struct request_context *req) /**************************************************************************** Reply to an unknown request ****************************************************************************/ -void reply_unknown(struct request_context *req) +void reply_unknown(struct smbsrv_request *req) { int type; @@ -204,7 +204,7 @@ void reply_unknown(struct request_context *req) /**************************************************************************** Reply to an ioctl (async reply) ****************************************************************************/ -static void reply_ioctl_send(struct request_context *req) +static void reply_ioctl_send(struct smbsrv_request *req) { union smb_ioctl *io = req->async.private; @@ -224,7 +224,7 @@ static void reply_ioctl_send(struct request_context *req) /**************************************************************************** Reply to an ioctl. ****************************************************************************/ -void reply_ioctl(struct request_context *req) +void reply_ioctl(struct smbsrv_request *req) { union smb_ioctl *io; @@ -249,7 +249,7 @@ void reply_ioctl(struct request_context *req) /**************************************************************************** Reply to a chkpth. ****************************************************************************/ -void reply_chkpth(struct request_context *req) +void reply_chkpth(struct smbsrv_request *req) { struct smb_chkpath *io; @@ -267,7 +267,7 @@ void reply_chkpth(struct request_context *req) /**************************************************************************** Reply to a getatr (async reply) ****************************************************************************/ -static void reply_getatr_send(struct request_context *req) +static void reply_getatr_send(struct smbsrv_request *req) { union smb_fileinfo *st = req->async.private; @@ -289,7 +289,7 @@ static void reply_getatr_send(struct request_context *req) /**************************************************************************** Reply to a getatr. ****************************************************************************/ -void reply_getatr(struct request_context *req) +void reply_getatr(struct smbsrv_request *req) { union smb_fileinfo *st; @@ -317,7 +317,7 @@ void reply_getatr(struct request_context *req) /**************************************************************************** Reply to a setatr. ****************************************************************************/ -void reply_setatr(struct request_context *req) +void reply_setatr(struct smbsrv_request *req) { union smb_setfileinfo *st; @@ -348,7 +348,7 @@ void reply_setatr(struct request_context *req) /**************************************************************************** Reply to a dskattr (async reply) ****************************************************************************/ -static void reply_dskattr_send(struct request_context *req) +static void reply_dskattr_send(struct smbsrv_request *req) { union smb_fsinfo *fs = req->async.private; @@ -371,7 +371,7 @@ static void reply_dskattr_send(struct request_context *req) /**************************************************************************** Reply to a dskattr. ****************************************************************************/ -void reply_dskattr(struct request_context *req) +void reply_dskattr(struct smbsrv_request *req) { union smb_fsinfo *fs; @@ -393,7 +393,7 @@ void reply_dskattr(struct request_context *req) /**************************************************************************** Reply to an open (async reply) ****************************************************************************/ -static void reply_open_send(struct request_context *req) +static void reply_open_send(struct smbsrv_request *req) { union smb_open *oi = req->async.private; @@ -414,7 +414,7 @@ static void reply_open_send(struct request_context *req) /**************************************************************************** Reply to an open. ****************************************************************************/ -void reply_open(struct request_context *req) +void reply_open(struct smbsrv_request *req) { union smb_open *oi; @@ -446,7 +446,7 @@ void reply_open(struct request_context *req) /**************************************************************************** Reply to an open and X (async reply) ****************************************************************************/ -static void reply_open_and_X_send(struct request_context *req) +static void reply_open_and_X_send(struct smbsrv_request *req) { union smb_open *oi = req->async.private; @@ -483,7 +483,7 @@ static void reply_open_and_X_send(struct request_context *req) /**************************************************************************** Reply to an open and X. ****************************************************************************/ -void reply_open_and_X(struct request_context *req) +void reply_open_and_X(struct smbsrv_request *req) { union smb_open *oi; @@ -521,7 +521,7 @@ void reply_open_and_X(struct request_context *req) /**************************************************************************** Reply to a mknew or a create. ****************************************************************************/ -static void reply_mknew_send(struct request_context *req) +static void reply_mknew_send(struct smbsrv_request *req) { union smb_open *oi = req->async.private; @@ -539,7 +539,7 @@ static void reply_mknew_send(struct request_context *req) /**************************************************************************** Reply to a mknew or a create. ****************************************************************************/ -void reply_mknew(struct request_context *req) +void reply_mknew(struct smbsrv_request *req) { union smb_open *oi; @@ -570,7 +570,7 @@ void reply_mknew(struct request_context *req) /**************************************************************************** Reply to a create temporary file (async reply) ****************************************************************************/ -static void reply_ctemp_send(struct request_context *req) +static void reply_ctemp_send(struct smbsrv_request *req) { union smb_open *oi = req->async.private; @@ -590,7 +590,7 @@ static void reply_ctemp_send(struct request_context *req) /**************************************************************************** Reply to a create temporary file. ****************************************************************************/ -void reply_ctemp(struct request_context *req) +void reply_ctemp(struct smbsrv_request *req) { union smb_open *oi; @@ -624,7 +624,7 @@ void reply_ctemp(struct request_context *req) /**************************************************************************** Reply to a unlink ****************************************************************************/ -void reply_unlink(struct request_context *req) +void reply_unlink(struct smbsrv_request *req) { struct smb_unlink *unl; @@ -651,7 +651,7 @@ void reply_unlink(struct request_context *req) only the 4 byte NBT header This command must be replied to synchronously ****************************************************************************/ -void reply_readbraw(struct request_context *req) +void reply_readbraw(struct smbsrv_request *req) { NTSTATUS status; union smb_read io; @@ -712,7 +712,7 @@ failed: /**************************************************************************** Reply to a lockread (async reply) ****************************************************************************/ -static void reply_lockread_send(struct request_context *req) +static void reply_lockread_send(struct smbsrv_request *req) { union smb_read *io = req->async.private; @@ -738,7 +738,7 @@ static void reply_lockread_send(struct request_context *req) Reply to a lockread (core+ protocol). note that the lock is a write lock, not a read lock! ****************************************************************************/ -void reply_lockread(struct request_context *req) +void reply_lockread(struct smbsrv_request *req) { union smb_read *io; @@ -772,7 +772,7 @@ void reply_lockread(struct request_context *req) /**************************************************************************** Reply to a read (async reply) ****************************************************************************/ -static void reply_read_send(struct request_context *req) +static void reply_read_send(struct smbsrv_request *req) { union smb_read *io = req->async.private; @@ -796,7 +796,7 @@ static void reply_read_send(struct request_context *req) /**************************************************************************** Reply to a read. ****************************************************************************/ -void reply_read(struct request_context *req) +void reply_read(struct smbsrv_request *req) { union smb_read *io; @@ -830,7 +830,7 @@ void reply_read(struct request_context *req) /**************************************************************************** Reply to a read and X (async reply) ****************************************************************************/ -static void reply_read_and_X_send(struct request_context *req) +static void reply_read_and_X_send(struct smbsrv_request *req) { union smb_read *io = req->async.private; @@ -857,7 +857,7 @@ static void reply_read_and_X_send(struct request_context *req) /**************************************************************************** Reply to a read and X. ****************************************************************************/ -void reply_read_and_X(struct request_context *req) +void reply_read_and_X(struct smbsrv_request *req) { union smb_read *io; @@ -900,7 +900,7 @@ void reply_read_and_X(struct request_context *req) /**************************************************************************** Reply to a writebraw (core+ or LANMAN1.0 protocol). ****************************************************************************/ -void reply_writebraw(struct request_context *req) +void reply_writebraw(struct smbsrv_request *req) { /* this one is damn complex - put it off for now */ req_reply_error(req, NT_STATUS_FOOBAR); @@ -910,7 +910,7 @@ void reply_writebraw(struct request_context *req) /**************************************************************************** Reply to a writeunlock (async reply) ****************************************************************************/ -static void reply_writeunlock_send(struct request_context *req) +static void reply_writeunlock_send(struct smbsrv_request *req) { union smb_write *io = req->async.private; @@ -927,7 +927,7 @@ static void reply_writeunlock_send(struct request_context *req) /**************************************************************************** Reply to a writeunlock (core+). ****************************************************************************/ -void reply_writeunlock(struct request_context *req) +void reply_writeunlock(struct smbsrv_request *req) { union smb_write *io; @@ -967,7 +967,7 @@ void reply_writeunlock(struct request_context *req) /**************************************************************************** Reply to a write (async reply) ****************************************************************************/ -static void reply_write_send(struct request_context *req) +static void reply_write_send(struct smbsrv_request *req) { union smb_write *io = req->async.private; @@ -984,7 +984,7 @@ static void reply_write_send(struct request_context *req) /**************************************************************************** Reply to a write ****************************************************************************/ -void reply_write(struct request_context *req) +void reply_write(struct smbsrv_request *req) { union smb_write *io; @@ -1023,7 +1023,7 @@ void reply_write(struct request_context *req) /**************************************************************************** Reply to a write and X (async reply) ****************************************************************************/ -static void reply_write_and_X_send(struct request_context *req) +static void reply_write_and_X_send(struct smbsrv_request *req) { union smb_write *io = req->async.private; @@ -1045,7 +1045,7 @@ static void reply_write_and_X_send(struct request_context *req) /**************************************************************************** Reply to a write and X. ****************************************************************************/ -void reply_write_and_X(struct request_context *req) +void reply_write_and_X(struct smbsrv_request *req) { union smb_write *io; @@ -1089,7 +1089,7 @@ void reply_write_and_X(struct request_context *req) /**************************************************************************** Reply to a lseek (async reply) ****************************************************************************/ -static void reply_lseek_send(struct request_context *req) +static void reply_lseek_send(struct smbsrv_request *req) { struct smb_seek *io = req->async.private; @@ -1106,7 +1106,7 @@ static void reply_lseek_send(struct request_context *req) /**************************************************************************** Reply to a lseek. ****************************************************************************/ -void reply_lseek(struct request_context *req) +void reply_lseek(struct smbsrv_request *req) { struct smb_seek *io; @@ -1129,7 +1129,7 @@ void reply_lseek(struct request_context *req) /**************************************************************************** Reply to a flush. ****************************************************************************/ -void reply_flush(struct request_context *req) +void reply_flush(struct smbsrv_request *req) { struct smb_flush *io; @@ -1151,7 +1151,7 @@ void reply_flush(struct request_context *req) /**************************************************************************** Reply to a exit. ****************************************************************************/ -void reply_exit(struct request_context *req) +void reply_exit(struct smbsrv_request *req) { REQ_CHECK_WCT(req, 0); @@ -1174,7 +1174,7 @@ void reply_exit(struct request_context *req) Note that this has to deal with closing a directory opened by NT SMB's. ****************************************************************************/ -void reply_close(struct request_context *req) +void reply_close(struct smbsrv_request *req) { union smb_close *io; @@ -1199,7 +1199,7 @@ void reply_close(struct request_context *req) /**************************************************************************** Reply to a writeclose (async reply) ****************************************************************************/ -static void reply_writeclose_send(struct request_context *req) +static void reply_writeclose_send(struct smbsrv_request *req) { union smb_write *io = req->async.private; @@ -1216,7 +1216,7 @@ static void reply_writeclose_send(struct request_context *req) /**************************************************************************** Reply to a writeclose (Core+ protocol). ****************************************************************************/ -void reply_writeclose(struct request_context *req) +void reply_writeclose(struct smbsrv_request *req) { union smb_write *io; @@ -1252,7 +1252,7 @@ void reply_writeclose(struct request_context *req) /**************************************************************************** Reply to a lock. ****************************************************************************/ -void reply_lock(struct request_context *req) +void reply_lock(struct smbsrv_request *req) { union smb_lock *lck; @@ -1277,7 +1277,7 @@ void reply_lock(struct request_context *req) /**************************************************************************** Reply to a unlock. ****************************************************************************/ -void reply_unlock(struct request_context *req) +void reply_unlock(struct smbsrv_request *req) { union smb_lock *lck; @@ -1302,7 +1302,7 @@ void reply_unlock(struct request_context *req) /**************************************************************************** Reply to a tdis. ****************************************************************************/ -void reply_tdis(struct request_context *req) +void reply_tdis(struct smbsrv_request *req) { REQ_CHECK_WCT(req, 0); @@ -1319,7 +1319,7 @@ void reply_tdis(struct request_context *req) Reply to a echo. This is one of the few calls that is handled directly (the backends don't see it at all) ****************************************************************************/ -void reply_echo(struct request_context *req) +void reply_echo(struct smbsrv_request *req) { uint16_t count; int i; @@ -1351,7 +1351,7 @@ void reply_echo(struct request_context *req) /**************************************************************************** Reply to a printopen (async reply) ****************************************************************************/ -static void reply_printopen_send(struct request_context *req) +static void reply_printopen_send(struct smbsrv_request *req) { union smb_open *oi = req->async.private; @@ -1368,7 +1368,7 @@ static void reply_printopen_send(struct request_context *req) /**************************************************************************** Reply to a printopen. ****************************************************************************/ -void reply_printopen(struct request_context *req) +void reply_printopen(struct smbsrv_request *req) { union smb_open *oi; @@ -1394,7 +1394,7 @@ void reply_printopen(struct request_context *req) /**************************************************************************** Reply to a printclose. ****************************************************************************/ -void reply_printclose(struct request_context *req) +void reply_printclose(struct smbsrv_request *req) { union smb_close *io; @@ -1416,7 +1416,7 @@ void reply_printclose(struct request_context *req) /**************************************************************************** Reply to a printqueue. ****************************************************************************/ -void reply_printqueue_send(struct request_context *req) +void reply_printqueue_send(struct smbsrv_request *req) { union smb_lpq *lpq = req->async.private; int i, maxcount; @@ -1461,7 +1461,7 @@ void reply_printqueue_send(struct request_context *req) /**************************************************************************** Reply to a printqueue. ****************************************************************************/ -void reply_printqueue(struct request_context *req) +void reply_printqueue(struct smbsrv_request *req) { union smb_lpq *lpq; @@ -1486,7 +1486,7 @@ void reply_printqueue(struct request_context *req) /**************************************************************************** Reply to a printwrite. ****************************************************************************/ -void reply_printwrite(struct request_context *req) +void reply_printwrite(struct smbsrv_request *req) { union smb_write *io; @@ -1523,7 +1523,7 @@ void reply_printwrite(struct request_context *req) /**************************************************************************** Reply to a mkdir. ****************************************************************************/ -void reply_mkdir(struct request_context *req) +void reply_mkdir(struct smbsrv_request *req) { union smb_mkdir *io; @@ -1546,7 +1546,7 @@ void reply_mkdir(struct request_context *req) /**************************************************************************** Reply to a rmdir. ****************************************************************************/ -void reply_rmdir(struct request_context *req) +void reply_rmdir(struct smbsrv_request *req) { struct smb_rmdir *io; @@ -1568,7 +1568,7 @@ void reply_rmdir(struct request_context *req) /**************************************************************************** Reply to a mv. ****************************************************************************/ -void reply_mv(struct request_context *req) +void reply_mv(struct smbsrv_request *req) { union smb_rename *io; char *p; @@ -1601,7 +1601,7 @@ void reply_mv(struct request_context *req) /**************************************************************************** Reply to an NT rename. ****************************************************************************/ -void reply_ntrename(struct request_context *req) +void reply_ntrename(struct smbsrv_request *req) { union smb_rename *io; char *p; @@ -1635,7 +1635,7 @@ void reply_ntrename(struct request_context *req) /**************************************************************************** Reply to a file copy (async reply) ****************************************************************************/ -static void reply_copy_send(struct request_context *req) +static void reply_copy_send(struct smbsrv_request *req) { struct smb_copy *cp = req->async.private; @@ -1652,7 +1652,7 @@ static void reply_copy_send(struct request_context *req) /**************************************************************************** Reply to a file copy. ****************************************************************************/ -void reply_copy(struct request_context *req) +void reply_copy(struct smbsrv_request *req) { struct smb_copy *cp; char *p; @@ -1686,7 +1686,7 @@ void reply_copy(struct request_context *req) /**************************************************************************** Reply to a lockingX request (async send) ****************************************************************************/ -static void reply_lockingX_send(struct request_context *req) +static void reply_lockingX_send(struct smbsrv_request *req) { union smb_lock *lck = req->async.private; @@ -1712,7 +1712,7 @@ static void reply_lockingX_send(struct request_context *req) /**************************************************************************** Reply to a lockingX request. ****************************************************************************/ -void reply_lockingX(struct request_context *req) +void reply_lockingX(struct smbsrv_request *req) { union smb_lock *lck; uint_t total_locks, i; @@ -1786,7 +1786,7 @@ void reply_lockingX(struct request_context *req) /**************************************************************************** Reply to a SMBreadbmpx (read block multiplex) request. ****************************************************************************/ -void reply_readbmpx(struct request_context *req) +void reply_readbmpx(struct smbsrv_request *req) { /* tell the client to not use a multiplexed read - its too broken to use */ req_reply_dos_error(req, ERRSRV, ERRuseSTD); @@ -1796,7 +1796,7 @@ void reply_readbmpx(struct request_context *req) /**************************************************************************** Reply to a SMBsetattrE. ****************************************************************************/ -void reply_setattrE(struct request_context *req) +void reply_setattrE(struct smbsrv_request *req) { union smb_setfileinfo *info; @@ -1822,7 +1822,7 @@ void reply_setattrE(struct request_context *req) /**************************************************************************** Reply to a SMBwritebmpx (write block multiplex primary) request. ****************************************************************************/ -void reply_writebmpx(struct request_context *req) +void reply_writebmpx(struct smbsrv_request *req) { /* we will need to implement this one for OS/2, but right now I can't be bothered */ req_reply_error(req, NT_STATUS_FOOBAR); @@ -1832,7 +1832,7 @@ void reply_writebmpx(struct request_context *req) /**************************************************************************** Reply to a SMBwritebs (write block multiplex secondary) request. ****************************************************************************/ -void reply_writebs(struct request_context *req) +void reply_writebs(struct smbsrv_request *req) { /* see reply_writebmpx */ req_reply_error(req, NT_STATUS_FOOBAR); @@ -1843,7 +1843,7 @@ void reply_writebs(struct request_context *req) /**************************************************************************** Reply to a SMBgetattrE (async reply) ****************************************************************************/ -static void reply_getattrE_send(struct request_context *req) +static void reply_getattrE_send(struct smbsrv_request *req) { union smb_fileinfo *info = req->async.private; @@ -1865,7 +1865,7 @@ static void reply_getattrE_send(struct request_context *req) /**************************************************************************** Reply to a SMBgetattrE. ****************************************************************************/ -void reply_getattrE(struct request_context *req) +void reply_getattrE(struct smbsrv_request *req) { union smb_fileinfo *info; @@ -1889,7 +1889,7 @@ void reply_getattrE(struct request_context *req) /**************************************************************************** reply to an old style session setup command ****************************************************************************/ -static void reply_sesssetup_old(struct request_context *req) +static void reply_sesssetup_old(struct smbsrv_request *req) { NTSTATUS status; union smb_sesssetup sess; @@ -1947,7 +1947,7 @@ static void reply_sesssetup_old(struct request_context *req) /**************************************************************************** reply to an NT1 style session setup command ****************************************************************************/ -static void reply_sesssetup_nt1(struct request_context *req) +static void reply_sesssetup_nt1(struct smbsrv_request *req) { NTSTATUS status; union smb_sesssetup sess; @@ -2017,7 +2017,7 @@ static void reply_sesssetup_nt1(struct request_context *req) /**************************************************************************** reply to an SPNEGO style session setup command ****************************************************************************/ -static void reply_sesssetup_spnego(struct request_context *req) +static void reply_sesssetup_spnego(struct smbsrv_request *req) { NTSTATUS status; union smb_sesssetup sess; @@ -2074,7 +2074,7 @@ static void reply_sesssetup_spnego(struct request_context *req) /**************************************************************************** reply to a session setup command ****************************************************************************/ -void reply_sesssetup(struct request_context *req) +void reply_sesssetup(struct smbsrv_request *req) { switch (req->in.wct) { case 10: @@ -2099,7 +2099,7 @@ void reply_sesssetup(struct request_context *req) /**************************************************************************** Reply to a SMBulogoffX. ****************************************************************************/ -void reply_ulogoffX(struct request_context *req) +void reply_ulogoffX(struct smbsrv_request *req) { uint16_t vuid; @@ -2125,7 +2125,7 @@ void reply_ulogoffX(struct request_context *req) /**************************************************************************** Reply to an SMBfindclose request ****************************************************************************/ -void reply_findclose(struct request_context *req) +void reply_findclose(struct smbsrv_request *req) { NTSTATUS status; union smb_search_close io; @@ -2154,7 +2154,7 @@ void reply_findclose(struct request_context *req) /**************************************************************************** Reply to an SMBfindnclose request ****************************************************************************/ -void reply_findnclose(struct request_context *req) +void reply_findnclose(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2163,7 +2163,7 @@ void reply_findnclose(struct request_context *req) /**************************************************************************** Reply to an SMBntcreateX request (async send) ****************************************************************************/ -static void reply_ntcreate_and_X_send(struct request_context *req) +static void reply_ntcreate_and_X_send(struct smbsrv_request *req) { union smb_open *io = req->async.private; @@ -2196,7 +2196,7 @@ static void reply_ntcreate_and_X_send(struct request_context *req) /**************************************************************************** Reply to an SMBntcreateX request ****************************************************************************/ -void reply_ntcreate_and_X(struct request_context *req) +void reply_ntcreate_and_X(struct smbsrv_request *req) { union smb_open *io; uint16_t fname_len; @@ -2245,7 +2245,7 @@ void reply_ntcreate_and_X(struct request_context *req) /**************************************************************************** Reply to an SMBntcancel request ****************************************************************************/ -void reply_ntcancel(struct request_context *req) +void reply_ntcancel(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2253,7 +2253,7 @@ void reply_ntcancel(struct request_context *req) /**************************************************************************** Reply to an SMBsends request ****************************************************************************/ -void reply_sends(struct request_context *req) +void reply_sends(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2261,7 +2261,7 @@ void reply_sends(struct request_context *req) /**************************************************************************** Reply to an SMBsendstrt request ****************************************************************************/ -void reply_sendstrt(struct request_context *req) +void reply_sendstrt(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2269,7 +2269,7 @@ void reply_sendstrt(struct request_context *req) /**************************************************************************** Reply to an SMBsendend request ****************************************************************************/ -void reply_sendend(struct request_context *req) +void reply_sendend(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2277,7 +2277,7 @@ void reply_sendend(struct request_context *req) /**************************************************************************** Reply to an SMBsendtxt request ****************************************************************************/ -void reply_sendtxt(struct request_context *req) +void reply_sendtxt(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2287,7 +2287,7 @@ void reply_sendtxt(struct request_context *req) /**************************************************************************** Reply to a special message - a SMB packet with non zero NBT message type ****************************************************************************/ -void reply_special(struct request_context *req) +void reply_special(struct smbsrv_request *req) { uint8_t msg_type; char buf[4]; diff --git a/source4/smb_server/request.c b/source4/smb_server/request.c index 6361325f22..d845a78c0d 100644 --- a/source4/smb_server/request.c +++ b/source4/smb_server/request.c @@ -19,7 +19,7 @@ */ /* - this file implements functions for manipulating the 'struct request_context' structure in smbd + this file implements functions for manipulating the 'struct smbsrv_request' structure in smbd */ #include "includes.h" @@ -28,7 +28,7 @@ #define REQ_OVER_ALLOCATION 256 /* destroy a request structure */ -void req_destroy(struct request_context *req) +void req_destroy(struct smbsrv_request *req) { /* the request might be marked protected. This is done by the * SMBecho code for example */ @@ -45,9 +45,9 @@ void req_destroy(struct request_context *req) construct a basic request packet, mostly used to construct async packets such as change notify and oplock break requests ****************************************************************************/ -struct request_context *init_smb_request(struct smbsrv_context *smb_ctx) +struct smbsrv_request *init_smb_request(struct smbsrv_context *smb_ctx) { - struct request_context *req; + struct smbsrv_request *req; TALLOC_CTX *mem_ctx; /* each request gets its own talloc context. The request @@ -79,7 +79,7 @@ struct request_context *init_smb_request(struct smbsrv_context *smb_ctx) /* setup a chained reply in req->out with the given word count and initial data buffer size. */ -static void req_setup_chain_reply(struct request_context *req, uint_t wct, uint_t buflen) +static void req_setup_chain_reply(struct smbsrv_request *req, uint_t wct, uint_t buflen) { uint32_t chain_base_size = req->out.size; @@ -111,7 +111,7 @@ static void req_setup_chain_reply(struct request_context *req, uint_t wct, uint_ the caller will then fill in the command words and data before calling req_send_reply() to send the reply on its way */ -void req_setup_reply(struct request_context *req, uint_t wct, uint_t buflen) +void req_setup_reply(struct smbsrv_request *req, uint_t wct, uint_t buflen) { if (req->chain_count != 0) { req_setup_chain_reply(req, wct, buflen); @@ -172,7 +172,7 @@ void req_setup_reply(struct request_context *req, uint_t wct, uint_t buflen) note that this is deliberately a signed integer reply */ -int req_max_data(struct request_context *req) +int req_max_data(struct smbsrv_request *req) { int ret; ret = req->smb_ctx->negotiate.max_send; @@ -190,7 +190,7 @@ int req_max_data(struct request_context *req) To cope with this req->out.ptr is supplied. This will be updated to point at the same offset into the packet as before this call */ -static void req_grow_allocation(struct request_context *req, uint_t new_size) +static void req_grow_allocation(struct smbsrv_request *req, uint_t new_size) { int delta; char *buf2; @@ -231,7 +231,7 @@ static void req_grow_allocation(struct request_context *req, uint_t new_size) To cope with this req->out.ptr is supplied. This will be updated to point at the same offset into the packet as before this call */ -void req_grow_data(struct request_context *req, uint_t new_size) +void req_grow_data(struct smbsrv_request *req, uint_t new_size) { int delta; @@ -256,7 +256,7 @@ void req_grow_data(struct request_context *req, uint_t new_size) note that this only looks at req->out.buffer and req->out.size, allowing manually constructed packets to be sent */ -void req_send_reply_nosign(struct request_context *req) +void req_send_reply_nosign(struct smbsrv_request *req) { if (req->out.size > NBT_HDR_SIZE) { _smb_setlen(req->out.buffer, req->out.size - NBT_HDR_SIZE); @@ -275,7 +275,7 @@ void req_send_reply_nosign(struct request_context *req) note that this only looks at req->out.buffer and req->out.size, allowing manually constructed packets to be sent */ -void req_send_reply(struct request_context *req) +void req_send_reply(struct smbsrv_request *req) { req_sign_packet(req); @@ -288,7 +288,7 @@ void req_send_reply(struct request_context *req) construct and send an error packet with a forced DOS error code this is needed to match win2000 behaviour for some parts of the protocol */ -void req_reply_dos_error(struct request_context *req, uint8_t eclass, uint16_t ecode) +void req_reply_dos_error(struct smbsrv_request *req, uint8_t eclass, uint16_t ecode) { /* if the basic packet hasn't been setup yet then do it now */ if (req->out.buffer == NULL) { @@ -304,7 +304,7 @@ void req_reply_dos_error(struct request_context *req, uint8_t eclass, uint16_t e /* setup the header of a reply to include an NTSTATUS code */ -void req_setup_error(struct request_context *req, NTSTATUS status) +void req_setup_error(struct smbsrv_request *req, NTSTATUS status) { if (!lp_nt_status_support() || !(req->smb_ctx->negotiate.client_caps & CAP_STATUS32)) { /* convert to DOS error codes */ @@ -332,7 +332,7 @@ void req_setup_error(struct request_context *req, NTSTATUS status) construct and send an error packet, then destroy the request auto-converts to DOS error format when appropriate */ -void req_reply_error(struct request_context *req, NTSTATUS status) +void req_reply_error(struct smbsrv_request *req, NTSTATUS status) { req_setup_reply(req, 0, 0); @@ -352,7 +352,7 @@ void req_reply_error(struct request_context *req, NTSTATUS status) if dest_len is -1 then no limit applies */ -size_t req_push_str(struct request_context *req, char *dest, const char *str, int dest_len, uint_t flags) +size_t req_push_str(struct smbsrv_request *req, char *dest, const char *str, int dest_len, uint_t flags) { size_t len; uint_t grow_size; @@ -397,7 +397,7 @@ size_t req_push_str(struct request_context *req, char *dest, const char *str, in append raw bytes into the data portion of the request packet return the number of bytes added */ -size_t req_append_bytes(struct request_context *req, +size_t req_append_bytes(struct smbsrv_request *req, const uint8_t *bytes, size_t byte_len) { req_grow_allocation(req, byte_len + req->out.data_size); @@ -409,7 +409,7 @@ size_t req_append_bytes(struct request_context *req, append variable block (type 5 buffer) into the data portion of the request packet return the number of bytes added */ -size_t req_append_var_block(struct request_context *req, +size_t req_append_var_block(struct smbsrv_request *req, const uint8_t *bytes, uint16_t byte_len) { req_grow_allocation(req, byte_len + 3 + req->out.data_size); @@ -434,7 +434,7 @@ size_t req_append_var_block(struct request_context *req, on failure zero is returned and *dest is set to NULL, otherwise the number of bytes consumed in the packet is returned */ -static size_t req_pull_ucs2(struct request_context *req, const char **dest, const char *src, int byte_len, uint_t flags) +static size_t req_pull_ucs2(struct smbsrv_request *req, const char **dest, const char *src, int byte_len, uint_t flags) { int src_len, src_len2, alignment=0; ssize_t ret; @@ -491,7 +491,7 @@ static size_t req_pull_ucs2(struct request_context *req, const char **dest, cons on failure zero is returned and *dest is set to NULL, otherwise the number of bytes consumed in the packet is returned */ -static size_t req_pull_ascii(struct request_context *req, const char **dest, const char *src, int byte_len, uint_t flags) +static size_t req_pull_ascii(struct smbsrv_request *req, const char **dest, const char *src, int byte_len, uint_t flags) { int src_len, src_len2; ssize_t ret; @@ -538,7 +538,7 @@ static size_t req_pull_ascii(struct request_context *req, const char **dest, con on failure zero is returned and *dest is set to NULL, otherwise the number of bytes consumed in the packet is returned */ -size_t req_pull_string(struct request_context *req, const char **dest, const char *src, int byte_len, uint_t flags) +size_t req_pull_string(struct smbsrv_request *req, const char **dest, const char *src, int byte_len, uint_t flags) { if (!(flags & STR_ASCII) && (((flags & STR_UNICODE) || (req->flags2 & FLAGS2_UNICODE_STRINGS)))) { @@ -558,7 +558,7 @@ size_t req_pull_string(struct request_context *req, const char **dest, const cha on failure *dest is set to the zero length string. This seems to match win2000 behaviour */ -size_t req_pull_ascii4(struct request_context *req, const char **dest, const char *src, uint_t flags) +size_t req_pull_ascii4(struct smbsrv_request *req, const char **dest, const char *src, uint_t flags) { ssize_t ret; @@ -587,7 +587,7 @@ size_t req_pull_ascii4(struct request_context *req, const char **dest, const cha return False if any part is outside the data portion of the packet */ -BOOL req_pull_blob(struct request_context *req, const char *src, int len, DATA_BLOB *blob) +BOOL req_pull_blob(struct smbsrv_request *req, const char *src, int len, DATA_BLOB *blob) { if (len != 0 && req_data_oob(req, src, len)) { return False; @@ -600,7 +600,7 @@ BOOL req_pull_blob(struct request_context *req, const char *src, int len, DATA_B /* check that a lump of data in a request is within the bounds of the data section of the packet */ -BOOL req_data_oob(struct request_context *req, const char *ptr, uint32_t count) +BOOL req_data_oob(struct smbsrv_request *req, const char *ptr, uint32_t count) { if (count == 0) { return False; @@ -620,7 +620,7 @@ BOOL req_data_oob(struct request_context *req, const char *ptr, uint32_t count) /* pull an open file handle from a packet, taking account of the chained_fnum */ -uint16_t req_fnum(struct request_context *req, const char *base, uint_t offset) +uint16_t req_fnum(struct smbsrv_request *req, const char *base, uint_t offset) { if (req->chained_fnum != -1) { return req->chained_fnum; diff --git a/source4/smb_server/search.c b/source4/smb_server/search.c index 40ea53c235..282f4bd1a3 100644 --- a/source4/smb_server/search.c +++ b/source4/smb_server/search.c @@ -57,7 +57,7 @@ /* a structure to encapsulate the state information about * an in-progress search first/next operation */ struct search_state { - struct request_context *req; + struct smbsrv_request *req; union smb_search_data *file; uint16_t last_entry_offset; }; @@ -65,7 +65,7 @@ struct search_state { /* fill a single entry in a search find reply */ -static void find_fill_info(struct request_context *req, +static void find_fill_info(struct smbsrv_request *req, union smb_search_data *file) { char *p = req->out.data + req->out.data_size; @@ -100,7 +100,7 @@ static BOOL find_callback(void *private, union smb_search_data *file) /**************************************************************************** Reply to a search. ****************************************************************************/ -void reply_search(struct request_context *req) +void reply_search(struct smbsrv_request *req) { union smb_search_first *sf; union smb_search_next *sn; @@ -176,7 +176,7 @@ void reply_search(struct request_context *req) /**************************************************************************** Reply to a fclose (async reply) ****************************************************************************/ -static void reply_fclose_send(struct request_context *req) +static void reply_fclose_send(struct smbsrv_request *req) { CHECK_ASYNC_STATUS; @@ -190,7 +190,7 @@ static void reply_fclose_send(struct request_context *req) /**************************************************************************** Reply to fclose (stop directory search). ****************************************************************************/ -void reply_fclose(struct request_context *req) +void reply_fclose(struct smbsrv_request *req) { union smb_search_next *sn; DATA_BLOB resume_key; diff --git a/source4/smb_server/service.c b/source4/smb_server/service.c index 61cc8c718d..082a7d02da 100644 --- a/source4/smb_server/service.c +++ b/source4/smb_server/service.c @@ -135,7 +135,7 @@ static int find_service(const char *service) Make a connection, given the snum to connect to, and the vuser of the connecting user if appropriate. ****************************************************************************/ -static NTSTATUS make_connection_snum(struct request_context *req, +static NTSTATUS make_connection_snum(struct smbsrv_request *req, int snum, enum ntvfs_type type, DATA_BLOB password, const char *dev) @@ -208,7 +208,7 @@ static NTSTATUS make_connection_snum(struct request_context *req, * * @param service ****************************************************************************/ -static NTSTATUS make_connection(struct request_context *req, +static NTSTATUS make_connection(struct smbsrv_request *req, const char *service, DATA_BLOB password, const char *dev, uint16_t vuid) { @@ -274,7 +274,7 @@ void close_cnum(struct smbsrv_tcon *tcon) /* backend for tree connect call */ -NTSTATUS tcon_backend(struct request_context *req, union smb_tcon *con) +NTSTATUS tcon_backend(struct smbsrv_request *req, union smb_tcon *con) { NTSTATUS status; diff --git a/source4/smb_server/sesssetup.c b/source4/smb_server/sesssetup.c index f438f84712..f766d9bd0f 100644 --- a/source4/smb_server/sesssetup.c +++ b/source4/smb_server/sesssetup.c @@ -26,7 +26,7 @@ /* setup the OS, Lanman and domain portions of a session setup reply */ -static void sesssetup_common_strings(struct request_context *req, +static void sesssetup_common_strings(struct smbsrv_request *req, char **os, char **lanman, char **domain) { (*os) = talloc_asprintf(req->mem_ctx, "Unix"); @@ -38,7 +38,7 @@ static void sesssetup_common_strings(struct request_context *req, /* handler for old style session setup */ -static NTSTATUS sesssetup_old(struct request_context *req, union smb_sesssetup *sess) +static NTSTATUS sesssetup_old(struct smbsrv_request *req, union smb_sesssetup *sess) { NTSTATUS status; struct auth_usersupplied_info *user_info = NULL; @@ -86,7 +86,7 @@ static NTSTATUS sesssetup_old(struct request_context *req, union smb_sesssetup * /* handler for NT1 style session setup */ -static NTSTATUS sesssetup_nt1(struct request_context *req, union smb_sesssetup *sess) +static NTSTATUS sesssetup_nt1(struct smbsrv_request *req, union smb_sesssetup *sess) { NTSTATUS status; struct auth_usersupplied_info *user_info = NULL; @@ -136,7 +136,7 @@ static NTSTATUS sesssetup_nt1(struct request_context *req, union smb_sesssetup * /* handler for SPNEGO style session setup */ -static NTSTATUS sesssetup_spnego(struct request_context *req, union smb_sesssetup *sess) +static NTSTATUS sesssetup_spnego(struct smbsrv_request *req, union smb_sesssetup *sess) { /* defer this one for now */ return NT_STATUS_INVALID_LEVEL; @@ -145,7 +145,7 @@ static NTSTATUS sesssetup_spnego(struct request_context *req, union smb_sesssetu /* backend for sessionsetup call - this takes all 3 variants of the call */ -NTSTATUS sesssetup_backend(struct request_context *req, +NTSTATUS sesssetup_backend(struct smbsrv_request *req, union smb_sesssetup *sess) { switch (sess->generic.level) { diff --git a/source4/smb_server/signing.c b/source4/smb_server/signing.c index 9fcd875e39..4765d9d6c3 100644 --- a/source4/smb_server/signing.c +++ b/source4/smb_server/signing.c @@ -23,7 +23,7 @@ /* mark the flags2 field in a packet as signed */ -static void mark_packet_signed(struct request_context *req) +static void mark_packet_signed(struct smbsrv_request *req) { uint16_t flags2; flags2 = SVAL(req->out.hdr, HDR_FLG2); @@ -51,7 +51,7 @@ static void calc_signature(uint8_t *buffer, size_t length, /* sign an outgoing packet */ -void req_sign_packet(struct request_context *req) +void req_sign_packet(struct smbsrv_request *req) { /* check if we are doing signing on this connection */ if (req->smb_ctx->signing.signing_state != SMB_SIGNING_REQUIRED) { @@ -90,7 +90,7 @@ void srv_setup_signing(struct smbsrv_context *smb_ctx, /* allocate a sequence number to a request */ -static void req_signing_alloc_seq_num(struct request_context *req) +static void req_signing_alloc_seq_num(struct smbsrv_request *req) { req->seq_num = req->smb_ctx->signing.next_seq_num; @@ -104,7 +104,7 @@ static void req_signing_alloc_seq_num(struct request_context *req) /* check the signature of an incoming packet */ -BOOL req_signing_check_incoming(struct request_context *req) +BOOL req_signing_check_incoming(struct smbsrv_request *req) { uint8_t client_md5_mac[8], signature[8]; diff --git a/source4/smb_server/smb_server.c b/source4/smb_server/smb_server.c index 6fdfdb6097..b32cf5b7af 100644 --- a/source4/smb_server/smb_server.c +++ b/source4/smb_server/smb_server.c @@ -27,7 +27,7 @@ */ BOOL req_send_oplock_break(struct smbsrv_tcon *tcon, uint16_t fnum, uint8_t level) { - struct request_context *req; + struct smbsrv_request *req; req = init_smb_request(tcon->smb_ctx); @@ -57,11 +57,11 @@ BOOL req_send_oplock_break(struct smbsrv_tcon *tcon, uint16_t fnum, uint8_t leve /**************************************************************************** receive a SMB request from the wire, forming a request_context from the result ****************************************************************************/ -static struct request_context *receive_smb_request(struct smbsrv_context *smb_ctx) +static struct smbsrv_request *receive_smb_request(struct smbsrv_context *smb_ctx) { ssize_t len, len2; char header[4]; - struct request_context *req; + struct smbsrv_request *req; len = read_data(smb_ctx->socket.fd, header, 4); if (len != 4) { @@ -116,7 +116,7 @@ static struct request_context *receive_smb_request(struct smbsrv_context *smb_ct /* setup the user_ctx element of a request */ -static void setup_user_context(struct request_context *req) +static void setup_user_context(struct smbsrv_request *req) { struct smbsrv_user *user_ctx; @@ -150,7 +150,7 @@ force write permissions on print services. static const struct smb_message_struct { const char *name; - void (*fn)(struct request_context *); + void (*fn)(struct smbsrv_request *); int flags; } smb_messages[256] = { @@ -433,7 +433,7 @@ for sending the reply themselves, rather than returning a size to this function The reply functions may also choose to delay the processing by pushing the message onto the message queue ****************************************************************************/ -static void switch_message(int type, struct request_context *req) +static void switch_message(int type, struct smbsrv_request *req) { int flags; uint16_t session_tag; @@ -548,7 +548,7 @@ static void switch_message(int type, struct request_context *req) /**************************************************************************** Construct a reply to the incoming packet. ****************************************************************************/ -static void construct_reply(struct request_context *req) +static void construct_reply(struct smbsrv_request *req) { uint8_t type = CVAL(req->in.hdr,HDR_COM); @@ -596,7 +596,7 @@ static void construct_reply(struct request_context *req) we call this when first first part of a possibly chained request has been completed and we need to call the 2nd part, if any */ -void chain_reply(struct request_context *req) +void chain_reply(struct smbsrv_request *req) { uint16_t chain_cmd, chain_offset; char *vwv, *data; @@ -782,7 +782,7 @@ void open_sockets_smbd(struct event_context *events, void smbd_read_handler(struct event_context *ev, struct fd_event *fde, time_t t, uint16_t flags) { - struct request_context *req; + struct smbsrv_request *req; struct smbsrv_context *smb_ctx = fde->private; req = receive_smb_request(smb_ctx); @@ -806,7 +806,7 @@ void smbd_read_handler(struct event_context *ev, struct fd_event *fde, */ void smbd_process_async(struct smbsrv_context *smb_ctx) { - struct request_context *req; + struct smbsrv_request *req; req = receive_smb_request(smb_ctx); if (!req) { diff --git a/source4/smb_server/trans2.c b/source4/smb_server/trans2.c index 738247b713..0ab1ca0b7c 100644 --- a/source4/smb_server/trans2.c +++ b/source4/smb_server/trans2.c @@ -32,7 +32,7 @@ /* grow the data allocation size of a trans2 reply - this guarantees that requests to grow the data size later will not change the pointer */ -static void trans2_grow_data_allocation(struct request_context *req, +static void trans2_grow_data_allocation(struct smbsrv_request *req, struct smb_trans2 *trans, uint16_t new_size) { @@ -44,7 +44,7 @@ static void trans2_grow_data_allocation(struct request_context *req, /* grow the data size of a trans2 reply */ -static void trans2_grow_data(struct request_context *req, +static void trans2_grow_data(struct smbsrv_request *req, struct smb_trans2 *trans, uint16_t new_size) { @@ -53,7 +53,7 @@ static void trans2_grow_data(struct request_context *req, } /* grow the data, zero filling any new bytes */ -static void trans2_grow_data_fill(struct request_context *req, +static void trans2_grow_data_fill(struct smbsrv_request *req, struct smb_trans2 *trans, uint16_t new_size) { @@ -66,7 +66,7 @@ static void trans2_grow_data_fill(struct request_context *req, /* setup a trans2 reply, given the data and params sizes */ -static void trans2_setup_reply(struct request_context *req, +static void trans2_setup_reply(struct smbsrv_request *req, struct smb_trans2 *trans, uint16_t param_size, uint16_t data_size, uint16_t setup_count) @@ -83,7 +83,7 @@ static void trans2_setup_reply(struct request_context *req, /* pull a string from a blob in a trans2 request */ -static size_t trans2_pull_blob_string(struct request_context *req, +static size_t trans2_pull_blob_string(struct smbsrv_request *req, const DATA_BLOB *blob, uint16_t offset, const char **str, @@ -107,7 +107,7 @@ static size_t trans2_pull_blob_string(struct request_context *req, push a string into the data section of a trans2 request return the number of bytes consumed in the output */ -static size_t trans2_push_data_string(struct request_context *req, +static size_t trans2_push_data_string(struct smbsrv_request *req, struct smb_trans2 *trans, uint16_t len_offset, uint16_t offset, @@ -176,7 +176,7 @@ static size_t trans2_push_data_string(struct request_context *req, len_offset points to the place in the packet where the length field should go */ -static void trans2_append_data_string(struct request_context *req, +static void trans2_append_data_string(struct smbsrv_request *req, struct smb_trans2 *trans, const WIRE_STRING *str, uint_t len_offset, @@ -196,7 +196,7 @@ static void trans2_append_data_string(struct request_context *req, /* trans2 qfsinfo implementation */ -static NTSTATUS trans2_qfsinfo(struct request_context *req, struct smb_trans2 *trans) +static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *trans) { union smb_fsinfo fsinfo; NTSTATUS status; @@ -391,7 +391,7 @@ static NTSTATUS trans2_qfsinfo(struct request_context *req, struct smb_trans2 *t /* fill in the reply from a qpathinfo or qfileinfo call */ -static NTSTATUS trans2_fileinfo_fill(struct request_context *req, struct smb_trans2 *trans, +static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_trans2 *trans, union smb_fileinfo *st) { uint_t i; @@ -614,7 +614,7 @@ static NTSTATUS trans2_fileinfo_fill(struct request_context *req, struct smb_tra /* trans2 qpathinfo implementation */ -static NTSTATUS trans2_qpathinfo(struct request_context *req, struct smb_trans2 *trans) +static NTSTATUS trans2_qpathinfo(struct smbsrv_request *req, struct smb_trans2 *trans) { union smb_fileinfo st; NTSTATUS status; @@ -654,7 +654,7 @@ static NTSTATUS trans2_qpathinfo(struct request_context *req, struct smb_trans2 /* trans2 qpathinfo implementation */ -static NTSTATUS trans2_qfileinfo(struct request_context *req, struct smb_trans2 *trans) +static NTSTATUS trans2_qfileinfo(struct smbsrv_request *req, struct smb_trans2 *trans) { union smb_fileinfo st; NTSTATUS status; @@ -690,7 +690,7 @@ static NTSTATUS trans2_qfileinfo(struct request_context *req, struct smb_trans2 /* parse a trans2 setfileinfo/setpathinfo data blob */ -static NTSTATUS trans2_parse_sfileinfo(struct request_context *req, +static NTSTATUS trans2_parse_sfileinfo(struct smbsrv_request *req, union smb_setfileinfo *st, const DATA_BLOB *blob) { @@ -786,7 +786,7 @@ static NTSTATUS trans2_parse_sfileinfo(struct request_context *req, /* trans2 setfileinfo implementation */ -static NTSTATUS trans2_setfileinfo(struct request_context *req, struct smb_trans2 *trans) +static NTSTATUS trans2_setfileinfo(struct smbsrv_request *req, struct smb_trans2 *trans) { union smb_setfileinfo st; NTSTATUS status; @@ -824,7 +824,7 @@ static NTSTATUS trans2_setfileinfo(struct request_context *req, struct smb_trans /* trans2 setpathinfo implementation */ -static NTSTATUS trans2_setpathinfo(struct request_context *req, struct smb_trans2 *trans) +static NTSTATUS trans2_setpathinfo(struct smbsrv_request *req, struct smb_trans2 *trans) { union smb_setfileinfo st; NTSTATUS status; @@ -863,7 +863,7 @@ static NTSTATUS trans2_setpathinfo(struct request_context *req, struct smb_trans /* a structure to encapsulate the state information about an in-progress ffirst/fnext operation */ struct find_state { - struct request_context *req; + struct smbsrv_request *req; struct smb_trans2 *trans; enum search_level level; uint16_t last_entry_offset; @@ -873,7 +873,7 @@ struct find_state { /* fill a single entry in a trans2 find reply */ -static void find_fill_info(struct request_context *req, +static void find_fill_info(struct smbsrv_request *req, struct smb_trans2 *trans, struct find_state *state, union smb_search_data *file) @@ -1069,7 +1069,7 @@ static BOOL find_callback(void *private, union smb_search_data *file) /* trans2 findfirst implementation */ -static NTSTATUS trans2_findfirst(struct request_context *req, struct smb_trans2 *trans) +static NTSTATUS trans2_findfirst(struct smbsrv_request *req, struct smb_trans2 *trans) { union smb_search_first search; NTSTATUS status; @@ -1129,7 +1129,7 @@ static NTSTATUS trans2_findfirst(struct request_context *req, struct smb_trans2 /* trans2 findnext implementation */ -static NTSTATUS trans2_findnext(struct request_context *req, struct smb_trans2 *trans) +static NTSTATUS trans2_findnext(struct smbsrv_request *req, struct smb_trans2 *trans) { union smb_search_next search; NTSTATUS status; @@ -1188,7 +1188,7 @@ static NTSTATUS trans2_findnext(struct request_context *req, struct smb_trans2 * /* backend for trans2 requests */ -static NTSTATUS trans2_backend(struct request_context *req, struct smb_trans2 *trans) +static NTSTATUS trans2_backend(struct smbsrv_request *req, struct smb_trans2 *trans) { if (req->tcon->ntvfs_ops->trans2 != NULL) { /* direct trans2 pass thru */ @@ -1226,7 +1226,7 @@ static NTSTATUS trans2_backend(struct request_context *req, struct smb_trans2 *t /* backend for trans requests */ -static NTSTATUS trans_backend(struct request_context *req, struct smb_trans2 *trans) +static NTSTATUS trans_backend(struct smbsrv_request *req, struct smb_trans2 *trans) { if (!req->tcon->ntvfs_ops->trans) { return NT_STATUS_NOT_IMPLEMENTED; @@ -1238,7 +1238,7 @@ static NTSTATUS trans_backend(struct request_context *req, struct smb_trans2 *tr /**************************************************************************** Reply to an SMBtrans or SMBtrans2 request ****************************************************************************/ -void reply_trans_generic(struct request_context *req, uint8_t command) +void reply_trans_generic(struct smbsrv_request *req, uint8_t command) { struct smb_trans2 trans; int i; @@ -1391,7 +1391,7 @@ void reply_trans_generic(struct request_context *req, uint8_t command) /**************************************************************************** Reply to an SMBtrans2 ****************************************************************************/ -void reply_trans2(struct request_context *req) +void reply_trans2(struct smbsrv_request *req) { reply_trans_generic(req, SMBtrans2); } @@ -1399,7 +1399,7 @@ void reply_trans2(struct request_context *req) /**************************************************************************** Reply to an SMBtrans ****************************************************************************/ -void reply_trans(struct request_context *req) +void reply_trans(struct smbsrv_request *req) { reply_trans_generic(req, SMBtrans); } @@ -1407,7 +1407,7 @@ void reply_trans(struct request_context *req) /**************************************************************************** Reply to an SMBtranss2 request ****************************************************************************/ -void reply_transs2(struct request_context *req) +void reply_transs2(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } -- cgit