smbd: Remove unused "pcd" arg from smb1_srv_send()

Looks larger than it is, "git clang-format" added a few lines

Signed-off-by: Volker Lendecke <vl@samba.org>
Reviewed-by: Jeremy Allison <jra@samba.org>

diff --git a/source3/smbd/proto.h b/source3/smbd/proto.h
index 3b0dc27a9c7d974908260217f54ea9bdf5cf789b..11c5f3a22722022a0f8111adf96061746a9abada 100644 (file)
--- a/source3/smbd/proto.h
+++ b/source3/smbd/proto.h
@@ -865,10 +865,11 @@ NTSTATUS make_default_filesystem_acl(
 /* The following definitions come from smbd/smb2_process.c  */
 
 #if !defined(WITH_SMB1SERVER)
-bool smb1_srv_send(struct smbXsrv_connection *xconn, char *buffer,
-                  bool do_signing, uint32_t seqnum,
-                  bool do_encrypt,
-                  struct smb_perfcount_data *pcd);
+bool smb1_srv_send(struct smbXsrv_connection *xconn,
+                  char *buffer,
+                  bool do_signing,
+                  uint32_t seqnum,
+                  bool do_encrypt);
 #endif
 size_t srv_smb1_set_message(char *buf,
                       size_t num_words,

diff --git a/source3/smbd/smb1_aio.c b/source3/smbd/smb1_aio.c
index 8807fde42b3363d253b0dd8e86dc4c94d095fe7e..d54a37273120047fa198a1e18234df6f799cab96 100644 (file)
--- a/source3/smbd/smb1_aio.c
+++ b/source3/smbd/smb1_aio.c
@@ -179,9 +179,11 @@ static void aio_pread_smb1_done(struct tevent_req *req)
        _smb_setlen_large(outbuf, outsize);
 
        show_msg(outbuf);
-       if (!smb1_srv_send(aio_ex->smbreq->xconn, outbuf,
-                         true, aio_ex->smbreq->seqnum+1,
-                         IS_CONN_ENCRYPTED(fsp->conn), NULL)) {
+       if (!smb1_srv_send(aio_ex->smbreq->xconn,
+                          outbuf,
+                          true,
+                          aio_ex->smbreq->seqnum + 1,
+                          IS_CONN_ENCRYPTED(fsp->conn))) {
                exit_server_cleanly("handle_aio_read_complete: smb1_srv_send "
                                    "failed.");
        }
@@ -292,10 +294,10 @@ NTSTATUS schedule_aio_write_and_X(connection_struct *conn,
                 SSVAL(aio_ex->outbuf.data,smb_vwv4,(numtowrite>>16)&1);
                show_msg((char *)aio_ex->outbuf.data);
                if (!smb1_srv_send(aio_ex->smbreq->xconn,
-                               (char *)aio_ex->outbuf.data,
-                               true, aio_ex->smbreq->seqnum+1,
-                               IS_CONN_ENCRYPTED(fsp->conn),
-                               &aio_ex->smbreq->pcd)) {
+                                  (char *)aio_ex->outbuf.data,
+                                  true,
+                                  aio_ex->smbreq->seqnum + 1,
+                                  IS_CONN_ENCRYPTED(fsp->conn))) {
                        exit_server_cleanly("schedule_aio_write_and_X: "
                                            "smb1_srv_send failed.");
                }
@@ -389,10 +391,11 @@ static void aio_pwrite_smb1_done(struct tevent_req *req)
        }
 
        show_msg(outbuf);
-       if (!smb1_srv_send(aio_ex->smbreq->xconn, outbuf,
-                         true, aio_ex->smbreq->seqnum+1,
-                         IS_CONN_ENCRYPTED(fsp->conn),
-                         NULL)) {
+       if (!smb1_srv_send(aio_ex->smbreq->xconn,
+                          outbuf,
+                          true,
+                          aio_ex->smbreq->seqnum + 1,
+                          IS_CONN_ENCRYPTED(fsp->conn))) {
                exit_server_cleanly("handle_aio_write_complete: "
                                    "smb1_srv_send failed.");
        }

diff --git a/source3/smbd/smb1_ipc.c b/source3/smbd/smb1_ipc.c
index 1f289e4fc3af84899c93fd892af6b131bc8ecc05..ec25a540a7013b8d04f595640def918c9f9a86bc 100644 (file)
--- a/source3/smbd/smb1_ipc.c
+++ b/source3/smbd/smb1_ipc.c
@@ -141,9 +141,11 @@ void send_trans_reply(connection_struct *conn,
        }
 
        show_msg((char *)req->outbuf);
-       if (!smb1_srv_send(xconn, (char *)req->outbuf,
-                         true, req->seqnum+1,
-                         IS_CONN_ENCRYPTED(conn), &req->pcd)) {
+       if (!smb1_srv_send(xconn,
+                          (char *)req->outbuf,
+                          true,
+                          req->seqnum + 1,
+                          IS_CONN_ENCRYPTED(conn))) {
                exit_server_cleanly("send_trans_reply: smb1_srv_send failed.");
        }
 
@@ -201,11 +203,14 @@ void send_trans_reply(connection_struct *conn,
                }
 
                show_msg((char *)req->outbuf);
-               if (!smb1_srv_send(xconn, (char *)req->outbuf,
-                                 true, req->seqnum+1,
-                                 IS_CONN_ENCRYPTED(conn), &req->pcd))
+               if (!smb1_srv_send(xconn,
+                                  (char *)req->outbuf,
+                                  true,
+                                  req->seqnum + 1,
+                                  IS_CONN_ENCRYPTED(conn))) {
                        exit_server_cleanly("send_trans_reply: smb1_srv_send "
                                            "failed.");
+               }
 
                tot_data_sent  += this_ldata;
                tot_param_sent += this_lparam;
@@ -330,14 +335,14 @@ static void api_dcerpc_cmd_write_done(struct tevent_req *subreq)
        return;
 
  send:
-       if (!smb1_srv_send(
-                   req->xconn, (char *)req->outbuf,
-                   true, req->seqnum+1,
-                   IS_CONN_ENCRYPTED(req->conn) || req->encrypted,
-                   &req->pcd)) {
-               exit_server_cleanly("api_dcerpc_cmd_write_done: "
-                                   "smb1_srv_send failed.");
-       }
+        if (!smb1_srv_send(req->xconn,
+                           (char *)req->outbuf,
+                           true,
+                           req->seqnum + 1,
+                           IS_CONN_ENCRYPTED(req->conn) || req->encrypted)) {
+                exit_server_cleanly("api_dcerpc_cmd_write_done: "
+                                    "smb1_srv_send failed.");
+        }
        TALLOC_FREE(req);
 }
 
@@ -364,10 +369,12 @@ static void api_dcerpc_cmd_read_done(struct tevent_req *subreq)
                           NT_STATUS_EQUAL(old, status)?"":nt_errstr(status)));
                reply_nterror(req, status);
 
-               if (!smb1_srv_send(req->xconn, (char *)req->outbuf,
-                                 true, req->seqnum+1,
-                                 IS_CONN_ENCRYPTED(req->conn)
-                                 ||req->encrypted, &req->pcd)) {
+               if (!smb1_srv_send(req->xconn,
+                                  (char *)req->outbuf,
+                                  true,
+                                  req->seqnum + 1,
+                                  IS_CONN_ENCRYPTED(req->conn) ||
+                                          req->encrypted)) {
                        exit_server_cleanly("api_dcerpc_cmd_read_done: "
                                            "smb1_srv_send failed.");
                }

diff --git a/source3/smbd/smb1_negprot.c b/source3/smbd/smb1_negprot.c
index db6cf629d9c5c77d60dfdae646eeece31b52a9b0..9b4b51e4b55d9d52e8867a5472d842ceec6aa070 100644 (file)
--- a/source3/smbd/smb1_negprot.c
+++ b/source3/smbd/smb1_negprot.c
@@ -667,8 +667,7 @@ void reply_negprot(struct smb_request *req)
                reply_smb1_outbuf(req, 1, 0);
                SSVAL(req->outbuf, smb_vwv0, NO_PROTOCOL_CHOSEN);
 
-               ok = smb1_srv_send(xconn, (char *)req->outbuf,
-                                 false, 0, false, NULL);
+               ok = smb1_srv_send(xconn, (char *)req->outbuf, false, 0, false);
                if (!ok) {
                        DBG_NOTICE("smb1_srv_send failed\n");
                }

diff --git a/source3/smbd/smb1_nttrans.c b/source3/smbd/smb1_nttrans.c
index 1e2a7961d01fde014ef02413fff66e4c318c841e..660d5e820abecd871471879b0c119148f14be964 100644 (file)
--- a/source3/smbd/smb1_nttrans.c
+++ b/source3/smbd/smb1_nttrans.c
@@ -84,10 +84,10 @@ static void send_nt_replies(connection_struct *conn,
                }
                show_msg((char *)req->outbuf);
                if (!smb1_srv_send(xconn,
-                               (char *)req->outbuf,
-                               true, req->seqnum+1,
-                               IS_CONN_ENCRYPTED(conn),
-                               &req->pcd)) {
+                                  (char *)req->outbuf,
+                                  true,
+                                  req->seqnum + 1,
+                                  IS_CONN_ENCRYPTED(conn))) {
                        exit_server_cleanly("send_nt_replies: smb1_srv_send failed.");
                }
                TALLOC_FREE(req->outbuf);
@@ -248,10 +248,10 @@ static void send_nt_replies(connection_struct *conn,
                /* Send the packet */
                show_msg((char *)req->outbuf);
                if (!smb1_srv_send(xconn,
-                               (char *)req->outbuf,
-                               true, req->seqnum+1,
-                               IS_CONN_ENCRYPTED(conn),
-                               &req->pcd)) {
+                                  (char *)req->outbuf,
+                                  true,
+                                  req->seqnum + 1,
+                                  IS_CONN_ENCRYPTED(conn))) {
                        exit_server_cleanly("send_nt_replies: smb1_srv_send failed.");
                }
 

diff --git a/source3/smbd/smb1_oplock.c b/source3/smbd/smb1_oplock.c
index 6425eff67b295124929f5374115726f9f83686ad..5b8a09b2b73e2b8e594474ab7ece8b926e69ebb4 100644 (file)
--- a/source3/smbd/smb1_oplock.c
+++ b/source3/smbd/smb1_oplock.c
@@ -62,9 +62,10 @@ void send_break_message_smb1(files_struct *fsp, int level)
 
        show_msg(break_msg);
        if (!smb1_srv_send(xconn,
-                       break_msg, false, 0,
-                       IS_CONN_ENCRYPTED(fsp->conn),
-                       NULL)) {
+                          break_msg,
+                          false,
+                          0,
+                          IS_CONN_ENCRYPTED(fsp->conn))) {
                exit_server_cleanly("send_break_message_smb1: "
                        "smb1_srv_send failed.");
        }

diff --git a/source3/smbd/smb1_pipes.c b/source3/smbd/smb1_pipes.c
index 21ec2df5c381960709d337edad045314d766608e..6daafccdd068c7e9c45edefa06d070c18b5cf910 100644 (file)
--- a/source3/smbd/smb1_pipes.c
+++ b/source3/smbd/smb1_pipes.c
@@ -446,11 +446,12 @@ static void pipe_write_done(struct tevent_req *subreq)
        DEBUG(3,("write-IPC nwritten=%d\n", (int)nwritten));
 
  send:
-       if (!smb1_srv_send(req->xconn, (char *)req->outbuf,
-                         true, req->seqnum+1,
-                         IS_CONN_ENCRYPTED(req->conn)||req->encrypted,
-                         &req->pcd)) {
-               exit_server_cleanly("construct_reply: smb1_srv_send failed.");
-       }
+        if (!smb1_srv_send(req->xconn,
+                           (char *)req->outbuf,
+                           true,
+                           req->seqnum + 1,
+                           IS_CONN_ENCRYPTED(req->conn) || req->encrypted)) {
+                exit_server_cleanly("construct_reply: smb1_srv_send failed.");
+        }
        TALLOC_FREE(req);
 }

diff --git a/source3/smbd/smb1_process.c b/source3/smbd/smb1_process.c
index accda5368c4f8c61deb721b8805c5a7589f0d2b6..0d2724fcff05f0abca99f0251b05300c6f59c79d 100644 (file)
--- a/source3/smbd/smb1_process.c
+++ b/source3/smbd/smb1_process.c
@@ -208,10 +208,11 @@ void smbd_unlock_socket(struct smbXsrv_connection *xconn)
  Send an smb to a fd.
 ****************************************************************************/
 
-bool smb1_srv_send(struct smbXsrv_connection *xconn, char *buffer,
-                  bool do_signing, uint32_t seqnum,
-                  bool do_encrypt,
-                  struct smb_perfcount_data *pcd)
+bool smb1_srv_send(struct smbXsrv_connection *xconn,
+                  char *buffer,
+                  bool do_signing,
+                  uint32_t seqnum,
+                  bool do_encrypt)
 {
        size_t len = 0;
        ssize_t ret;
@@ -1349,8 +1350,7 @@ static void construct_reply_chain(struct smbXsrv_connection *xconn,
                char errbuf[smb_size];
                error_packet(errbuf, 0, 0, NT_STATUS_INVALID_PARAMETER,
                             __LINE__, __FILE__);
-               if (!smb1_srv_send(xconn, errbuf, true, seqnum, encrypted,
-                                 NULL)) {
+               if (!smb1_srv_send(xconn, errbuf, true, seqnum, encrypted)) {
                        exit_server_cleanly("construct_reply_chain: "
                                            "smb1_srv_send failed.");
                }
@@ -1472,10 +1472,11 @@ void smb_request_done(struct smb_request *req)
 
 shipit:
        if (!smb1_srv_send(first_req->xconn,
-                         (char *)first_req->outbuf,
-                         true, first_req->seqnum+1,
-                         IS_CONN_ENCRYPTED(req->conn)||first_req->encrypted,
-                         &first_req->pcd)) {
+                          (char *)first_req->outbuf,
+                          true,
+                          first_req->seqnum + 1,
+                          IS_CONN_ENCRYPTED(req->conn) ||
+                                  first_req->encrypted)) {
                exit_server_cleanly("construct_reply_chain: smb1_srv_send "
                                    "failed.");
        }
@@ -1487,9 +1488,11 @@ error:
        {
                char errbuf[smb_size];
                error_packet(errbuf, 0, 0, status, __LINE__, __FILE__);
-               if (!smb1_srv_send(req->xconn, errbuf, true,
-                                 req->seqnum+1, req->encrypted,
-                                 NULL)) {
+               if (!smb1_srv_send(req->xconn,
+                                  errbuf,
+                                  true,
+                                  req->seqnum + 1,
+                                  req->encrypted)) {
                        exit_server_cleanly("construct_reply_chain: "
                                            "smb1_srv_send failed.");
                }
@@ -2421,10 +2424,7 @@ static bool smbd_echo_reply(struct smbd_echo_state *state,
                memcpy(smb_buf(req.outbuf), req.buf, req.buflen);
        }
 
-       ok = smb1_srv_send(req.xconn,
-                         (char *)outbuf,
-                         true, seqnum+1,
-                         false, &req.pcd);
+       ok = smb1_srv_send(req.xconn, (char *)outbuf, true, seqnum + 1, false);
        TALLOC_FREE(outbuf);
        if (!ok) {
                exit(1);

diff --git a/source3/smbd/smb1_process.h b/source3/smbd/smb1_process.h
index 53074e090f6f19d0221f5cc4f1ebd9107e5c5dc2..59e37283697eebe090ce03a936707242aac4eef5 100644 (file)
--- a/source3/smbd/smb1_process.h
+++ b/source3/smbd/smb1_process.h
@@ -18,10 +18,11 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-bool smb1_srv_send(struct smbXsrv_connection *xconn, char *buffer,
-                  bool do_signing, uint32_t seqnum,
-                  bool do_encrypt,
-                  struct smb_perfcount_data *pcd);
+bool smb1_srv_send(struct smbXsrv_connection *xconn,
+                  char *buffer,
+                  bool do_signing,
+                  uint32_t seqnum,
+                  bool do_encrypt);
 NTSTATUS allow_new_trans(struct trans_state *list, uint64_t mid);
 void smb_request_done(struct smb_request *req);
 const char *smb_fn_name(int type);

diff --git a/source3/smbd/smb1_reply.c b/source3/smbd/smb1_reply.c
index ee4752ff526f0487219e0b8b8023ca6105ebc9f6..652ff328b414ddb14452e25c6a0804872877bd69 100644 (file)
--- a/source3/smbd/smb1_reply.c
+++ b/source3/smbd/smb1_reply.c
@@ -3097,11 +3097,10 @@ static void reply_lockread_locked(struct tevent_req *subreq)
 
 send:
        ok = smb1_srv_send(req->xconn,
-                         (char *)req->outbuf,
-                         true,
-                         req->seqnum+1,
-                         IS_CONN_ENCRYPTED(req->conn),
-                         NULL);
+                          (char *)req->outbuf,
+                          true,
+                          req->seqnum + 1,
+                          IS_CONN_ENCRYPTED(req->conn));
        if (!ok) {
                exit_server_cleanly("reply_lock_done: smb1_srv_send failed.");
        }
@@ -3826,10 +3825,10 @@ void reply_writebraw(struct smb_request *req)
        SSVALS(buf,smb_vwv0,0xFFFF);
        show_msg(buf);
        if (!smb1_srv_send(req->xconn,
-                         buf,
-                         false, 0, /* no signing */
-                         IS_CONN_ENCRYPTED(conn),
-                         &req->pcd)) {
+                          buf,
+                          false,
+                          0, /* no signing */
+                          IS_CONN_ENCRYPTED(conn))) {
                exit_server_cleanly("reply_writebraw: smb1_srv_send "
                        "failed.");
        }
@@ -5281,11 +5280,10 @@ static void reply_lock_done(struct tevent_req *subreq)
        }
 
        ok = smb1_srv_send(req->xconn,
-                         (char *)req->outbuf,
-                         true,
-                         req->seqnum+1,
-                         IS_CONN_ENCRYPTED(req->conn),
-                         NULL);
+                          (char *)req->outbuf,
+                          true,
+                          req->seqnum + 1,
+                          IS_CONN_ENCRYPTED(req->conn));
        if (!ok) {
                exit_server_cleanly("reply_lock_done: smb1_srv_send failed.");
        }
@@ -5571,15 +5569,11 @@ static void reply_tdis_done(struct tevent_req *req)
 void reply_echo(struct smb_request *req)
 {
        connection_struct *conn = req->conn;
-       struct smb_perfcount_data local_pcd;
-       struct smb_perfcount_data *cur_pcd;
        int smb_reverb;
        int seq_num;
 
        START_PROFILE(SMBecho);
 
-       smb_init_perfcount_data(&local_pcd);
-
        if (req->wct < 1) {
                reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
                END_PROFILE(SMBecho);
@@ -5602,21 +5596,14 @@ void reply_echo(struct smb_request *req)
 
        for (seq_num = 1 ; seq_num <= smb_reverb ; seq_num++) {
 
-               /* this makes sure we catch the request pcd */
-               if (seq_num == smb_reverb) {
-                       cur_pcd = &req->pcd;
-               } else {
-                       cur_pcd = &local_pcd;
-               }
-
                SSVAL(req->outbuf,smb_vwv0,seq_num);
 
                show_msg((char *)req->outbuf);
                if (!smb1_srv_send(req->xconn,
-                               (char *)req->outbuf,
-                               true, req->seqnum+1,
-                               IS_CONN_ENCRYPTED(conn)||req->encrypted,
-                               cur_pcd))
+                                  (char *)req->outbuf,
+                                  true,
+                                  req->seqnum + 1,
+                                  IS_CONN_ENCRYPTED(conn) || req->encrypted))
                        exit_server_cleanly("reply_echo: smb1_srv_send failed.");
        }
 
@@ -6690,11 +6677,10 @@ static void reply_lockingx_done(struct tevent_req *subreq)
        }
 
        ok = smb1_srv_send(req->xconn,
-                         (char *)req->outbuf,
-                         true,
-                         req->seqnum+1,
-                         IS_CONN_ENCRYPTED(req->conn),
-                         NULL);
+                          (char *)req->outbuf,
+                          true,
+                          req->seqnum + 1,
+                          IS_CONN_ENCRYPTED(req->conn));
        if (!ok) {
                exit_server_cleanly("reply_lock_done: smb1_srv_send failed.");
        }

diff --git a/source3/smbd/smb1_trans2.c b/source3/smbd/smb1_trans2.c
index e65a538692b8e70755a7e52fe9b651afe574a03c..8a42591987faf54c7a1c59abf4a9f26989442476 100644 (file)
--- a/source3/smbd/smb1_trans2.c
+++ b/source3/smbd/smb1_trans2.c
@@ -109,10 +109,10 @@ static void send_trans2_replies(connection_struct *conn,
                }
                show_msg((char *)req->outbuf);
                if (!smb1_srv_send(xconn,
-                               (char *)req->outbuf,
-                               true, req->seqnum+1,
-                               IS_CONN_ENCRYPTED(conn),
-                               &req->pcd)) {
+                                  (char *)req->outbuf,
+                                  true,
+                                  req->seqnum + 1,
+                                  IS_CONN_ENCRYPTED(conn))) {
                        exit_server_cleanly("send_trans2_replies: smb1_srv_send failed.");
                }
                TALLOC_FREE(req->outbuf);
@@ -249,11 +249,12 @@ static void send_trans2_replies(connection_struct *conn,
                /* Send the packet */
                show_msg((char *)req->outbuf);
                if (!smb1_srv_send(xconn,
-                               (char *)req->outbuf,
-                               true, req->seqnum+1,
-                               IS_CONN_ENCRYPTED(conn),
-                               &req->pcd))
+                                  (char *)req->outbuf,
+                                  true,
+                                  req->seqnum + 1,
+                                  IS_CONN_ENCRYPTED(conn))) {
                        exit_server_cleanly("send_trans2_replies: smb1_srv_send failed.");
+               }
 
                TALLOC_FREE(req->outbuf);
 
@@ -428,13 +429,11 @@ static void smb_set_posix_lock_done(struct tevent_req *subreq)
                        0xffff);
        } else {
                reply_nterror(req, status);
-               ok = smb1_srv_send(
-                       req->xconn,
-                       (char *)req->outbuf,
-                       true,
-                       req->seqnum+1,
-                       IS_CONN_ENCRYPTED(req->conn),
-                       NULL);
+               ok = smb1_srv_send(req->xconn,
+                                  (char *)req->outbuf,
+                                  true,
+                                  req->seqnum + 1,
+                                  IS_CONN_ENCRYPTED(req->conn));
                if (!ok) {
                        exit_server_cleanly("smb_set_posix_lock_done: "
                                            "smb1_srv_send failed.");

diff --git a/source3/smbd/smb2_negprot.c b/source3/smbd/smb2_negprot.c
index c13f472c4e9121097a8dad94370f75b37553e459..5ac004bb27607a7ce1e013f6c7e315e97fc77dbc 100644 (file)
--- a/source3/smbd/smb2_negprot.c
+++ b/source3/smbd/smb2_negprot.c
@@ -1180,8 +1180,7 @@ NTSTATUS smb2_multi_protocol_reply_negprot(struct smb_request *req)
                reply_smb1_outbuf(req, 1, 0);
                SSVAL(req->outbuf, smb_vwv0, NO_PROTOCOL_CHOSEN);
 
-               ok = smb1_srv_send(xconn, (char *)req->outbuf,
-                                 false, 0, false, NULL);
+               ok = smb1_srv_send(xconn, (char *)req->outbuf, false, 0, false);
                if (!ok) {
                        DBG_NOTICE("smb1_srv_send failed\n");
                }

diff --git a/source3/smbd/smb2_process.c b/source3/smbd/smb2_process.c
index dde64ff57c5f2a5dad3d8aca3aed7744ee2a1eb8..d9e477aa940a4bab4223af0719caedf97f29e1dd 100644 (file)
--- a/source3/smbd/smb2_process.c
+++ b/source3/smbd/smb2_process.c
@@ -67,10 +67,11 @@ static struct pending_message_list *get_deferred_open_message_smb(
        struct smbd_server_connection *sconn, uint64_t mid);
 
 #if !defined(WITH_SMB1SERVER)
-bool smb1_srv_send(struct smbXsrv_connection *xconn, char *buffer,
-                  bool do_signing, uint32_t seqnum,
-                  bool do_encrypt,
-                  struct smb_perfcount_data *pcd)
+bool smb1_srv_send(struct smbXsrv_connection *xconn,
+                  char *buffer,
+                  bool do_signing,
+                  uint32_t seqnum,
+                  bool do_encrypt)
 {
        size_t len = 0;
        ssize_t ret;
@@ -806,9 +807,10 @@ static void construct_reply_smb1negprot(struct smbXsrv_connection *xconn,
        if (!NT_STATUS_IS_OK(status)) {
                if (!smb1_srv_send(req->xconn,
                                   (char *)req->outbuf,
-                                  true, req->seqnum+1,
-                                  IS_CONN_ENCRYPTED(req->conn)||req->encrypted,
-                                  &req->pcd)) {
+                                  true,
+                                  req->seqnum + 1,
+                                  IS_CONN_ENCRYPTED(req->conn) ||
+                                          req->encrypted)) {
                        exit_server_cleanly("construct_reply_smb1negprot: "
                                            "smb1_srv_send failed.");
                }
@@ -1816,8 +1818,7 @@ void smbd_process(struct tevent_context *ev_ctx,
                 * name"
                 */
                unsigned char buf[5] = {0x83, 0, 0, 1, 0x81};
-               (void)smb1_srv_send(xconn,(char *)buf, false,
-                                   0, false, NULL);
+               (void)smb1_srv_send(xconn, (char *)buf, false, 0, false);
                exit_server_cleanly("connection denied");
        } else if (!NT_STATUS_IS_OK(status)) {
                exit_server_cleanly(nt_errstr(status));

diff --git a/source3/smbd/smb2_reply.c b/source3/smbd/smb2_reply.c
index ba0b38c7d6f57cdf3d3fffe6b1161eb581bd6713..f361ddcdefe48a1ced0b2456b91abf481a721c54 100644 (file)
--- a/source3/smbd/smb2_reply.c
+++ b/source3/smbd/smb2_reply.c
@@ -656,8 +656,7 @@ static bool netbios_session_retarget(struct smbXsrv_connection *xconn,
        *(uint32_t *)(outbuf+4) = in_addr->sin_addr.s_addr;
        *(uint16_t *)(outbuf+8) = htons(retarget_port);
 
-       if (!smb1_srv_send(xconn, (char *)outbuf, false, 0, false,
-                         NULL)) {
+       if (!smb1_srv_send(xconn, (char *)outbuf, false, 0, false)) {
                exit_server_cleanly("netbios_session_retarget: smb1_srv_send "
                                    "failed.");
        }
@@ -815,7 +814,7 @@ void reply_special(struct smbXsrv_connection *xconn, char *inbuf, size_t inbuf_s
        DEBUG(5,("init msg_type=0x%x msg_flags=0x%x\n",
                    msg_type, msg_flags));
 
-       if (!smb1_srv_send(xconn, outbuf, false, 0, false, NULL)) {
+       if (!smb1_srv_send(xconn, outbuf, false, 0, false)) {
                exit_server_cleanly("reply_special: smb1_srv_send failed.");
        }