libcli/smb/read_smb.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Infrastructure for async SMB client requests
   4    Copyright (C) Volker Lendecke 2008
   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/async_req/async_sock.h"
  23 #include "read_smb.h"
  24 #include "lib/util/tevent_unix.h"
  25 #include "libcli/smb/smb_constants.h"
  26
  27 /*
  28  * Read an smb packet asynchronously, discard keepalives
  29  */
  30
  31 struct read_smb_state {
  32         struct tevent_context *ev;
  33         int fd;
  34         uint8_t *buf;
  35 };
  36
  37 static ssize_t read_smb_more(uint8_t *buf, size_t buflen, void *private_data);
  38 static void read_smb_done(struct tevent_req *subreq);
  39
  40 struct tevent_req *read_smb_send(TALLOC_CTX *mem_ctx,
  41                                  struct tevent_context *ev,
  42                                  int fd)
  43 {
  44         struct tevent_req *result, *subreq;
  45         struct read_smb_state *state;
  46
  47         result = tevent_req_create(mem_ctx, &state, struct read_smb_state);
  48         if (result == NULL) {
  49                 return NULL;
  50         }
  51         state->ev = ev;
  52         state->fd = fd;
  53
  54         subreq = read_packet_send(state, ev, fd, 4, read_smb_more, NULL);
  55         if (subreq == NULL) {
  56                 goto fail;
  57         }
  58         tevent_req_set_callback(subreq, read_smb_done, result);
  59         return result;
  60  fail:
  61         TALLOC_FREE(result);
  62         return NULL;
  63 }
  64
  65 static ssize_t read_smb_more(uint8_t *buf, size_t buflen, void *private_data)
  66 {
  67         if (buflen > 4) {
  68                 return 0;       /* We've been here, we're done */
  69         }
  70         return smb_len_tcp(buf);
  71 }
  72
  73 static void read_smb_done(struct tevent_req *subreq)
  74 {
  75         struct tevent_req *req = tevent_req_callback_data(
  76                 subreq, struct tevent_req);
  77         struct read_smb_state *state = tevent_req_data(
  78                 req, struct read_smb_state);
  79         ssize_t len;
  80         int err;
  81
  82         len = read_packet_recv(subreq, state, &state->buf, &err);
  83         TALLOC_FREE(subreq);
  84         if (len == -1) {
  85                 tevent_req_error(req, err);
  86                 return;
  87         }
  88
  89         if (CVAL(state->buf, 0) == NBSSkeepalive) {
  90                 subreq = read_packet_send(state, state->ev, state->fd, 4,
  91                                           read_smb_more, NULL);
  92                 if (tevent_req_nomem(subreq, req)) {
  93                         return;
  94                 }
  95                 tevent_req_set_callback(subreq, read_smb_done, req);
  96                 return;
  97         }
  98         tevent_req_done(req);
  99 }
 100
 101 ssize_t read_smb_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 102                       uint8_t **pbuf, int *perrno)
 103 {
 104         struct read_smb_state *state = tevent_req_data(
 105                 req, struct read_smb_state);
 106
 107         if (tevent_req_is_unix_error(req, perrno)) {
 108                 return -1;
 109         }
 110         *pbuf = talloc_move(mem_ctx, &state->buf);
 111         return talloc_get_size(*pbuf);
 112 }