Use "vwv" in trans parsing

diff --git a/source3/smbd/ipc.c b/source3/smbd/ipc.c
index c203445d45f486da25ef98b22aeee45ab398a468..3d70e7ab968a769a33a8cfda893f90409a9cd853 100644 (file)
--- a/source3/smbd/ipc.c
+++ b/source3/smbd/ipc.c
@@ -506,10 +506,10 @@ void reply_trans(struct smb_request *req)
 
        size = smb_len(req->inbuf) + 4;
        av_size = smb_len(req->inbuf);
-       dsoff = SVAL(req->inbuf, smb_dsoff);
-       dscnt = SVAL(req->inbuf, smb_dscnt);
-       psoff = SVAL(req->inbuf, smb_psoff);
-       pscnt = SVAL(req->inbuf, smb_pscnt);
+       dsoff = SVAL(req->vwv+12, 0);
+       dscnt = SVAL(req->vwv+11, 0);
+       psoff = SVAL(req->vwv+10, 0);
+       pscnt = SVAL(req->vwv+9, 0);
 
        result = allow_new_trans(conn->pending_trans, req->mid);
        if (!NT_STATUS_IS_OK(result)) {
@@ -531,15 +531,15 @@ void reply_trans(struct smb_request *req)
 
        state->mid = req->mid;
        state->vuid = req->vuid;
-       state->setup_count = CVAL(req->inbuf, smb_suwcnt);
+       state->setup_count = CVAL(req->vwv+13, 0);
        state->setup = NULL;
-       state->total_param = SVAL(req->inbuf, smb_tpscnt);
+       state->total_param = SVAL(req->vwv+0, 0);
        state->param = NULL;
-       state->total_data = SVAL(req->inbuf, smb_tdscnt);
+       state->total_data = SVAL(req->vwv+1, 0);
        state->data = NULL;
-       state->max_param_return = SVAL(req->inbuf, smb_mprcnt);
-       state->max_data_return = SVAL(req->inbuf, smb_mdrcnt);
-       state->max_setup_return = CVAL(req->inbuf, smb_msrcnt);
+       state->max_param_return = SVAL(req->vwv+2, 0);
+       state->max_data_return = SVAL(req->vwv+3, 0);
+       state->max_setup_return = CVAL(req->vwv+4, 0);
        state->close_on_completion = BITSETW(req->vwv+5, 0);
        state->one_way = BITSETW(req->vwv+5, 1);
 
@@ -717,13 +717,13 @@ void reply_transs(struct smb_request *req)
 
        av_size = smb_len(req->inbuf);
 
-       pcnt = SVAL(req->inbuf, smb_spscnt);
-       poff = SVAL(req->inbuf, smb_spsoff);
-       pdisp = SVAL(req->inbuf, smb_spsdisp);
+       pcnt = SVAL(req->vwv+2, 0);
+       poff = SVAL(req->vwv+3, 0);
+       pdisp = SVAL(req->vwv+4, 0);
 
-       dcnt = SVAL(req->inbuf, smb_sdscnt);
-       doff = SVAL(req->inbuf, smb_sdsoff);
-       ddisp = SVAL(req->inbuf, smb_sdsdisp);
+       dcnt = SVAL(req->vwv+5, 0);
+       doff = SVAL(req->vwv+6, 0);
+       ddisp = SVAL(req->vwv+7, 0);
 
        state->received_param += pcnt;
        state->received_data += dcnt;

diff --git a/source3/smbd/nttrans.c b/source3/smbd/nttrans.c
index 83b0ff6cd336913ec55bfcfaa0f2a4fbdfb8f03e..f711b588c5ec1c9b76aefb61168bb234097bdc33 100644 (file)
--- a/source3/smbd/nttrans.c
+++ b/source3/smbd/nttrans.c
@@ -304,7 +304,7 @@ static void do_ntcreate_pipe_open(connection_struct *conn,
        char *fname = NULL;
        int pnum = -1;
        char *p = NULL;
-       uint32 flags = IVAL(req->inbuf,smb_ntcreate_Flags);
+       uint32 flags = IVAL(req->vwv+3, 1);
        TALLOC_CTX *ctx = talloc_tos();
 
        srvstr_pull_req_talloc(ctx, req, &fname, req->buf, STR_TERMINATE);
@@ -407,20 +407,17 @@ void reply_ntcreate_and_X(struct smb_request *req)
                return;
        }
 
-       flags = IVAL(req->inbuf,smb_ntcreate_Flags);
-       access_mask = IVAL(req->inbuf,smb_ntcreate_DesiredAccess);
-       file_attributes = IVAL(req->inbuf,smb_ntcreate_FileAttributes);
-       share_access = IVAL(req->inbuf,smb_ntcreate_ShareAccess);
-       create_disposition = IVAL(req->inbuf,smb_ntcreate_CreateDisposition);
-       create_options = IVAL(req->inbuf,smb_ntcreate_CreateOptions);
-       root_dir_fid = (uint16)IVAL(req->inbuf,smb_ntcreate_RootDirectoryFid);
+       flags = IVAL(req->vwv+3, 1);
+       access_mask = IVAL(req->vwv+7, 1);
+       file_attributes = IVAL(req->vwv+13, 1);
+       share_access = IVAL(req->vwv+15, 1);
+       create_disposition = IVAL(req->vwv+17, 1);
+       create_options = IVAL(req->vwv+19, 1);
+       root_dir_fid = (uint16)IVAL(req->vwv+5, 1);
 
-       allocation_size = (uint64_t)IVAL(req->inbuf,
-                                            smb_ntcreate_AllocationSize);
+       allocation_size = (uint64_t)IVAL(req->vwv+9, 1);
 #ifdef LARGE_SMB_OFF_T
-       allocation_size |= (((uint64_t)IVAL(
-                                    req->inbuf,
-                                    smb_ntcreate_AllocationSize + 4)) << 32);
+       allocation_size |= (((uint64_t)IVAL(req->vwv+11, 1)) << 32);
 #endif
 
        srvstr_get_path_req(ctx, req, &fname, (const char *)req->buf,
@@ -2535,11 +2532,11 @@ void reply_nttrans(struct smb_request *req)
 
        size = smb_len(req->inbuf) + 4;
        av_size = smb_len(req->inbuf);
-       pscnt = IVAL(req->inbuf,smb_nt_ParameterCount);
-       psoff = IVAL(req->inbuf,smb_nt_ParameterOffset);
-       dscnt = IVAL(req->inbuf,smb_nt_DataCount);
-       dsoff = IVAL(req->inbuf,smb_nt_DataOffset);
-       function_code = SVAL(req->inbuf, smb_nt_Function);
+       pscnt = IVAL(req->vwv+9, 1);
+       psoff = IVAL(req->vwv+11, 1);
+       dscnt = IVAL(req->vwv+13, 1);
+       dsoff = IVAL(req->vwv+15, 1);
+       function_code = SVAL(req->vwv+18, 0);
 
        if (IS_IPC(conn) && (function_code != NT_TRANSACT_CREATE)) {
                reply_doserror(req, ERRSRV, ERRaccess);
@@ -2565,15 +2562,15 @@ void reply_nttrans(struct smb_request *req)
 
        state->mid = req->mid;
        state->vuid = req->vuid;
-       state->total_data = IVAL(req->inbuf, smb_nt_TotalDataCount);
+       state->total_data = IVAL(req->vwv+3, 1);
        state->data = NULL;
-       state->total_param = IVAL(req->inbuf, smb_nt_TotalParameterCount);
+       state->total_param = IVAL(req->vwv+1, 1);
        state->param = NULL;
-       state->max_data_return = IVAL(req->inbuf,smb_nt_MaxDataCount);
-       state->max_param_return = IVAL(req->inbuf,smb_nt_MaxParameterCount);
+       state->max_data_return = IVAL(req->vwv+7, 1);
+       state->max_param_return = IVAL(req->vwv+5, 1);
 
        /* setup count is in *words* */
-       state->setup_count = 2*CVAL(req->inbuf,smb_nt_SetupCount);
+       state->setup_count = 2*CVAL(req->vwv+17, 1);
        state->setup = NULL;
        state->call = function_code;
 
@@ -2760,25 +2757,23 @@ void reply_nttranss(struct smb_request *req)
 
        /* Revise state->total_param and state->total_data in case they have
           changed downwards */
-       if (IVAL(req->inbuf, smb_nts_TotalParameterCount)
-           < state->total_param) {
-               state->total_param = IVAL(req->inbuf,
-                                         smb_nts_TotalParameterCount);
+       if (IVAL(req->vwv+1, 1) < state->total_param) {
+               state->total_param = IVAL(req->vwv+1, 1);
        }
-       if (IVAL(req->inbuf, smb_nts_TotalDataCount) < state->total_data) {
-               state->total_data = IVAL(req->inbuf, smb_nts_TotalDataCount);
+       if (IVAL(req->vwv+3, 1) < state->total_data) {
+               state->total_data = IVAL(req->vwv+3, 1);
        }
 
        size = smb_len(req->inbuf) + 4;
        av_size = smb_len(req->inbuf);
 
-       pcnt = IVAL(req->inbuf,smb_nts_ParameterCount);
-       poff = IVAL(req->inbuf, smb_nts_ParameterOffset);
-       pdisp = IVAL(req->inbuf, smb_nts_ParameterDisplacement);
+       pcnt = IVAL(req->vwv+5, 1);
+       poff = IVAL(req->vwv+7, 1);
+       pdisp = IVAL(req->vwv+9, 1);
 
-       dcnt = IVAL(req->inbuf, smb_nts_DataCount);
-       ddisp = IVAL(req->inbuf, smb_nts_DataDisplacement);
-       doff = IVAL(req->inbuf, smb_nts_DataOffset);
+       dcnt = IVAL(req->vwv+11, 1);
+       doff = IVAL(req->vwv+13, 1);
+       ddisp = IVAL(req->vwv+15, 1);
 
        state->received_param += pcnt;
        state->received_data += dcnt;

diff --git a/source3/smbd/trans2.c b/source3/smbd/trans2.c
index f9376fc292cf5e4c46b54805ef83acfc266e6d87..df8b272c793d4c9b1a6323ae5072ce6626edaaba 100644 (file)
--- a/source3/smbd/trans2.c
+++ b/source3/smbd/trans2.c
@@ -7540,11 +7540,11 @@ void reply_trans2(struct smb_request *req)
                return;
        }
 
-       dsoff = SVAL(req->inbuf, smb_dsoff);
-       dscnt = SVAL(req->inbuf, smb_dscnt);
-       psoff = SVAL(req->inbuf, smb_psoff);
-       pscnt = SVAL(req->inbuf, smb_pscnt);
-       tran_call = SVAL(req->inbuf, smb_setup0);
+       dsoff = SVAL(req->vwv+12, 0);
+       dscnt = SVAL(req->vwv+11, 0);
+       psoff = SVAL(req->vwv+10, 0);
+       pscnt = SVAL(req->vwv+9, 0);
+       tran_call = SVAL(req->vwv+14, 0);
        size = smb_len(req->inbuf) + 4;
        av_size = smb_len(req->inbuf);
 
@@ -7584,15 +7584,15 @@ void reply_trans2(struct smb_request *req)
 
        state->mid = req->mid;
        state->vuid = req->vuid;
-       state->setup_count = SVAL(req->inbuf, smb_suwcnt);
+       state->setup_count = SVAL(req->vwv+13, 0);
        state->setup = NULL;
-       state->total_param = SVAL(req->inbuf, smb_tpscnt);
+       state->total_param = SVAL(req->vwv+0, 0);
        state->param = NULL;
-       state->total_data =  SVAL(req->inbuf, smb_tdscnt);
+       state->total_data =  SVAL(req->vwv+1, 0);
        state->data = NULL;
-       state->max_param_return = SVAL(req->inbuf, smb_mprcnt);
-       state->max_data_return  = SVAL(req->inbuf, smb_mdrcnt);
-       state->max_setup_return = SVAL(req->inbuf, smb_msrcnt);
+       state->max_param_return = SVAL(req->vwv+2, 0);
+       state->max_data_return  = SVAL(req->vwv+3, 0);
+       state->max_setup_return = SVAL(req->vwv+4, 0);
        state->close_on_completion = BITSETW(req->vwv+5, 0);
        state->one_way = BITSETW(req->vwv+5, 1);
 
@@ -7758,18 +7758,18 @@ void reply_transs2(struct smb_request *req)
        /* Revise state->total_param and state->total_data in case they have
           changed downwards */
 
-       if (SVAL(req->inbuf, smb_tpscnt) < state->total_param)
-               state->total_param = SVAL(req->inbuf, smb_tpscnt);
-       if (SVAL(req->inbuf, smb_tdscnt) < state->total_data)
-               state->total_data = SVAL(req->inbuf, smb_tdscnt);
+       if (SVAL(req->vwv+0, 0) < state->total_param)
+               state->total_param = SVAL(req->vwv+0, 0);
+       if (SVAL(req->vwv+1, 0) < state->total_data)
+               state->total_data = SVAL(req->vwv+1, 0);
 
-       pcnt = SVAL(req->inbuf, smb_spscnt);
-       poff = SVAL(req->inbuf, smb_spsoff);
-       pdisp = SVAL(req->inbuf, smb_spsdisp);
+       pcnt = SVAL(req->vwv+2, 0);
+       poff = SVAL(req->vwv+3, 0);
+       pdisp = SVAL(req->vwv+4, 0);
 
-       dcnt = SVAL(req->inbuf, smb_sdscnt);
-       doff = SVAL(req->inbuf, smb_sdsoff);
-       ddisp = SVAL(req->inbuf, smb_sdsdisp);
+       dcnt = SVAL(req->vwv+5, 0);
+       doff = SVAL(req->vwv+6, 0);
+       ddisp = SVAL(req->vwv+7, 0);
 
        state->received_param += pcnt;
        state->received_data += dcnt;