Remove a bunch of direct inbuf references by adding "buf" to smb_request
authorVolker Lendecke <vl@samba.org>
Sat, 1 Nov 2008 16:35:48 +0000 (17:35 +0100)
committerVolker Lendecke <vl@samba.org>
Sat, 1 Nov 2008 18:41:08 +0000 (19:41 +0100)
source3/include/smb.h
source3/smbd/ipc.c
source3/smbd/message.c
source3/smbd/negprot.c
source3/smbd/nttrans.c
source3/smbd/pipes.c
source3/smbd/process.c
source3/smbd/reply.c
source3/smbd/sesssetup.c

index d682052c6369d5b5e125cb8dec28af235bc84d9d..e2cd0e571ce03f39e8efe4612143f6442c3e3e79 100644 (file)
@@ -632,6 +632,7 @@ struct smb_request {
        uint16 tid;
        uint8  wct;
        uint16_t buflen;
+       const uint8_t *buf;
        const uint8 *inbuf;
        uint8 *outbuf;
        size_t unread_bytes;
index 0ce226809e1dde8630adf649bc2e59e000fce562..d11c8c7cd51fecdf1779ed518865f825b4d779b0 100644 (file)
@@ -544,7 +544,7 @@ void reply_trans(struct smb_request *req)
        state->one_way = BITSETW(req->inbuf+smb_vwv5,1);
 
        srvstr_pull_buf_talloc(state, req->inbuf, req->flags2, &state->name,
-                       smb_buf(req->inbuf), STR_TERMINATE);
+                              req->buf, STR_TERMINATE);
 
        if ((dscnt > state->total_data) || (pscnt > state->total_param) ||
                        !state->name)
index 62df5c37ebfbb7a98af0e4350b99b5f2b6f800a0..6977b586dfa86387485d36bba69c3c1494b2b18e 100644 (file)
@@ -140,8 +140,8 @@ void reply_sends(struct smb_request *req)
 {
        struct msg_state *state;
        int len;
-       char *msg;
-       char *p;
+       const char *msg;
+       const char *p;
 
        START_PROFILE(SMBsends);
 
@@ -153,7 +153,7 @@ void reply_sends(struct smb_request *req)
 
        state = talloc(talloc_tos(), struct msg_state);
 
-       p = smb_buf(req->inbuf)+1;
+       p = (const char *)req->buf + 1;
        p += srvstr_pull_buf_talloc(
                state, (char *)req->inbuf, req->flags2, &state->from, p,
                STR_ASCII|STR_TERMINATE) + 1;
@@ -191,7 +191,7 @@ void reply_sends(struct smb_request *req)
 
 void reply_sendstrt(struct smb_request *req)
 {
-       char *p;
+       const char *p;
 
        START_PROFILE(SMBsendstrt);
 
@@ -211,7 +211,7 @@ void reply_sendstrt(struct smb_request *req)
                return;
        }
 
-       p = smb_buf(req->inbuf)+1;
+       p = (const char *)req->buf+1;
        p += srvstr_pull_buf_talloc(
                smbd_msg_state, (char *)req->inbuf, req->flags2,
                &smbd_msg_state->from, p, STR_ASCII|STR_TERMINATE) + 1;
@@ -236,7 +236,7 @@ void reply_sendstrt(struct smb_request *req)
 void reply_sendtxt(struct smb_request *req)
 {
        int len;
-       char *msg;
+       const char *msg;
        char *tmp;
        size_t old_len;
 
@@ -254,7 +254,7 @@ void reply_sendtxt(struct smb_request *req)
                return;
        }
 
-       msg = smb_buf(req->inbuf) + 1;
+       msg = (const char *)req->buf + 1;
 
        old_len = talloc_get_size(smbd_msg_state->msg);
 
index 84f111fb0264ea5d7b2eea4e89cd7ca178cdc730..1fe0193e00113f5ad643ece855fff5fb60858000 100644 (file)
@@ -510,8 +510,7 @@ void reply_negprot(struct smb_request *req)
        size_t size = smb_len(req->inbuf) + 4;
        int choice= -1;
        int protocol;
-       char *p;
-       int bcc = SVAL(smb_buf(req->inbuf),-2);
+       const char *p;
        int arch = ARCH_ALL;
        int num_cliprotos;
        char **cliprotos;
@@ -535,12 +534,12 @@ void reply_negprot(struct smb_request *req)
                return;
        }
 
-       p = smb_buf(req->inbuf) + 1;
+       p = (const char *)req->buf + 1;
 
        num_cliprotos = 0;
        cliprotos = NULL;
 
-       while (p < (smb_buf(req->inbuf) + bcc)) {
+       while (smb_bufrem(req->inbuf, p) > 0) {
 
                char **tmp;
 
index 30841686fb4139470bfe174b2aa70ce697c7246c..dace8f6d8c22c316532d0c8ec90ae7ade1745a33 100644 (file)
@@ -308,7 +308,7 @@ static void do_ntcreate_pipe_open(connection_struct *conn,
        TALLOC_CTX *ctx = talloc_tos();
 
        srvstr_pull_buf_talloc(ctx, (char *)req->inbuf, req->flags2, &fname,
-                       smb_buf(req->inbuf), STR_TERMINATE);
+                              req->buf, STR_TERMINATE);
 
        if (!fname) {
                reply_botherror(req, NT_STATUS_OBJECT_NAME_NOT_FOUND,
@@ -425,7 +425,7 @@ void reply_ntcreate_and_X(struct smb_request *req)
 #endif
 
        srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname,
-                       smb_buf(req->inbuf), 0, STR_TERMINATE, &status);
+                       (const char *)req->buf, 0, STR_TERMINATE, &status);
 
        if (!NT_STATUS_IS_OK(status)) {
                reply_nterror(req, status);
@@ -1228,7 +1228,7 @@ void reply_ntrename(struct smb_request *req)
        connection_struct *conn = req->conn;
        char *oldname = NULL;
        char *newname = NULL;
-       char *p;
+       const char *p;
        NTSTATUS status;
        bool src_has_wcard = False;
        bool dest_has_wcard = False;
@@ -1247,7 +1247,7 @@ void reply_ntrename(struct smb_request *req)
        attrs = SVAL(req->inbuf,smb_vwv0);
        rename_type = SVAL(req->inbuf,smb_vwv1);
 
-       p = smb_buf(req->inbuf) + 1;
+       p = (const char *)req->buf + 1;
        p += srvstr_get_path_wcard(ctx, (char *)req->inbuf, req->flags2, &oldname, p,
                                   0, STR_TERMINATE, &status,
                                   &src_has_wcard);
index d971e9dc6201941da435e5d21a41e073780fead2..2ce60c762e13c8d30582dd9d53aa122e4d499dec 100644 (file)
@@ -49,7 +49,7 @@ void reply_open_pipe_and_X(connection_struct *conn, struct smb_request *req)
 
        /* XXXX we need to handle passed times, sattr and flags */
        srvstr_pull_buf_talloc(ctx, req->inbuf, req->flags2, &pipe_name,
-                       smb_buf(req->inbuf), STR_TERMINATE);
+                              req->buf, STR_TERMINATE);
        if (!pipe_name) {
                reply_botherror(req, NT_STATUS_OBJECT_NAME_NOT_FOUND,
                                ERRDOS, ERRbadpipe);
@@ -122,7 +122,7 @@ void reply_pipe_write(struct smb_request *req)
        files_struct *fsp = file_fsp(req, SVAL(req->inbuf,smb_vwv0));
        size_t numtowrite = SVAL(req->inbuf,smb_vwv1);
        ssize_t nwritten;
-       uint8_t *data;
+       const uint8_t *data;
 
        if (!fsp_is_np(fsp)) {
                reply_doserror(req, ERRDOS, ERRbadfid);
@@ -134,7 +134,7 @@ void reply_pipe_write(struct smb_request *req)
                return;
        }
 
-       data = (uint8_t *)smb_buf(req->inbuf) + 3;
+       data = req->buf + 3;
 
        if (numtowrite == 0) {
                nwritten = 0;
index 8e1add3fb14fd6c41046a0bfab43299ff2cf1c53..bd665f3868829f47a81b4904deae678c3ea299d3 100644 (file)
@@ -376,6 +376,7 @@ void init_smb_request(struct smb_request *req,
        req->tid    = SVAL(inbuf, smb_tid);
        req->wct    = CVAL(inbuf, smb_wct);
        req->buflen = smb_buflen(inbuf);
+       req->buf    = (const uint8_t *)smb_buf(inbuf);
        req->unread_bytes = unread_bytes;
        req->encrypted = encrypted;
        req->conn = conn_find(req->tid);
index bbdf34e3e9055259f8bf209f5bc8ea13f714d350..a9c489cef4742a9e701b18918195b56cfd3e2fa8 100644 (file)
@@ -517,7 +517,7 @@ void reply_tcon(struct smb_request *req)
        char *dev = NULL;
        int pwlen=0;
        NTSTATUS nt_status;
-       char *p;
+       const char *p;
        DATA_BLOB password_blob;
        TALLOC_CTX *ctx = talloc_tos();
 
@@ -529,7 +529,7 @@ void reply_tcon(struct smb_request *req)
                return;
        }
 
-       p = smb_buf(req->inbuf)+1;
+       p = (const char *)req->buf + 1;
        p += srvstr_pull_buf_talloc(ctx, req->inbuf, req->flags2,
                                    &service_buf, p, STR_TERMINATE) + 1;
        pwlen = srvstr_pull_buf_talloc(ctx, req->inbuf, req->flags2,
@@ -583,7 +583,7 @@ void reply_tcon(struct smb_request *req)
 void reply_tcon_and_X(struct smb_request *req)
 {
        connection_struct *conn = req->conn;
-       char *service = NULL;
+       const char *service = NULL;
        DATA_BLOB password;
        TALLOC_CTX *ctx = talloc_tos();
        /* what the cleint thinks the device is */
@@ -593,7 +593,7 @@ void reply_tcon_and_X(struct smb_request *req)
        NTSTATUS nt_status;
        int passlen;
        char *path = NULL;
-       char *p, *q;
+       const char *p, *q;
        uint16 tcon_flags;
 
        START_PROFILE(SMBtconX);
@@ -621,23 +621,21 @@ void reply_tcon_and_X(struct smb_request *req)
        }
 
        if (global_encrypted_passwords_negotiated) {
-               password = data_blob_talloc(talloc_tos(), smb_buf(req->inbuf),
-                                           passlen);
+               password = data_blob_talloc(talloc_tos(), req->buf, passlen);
                if (lp_security() == SEC_SHARE) {
                        /*
                         * Security = share always has a pad byte
                         * after the password.
                         */
-                       p = smb_buf(req->inbuf) + passlen + 1;
+                       p = (const char *)req->buf + passlen + 1;
                } else {
-                       p = smb_buf(req->inbuf) + passlen;
+                       p = (const char *)req->buf + passlen;
                }
        } else {
-               password = data_blob_talloc(talloc_tos(), smb_buf(req->inbuf),
-                                           passlen+1);
+               password = data_blob_talloc(talloc_tos(), req->buf, passlen+1);
                /* Ensure correct termination */
                password.data[passlen]=0;
-               p = smb_buf(req->inbuf) + passlen + 1;
+               p = (const char *)req->buf + passlen + 1;
        }
 
        p += srvstr_pull_buf_talloc(ctx, req->inbuf, req->flags2, &path, p,
@@ -887,8 +885,7 @@ void reply_checkpath(struct smb_request *req)
        START_PROFILE(SMBcheckpath);
 
        srvstr_get_path(ctx,(char *)req->inbuf, req->flags2, &name,
-                       smb_buf(req->inbuf) + 1, 0,
-                       STR_TERMINATE, &status);
+                       (const char *)req->buf + 1, 0, STR_TERMINATE, &status);
        if (!NT_STATUS_IS_OK(status)) {
                status = map_checkpath_error((char *)req->inbuf, status);
                reply_nterror(req, status);
@@ -979,13 +976,13 @@ void reply_getatr(struct smb_request *req)
        int mode=0;
        SMB_OFF_T size=0;
        time_t mtime=0;
-       char *p;
+       const char *p;
        NTSTATUS status;
        TALLOC_CTX *ctx = talloc_tos();
 
        START_PROFILE(SMBgetatr);
 
-       p = smb_buf(req->inbuf) + 1;
+       p = (const char *)req->buf + 1;
        p += srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname, p,
                             0, STR_TERMINATE, &status);
        if (!NT_STATUS_IS_OK(status)) {
@@ -1081,7 +1078,7 @@ void reply_setatr(struct smb_request *req)
        int mode;
        time_t mtime;
        SMB_STRUCT_STAT sbuf;
-       char *p;
+       const char *p;
        NTSTATUS status;
        TALLOC_CTX *ctx = talloc_tos();
 
@@ -1094,7 +1091,7 @@ void reply_setatr(struct smb_request *req)
                return;
        }
 
-       p = smb_buf(req->inbuf) + 1;
+       p = (const char *)req->buf + 1;
        p += srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname, p,
                                0, STR_TERMINATE, &status);
        if (!NT_STATUS_IS_OK(status)) {
@@ -1236,7 +1233,7 @@ void reply_dskattr(struct smb_request *req)
 void reply_search(struct smb_request *req)
 {
        connection_struct *conn = req->conn;
-       char *mask = NULL;
+       const char *mask = NULL;
        char *directory = NULL;
        char *fname = NULL;
        SMB_OFF_T size;
@@ -1246,7 +1243,7 @@ void reply_search(struct smb_request *req)
        unsigned int numentries = 0;
        unsigned int maxentries = 0;
        bool finished = False;
-       char *p;
+       const char *p;
        int status_len;
        char *path = NULL;
        char status[21];
@@ -1281,7 +1278,7 @@ void reply_search(struct smb_request *req)
        reply_outbuf(req, 1, 3);
        maxentries = SVAL(req->inbuf,smb_vwv0);
        dirtype = SVAL(req->inbuf,smb_vwv1);
-       p = smb_buf(req->inbuf) + 1;
+       p = (const char *)req->buf + 1;
        p += srvstr_get_path_wcard(ctx,
                                (char *)req->inbuf,
                                req->flags2,
@@ -1544,7 +1541,7 @@ void reply_fclose(struct smb_request *req)
        int status_len;
        char status[21];
        int dptr_num= -2;
-       char *p;
+       const char *p;
        char *path = NULL;
        NTSTATUS err;
        bool path_contains_wcard = False;
@@ -1558,7 +1555,7 @@ void reply_fclose(struct smb_request *req)
                return;
        }
 
-       p = smb_buf(req->inbuf) + 1;
+       p = (const char *)req->buf + 1;
        p += srvstr_get_path_wcard(ctx,
                                (char *)req->inbuf,
                                req->flags2,
@@ -1636,8 +1633,7 @@ void reply_open(struct smb_request *req)
        dos_attr = SVAL(req->inbuf,smb_vwv1);
 
        srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname,
-                       smb_buf(req->inbuf)+1, 0,
-                       STR_TERMINATE, &status);
+                       (const char *)req->buf+1, 0, STR_TERMINATE, &status);
        if (!NT_STATUS_IS_OK(status)) {
                reply_nterror(req, status);
                END_PROFILE(SMBopen);
@@ -1781,8 +1777,7 @@ void reply_open_and_X(struct smb_request *req)
 
        /* XXXX we need to handle passed times, sattr and flags */
        srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname,
-                       smb_buf(req->inbuf), 0, STR_TERMINATE,
-                       &status);
+                       (const char *)req->buf, 0, STR_TERMINATE, &status);
        if (!NT_STATUS_IS_OK(status)) {
                reply_nterror(req, status);
                END_PROFILE(SMBopenX);
@@ -1978,8 +1973,7 @@ void reply_mknew(struct smb_request *req)
                        /* mtime. */
 
        srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname,
-                        smb_buf(req->inbuf) + 1, 0,
-                       STR_TERMINATE, &status);
+                        (const char *)req->buf + 1, 0, STR_TERMINATE, &status);
        if (!NT_STATUS_IS_OK(status)) {
                reply_nterror(req, status);
                END_PROFILE(SMBcreate);
@@ -2084,8 +2078,7 @@ void reply_ctemp(struct smb_request *req)
        oplock_request = CORE_OPLOCK_REQUEST(req->inbuf);
 
        srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname,
-                       smb_buf(req->inbuf)+1, 0, STR_TERMINATE,
-                       &status);
+                       (const char *)req->buf+1, 0, STR_TERMINATE, &status);
        if (!NT_STATUS_IS_OK(status)) {
                reply_nterror(req, status);
                END_PROFILE(SMBctemp);
@@ -2555,8 +2548,8 @@ void reply_unlink(struct smb_request *req)
        dirtype = SVAL(req->inbuf,smb_vwv0);
 
        srvstr_get_path_wcard(ctx, (char *)req->inbuf, req->flags2, &name,
-                             smb_buf(req->inbuf) + 1, 0,
-                             STR_TERMINATE, &status, &path_contains_wcard);
+                             (const char *)req->buf + 1, 0, STR_TERMINATE,
+                             &status, &path_contains_wcard);
        if (!NT_STATUS_IS_OK(status)) {
                reply_nterror(req, status);
                END_PROFILE(SMBunlink);
@@ -3642,7 +3635,7 @@ void reply_writeunlock(struct smb_request *req)
        ssize_t nwritten = -1;
        size_t numtowrite;
        SMB_OFF_T startpos;
-       char *data;
+       const char *data;
        NTSTATUS status = NT_STATUS_OK;
        files_struct *fsp;
 
@@ -3669,7 +3662,7 @@ void reply_writeunlock(struct smb_request *req)
 
        numtowrite = SVAL(req->inbuf,smb_vwv1);
        startpos = IVAL_TO_SMB_OFF_T(req->inbuf,smb_vwv2);
-       data = smb_buf(req->inbuf) + 3;
+       data = (const char *)req->buf + 3;
 
        if (numtowrite
            && is_locked(fsp, (uint32)req->smbpid, (uint64_t)numtowrite,
@@ -3742,7 +3735,7 @@ void reply_write(struct smb_request *req)
        size_t numtowrite;
        ssize_t nwritten = -1;
        SMB_OFF_T startpos;
-       char *data;
+       const char *data;
        files_struct *fsp;
        NTSTATUS status;
 
@@ -3776,7 +3769,7 @@ void reply_write(struct smb_request *req)
 
        numtowrite = SVAL(req->inbuf,smb_vwv1);
        startpos = IVAL_TO_SMB_OFF_T(req->inbuf,smb_vwv2);
-       data = smb_buf(req->inbuf) + 3;
+       data = (const char *)req->buf + 3;
 
        if (is_locked(fsp, (uint32)req->smbpid, (uint64_t)numtowrite,
                      (uint64_t)startpos, WRITE_LOCK)) {
@@ -4326,7 +4319,7 @@ void reply_writeclose(struct smb_request *req)
        ssize_t nwritten = -1;
        NTSTATUS close_status = NT_STATUS_OK;
        SMB_OFF_T startpos;
-       char *data;
+       const char *data;
        struct timespec mtime;
        files_struct *fsp;
 
@@ -4354,7 +4347,7 @@ void reply_writeclose(struct smb_request *req)
        startpos = IVAL_TO_SMB_OFF_T(req->inbuf,smb_vwv2);
        mtime = convert_time_t_to_timespec(srv_make_unix_date3(
                                                   req->inbuf+smb_vwv4));
-       data = smb_buf(req->inbuf) + 1;
+       data = (const char *)req->buf + 1;
 
        if (numtowrite
            && is_locked(fsp, (uint32)req->smbpid, (uint64_t)numtowrite,
@@ -4571,7 +4564,7 @@ void reply_echo(struct smb_request *req)
 
        /* copy any incoming data back out */
        if (req->buflen > 0) {
-               memcpy(smb_buf(req->outbuf), smb_buf(req->inbuf), req->buflen);
+               memcpy(smb_buf(req->outbuf), req->buf, req->buflen);
        }
 
        if (smb_reverb > 100) {
@@ -4789,7 +4782,7 @@ void reply_printwrite(struct smb_request *req)
 {
        connection_struct *conn = req->conn;
        int numtowrite;
-       char *data;
+       const char *data;
        files_struct *fsp;
 
        START_PROFILE(SMBsplwr);
@@ -4819,7 +4812,7 @@ void reply_printwrite(struct smb_request *req)
                return;
        }
 
-       numtowrite = SVAL(smb_buf(req->inbuf),1);
+       numtowrite = SVAL(req->buf, 1);
 
        if (req->buflen < numtowrite + 3) {
                reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
@@ -4827,7 +4820,7 @@ void reply_printwrite(struct smb_request *req)
                return;
        }
 
-       data = smb_buf(req->inbuf) + 3;
+       data = (const char *)req->buf + 3;
 
        if (write_file(req,fsp,data,-1,numtowrite) != numtowrite) {
                reply_unixerror(req, ERRHRD, ERRdiskfull);
@@ -4856,8 +4849,7 @@ void reply_mkdir(struct smb_request *req)
        START_PROFILE(SMBmkdir);
 
        srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &directory,
-                       smb_buf(req->inbuf) + 1, 0,
-                       STR_TERMINATE, &status);
+                       (const char *)req->buf + 1, 0, STR_TERMINATE, &status);
        if (!NT_STATUS_IS_OK(status)) {
                reply_nterror(req, status);
                END_PROFILE(SMBmkdir);
@@ -5127,8 +5119,7 @@ void reply_rmdir(struct smb_request *req)
        START_PROFILE(SMBrmdir);
 
        srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &directory,
-                       smb_buf(req->inbuf) + 1, 0,
-                       STR_TERMINATE, &status);
+                       (const char *)req->buf + 1, 0, STR_TERMINATE, &status);
        if (!NT_STATUS_IS_OK(status)) {
                reply_nterror(req, status);
                END_PROFILE(SMBrmdir);
@@ -5908,7 +5899,7 @@ void reply_mv(struct smb_request *req)
        connection_struct *conn = req->conn;
        char *name = NULL;
        char *newname = NULL;
-       char *p;
+       const char *p;
        uint32 attrs;
        NTSTATUS status;
        bool src_has_wcard = False;
@@ -5925,7 +5916,7 @@ void reply_mv(struct smb_request *req)
 
        attrs = SVAL(req->inbuf,smb_vwv0);
 
-       p = smb_buf(req->inbuf) + 1;
+       p = (const char *)req->buf + 1;
        p += srvstr_get_path_wcard(ctx, (char *)req->inbuf, req->flags2, &name, p,
                                   0, STR_TERMINATE, &status,
                                   &src_has_wcard);
@@ -6169,7 +6160,7 @@ void reply_copy(struct smb_request *req)
        ofun = SVAL(req->inbuf,smb_vwv1);
        flags = SVAL(req->inbuf,smb_vwv2);
 
-       p = smb_buf(req->inbuf);
+       p = (const char *)req->buf;
        p += srvstr_get_path_wcard(ctx, (char *)req->inbuf, req->flags2, &name, p,
                                   0, STR_TERMINATE, &status,
                                   &source_has_wild);
@@ -6613,7 +6604,7 @@ void reply_lockingX(struct smb_request *req)
        uint32 lock_pid;
        int32 lock_timeout;
        int i;
-       char *data;
+       const uint8_t *data;
        bool large_file_format;
        bool err;
        NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
@@ -6639,7 +6630,7 @@ void reply_lockingX(struct smb_request *req)
                return;
        }
 
-       data = smb_buf(req->inbuf);
+       data = req->buf;
 
        if (locktype & LOCKING_ANDX_CHANGE_LOCKTYPE) {
                /* we don't support these - and CANCEL_LOCK makes w2k
index 02931e49f4ce5f6e9d62be1ab60326f468aa1a95..12fa5e09844ef373659390a629bb2d8beecb8ea8 100644 (file)
@@ -1161,7 +1161,7 @@ static NTSTATUS check_spnego_blob_complete(uint16 smbpid, uint16 vuid,
 
 static void reply_sesssetup_and_X_spnego(struct smb_request *req)
 {
-       uint8 *p;
+       const uint8 *p;
        DATA_BLOB blob1;
        size_t bufrem;
        fstring native_os, native_lanman, primary_domain;
@@ -1185,7 +1185,7 @@ static void reply_sesssetup_and_X_spnego(struct smb_request *req)
 
        }
 
-       p = (uint8 *)smb_buf(req->inbuf);
+       p = req->buf;
 
        if (data_blob_len == 0) {
                /* an invalid request */
@@ -1454,16 +1454,15 @@ void reply_sesssetup_and_X(struct smb_request *req)
                }
 
                if (doencrypt) {
-                       lm_resp = data_blob(smb_buf(req->inbuf), passlen1);
+                       lm_resp = data_blob(req->buf, passlen1);
                } else {
-                       plaintext_password = data_blob(smb_buf(req->inbuf),
-                                                      passlen1+1);
+                       plaintext_password = data_blob(req->buf, passlen1+1);
                        /* Ensure null termination */
                        plaintext_password.data[passlen1] = 0;
                }
 
                srvstr_pull_buf(req->inbuf, req->flags2, user,
-                               smb_buf(req->inbuf)+passlen1, sizeof(user),
+                               req->buf + passlen1, sizeof(user),
                                STR_TERMINATE);
                *domain = 0;
 
@@ -1471,8 +1470,8 @@ void reply_sesssetup_and_X(struct smb_request *req)
                uint16 passlen1 = SVAL(req->inbuf,smb_vwv7);
                uint16 passlen2 = SVAL(req->inbuf,smb_vwv8);
                enum remote_arch_types ra_type = get_remote_arch();
-               char *p = smb_buf(req->inbuf);
-               char *save_p = smb_buf(req->inbuf);
+               const uint8_t *p = req->buf;
+               const uint8_t *save_p = req->buf;
                uint16 byte_count;
 
 
@@ -1557,7 +1556,7 @@ void reply_sesssetup_and_X(struct smb_request *req)
                                                        req->inbuf,
                                                        req->flags2,
                                                        &pass,
-                                                       smb_buf(req->inbuf),
+                                                       req->buf,
                                                        passlen1,
                                                        STR_TERMINATE|STR_ASCII);
                        } else {
@@ -1565,7 +1564,7 @@ void reply_sesssetup_and_X(struct smb_request *req)
                                                        req->inbuf,
                                                        req->flags2,
                                                        &pass,
-                                                       smb_buf(req->inbuf),
+                                                       req->buf,
                                                        unic ? passlen2 : passlen1,
                                                        STR_TERMINATE);
                        }