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_close_state {
      27             :         uint8_t fixed[24];
      28             : };
      29             : 
      30             : static void smb2cli_close_done(struct tevent_req *subreq);
      31             : 
      32       77644 : struct tevent_req *smb2cli_close_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             :                                       uint16_t flags,
      39             :                                       uint64_t fid_persistent,
      40             :                                       uint64_t fid_volatile)
      41             : {
      42         524 :         struct tevent_req *req, *subreq;
      43         524 :         struct smb2cli_close_state *state;
      44         524 :         uint8_t *fixed;
      45             : 
      46       77644 :         req = tevent_req_create(mem_ctx, &state,
      47             :                                 struct smb2cli_close_state);
      48       77644 :         if (req == NULL) {
      49           0 :                 return NULL;
      50             :         }
      51       77644 :         fixed = state->fixed;
      52       77644 :         SSVAL(fixed, 0, 24);
      53       77644 :         SSVAL(fixed, 2, flags);
      54       77644 :         SBVAL(fixed, 8, fid_persistent);
      55       77644 :         SBVAL(fixed, 16, fid_volatile);
      56             : 
      57       78168 :         subreq = smb2cli_req_send(state, ev, conn, SMB2_OP_CLOSE,
      58             :                                   0, 0, /* flags */
      59             :                                   timeout_msec,
      60             :                                   tcon,
      61             :                                   session,
      62       77644 :                                   state->fixed, sizeof(state->fixed),
      63             :                                   NULL, 0, /* dyn* */
      64             :                                   0); /* max_dyn_len */
      65       77644 :         if (tevent_req_nomem(subreq, req)) {
      66           0 :                 return tevent_req_post(req, ev);
      67             :         }
      68       77644 :         tevent_req_set_callback(subreq, smb2cli_close_done, req);
      69       77644 :         return req;
      70             : }
      71             : 
      72       70891 : static void smb2cli_close_done(struct tevent_req *subreq)
      73             : {
      74          62 :         struct tevent_req *req =
      75       70891 :                 tevent_req_callback_data(subreq,
      76             :                 struct tevent_req);
      77          62 :         NTSTATUS status;
      78          62 :         static const struct smb2cli_req_expected_response expected[] = {
      79             :         {
      80             :                 .status = NT_STATUS_OK,
      81             :                 .body_size = 0x3C
      82             :         }
      83             :         };
      84             : 
      85       70891 :         status = smb2cli_req_recv(subreq, NULL, NULL,
      86             :                                   expected, ARRAY_SIZE(expected));
      87       70891 :         TALLOC_FREE(subreq);
      88       70891 :         if (tevent_req_nterror(req, status)) {
      89          11 :                 return;
      90             :         }
      91       70880 :         tevent_req_done(req);
      92             : }
      93             : 
      94       70620 : NTSTATUS smb2cli_close_recv(struct tevent_req *req)
      95             : {
      96       70620 :         return tevent_req_simple_recv_ntstatus(req);
      97             : }
      98             : 
      99       13754 : NTSTATUS smb2cli_close(struct smbXcli_conn *conn,
     100             :                        uint32_t timeout_msec,
     101             :                        struct smbXcli_session *session,
     102             :                        struct smbXcli_tcon *tcon,
     103             :                        uint16_t flags,
     104             :                        uint64_t fid_persistent,
     105             :                        uint64_t fid_volatile)
     106             : {
     107       13754 :         TALLOC_CTX *frame = talloc_stackframe();
     108           0 :         struct tevent_context *ev;
     109           0 :         struct tevent_req *req;
     110       13754 :         NTSTATUS status = NT_STATUS_NO_MEMORY;
     111             : 
     112       13754 :         if (smbXcli_conn_has_async_calls(conn)) {
     113             :                 /*
     114             :                  * Can't use sync call while an async call is in flight
     115             :                  */
     116           0 :                 status = NT_STATUS_INVALID_PARAMETER;
     117           0 :                 goto fail;
     118             :         }
     119       13754 :         ev = samba_tevent_context_init(frame);
     120       13754 :         if (ev == NULL) {
     121           0 :                 goto fail;
     122             :         }
     123       13754 :         req = smb2cli_close_send(frame, ev, conn, timeout_msec,
     124             :                                  session, tcon, flags,
     125             :                                  fid_persistent, fid_volatile);
     126       13754 :         if (req == NULL) {
     127           0 :                 goto fail;
     128             :         }
     129       13754 :         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
     130           0 :                 goto fail;
     131             :         }
     132       13754 :         status = smb2cli_close_recv(req);
     133       13754 :  fail:
     134       13754 :         TALLOC_FREE(frame);
     135       13754 :         return status;
     136             : }