source3/librpc/gen_ndr/cli_echo.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "librpc/gen_ndr/cli_echo.h"
   8
   9 NTSTATUS rpccli_echo_AddOne(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32_t in_data, uint32_t *out_data)
  10 {
  11         struct echo_AddOne r;
  12         NTSTATUS status;
  13
  14         /* In parameters */
  15         r.in.in_data = in_data;
  16
  17         if (DEBUGLEVEL >= 10)
  18                 NDR_PRINT_IN_DEBUG(echo_AddOne, &r);
  19
  20         status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_ADDONE, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_AddOne, (ndr_push_flags_fn_t)ndr_push_echo_AddOne);
  21
  22         if ( !NT_STATUS_IS_OK(status) ) {
  23                 return status;
  24         }
  25
  26         if (DEBUGLEVEL >= 10)
  27                 NDR_PRINT_OUT_DEBUG(echo_AddOne, &r);
  28
  29         if (NT_STATUS_IS_ERR(status)) {
  30                 return status;
  31         }
  32
  33         /* Return variables */
  34         *out_data = *r.out.out_data;
  35
  36         /* Return result */
  37         return NT_STATUS_OK;
  38 }
  39
  40 NTSTATUS rpccli_echo_EchoData(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32_t len, uint8_t *in_data, uint8_t **out_data)
  41 {
  42         struct echo_EchoData r;
  43         NTSTATUS status;
  44
  45         /* In parameters */
  46         r.in.len = len;
  47         r.in.in_data = in_data;
  48
  49         if (DEBUGLEVEL >= 10)
  50                 NDR_PRINT_IN_DEBUG(echo_EchoData, &r);
  51
  52         status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_ECHODATA, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_EchoData, (ndr_push_flags_fn_t)ndr_push_echo_EchoData);
  53
  54         if ( !NT_STATUS_IS_OK(status) ) {
  55                 return status;
  56         }
  57
  58         if (DEBUGLEVEL >= 10)
  59                 NDR_PRINT_OUT_DEBUG(echo_EchoData, &r);
  60
  61         if (NT_STATUS_IS_ERR(status)) {
  62                 return status;
  63         }
  64
  65         /* Return variables */
  66         *out_data = r.out.out_data;
  67
  68         /* Return result */
  69         return NT_STATUS_OK;
  70 }
  71
  72 NTSTATUS rpccli_echo_SinkData(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32_t len, uint8_t *data)
  73 {
  74         struct echo_SinkData r;
  75         NTSTATUS status;
  76
  77         /* In parameters */
  78         r.in.len = len;
  79         r.in.data = data;
  80
  81         if (DEBUGLEVEL >= 10)
  82                 NDR_PRINT_IN_DEBUG(echo_SinkData, &r);
  83
  84         status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_SINKDATA, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_SinkData, (ndr_push_flags_fn_t)ndr_push_echo_SinkData);
  85
  86         if ( !NT_STATUS_IS_OK(status) ) {
  87                 return status;
  88         }
  89
  90         if (DEBUGLEVEL >= 10)
  91                 NDR_PRINT_OUT_DEBUG(echo_SinkData, &r);
  92
  93         if (NT_STATUS_IS_ERR(status)) {
  94                 return status;
  95         }
  96
  97         /* Return variables */
  98
  99         /* Return result */
 100         return NT_STATUS_OK;
 101 }
 102
 103 NTSTATUS rpccli_echo_SourceData(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32_t len, uint8_t **data)
 104 {
 105         struct echo_SourceData r;
 106         NTSTATUS status;
 107
 108         /* In parameters */
 109         r.in.len = len;
 110
 111         if (DEBUGLEVEL >= 10)
 112                 NDR_PRINT_IN_DEBUG(echo_SourceData, &r);
 113
 114         status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_SOURCEDATA, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_SourceData, (ndr_push_flags_fn_t)ndr_push_echo_SourceData);
 115
 116         if ( !NT_STATUS_IS_OK(status) ) {
 117                 return status;
 118         }
 119
 120         if (DEBUGLEVEL >= 10)
 121                 NDR_PRINT_OUT_DEBUG(echo_SourceData, &r);
 122
 123         if (NT_STATUS_IS_ERR(status)) {
 124                 return status;
 125         }
 126
 127         /* Return variables */
 128         *data = r.out.data;
 129
 130         /* Return result */
 131         return NT_STATUS_OK;
 132 }
 133
 134 NTSTATUS rpccli_echo_TestCall(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *s1, const char **s2)
 135 {
 136         struct echo_TestCall r;
 137         NTSTATUS status;
 138
 139         /* In parameters */
 140         r.in.s1 = s1;
 141
 142         if (DEBUGLEVEL >= 10)
 143                 NDR_PRINT_IN_DEBUG(echo_TestCall, &r);
 144
 145         status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTCALL, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestCall, (ndr_push_flags_fn_t)ndr_push_echo_TestCall);
 146
 147         if ( !NT_STATUS_IS_OK(status) ) {
 148                 return status;
 149         }
 150
 151         if (DEBUGLEVEL >= 10)
 152                 NDR_PRINT_OUT_DEBUG(echo_TestCall, &r);
 153
 154         if (NT_STATUS_IS_ERR(status)) {
 155                 return status;
 156         }
 157
 158         /* Return variables */
 159         *s2 = *r.out.s2;
 160
 161         /* Return result */
 162         return NT_STATUS_OK;
 163 }
 164
 165 NTSTATUS rpccli_echo_TestCall2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t level, union echo_Info *info)
 166 {
 167         struct echo_TestCall2 r;
 168         NTSTATUS status;
 169
 170         /* In parameters */
 171         r.in.level = level;
 172
 173         if (DEBUGLEVEL >= 10)
 174                 NDR_PRINT_IN_DEBUG(echo_TestCall2, &r);
 175
 176         status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTCALL2, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestCall2, (ndr_push_flags_fn_t)ndr_push_echo_TestCall2);
 177
 178         if ( !NT_STATUS_IS_OK(status) ) {
 179                 return status;
 180         }
 181
 182         if (DEBUGLEVEL >= 10)
 183                 NDR_PRINT_OUT_DEBUG(echo_TestCall2, &r);
 184
 185         if (NT_STATUS_IS_ERR(status)) {
 186                 return status;
 187         }
 188
 189         /* Return variables */
 190         *info = *r.out.info;
 191
 192         /* Return result */
 193         return r.out.result;
 194 }
 195
 196 NTSTATUS rpccli_echo_TestSleep(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32_t seconds)
 197 {
 198         struct echo_TestSleep r;
 199         NTSTATUS status;
 200
 201         /* In parameters */
 202         r.in.seconds = seconds;
 203
 204         if (DEBUGLEVEL >= 10)
 205                 NDR_PRINT_IN_DEBUG(echo_TestSleep, &r);
 206
 207         status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTSLEEP, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestSleep, (ndr_push_flags_fn_t)ndr_push_echo_TestSleep);
 208
 209         if ( !NT_STATUS_IS_OK(status) ) {
 210                 return status;
 211         }
 212
 213         if (DEBUGLEVEL >= 10)
 214                 NDR_PRINT_OUT_DEBUG(echo_TestSleep, &r);
 215
 216         if (NT_STATUS_IS_ERR(status)) {
 217                 return status;
 218         }
 219
 220         /* Return variables */
 221
 222         /* Return result */
 223         /* Sorry, don't know how to convert uint32 to NTSTATUS */
 224         return NT_STATUS_OK;
 225 }
 226
 227 NTSTATUS rpccli_echo_TestEnum(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, enum echo_Enum1 *foo1, struct echo_Enum2 *foo2, union echo_Enum3 *foo3)
 228 {
 229         struct echo_TestEnum r;
 230         NTSTATUS status;
 231
 232         /* In parameters */
 233         r.in.foo1 = foo1;
 234         r.in.foo2 = foo2;
 235         r.in.foo3 = foo3;
 236
 237         if (DEBUGLEVEL >= 10)
 238                 NDR_PRINT_IN_DEBUG(echo_TestEnum, &r);
 239
 240         status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestEnum, (ndr_push_flags_fn_t)ndr_push_echo_TestEnum);
 241
 242         if ( !NT_STATUS_IS_OK(status) ) {
 243                 return status;
 244         }
 245
 246         if (DEBUGLEVEL >= 10)
 247                 NDR_PRINT_OUT_DEBUG(echo_TestEnum, &r);
 248
 249         if (NT_STATUS_IS_ERR(status)) {
 250                 return status;
 251         }
 252
 253         /* Return variables */
 254         *foo1 = *r.out.foo1;
 255         *foo2 = *r.out.foo2;
 256         *foo3 = *r.out.foo3;
 257
 258         /* Return result */
 259         return NT_STATUS_OK;
 260 }
 261
 262 NTSTATUS rpccli_echo_TestSurrounding(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct echo_Surrounding *data)
 263 {
 264         struct echo_TestSurrounding r;
 265         NTSTATUS status;
 266
 267         /* In parameters */
 268         r.in.data = data;
 269
 270         if (DEBUGLEVEL >= 10)
 271                 NDR_PRINT_IN_DEBUG(echo_TestSurrounding, &r);
 272
 273         status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTSURROUNDING, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestSurrounding, (ndr_push_flags_fn_t)ndr_push_echo_TestSurrounding);
 274
 275         if ( !NT_STATUS_IS_OK(status) ) {
 276                 return status;
 277         }
 278
 279         if (DEBUGLEVEL >= 10)
 280                 NDR_PRINT_OUT_DEBUG(echo_TestSurrounding, &r);
 281
 282         if (NT_STATUS_IS_ERR(status)) {
 283                 return status;
 284         }
 285
 286         /* Return variables */
 287         *data = *r.out.data;
 288
 289         /* Return result */
 290         return NT_STATUS_OK;
 291 }
 292
 293 NTSTATUS rpccli_echo_TestDoublePointer(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t ***data)
 294 {
 295         struct echo_TestDoublePointer r;
 296         NTSTATUS status;
 297
 298         /* In parameters */
 299         r.in.data = data;
 300
 301         if (DEBUGLEVEL >= 10)
 302                 NDR_PRINT_IN_DEBUG(echo_TestDoublePointer, &r);
 303
 304         status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTDOUBLEPOINTER, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestDoublePointer, (ndr_push_flags_fn_t)ndr_push_echo_TestDoublePointer);
 305
 306         if ( !NT_STATUS_IS_OK(status) ) {
 307                 return status;
 308         }
 309
 310         if (DEBUGLEVEL >= 10)
 311                 NDR_PRINT_OUT_DEBUG(echo_TestDoublePointer, &r);
 312
 313         if (NT_STATUS_IS_ERR(status)) {
 314                 return status;
 315         }
 316
 317         /* Return variables */
 318
 319         /* Return result */
 320         /* Sorry, don't know how to convert uint16 to NTSTATUS */
 321         return NT_STATUS_OK;
 322 }
 323