Line data    Source code

       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             :    smb2 lib
       4             :    Copyright (C) Volker Lendecke 2011
       5             : 
       6             :    This program is free software; you can redistribute it and/or modify
       7             :    it under the terms of the GNU General Public License as published by
       8             :    the Free Software Foundation; either version 3 of the License, or
       9             :    (at your option) any later version.
      10             : 
      11             :    This program is distributed in the hope that it will be useful,
      12             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             :    GNU General Public License for more details.
      15             : 
      16             :    You should have received a copy of the GNU General Public License
      17             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      18             : */
      19             : 
      20             : #include "includes.h"
      21             : #include "system/network.h"
      22             : #include "lib/util/tevent_ntstatus.h"
      23             : #include "smb_common.h"
      24             : #include "smbXcli_base.h"
      25             : 
      26             : struct smb2cli_flush_state {
      27             :         uint8_t fixed[24];
      28             : };
      29             : 
      30             : static void smb2cli_flush_done(struct tevent_req *subreq);
      31             : 
      32          74 : struct tevent_req *smb2cli_flush_send(TALLOC_CTX *mem_ctx,
      33             :                                        struct tevent_context *ev,
      34             :                                        struct smbXcli_conn *conn,
      35             :                                        uint32_t timeout_msec,
      36             :                                        struct smbXcli_session *session,
      37             :                                        struct smbXcli_tcon *tcon,
      38             :                                        uint64_t fid_persistent,
      39             :                                        uint64_t fid_volatile)
      40             : {
      41           0 :         struct tevent_req *req, *subreq;
      42           0 :         struct smb2cli_flush_state *state;
      43           0 :         uint8_t *fixed;
      44             : 
      45          74 :         req = tevent_req_create(mem_ctx, &state,
      46             :                                 struct smb2cli_flush_state);
      47          74 :         if (req == NULL) {
      48           0 :                 return NULL;
      49             :         }
      50          74 :         fixed = state->fixed;
      51          74 :         SSVAL(fixed, 0, 24);
      52          74 :         SBVAL(fixed, 8, fid_persistent);
      53          74 :         SBVAL(fixed, 16, fid_volatile);
      54             : 
      55          74 :         subreq = smb2cli_req_send(state, ev, conn, SMB2_OP_FLUSH,
      56             :                                   0, 0, /* flags */
      57             :                                   timeout_msec,
      58             :                                   tcon,
      59             :                                   session,
      60          74 :                                   state->fixed, sizeof(state->fixed),
      61             :                                   NULL, 0, /* dyn* */
      62             :                                   0); /* max_dyn_len */
      63          74 :         if (tevent_req_nomem(subreq, req)) {
      64           0 :                 return tevent_req_post(req, ev);
      65             :         }
      66          74 :         tevent_req_set_callback(subreq, smb2cli_flush_done, req);
      67          74 :         return req;
      68             : }
      69             : 
      70          74 : static void smb2cli_flush_done(struct tevent_req *subreq)
      71             : {
      72           0 :         struct tevent_req *req =
      73          74 :                 tevent_req_callback_data(subreq,
      74             :                 struct tevent_req);
      75           0 :         NTSTATUS status;
      76           0 :         static const struct smb2cli_req_expected_response expected[] = {
      77             :         {
      78             :                 .status = NT_STATUS_OK,
      79             :                 .body_size = 0x04
      80             :         }
      81             :         };
      82             : 
      83          74 :         status = smb2cli_req_recv(subreq, NULL, NULL,
      84             :                                   expected, ARRAY_SIZE(expected));
      85          74 :         TALLOC_FREE(subreq);
      86          74 :         if (tevent_req_nterror(req, status)) {
      87          28 :                 return;
      88             :         }
      89          46 :         tevent_req_done(req);
      90             : }
      91             : 
      92          74 : NTSTATUS smb2cli_flush_recv(struct tevent_req *req)
      93             : {
      94          74 :         return tevent_req_simple_recv_ntstatus(req);
      95             : }
      96             : 
      97          74 : NTSTATUS smb2cli_flush(struct smbXcli_conn *conn,
      98             :                        uint32_t timeout_msec,
      99             :                        struct smbXcli_session *session,
     100             :                        struct smbXcli_tcon *tcon,
     101             :                        uint64_t fid_persistent,
     102             :                        uint64_t fid_volatile)
     103             : {
     104          74 :         TALLOC_CTX *frame = talloc_stackframe();
     105           0 :         struct tevent_context *ev;
     106           0 :         struct tevent_req *req;
     107          74 :         NTSTATUS status = NT_STATUS_NO_MEMORY;
     108             : 
     109          74 :         if (smbXcli_conn_has_async_calls(conn)) {
     110             :                 /*
     111             :                  * Can't use sync call while an async call is in flight
     112             :                  */
     113           0 :                 status = NT_STATUS_INVALID_PARAMETER;
     114           0 :                 goto fail;
     115             :         }
     116          74 :         ev = samba_tevent_context_init(frame);
     117          74 :         if (ev == NULL) {
     118           0 :                 goto fail;
     119             :         }
     120          74 :         req = smb2cli_flush_send(frame, ev, conn, timeout_msec,
     121             :                                  session, tcon,
     122             :                                  fid_persistent, fid_volatile);
     123          74 :         if (req == NULL) {
     124           0 :                 goto fail;
     125             :         }
     126          74 :         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
     127           0 :                 goto fail;
     128             :         }
     129          74 :         status = smb2cli_flush_recv(req);
     130          74 :  fail:
     131          74 :         TALLOC_FREE(frame);
     132          74 :         return status;
     133             : }