LCOV - code coverage report
Current view: top level - source3/rpc_server - srv_pipe_hnd.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 134 160 83.8 %
Date: 2024-02-28 12:06:22 Functions: 11 11 100.0 %

          Line data    Source code
       1             : /*
       2             :  *  Unix SMB/CIFS implementation.
       3             :  *  RPC Pipe client / server routines
       4             :  *  Copyright (C) Andrew Tridgell              1992-1998,
       5             :  *  Largely re-written : 2005
       6             :  *  Copyright (C) Jeremy Allison                1998 - 2005
       7             :  *
       8             :  *  This program is free software; you can redistribute it and/or modify
       9             :  *  it under the terms of the GNU General Public License as published by
      10             :  *  the Free Software Foundation; either version 3 of the License, or
      11             :  *  (at your option) any later version.
      12             :  *
      13             :  *  This program is distributed in the hope that it will be useful,
      14             :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16             :  *  GNU General Public License for more details.
      17             :  *
      18             :  *  You should have received a copy of the GNU General Public License
      19             :  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
      20             :  */
      21             : 
      22             : #include "includes.h"
      23             : #include "fake_file.h"
      24             : #include "rpc_dce.h"
      25             : #include "ntdomain.h"
      26             : #include "rpc_server/rpc_ncacn_np.h"
      27             : #include "rpc_server/srv_pipe_hnd.h"
      28             : #include "rpc_client/local_np.h"
      29             : #include "rpc_server/rpc_server.h"
      30             : #include "rpc_server/rpc_config.h"
      31             : #include "../lib/tsocket/tsocket.h"
      32             : #include "../lib/util/tevent_ntstatus.h"
      33             : #include "librpc/ndr/ndr_table.h"
      34             : 
      35             : #undef DBGC_CLASS
      36             : #define DBGC_CLASS DBGC_RPC_SRV
      37             : 
      38      344017 : bool fsp_is_np(struct files_struct *fsp)
      39             : {
      40        7370 :         enum FAKE_FILE_TYPE type;
      41             : 
      42      344017 :         if ((fsp == NULL) || (fsp->fake_file_handle == NULL)) {
      43           0 :                 return false;
      44             :         }
      45             : 
      46      344017 :         type = fsp->fake_file_handle->type;
      47             : 
      48      344017 :         return (type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY);
      49             : }
      50             : 
      51       20464 : NTSTATUS np_open(TALLOC_CTX *mem_ctx, const char *name,
      52             :                  const struct tsocket_address *remote_client_address,
      53             :                  const struct tsocket_address *local_server_address,
      54             :                  struct auth_session_info *session_info,
      55             :                  struct tevent_context *ev_ctx,
      56             :                  struct messaging_context *msg_ctx,
      57             :                  struct dcesrv_context *dce_ctx,
      58             :                  struct fake_file_handle **phandle)
      59             : {
      60         620 :         struct fake_file_handle *handle;
      61       20464 :         struct npa_state *npa = NULL;
      62         620 :         int ret;
      63             : 
      64       20464 :         handle = talloc(mem_ctx, struct fake_file_handle);
      65       20464 :         if (handle == NULL) {
      66           0 :                 return NT_STATUS_NO_MEMORY;
      67             :         }
      68             : 
      69       20464 :         npa = npa_state_init(handle);
      70       20464 :         if (npa == NULL) {
      71           0 :                 TALLOC_FREE(handle);
      72           0 :                 return NT_STATUS_NO_MEMORY;
      73             :         }
      74       20464 :         *handle = (struct fake_file_handle) {
      75             :                 .type = FAKE_FILE_TYPE_NAMED_PIPE_PROXY,
      76             :                 .private_data = npa,
      77             :         };
      78             : 
      79       20464 :         ret = local_np_connect(
      80             :                 name,
      81             :                 NCACN_NP,
      82             :                 NULL,
      83             :                 remote_client_address,
      84             :                 NULL,
      85             :                 local_server_address,
      86             :                 session_info,
      87             :                 false,
      88             :                 npa,
      89             :                 &npa->stream);
      90       20464 :         if (ret != 0) {
      91         158 :                 DBG_DEBUG("local_np_connect failed: %s\n",
      92             :                           strerror(ret));
      93         158 :                 TALLOC_FREE(handle);
      94         158 :                 return map_nt_error_from_unix(ret);
      95             :         }
      96             : 
      97       20306 :         *phandle = handle;
      98             : 
      99       20306 :         return NT_STATUS_OK;
     100             : }
     101             : 
     102        1418 : bool np_read_in_progress(struct fake_file_handle *handle)
     103             : {
     104        1418 :         if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
     105           0 :                 struct npa_state *p =
     106        1418 :                         talloc_get_type_abort(handle->private_data,
     107             :                                               struct npa_state);
     108           0 :                 size_t read_count;
     109             : 
     110        1418 :                 read_count = tevent_queue_length(p->read_queue);
     111        1418 :                 if (read_count > 0) {
     112           0 :                         return true;
     113             :                 }
     114             : 
     115        1418 :                 return false;
     116             :         }
     117             : 
     118           0 :         return false;
     119             : }
     120             : 
     121             : struct np_write_state {
     122             :         struct tevent_context *ev;
     123             :         struct npa_state *p;
     124             :         struct iovec iov;
     125             :         ssize_t nwritten;
     126             : };
     127             : 
     128             : static void np_write_done(struct tevent_req *subreq);
     129             : 
     130      335042 : struct tevent_req *np_write_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
     131             :                                  struct fake_file_handle *handle,
     132             :                                  const uint8_t *data, size_t len)
     133             : {
     134        7323 :         struct tevent_req *req;
     135        7323 :         struct np_write_state *state;
     136      335042 :         struct npa_state *p = NULL;
     137      335042 :         struct tevent_req *subreq = NULL;
     138             : 
     139      335042 :         DBG_INFO("len: %zu\n", len);
     140      335042 :         dump_data(50, data, len);
     141             : 
     142      335042 :         req = tevent_req_create(mem_ctx, &state, struct np_write_state);
     143      335042 :         if (req == NULL) {
     144           0 :                 return NULL;
     145             :         }
     146             : 
     147      335042 :         if (handle->type != FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
     148           0 :                 tevent_req_nterror(req, NT_STATUS_INVALID_HANDLE);
     149           0 :                 return tevent_req_post(req, ev);
     150             :         }
     151             : 
     152      335042 :         if (len == 0) {
     153           0 :                 state->nwritten = 0;
     154           0 :                 tevent_req_done(req);
     155           0 :                 return tevent_req_post(req, ev);
     156             :         }
     157             : 
     158      335042 :         p = talloc_get_type_abort(handle->private_data, struct npa_state);
     159             : 
     160      335042 :         state->ev = ev;
     161      335042 :         state->p = p;
     162      335042 :         state->iov.iov_base = discard_const_p(void, data);
     163      335042 :         state->iov.iov_len = len;
     164             : 
     165      342365 :         subreq = tstream_writev_queue_send(
     166      335042 :                 state, ev, p->stream, p->write_queue, &state->iov, 1);
     167      335042 :         if (tevent_req_nomem(subreq, req)) {
     168           0 :                 return tevent_req_post(req, ev);
     169             :         }
     170      335042 :         tevent_req_set_callback(subreq, np_write_done, req);
     171      335042 :         return req;
     172             : }
     173             : 
     174      335042 : static void np_write_done(struct tevent_req *subreq)
     175             : {
     176      335042 :         struct tevent_req *req = tevent_req_callback_data(
     177             :                 subreq, struct tevent_req);
     178      335042 :         struct np_write_state *state = tevent_req_data(
     179             :                 req, struct np_write_state);
     180        7323 :         ssize_t received;
     181        7323 :         int err;
     182             : 
     183      335042 :         received = tstream_writev_queue_recv(subreq, &err);
     184      335042 :         if (received < 0) {
     185           0 :                 tevent_req_nterror(req, map_nt_error_from_unix(err));
     186           0 :                 return;
     187             :         }
     188      335042 :         state->nwritten = received;
     189      335042 :         tevent_req_done(req);
     190             : }
     191             : 
     192      335042 : NTSTATUS np_write_recv(struct tevent_req *req, ssize_t *pnwritten)
     193             : {
     194      335042 :         struct np_write_state *state = tevent_req_data(
     195             :                 req, struct np_write_state);
     196        7323 :         NTSTATUS status;
     197             : 
     198      335042 :         if (tevent_req_is_nterror(req, &status)) {
     199           0 :                 return status;
     200             :         }
     201      335042 :         *pnwritten = state->nwritten;
     202      335042 :         return NT_STATUS_OK;
     203             : }
     204             : 
     205             : struct np_ipc_readv_next_vector_state {
     206             :         uint8_t *buf;
     207             :         size_t len;
     208             :         off_t ofs;
     209             :         size_t remaining;
     210             : };
     211             : 
     212      335451 : static void np_ipc_readv_next_vector_init(struct np_ipc_readv_next_vector_state *s,
     213             :                                           uint8_t *buf, size_t len)
     214             : {
     215      342774 :         ZERO_STRUCTP(s);
     216             : 
     217      335451 :         s->buf = buf;
     218      335451 :         s->len = MIN(len, UINT16_MAX);
     219      328128 : }
     220             : 
     221     1006321 : static int np_ipc_readv_next_vector(struct tstream_context *stream,
     222             :                                     void *private_data,
     223             :                                     TALLOC_CTX *mem_ctx,
     224             :                                     struct iovec **_vector,
     225             :                                     size_t *count)
     226             : {
     227     1006321 :         struct np_ipc_readv_next_vector_state *state =
     228             :                 (struct np_ipc_readv_next_vector_state *)private_data;
     229       21963 :         struct iovec *vector;
     230       21963 :         ssize_t pending;
     231       21963 :         size_t wanted;
     232             : 
     233     1006321 :         if (state->ofs == state->len) {
     234        4099 :                 *_vector = NULL;
     235        4099 :                 *count = 0;
     236        4099 :                 return 0;
     237             :         }
     238             : 
     239     1002222 :         pending = tstream_pending_bytes(stream);
     240     1002222 :         if (pending == -1) {
     241           0 :                 return -1;
     242             :         }
     243             : 
     244     1002222 :         if (pending == 0 && state->ofs != 0) {
     245             :                 /* return a short read */
     246      331336 :                 *_vector = NULL;
     247      331336 :                 *count = 0;
     248      331336 :                 return 0;
     249             :         }
     250             : 
     251      670886 :         if (pending == 0) {
     252             :                 /* we want at least one byte and recheck again */
     253      328128 :                 wanted = 1;
     254             :         } else {
     255      335435 :                 size_t missing = state->len - state->ofs;
     256      335435 :                 if (pending > missing) {
     257             :                         /* there's more available */
     258           0 :                         state->remaining = pending - missing;
     259           0 :                         wanted = missing;
     260             :                 } else {
     261             :                         /* read what we can get and recheck in the next cycle */
     262      328115 :                         wanted = pending;
     263             :                 }
     264             :         }
     265             : 
     266      670886 :         vector = talloc_array(mem_ctx, struct iovec, 1);
     267      670886 :         if (!vector) {
     268           0 :                 return -1;
     269             :         }
     270             : 
     271      670886 :         vector[0].iov_base = state->buf + state->ofs;
     272      670886 :         vector[0].iov_len = wanted;
     273             : 
     274      670886 :         state->ofs += wanted;
     275             : 
     276      670886 :         *_vector = vector;
     277      670886 :         *count = 1;
     278      670886 :         return 0;
     279             : }
     280             : 
     281             : struct np_read_state {
     282             :         struct npa_state *p;
     283             :         struct np_ipc_readv_next_vector_state next_vector;
     284             : 
     285             :         ssize_t nread;
     286             :         bool is_data_outstanding;
     287             : };
     288             : 
     289             : static void np_read_done(struct tevent_req *subreq);
     290             : 
     291      335451 : struct tevent_req *np_read_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
     292             :                                 struct fake_file_handle *handle,
     293             :                                 uint8_t *data, size_t len)
     294             : {
     295        7323 :         struct tevent_req *req;
     296        7323 :         struct np_read_state *state;
     297      335451 :         struct npa_state *p = NULL;
     298      335451 :         struct tevent_req *subreq = NULL;
     299             : 
     300      335451 :         req = tevent_req_create(mem_ctx, &state, struct np_read_state);
     301      335451 :         if (req == NULL) {
     302           0 :                 return NULL;
     303             :         }
     304             : 
     305      335451 :         if (handle->type != FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
     306           0 :                 tevent_req_nterror(req, NT_STATUS_INVALID_HANDLE);
     307           0 :                 return tevent_req_post(req, ev);
     308             :         }
     309             : 
     310      335451 :         p = talloc_get_type_abort(handle->private_data, struct npa_state);
     311             : 
     312      335451 :         np_ipc_readv_next_vector_init(&state->next_vector, data, len);
     313             : 
     314      342774 :         subreq = tstream_readv_pdu_queue_send(
     315             :                 state,
     316             :                 ev,
     317             :                 p->stream,
     318             :                 p->read_queue,
     319             :                 np_ipc_readv_next_vector,
     320      335451 :                 &state->next_vector);
     321      335451 :         if (tevent_req_nomem(subreq, req)) {
     322           0 :                 return tevent_req_post(req, ev);
     323             :         }
     324      335451 :         tevent_req_set_callback(subreq, np_read_done, req);
     325      335451 :         return req;
     326             : }
     327             : 
     328      335450 : static void np_read_done(struct tevent_req *subreq)
     329             : {
     330      335450 :         struct tevent_req *req = tevent_req_callback_data(
     331             :                 subreq, struct tevent_req);
     332      335450 :         struct np_read_state *state = tevent_req_data(
     333             :                 req, struct np_read_state);
     334        7323 :         ssize_t ret;
     335        7323 :         int err;
     336             : 
     337      335450 :         ret = tstream_readv_pdu_queue_recv(subreq, &err);
     338      335450 :         TALLOC_FREE(subreq);
     339      335450 :         if (ret == -1) {
     340          15 :                 tevent_req_nterror(req, map_nt_error_from_unix(err));
     341          15 :                 return;
     342             :         }
     343             : 
     344      335435 :         state->nread = ret;
     345      335435 :         state->is_data_outstanding = (state->next_vector.remaining > 0);
     346             : 
     347      335435 :         tevent_req_done(req);
     348      335435 :         return;
     349             : }
     350             : 
     351      335450 : NTSTATUS np_read_recv(struct tevent_req *req, ssize_t *nread,
     352             :                       bool *is_data_outstanding)
     353             : {
     354      335450 :         struct np_read_state *state = tevent_req_data(
     355             :                 req, struct np_read_state);
     356        7323 :         NTSTATUS status;
     357             : 
     358      335450 :         if (tevent_req_is_nterror(req, &status)) {
     359          15 :                 return status;
     360             :         }
     361             : 
     362      335435 :         DEBUG(10, ("Received %d bytes. There is %smore data outstanding\n",
     363             :                    (int)state->nread, state->is_data_outstanding?"":"no "));
     364             : 
     365      335435 :         *nread = state->nread;
     366      335435 :         *is_data_outstanding = state->is_data_outstanding;
     367      335435 :         return NT_STATUS_OK;
     368             : }

Generated by: LCOV version 1.14