source/rpc_client/cli_echo.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    RPC pipe client
   5
   6    Copyright (C) Tim Potter 2003
   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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 NTSTATUS cli_echo_add_one(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  26                           uint32 request, uint32 *response)
  27 {
  28         prs_struct qbuf, rbuf;
  29         ECHO_Q_ADD_ONE q;
  30         ECHO_R_ADD_ONE r;
  31         BOOL result = False;
  32
  33         ZERO_STRUCT(q);
  34         ZERO_STRUCT(r);
  35
  36         /* Initialise parse structures */
  37
  38         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
  39         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
  40
  41         /* Marshall data and send request */
  42
  43         init_echo_q_add_one(&q, request);
  44
  45         if (!echo_io_q_add_one("", &q, &qbuf, 0) ||
  46             !rpc_api_pipe_req(cli, ECHO_ADD_ONE, &qbuf, &rbuf))
  47                 goto done;
  48
  49         /* Unmarshall response */
  50
  51         if (!echo_io_r_add_one("", &r, &rbuf, 0))
  52                 goto done;
  53
  54         if (response)
  55                 *response = r.response;
  56
  57         result = True;
  58
  59  done:
  60         prs_mem_free(&qbuf);
  61         prs_mem_free(&rbuf);
  62
  63         return result ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
  64 }
  65
  66 NTSTATUS cli_echo_data(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  67                        uint32 size, char *in_data, char **out_data)
  68 {
  69         prs_struct qbuf, rbuf;
  70         ECHO_Q_ECHO_DATA q;
  71         ECHO_R_ECHO_DATA r;
  72         BOOL result = False;
  73
  74         ZERO_STRUCT(q);
  75         ZERO_STRUCT(r);
  76
  77         /* Initialise parse structures */
  78
  79         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
  80         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
  81
  82         /* Marshall data and send request */
  83
  84         init_echo_q_echo_data(&q, size, in_data);
  85
  86         if (!echo_io_q_echo_data("", &q, &qbuf, 0) ||
  87             !rpc_api_pipe_req(cli, ECHO_DATA, &qbuf, &rbuf))
  88                 goto done;
  89
  90         /* Unmarshall response */
  91
  92         if (!echo_io_r_echo_data("", &r, &rbuf, 0))
  93                 goto done;
  94
  95         result = True;
  96
  97         if (out_data) {
  98                 *out_data = talloc(mem_ctx, size);
  99                 memcpy(*out_data, r.data, size);
 100         }
 101
 102  done:
 103         prs_mem_free(&qbuf);
 104         prs_mem_free(&rbuf);
 105
 106         return result ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 107 }
 108
 109 NTSTATUS cli_echo_sink_data(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 110                             uint32 size, char *in_data)
 111 {
 112         prs_struct qbuf, rbuf;
 113         ECHO_Q_SINK_DATA q;
 114         ECHO_R_SINK_DATA r;
 115         BOOL result = False;
 116
 117         ZERO_STRUCT(q);
 118         ZERO_STRUCT(r);
 119
 120         /* Initialise parse structures */
 121
 122         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 123         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 124
 125         /* Marshall data and send request */
 126
 127         init_echo_q_sink_data(&q, size, in_data);
 128
 129         if (!echo_io_q_sink_data("", &q, &qbuf, 0) ||
 130             !rpc_api_pipe_req(cli, ECHO_SINK_DATA, &qbuf, &rbuf)) {
 131                 goto done;
 132         }
 133
 134         /* Unmarshall response */
 135
 136         if (!echo_io_r_sink_data("", &r, &rbuf, 0)) {
 137                 goto done;
 138         }
 139
 140         result = True;
 141
 142  done:
 143         prs_mem_free(&qbuf);
 144         prs_mem_free(&rbuf);
 145
 146         return result ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 147 }
 148
 149 NTSTATUS cli_echo_source_data(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 150                               uint32 size, char **out_data)
 151 {
 152         prs_struct qbuf, rbuf;
 153         ECHO_Q_SOURCE_DATA q;
 154         ECHO_R_SOURCE_DATA r;
 155         BOOL result = False;
 156
 157         ZERO_STRUCT(q);
 158         ZERO_STRUCT(r);
 159
 160         /* Initialise parse structures */
 161
 162         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 163         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 164
 165         /* Marshall data and send request */
 166
 167         init_echo_q_source_data(&q, size);
 168
 169         if (!echo_io_q_source_data("", &q, &qbuf, 0) ||
 170             !rpc_api_pipe_req(cli, ECHO_SOURCE_DATA, &qbuf, &rbuf)) {
 171                 goto done;
 172         }
 173
 174         /* Unmarshall response */
 175
 176         if (!echo_io_r_source_data("", &r, &rbuf, 0)) {
 177                 goto done;
 178         }
 179
 180         result = True;
 181
 182  done:
 183         prs_mem_free(&qbuf);
 184         prs_mem_free(&rbuf);
 185
 186         return result ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 187 }