librpc/gen_ndr/ndr_rap_c.c

   1 /* client functions auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include <tevent.h>
   5 #include "lib/util/tevent_ntstatus.h"
   6 #include "../librpc/gen_ndr/ndr_rap.h"
   7 #include "../librpc/gen_ndr/ndr_rap_c.h"
   8
   9 /* rap - client functions generated by pidl */
  10
  11 NTSTATUS dcerpc_rap_NetShareEnum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct rap_NetShareEnum *r)
  12 {
  13
  14         NTSTATUS status;
  15
  16         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
  17                 NDR_PRINT_IN_DEBUG(rap_NetShareEnum, r);
  18         }
  19
  20         status = dcerpc_ndr_request(p, NULL, &ndr_table_rap,
  21                                     NDR_RAP_NETSHAREENUM, mem_ctx, r);
  22
  23         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
  24                 NDR_PRINT_OUT_DEBUG(rap_NetShareEnum, r);
  25         }
  26
  27         return status;
  28 }
  29
  30 static struct rpc_request *dcerpc_rap_NetShareEnum_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct rap_NetShareEnum *r)
  31 {
  32
  33         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
  34                 NDR_PRINT_IN_DEBUG(rap_NetShareEnum, r);
  35         }
  36
  37         return dcerpc_ndr_request_send(p, NULL, &ndr_table_rap,
  38                                        NDR_RAP_NETSHAREENUM, true, mem_ctx, r);
  39 }
  40
  41 static NTSTATUS dcerpc_rap_NetShareEnum_recv(struct rpc_request *rreq)
  42 {
  43 NTSTATUS status;
  44         struct dcerpc_pipe *p = rreq->p;
  45         struct rap_NetShareEnum *r = (struct rap_NetShareEnum *)rreq->ndr.struct_ptr;
  46
  47         status = dcerpc_ndr_request_recv(rreq);
  48
  49         if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
  50                 status = dcerpc_fault_to_nt_status(p->last_fault_code);
  51         }
  52
  53         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
  54                 NDR_PRINT_OUT_DEBUG(rap_NetShareEnum, r);
  55         }
  56
  57         return status;
  58 }
  59
  60 struct dcerpc_rap_NetShareEnum_r_state {
  61         TALLOC_CTX *out_mem_ctx;
  62 };
  63
  64 static void dcerpc_rap_NetShareEnum_r_done(struct rpc_request *subreq);
  65
  66 struct tevent_req *dcerpc_rap_NetShareEnum_r_send(TALLOC_CTX *mem_ctx,
  67         struct tevent_context *ev,
  68         struct dcerpc_binding_handle *h,
  69         struct rap_NetShareEnum *r)
  70 {
  71         struct tevent_req *req;
  72         struct dcerpc_rap_NetShareEnum_r_state *state;
  73         struct dcerpc_pipe *p =
  74                 talloc_get_type_abort(h->private_data,
  75                 struct dcerpc_pipe);
  76         struct rpc_request *subreq;
  77
  78         req = tevent_req_create(mem_ctx, &state,
  79                                 struct dcerpc_rap_NetShareEnum_r_state);
  80         if (req == NULL) {
  81                 return NULL;
  82         }
  83
  84         state->out_mem_ctx = talloc_new(state);
  85         if (tevent_req_nomem(state->out_mem_ctx, req)) {
  86                 return tevent_req_post(req, ev);
  87         }
  88
  89         subreq = dcerpc_rap_NetShareEnum_send(p, state->out_mem_ctx, r);
  90         if (tevent_req_nomem(subreq, req)) {
  91                 return tevent_req_post(req, ev);
  92         }
  93         subreq->async.callback = dcerpc_rap_NetShareEnum_r_done;
  94         subreq->async.private_data = req;
  95
  96         return req;
  97 }
  98
  99 static void dcerpc_rap_NetShareEnum_r_done(struct rpc_request *subreq)
 100 {
 101         struct tevent_req *req =
 102                 talloc_get_type_abort(subreq->async.private_data,
 103                 struct tevent_req);
 104         NTSTATUS status;
 105
 106         status = dcerpc_rap_NetShareEnum_recv(subreq);
 107         if (!NT_STATUS_IS_OK(status)) {
 108                 tevent_req_nterror(req, status);
 109                 return;
 110         }
 111
 112         tevent_req_done(req);
 113 }
 114
 115 NTSTATUS dcerpc_rap_NetShareEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 116 {
 117         struct dcerpc_rap_NetShareEnum_r_state *state =
 118                 tevent_req_data(req,
 119                 struct dcerpc_rap_NetShareEnum_r_state);
 120         NTSTATUS status;
 121
 122         if (tevent_req_is_nterror(req, &status)) {
 123                 tevent_req_received(req);
 124                 return status;
 125         }
 126
 127         talloc_steal(mem_ctx, state->out_mem_ctx);
 128
 129         tevent_req_received(req);
 130         return NT_STATUS_OK;
 131 }
 132
 133 NTSTATUS dcerpc_rap_NetShareEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetShareEnum *r)
 134 {
 135         struct dcerpc_pipe *p =
 136                 talloc_get_type_abort(h->private_data,
 137                 struct dcerpc_pipe);
 138
 139
 140         NTSTATUS status;
 141
 142         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 143                 NDR_PRINT_IN_DEBUG(rap_NetShareEnum, r);
 144         }
 145
 146         status = dcerpc_ndr_request(p, NULL, &ndr_table_rap,
 147                                     NDR_RAP_NETSHAREENUM, mem_ctx, r);
 148
 149         if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 150                 status = dcerpc_fault_to_nt_status(p->last_fault_code);
 151         }
 152
 153         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
 154                 NDR_PRINT_OUT_DEBUG(rap_NetShareEnum, r);
 155         }
 156         return status;
 157 }
 158
 159 NTSTATUS dcerpc_rap_NetServerEnum2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct rap_NetServerEnum2 *r)
 160 {
 161
 162         NTSTATUS status;
 163
 164         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 165                 NDR_PRINT_IN_DEBUG(rap_NetServerEnum2, r);
 166         }
 167
 168         status = dcerpc_ndr_request(p, NULL, &ndr_table_rap,
 169                                     NDR_RAP_NETSERVERENUM2, mem_ctx, r);
 170
 171         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
 172                 NDR_PRINT_OUT_DEBUG(rap_NetServerEnum2, r);
 173         }
 174
 175         return status;
 176 }
 177
 178 static struct rpc_request *dcerpc_rap_NetServerEnum2_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct rap_NetServerEnum2 *r)
 179 {
 180
 181         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 182                 NDR_PRINT_IN_DEBUG(rap_NetServerEnum2, r);
 183         }
 184
 185         return dcerpc_ndr_request_send(p, NULL, &ndr_table_rap,
 186                                        NDR_RAP_NETSERVERENUM2, true, mem_ctx, r);
 187 }
 188
 189 static NTSTATUS dcerpc_rap_NetServerEnum2_recv(struct rpc_request *rreq)
 190 {
 191 NTSTATUS status;
 192         struct dcerpc_pipe *p = rreq->p;
 193         struct rap_NetServerEnum2 *r = (struct rap_NetServerEnum2 *)rreq->ndr.struct_ptr;
 194
 195         status = dcerpc_ndr_request_recv(rreq);
 196
 197         if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 198                 status = dcerpc_fault_to_nt_status(p->last_fault_code);
 199         }
 200
 201         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
 202                 NDR_PRINT_OUT_DEBUG(rap_NetServerEnum2, r);
 203         }
 204
 205         return status;
 206 }
 207
 208 struct dcerpc_rap_NetServerEnum2_r_state {
 209         TALLOC_CTX *out_mem_ctx;
 210 };
 211
 212 static void dcerpc_rap_NetServerEnum2_r_done(struct rpc_request *subreq);
 213
 214 struct tevent_req *dcerpc_rap_NetServerEnum2_r_send(TALLOC_CTX *mem_ctx,
 215         struct tevent_context *ev,
 216         struct dcerpc_binding_handle *h,
 217         struct rap_NetServerEnum2 *r)
 218 {
 219         struct tevent_req *req;
 220         struct dcerpc_rap_NetServerEnum2_r_state *state;
 221         struct dcerpc_pipe *p =
 222                 talloc_get_type_abort(h->private_data,
 223                 struct dcerpc_pipe);
 224         struct rpc_request *subreq;
 225
 226         req = tevent_req_create(mem_ctx, &state,
 227                                 struct dcerpc_rap_NetServerEnum2_r_state);
 228         if (req == NULL) {
 229                 return NULL;
 230         }
 231
 232         state->out_mem_ctx = talloc_new(state);
 233         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 234                 return tevent_req_post(req, ev);
 235         }
 236
 237         subreq = dcerpc_rap_NetServerEnum2_send(p, state->out_mem_ctx, r);
 238         if (tevent_req_nomem(subreq, req)) {
 239                 return tevent_req_post(req, ev);
 240         }
 241         subreq->async.callback = dcerpc_rap_NetServerEnum2_r_done;
 242         subreq->async.private_data = req;
 243
 244         return req;
 245 }
 246
 247 static void dcerpc_rap_NetServerEnum2_r_done(struct rpc_request *subreq)
 248 {
 249         struct tevent_req *req =
 250                 talloc_get_type_abort(subreq->async.private_data,
 251                 struct tevent_req);
 252         NTSTATUS status;
 253
 254         status = dcerpc_rap_NetServerEnum2_recv(subreq);
 255         if (!NT_STATUS_IS_OK(status)) {
 256                 tevent_req_nterror(req, status);
 257                 return;
 258         }
 259
 260         tevent_req_done(req);
 261 }
 262
 263 NTSTATUS dcerpc_rap_NetServerEnum2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 264 {
 265         struct dcerpc_rap_NetServerEnum2_r_state *state =
 266                 tevent_req_data(req,
 267                 struct dcerpc_rap_NetServerEnum2_r_state);
 268         NTSTATUS status;
 269
 270         if (tevent_req_is_nterror(req, &status)) {
 271                 tevent_req_received(req);
 272                 return status;
 273         }
 274
 275         talloc_steal(mem_ctx, state->out_mem_ctx);
 276
 277         tevent_req_received(req);
 278         return NT_STATUS_OK;
 279 }
 280
 281 NTSTATUS dcerpc_rap_NetServerEnum2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetServerEnum2 *r)
 282 {
 283         struct dcerpc_pipe *p =
 284                 talloc_get_type_abort(h->private_data,
 285                 struct dcerpc_pipe);
 286
 287
 288         NTSTATUS status;
 289
 290         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 291                 NDR_PRINT_IN_DEBUG(rap_NetServerEnum2, r);
 292         }
 293
 294         status = dcerpc_ndr_request(p, NULL, &ndr_table_rap,
 295                                     NDR_RAP_NETSERVERENUM2, mem_ctx, r);
 296
 297         if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 298                 status = dcerpc_fault_to_nt_status(p->last_fault_code);
 299         }
 300
 301         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
 302                 NDR_PRINT_OUT_DEBUG(rap_NetServerEnum2, r);
 303         }
 304         return status;
 305 }
 306
 307 NTSTATUS dcerpc_rap_WserverGetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct rap_WserverGetInfo *r)
 308 {
 309
 310         NTSTATUS status;
 311
 312         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 313                 NDR_PRINT_IN_DEBUG(rap_WserverGetInfo, r);
 314         }
 315
 316         status = dcerpc_ndr_request(p, NULL, &ndr_table_rap,
 317                                     NDR_RAP_WSERVERGETINFO, mem_ctx, r);
 318
 319         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
 320                 NDR_PRINT_OUT_DEBUG(rap_WserverGetInfo, r);
 321         }
 322
 323         return status;
 324 }
 325
 326 static struct rpc_request *dcerpc_rap_WserverGetInfo_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct rap_WserverGetInfo *r)
 327 {
 328
 329         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 330                 NDR_PRINT_IN_DEBUG(rap_WserverGetInfo, r);
 331         }
 332
 333         return dcerpc_ndr_request_send(p, NULL, &ndr_table_rap,
 334                                        NDR_RAP_WSERVERGETINFO, true, mem_ctx, r);
 335 }
 336
 337 static NTSTATUS dcerpc_rap_WserverGetInfo_recv(struct rpc_request *rreq)
 338 {
 339 NTSTATUS status;
 340         struct dcerpc_pipe *p = rreq->p;
 341         struct rap_WserverGetInfo *r = (struct rap_WserverGetInfo *)rreq->ndr.struct_ptr;
 342
 343         status = dcerpc_ndr_request_recv(rreq);
 344
 345         if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 346                 status = dcerpc_fault_to_nt_status(p->last_fault_code);
 347         }
 348
 349         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
 350                 NDR_PRINT_OUT_DEBUG(rap_WserverGetInfo, r);
 351         }
 352
 353         return status;
 354 }
 355
 356 struct dcerpc_rap_WserverGetInfo_r_state {
 357         TALLOC_CTX *out_mem_ctx;
 358 };
 359
 360 static void dcerpc_rap_WserverGetInfo_r_done(struct rpc_request *subreq);
 361
 362 struct tevent_req *dcerpc_rap_WserverGetInfo_r_send(TALLOC_CTX *mem_ctx,
 363         struct tevent_context *ev,
 364         struct dcerpc_binding_handle *h,
 365         struct rap_WserverGetInfo *r)
 366 {
 367         struct tevent_req *req;
 368         struct dcerpc_rap_WserverGetInfo_r_state *state;
 369         struct dcerpc_pipe *p =
 370                 talloc_get_type_abort(h->private_data,
 371                 struct dcerpc_pipe);
 372         struct rpc_request *subreq;
 373
 374         req = tevent_req_create(mem_ctx, &state,
 375                                 struct dcerpc_rap_WserverGetInfo_r_state);
 376         if (req == NULL) {
 377                 return NULL;
 378         }
 379
 380         state->out_mem_ctx = talloc_new(state);
 381         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 382                 return tevent_req_post(req, ev);
 383         }
 384
 385         subreq = dcerpc_rap_WserverGetInfo_send(p, state->out_mem_ctx, r);
 386         if (tevent_req_nomem(subreq, req)) {
 387                 return tevent_req_post(req, ev);
 388         }
 389         subreq->async.callback = dcerpc_rap_WserverGetInfo_r_done;
 390         subreq->async.private_data = req;
 391
 392         return req;
 393 }
 394
 395 static void dcerpc_rap_WserverGetInfo_r_done(struct rpc_request *subreq)
 396 {
 397         struct tevent_req *req =
 398                 talloc_get_type_abort(subreq->async.private_data,
 399                 struct tevent_req);
 400         NTSTATUS status;
 401
 402         status = dcerpc_rap_WserverGetInfo_recv(subreq);
 403         if (!NT_STATUS_IS_OK(status)) {
 404                 tevent_req_nterror(req, status);
 405                 return;
 406         }
 407
 408         tevent_req_done(req);
 409 }
 410
 411 NTSTATUS dcerpc_rap_WserverGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 412 {
 413         struct dcerpc_rap_WserverGetInfo_r_state *state =
 414                 tevent_req_data(req,
 415                 struct dcerpc_rap_WserverGetInfo_r_state);
 416         NTSTATUS status;
 417
 418         if (tevent_req_is_nterror(req, &status)) {
 419                 tevent_req_received(req);
 420                 return status;
 421         }
 422
 423         talloc_steal(mem_ctx, state->out_mem_ctx);
 424
 425         tevent_req_received(req);
 426         return NT_STATUS_OK;
 427 }
 428
 429 NTSTATUS dcerpc_rap_WserverGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_WserverGetInfo *r)
 430 {
 431         struct dcerpc_pipe *p =
 432                 talloc_get_type_abort(h->private_data,
 433                 struct dcerpc_pipe);
 434
 435
 436         NTSTATUS status;
 437
 438         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 439                 NDR_PRINT_IN_DEBUG(rap_WserverGetInfo, r);
 440         }
 441
 442         status = dcerpc_ndr_request(p, NULL, &ndr_table_rap,
 443                                     NDR_RAP_WSERVERGETINFO, mem_ctx, r);
 444
 445         if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 446                 status = dcerpc_fault_to_nt_status(p->last_fault_code);
 447         }
 448
 449         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
 450                 NDR_PRINT_OUT_DEBUG(rap_WserverGetInfo, r);
 451         }
 452         return status;
 453 }
 454
 455 NTSTATUS dcerpc_rap_NetPrintQEnum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct rap_NetPrintQEnum *r)
 456 {
 457
 458         NTSTATUS status;
 459
 460         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 461                 NDR_PRINT_IN_DEBUG(rap_NetPrintQEnum, r);
 462         }
 463
 464         status = dcerpc_ndr_request(p, NULL, &ndr_table_rap,
 465                                     NDR_RAP_NETPRINTQENUM, mem_ctx, r);
 466
 467         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
 468                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQEnum, r);
 469         }
 470
 471         return status;
 472 }
 473
 474 static struct rpc_request *dcerpc_rap_NetPrintQEnum_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct rap_NetPrintQEnum *r)
 475 {
 476
 477         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 478                 NDR_PRINT_IN_DEBUG(rap_NetPrintQEnum, r);
 479         }
 480
 481         return dcerpc_ndr_request_send(p, NULL, &ndr_table_rap,
 482                                        NDR_RAP_NETPRINTQENUM, true, mem_ctx, r);
 483 }
 484
 485 static NTSTATUS dcerpc_rap_NetPrintQEnum_recv(struct rpc_request *rreq)
 486 {
 487 NTSTATUS status;
 488         struct dcerpc_pipe *p = rreq->p;
 489         struct rap_NetPrintQEnum *r = (struct rap_NetPrintQEnum *)rreq->ndr.struct_ptr;
 490
 491         status = dcerpc_ndr_request_recv(rreq);
 492
 493         if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 494                 status = dcerpc_fault_to_nt_status(p->last_fault_code);
 495         }
 496
 497         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
 498                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQEnum, r);
 499         }
 500
 501         return status;
 502 }
 503
 504 struct dcerpc_rap_NetPrintQEnum_r_state {
 505         TALLOC_CTX *out_mem_ctx;
 506 };
 507
 508 static void dcerpc_rap_NetPrintQEnum_r_done(struct rpc_request *subreq);
 509
 510 struct tevent_req *dcerpc_rap_NetPrintQEnum_r_send(TALLOC_CTX *mem_ctx,
 511         struct tevent_context *ev,
 512         struct dcerpc_binding_handle *h,
 513         struct rap_NetPrintQEnum *r)
 514 {
 515         struct tevent_req *req;
 516         struct dcerpc_rap_NetPrintQEnum_r_state *state;
 517         struct dcerpc_pipe *p =
 518                 talloc_get_type_abort(h->private_data,
 519                 struct dcerpc_pipe);
 520         struct rpc_request *subreq;
 521
 522         req = tevent_req_create(mem_ctx, &state,
 523                                 struct dcerpc_rap_NetPrintQEnum_r_state);
 524         if (req == NULL) {
 525                 return NULL;
 526         }
 527
 528         state->out_mem_ctx = talloc_new(state);
 529         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 530                 return tevent_req_post(req, ev);
 531         }
 532
 533         subreq = dcerpc_rap_NetPrintQEnum_send(p, state->out_mem_ctx, r);
 534         if (tevent_req_nomem(subreq, req)) {
 535                 return tevent_req_post(req, ev);
 536         }
 537         subreq->async.callback = dcerpc_rap_NetPrintQEnum_r_done;
 538         subreq->async.private_data = req;
 539
 540         return req;
 541 }
 542
 543 static void dcerpc_rap_NetPrintQEnum_r_done(struct rpc_request *subreq)
 544 {
 545         struct tevent_req *req =
 546                 talloc_get_type_abort(subreq->async.private_data,
 547                 struct tevent_req);
 548         NTSTATUS status;
 549
 550         status = dcerpc_rap_NetPrintQEnum_recv(subreq);
 551         if (!NT_STATUS_IS_OK(status)) {
 552                 tevent_req_nterror(req, status);
 553                 return;
 554         }
 555
 556         tevent_req_done(req);
 557 }
 558
 559 NTSTATUS dcerpc_rap_NetPrintQEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 560 {
 561         struct dcerpc_rap_NetPrintQEnum_r_state *state =
 562                 tevent_req_data(req,
 563                 struct dcerpc_rap_NetPrintQEnum_r_state);
 564         NTSTATUS status;
 565
 566         if (tevent_req_is_nterror(req, &status)) {
 567                 tevent_req_received(req);
 568                 return status;
 569         }
 570
 571         talloc_steal(mem_ctx, state->out_mem_ctx);
 572
 573         tevent_req_received(req);
 574         return NT_STATUS_OK;
 575 }
 576
 577 NTSTATUS dcerpc_rap_NetPrintQEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct rap_NetPrintQEnum *r)
 578 {
 579         struct dcerpc_pipe *p =
 580                 talloc_get_type_abort(h->private_data,
 581                 struct dcerpc_pipe);
 582
 583
 584         NTSTATUS status;
 585
 586         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 587                 NDR_PRINT_IN_DEBUG(rap_NetPrintQEnum, r);
 588         }
 589
 590         status = dcerpc_ndr_request(p, NULL, &ndr_table_rap,
 591                                     NDR_RAP_NETPRINTQENUM, mem_ctx, r);
 592
 593         if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 594                 status = dcerpc_fault_to_nt_status(p->last_fault_code);
 595         }
 596
 597         if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
 598                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQEnum, r);
 599         }
 600         return status;
 601 }
 602