00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include "includes.h"
00027 #include "rpc_client.h"
00028
00029
00030
00031
00032
00033
00034
00035
00036 static BOOL decode_printer_info_0(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00037 uint32 returned, PRINTER_INFO_0 **info)
00038 {
00039 uint32 i;
00040 PRINTER_INFO_0 *inf;
00041
00042 if (returned) {
00043 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_0, returned);
00044 if (!inf) {
00045 return False;
00046 }
00047 memset(inf, 0, returned*sizeof(PRINTER_INFO_0));
00048 } else {
00049 inf = NULL;
00050 }
00051
00052 prs_set_offset(&buffer->prs,0);
00053
00054 for (i=0; i<returned; i++) {
00055 if (!smb_io_printer_info_0("", buffer, &inf[i], 0)) {
00056 return False;
00057 }
00058 }
00059
00060 *info=inf;
00061 return True;
00062 }
00063
00064
00065
00066
00067 static BOOL decode_printer_info_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00068 uint32 returned, PRINTER_INFO_1 **info)
00069 {
00070 uint32 i;
00071 PRINTER_INFO_1 *inf;
00072
00073 if (returned) {
00074 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_1, returned);
00075 if (!inf) {
00076 return False;
00077 }
00078 memset(inf, 0, returned*sizeof(PRINTER_INFO_1));
00079 } else {
00080 inf = NULL;
00081 }
00082
00083 prs_set_offset(&buffer->prs,0);
00084
00085 for (i=0; i<returned; i++) {
00086 if (!smb_io_printer_info_1("", buffer, &inf[i], 0)) {
00087 return False;
00088 }
00089 }
00090
00091 *info=inf;
00092 return True;
00093 }
00094
00095
00096
00097
00098 static BOOL decode_printer_info_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00099 uint32 returned, PRINTER_INFO_2 **info)
00100 {
00101 uint32 i;
00102 PRINTER_INFO_2 *inf;
00103
00104 if (returned) {
00105 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_2, returned);
00106 if (!inf) {
00107 return False;
00108 }
00109 memset(inf, 0, returned*sizeof(PRINTER_INFO_2));
00110 } else {
00111 inf = NULL;
00112 }
00113
00114 prs_set_offset(&buffer->prs,0);
00115
00116 for (i=0; i<returned; i++) {
00117
00118 inf[i].secdesc = NULL;
00119 if (!smb_io_printer_info_2("", buffer, &inf[i], 0)) {
00120 return False;
00121 }
00122 }
00123
00124 *info=inf;
00125 return True;
00126 }
00127
00128
00129
00130
00131 static BOOL decode_printer_info_3(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00132 uint32 returned, PRINTER_INFO_3 **info)
00133 {
00134 uint32 i;
00135 PRINTER_INFO_3 *inf;
00136
00137 if (returned) {
00138 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_3, returned);
00139 if (!inf) {
00140 return False;
00141 }
00142 memset(inf, 0, returned*sizeof(PRINTER_INFO_3));
00143 } else {
00144 inf = NULL;
00145 }
00146
00147 prs_set_offset(&buffer->prs,0);
00148
00149 for (i=0; i<returned; i++) {
00150 inf[i].secdesc = NULL;
00151 if (!smb_io_printer_info_3("", buffer, &inf[i], 0)) {
00152 return False;
00153 }
00154 }
00155
00156 *info=inf;
00157 return True;
00158 }
00159
00160
00161
00162
00163 static BOOL decode_printer_info_7(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00164 uint32 returned, PRINTER_INFO_7 **info)
00165 {
00166 uint32 i;
00167 PRINTER_INFO_7 *inf;
00168
00169 if (returned) {
00170 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_7, returned);
00171 if (!inf) {
00172 return False;
00173 }
00174 memset(inf, 0, returned*sizeof(PRINTER_INFO_7));
00175 } else {
00176 inf = NULL;
00177 }
00178
00179 prs_set_offset(&buffer->prs,0);
00180
00181 for (i=0; i<returned; i++) {
00182 if (!smb_io_printer_info_7("", buffer, &inf[i], 0)) {
00183 return False;
00184 }
00185 }
00186
00187 *info=inf;
00188 return True;
00189 }
00190
00191
00192
00193
00194
00195 static BOOL decode_port_info_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00196 uint32 returned, PORT_INFO_1 **info)
00197 {
00198 uint32 i;
00199 PORT_INFO_1 *inf;
00200
00201 if (returned) {
00202 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_1, returned);
00203 if (!inf) {
00204 return False;
00205 }
00206 memset(inf, 0, returned*sizeof(PORT_INFO_1));
00207 } else {
00208 inf = NULL;
00209 }
00210
00211 prs_set_offset(&buffer->prs, 0);
00212
00213 for (i=0; i<returned; i++) {
00214 if (!smb_io_port_info_1("", buffer, &(inf[i]), 0)) {
00215 return False;
00216 }
00217 }
00218
00219 *info=inf;
00220 return True;
00221 }
00222
00223
00224
00225
00226 static BOOL decode_port_info_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00227 uint32 returned, PORT_INFO_2 **info)
00228 {
00229 uint32 i;
00230 PORT_INFO_2 *inf;
00231
00232 if (returned) {
00233 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_2, returned);
00234 if (!inf) {
00235 return False;
00236 }
00237 memset(inf, 0, returned*sizeof(PORT_INFO_2));
00238 } else {
00239 inf = NULL;
00240 }
00241
00242 prs_set_offset(&buffer->prs, 0);
00243
00244 for (i=0; i<returned; i++) {
00245 if (!smb_io_port_info_2("", buffer, &(inf[i]), 0)) {
00246 return False;
00247 }
00248 }
00249
00250 *info=inf;
00251 return True;
00252 }
00253
00254
00255
00256
00257 static BOOL decode_printer_driver_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00258 uint32 returned, DRIVER_INFO_1 **info)
00259 {
00260 uint32 i;
00261 DRIVER_INFO_1 *inf;
00262
00263 if (returned) {
00264 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_1, returned);
00265 if (!inf) {
00266 return False;
00267 }
00268 memset(inf, 0, returned*sizeof(DRIVER_INFO_1));
00269 } else {
00270 inf = NULL;
00271 }
00272
00273 prs_set_offset(&buffer->prs,0);
00274
00275 for (i=0; i<returned; i++) {
00276 if (!smb_io_printer_driver_info_1("", buffer, &(inf[i]), 0)) {
00277 return False;
00278 }
00279 }
00280
00281 *info=inf;
00282 return True;
00283 }
00284
00285
00286
00287
00288 static BOOL decode_printer_driver_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00289 uint32 returned, DRIVER_INFO_2 **info)
00290 {
00291 uint32 i;
00292 DRIVER_INFO_2 *inf;
00293
00294 if (returned) {
00295 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_2, returned);
00296 if (!inf) {
00297 return False;
00298 }
00299 memset(inf, 0, returned*sizeof(DRIVER_INFO_2));
00300 } else {
00301 inf = NULL;
00302 }
00303
00304 prs_set_offset(&buffer->prs,0);
00305
00306 for (i=0; i<returned; i++) {
00307 if (!smb_io_printer_driver_info_2("", buffer, &(inf[i]), 0)) {
00308 return False;
00309 }
00310 }
00311
00312 *info=inf;
00313 return True;
00314 }
00315
00316
00317
00318
00319 static BOOL decode_printer_driver_3(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00320 uint32 returned, DRIVER_INFO_3 **info)
00321 {
00322 uint32 i;
00323 DRIVER_INFO_3 *inf;
00324
00325 if (returned) {
00326 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_3, returned);
00327 if (!inf) {
00328 return False;
00329 }
00330 memset(inf, 0, returned*sizeof(DRIVER_INFO_3));
00331 } else {
00332 inf = NULL;
00333 }
00334
00335 prs_set_offset(&buffer->prs,0);
00336
00337 for (i=0; i<returned; i++) {
00338 if (!smb_io_printer_driver_info_3("", buffer, &(inf[i]), 0)) {
00339 return False;
00340 }
00341 }
00342
00343 *info=inf;
00344 return True;
00345 }
00346
00347
00348
00349
00350 static BOOL decode_printerdriverdir_1 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00351 uint32 returned, DRIVER_DIRECTORY_1 **info
00352 )
00353 {
00354 DRIVER_DIRECTORY_1 *inf;
00355
00356 inf=TALLOC_P(mem_ctx, DRIVER_DIRECTORY_1);
00357 if (!inf) {
00358 return False;
00359 }
00360 memset(inf, 0, sizeof(DRIVER_DIRECTORY_1));
00361
00362 prs_set_offset(&buffer->prs, 0);
00363
00364 if (!smb_io_driverdir_1("", buffer, inf, 0)) {
00365 return False;
00366 }
00367
00368 *info=inf;
00369 return True;
00370 }
00371
00372
00373
00374
00375 static BOOL decode_jobs_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00376 uint32 num_jobs, JOB_INFO_1 **jobs)
00377 {
00378 uint32 i;
00379
00380 if (num_jobs) {
00381 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_1, num_jobs);
00382 if (*jobs == NULL) {
00383 return False;
00384 }
00385 } else {
00386 *jobs = NULL;
00387 }
00388 prs_set_offset(&buffer->prs,0);
00389
00390 for (i = 0; i < num_jobs; i++) {
00391 if (!smb_io_job_info_1("", buffer, &((*jobs)[i]), 0)) {
00392 return False;
00393 }
00394 }
00395
00396 return True;
00397 }
00398
00399
00400
00401
00402 static BOOL decode_jobs_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00403 uint32 num_jobs, JOB_INFO_2 **jobs)
00404 {
00405 uint32 i;
00406
00407 if (num_jobs) {
00408 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_2, num_jobs);
00409 if (*jobs == NULL) {
00410 return False;
00411 }
00412 } else {
00413 *jobs = NULL;
00414 }
00415 prs_set_offset(&buffer->prs,0);
00416
00417 for (i = 0; i < num_jobs; i++) {
00418 if (!smb_io_job_info_2("", buffer, &((*jobs)[i]), 0)) {
00419 return False;
00420 }
00421 }
00422
00423 return True;
00424 }
00425
00426
00427
00428
00429 static BOOL decode_forms_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
00430 uint32 num_forms, FORM_1 **forms)
00431 {
00432 int i;
00433
00434 if (num_forms) {
00435 *forms = TALLOC_ARRAY(mem_ctx, FORM_1, num_forms);
00436 if (*forms == NULL) {
00437 return False;
00438 }
00439 } else {
00440 *forms = NULL;
00441 }
00442
00443 prs_set_offset(&buffer->prs,0);
00444
00445 for (i = 0; i < num_forms; i++) {
00446 if (!smb_io_form_1("", buffer, &((*forms)[i]), 0)) {
00447 return False;
00448 }
00449 }
00450
00451 return True;
00452 }
00453
00454
00455
00456
00457 WERROR rpccli_spoolss_open_printer_ex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00458 const char *printername, const char *datatype, uint32 access_required,
00459 const char *station, const char *username, POLICY_HND *pol)
00460 {
00461 prs_struct qbuf, rbuf;
00462 SPOOL_Q_OPEN_PRINTER_EX in;
00463 SPOOL_R_OPEN_PRINTER_EX out;
00464
00465 ZERO_STRUCT(in);
00466 ZERO_STRUCT(out);
00467
00468 make_spoolss_q_open_printer_ex( &in, printername, datatype,
00469 access_required, station, username );
00470
00471 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_OPENPRINTEREX,
00472 in, out,
00473 qbuf, rbuf,
00474 spoolss_io_q_open_printer_ex,
00475 spoolss_io_r_open_printer_ex,
00476 WERR_GENERAL_FAILURE );
00477
00478 memcpy( pol, &out.handle, sizeof(POLICY_HND) );
00479
00480 return out.status;
00481 }
00482
00483
00484
00485
00486 WERROR rpccli_spoolss_close_printer(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00487 POLICY_HND *pol)
00488 {
00489 prs_struct qbuf, rbuf;
00490 SPOOL_Q_CLOSEPRINTER in;
00491 SPOOL_R_CLOSEPRINTER out;
00492
00493 ZERO_STRUCT(in);
00494 ZERO_STRUCT(out);
00495
00496 make_spoolss_q_closeprinter( &in, pol );
00497
00498 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_CLOSEPRINTER,
00499 in, out,
00500 qbuf, rbuf,
00501 spoolss_io_q_closeprinter,
00502 spoolss_io_r_closeprinter,
00503 WERR_GENERAL_FAILURE );
00504
00505 return out.status;
00506 }
00507
00508
00509
00510
00511 WERROR rpccli_spoolss_enum_printers(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00512 char *name, uint32 flags, uint32 level,
00513 uint32 *num_printers, PRINTER_INFO_CTR *ctr)
00514 {
00515 prs_struct qbuf, rbuf;
00516 SPOOL_Q_ENUMPRINTERS in;
00517 SPOOL_R_ENUMPRINTERS out;
00518 RPC_BUFFER buffer;
00519 uint32 offered;
00520
00521 ZERO_STRUCT(in);
00522 ZERO_STRUCT(out);
00523
00524 offered = 0;
00525 rpcbuf_init(&buffer, offered, mem_ctx);
00526 make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
00527
00528 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERS,
00529 in, out,
00530 qbuf, rbuf,
00531 spoolss_io_q_enumprinters,
00532 spoolss_io_r_enumprinters,
00533 WERR_GENERAL_FAILURE );
00534
00535 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00536 offered = out.needed;
00537
00538 ZERO_STRUCT(in);
00539 ZERO_STRUCT(out);
00540
00541 rpcbuf_init(&buffer, offered, mem_ctx);
00542 make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
00543
00544 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERS,
00545 in, out,
00546 qbuf, rbuf,
00547 spoolss_io_q_enumprinters,
00548 spoolss_io_r_enumprinters,
00549 WERR_GENERAL_FAILURE );
00550 }
00551
00552 if ( !W_ERROR_IS_OK(out.status) )
00553 return out.status;
00554
00555 switch (level) {
00556 case 0:
00557 if (!decode_printer_info_0(mem_ctx, out.buffer, out.returned, &ctr->printers_0)) {
00558 return WERR_GENERAL_FAILURE;
00559 }
00560 break;
00561 case 1:
00562 if (!decode_printer_info_1(mem_ctx, out.buffer, out.returned, &ctr->printers_1)) {
00563 return WERR_GENERAL_FAILURE;
00564 }
00565 break;
00566 case 2:
00567 if (!decode_printer_info_2(mem_ctx, out.buffer, out.returned, &ctr->printers_2)) {
00568 return WERR_GENERAL_FAILURE;
00569 }
00570 break;
00571 case 3:
00572 if (!decode_printer_info_3(mem_ctx, out.buffer, out.returned, &ctr->printers_3)) {
00573 return WERR_GENERAL_FAILURE;
00574 }
00575 break;
00576 default:
00577 return WERR_UNKNOWN_LEVEL;
00578 }
00579
00580 *num_printers = out.returned;
00581
00582 return out.status;
00583 }
00584
00585
00586
00587
00588 WERROR rpccli_spoolss_enum_ports(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00589 uint32 level, uint32 *num_ports, PORT_INFO_CTR *ctr)
00590 {
00591 prs_struct qbuf, rbuf;
00592 SPOOL_Q_ENUMPORTS in;
00593 SPOOL_R_ENUMPORTS out;
00594 RPC_BUFFER buffer;
00595 fstring server;
00596 uint32 offered;
00597
00598 ZERO_STRUCT(in);
00599 ZERO_STRUCT(out);
00600
00601 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
00602 strupper_m(server);
00603
00604 offered = 0;
00605 rpcbuf_init(&buffer, offered, mem_ctx);
00606 make_spoolss_q_enumports( &in, server, level, &buffer, offered );
00607
00608 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPORTS,
00609 in, out,
00610 qbuf, rbuf,
00611 spoolss_io_q_enumports,
00612 spoolss_io_r_enumports,
00613 WERR_GENERAL_FAILURE );
00614
00615 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00616 offered = out.needed;
00617
00618 ZERO_STRUCT(in);
00619 ZERO_STRUCT(out);
00620
00621 rpcbuf_init(&buffer, offered, mem_ctx);
00622 make_spoolss_q_enumports( &in, server, level, &buffer, offered );
00623
00624 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPORTS,
00625 in, out,
00626 qbuf, rbuf,
00627 spoolss_io_q_enumports,
00628 spoolss_io_r_enumports,
00629 WERR_GENERAL_FAILURE );
00630 }
00631
00632 if ( !W_ERROR_IS_OK(out.status) )
00633 return out.status;
00634
00635 switch (level) {
00636 case 1:
00637 if (!decode_port_info_1(mem_ctx, out.buffer, out.returned, &ctr->port.info_1)) {
00638 return WERR_GENERAL_FAILURE;
00639 }
00640 break;
00641 case 2:
00642 if (!decode_port_info_2(mem_ctx, out.buffer, out.returned, &ctr->port.info_2)) {
00643 return WERR_GENERAL_FAILURE;
00644 }
00645 break;
00646 default:
00647 return WERR_UNKNOWN_LEVEL;
00648 }
00649
00650 *num_ports = out.returned;
00651
00652 return out.status;
00653 }
00654
00655
00656
00657
00658 WERROR rpccli_spoolss_getprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00659 POLICY_HND *pol, uint32 level,
00660 PRINTER_INFO_CTR *ctr)
00661 {
00662 prs_struct qbuf, rbuf;
00663 SPOOL_Q_GETPRINTER in;
00664 SPOOL_R_GETPRINTER out;
00665 RPC_BUFFER buffer;
00666 uint32 offered;
00667
00668 ZERO_STRUCT(in);
00669 ZERO_STRUCT(out);
00670
00671
00672
00673 offered = 0;
00674 rpcbuf_init(&buffer, offered, mem_ctx);
00675 make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
00676
00677 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTER,
00678 in, out,
00679 qbuf, rbuf,
00680 spoolss_io_q_getprinter,
00681 spoolss_io_r_getprinter,
00682 WERR_GENERAL_FAILURE );
00683
00684 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00685 offered = out.needed;
00686
00687 ZERO_STRUCT(in);
00688 ZERO_STRUCT(out);
00689
00690 rpcbuf_init(&buffer, offered, mem_ctx);
00691 make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
00692
00693 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTER,
00694 in, out,
00695 qbuf, rbuf,
00696 spoolss_io_q_getprinter,
00697 spoolss_io_r_getprinter,
00698 WERR_GENERAL_FAILURE );
00699 }
00700
00701 if ( !W_ERROR_IS_OK(out.status) )
00702 return out.status;
00703
00704 switch (level) {
00705 case 0:
00706 if (!decode_printer_info_0(mem_ctx, out.buffer, 1, &ctr->printers_0)) {
00707 return WERR_GENERAL_FAILURE;
00708 }
00709 break;
00710 case 1:
00711 if (!decode_printer_info_1(mem_ctx, out.buffer, 1, &ctr->printers_1)) {
00712 return WERR_GENERAL_FAILURE;
00713 }
00714 break;
00715 case 2:
00716 if (!decode_printer_info_2(mem_ctx, out.buffer, 1, &ctr->printers_2)) {
00717 return WERR_GENERAL_FAILURE;
00718 }
00719 break;
00720 case 3:
00721 if (!decode_printer_info_3(mem_ctx, out.buffer, 1, &ctr->printers_3)) {
00722 return WERR_GENERAL_FAILURE;
00723 }
00724 break;
00725 case 7:
00726 if (!decode_printer_info_7(mem_ctx, out.buffer, 1, &ctr->printers_7)) {
00727 return WERR_GENERAL_FAILURE;
00728 }
00729 break;
00730 default:
00731 return WERR_UNKNOWN_LEVEL;
00732 }
00733
00734 return out.status;
00735 }
00736
00737
00738
00739
00740 WERROR rpccli_spoolss_setprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00741 POLICY_HND *pol, uint32 level,
00742 PRINTER_INFO_CTR *ctr, uint32 command)
00743 {
00744 prs_struct qbuf, rbuf;
00745 SPOOL_Q_SETPRINTER in;
00746 SPOOL_R_SETPRINTER out;
00747
00748 ZERO_STRUCT(in);
00749 ZERO_STRUCT(out);
00750
00751 make_spoolss_q_setprinter( mem_ctx, &in, pol, level, ctr, command );
00752
00753 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTER,
00754 in, out,
00755 qbuf, rbuf,
00756 spoolss_io_q_setprinter,
00757 spoolss_io_r_setprinter,
00758 WERR_GENERAL_FAILURE );
00759
00760 return out.status;
00761 }
00762
00763
00764
00765
00766 WERROR rpccli_spoolss_getprinterdriver(struct rpc_pipe_client *cli,
00767 TALLOC_CTX *mem_ctx,
00768 POLICY_HND *pol, uint32 level,
00769 const char *env, int version, PRINTER_DRIVER_CTR *ctr)
00770 {
00771 prs_struct qbuf, rbuf;
00772 SPOOL_Q_GETPRINTERDRIVER2 in;
00773 SPOOL_R_GETPRINTERDRIVER2 out;
00774 RPC_BUFFER buffer;
00775 fstring server;
00776 uint32 offered;
00777
00778 ZERO_STRUCT(in);
00779 ZERO_STRUCT(out);
00780
00781 fstrcpy(server, cli->cli->desthost);
00782 strupper_m(server);
00783
00784 offered = 0;
00785 rpcbuf_init(&buffer, offered, mem_ctx);
00786 make_spoolss_q_getprinterdriver2( &in, pol, env, level,
00787 version, 2, &buffer, offered);
00788
00789 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVER2,
00790 in, out,
00791 qbuf, rbuf,
00792 spoolss_io_q_getprinterdriver2,
00793 spoolss_io_r_getprinterdriver2,
00794 WERR_GENERAL_FAILURE );
00795
00796 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00797 offered = out.needed;
00798
00799 ZERO_STRUCT(in);
00800 ZERO_STRUCT(out);
00801
00802 rpcbuf_init(&buffer, offered, mem_ctx);
00803 make_spoolss_q_getprinterdriver2( &in, pol, env, level,
00804 version, 2, &buffer, offered);
00805
00806 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVER2,
00807 in, out,
00808 qbuf, rbuf,
00809 spoolss_io_q_getprinterdriver2,
00810 spoolss_io_r_getprinterdriver2,
00811 WERR_GENERAL_FAILURE );
00812 }
00813
00814 if ( !W_ERROR_IS_OK(out.status) )
00815 return out.status;
00816
00817 switch (level) {
00818 case 1:
00819 if (!decode_printer_driver_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
00820 return WERR_GENERAL_FAILURE;
00821 }
00822 break;
00823 case 2:
00824 if (!decode_printer_driver_2(mem_ctx, out.buffer, 1, &ctr->info2)) {
00825 return WERR_GENERAL_FAILURE;
00826 }
00827 break;
00828 case 3:
00829 if (!decode_printer_driver_3(mem_ctx, out.buffer, 1, &ctr->info3)) {
00830 return WERR_GENERAL_FAILURE;
00831 }
00832 break;
00833 default:
00834 return WERR_UNKNOWN_LEVEL;
00835 }
00836
00837 return out.status;
00838 }
00839
00840
00841
00842
00843 WERROR rpccli_spoolss_enumprinterdrivers (struct rpc_pipe_client *cli,
00844 TALLOC_CTX *mem_ctx,
00845 uint32 level, const char *env,
00846 uint32 *num_drivers,
00847 PRINTER_DRIVER_CTR *ctr)
00848 {
00849 prs_struct qbuf, rbuf;
00850 SPOOL_Q_ENUMPRINTERDRIVERS in;
00851 SPOOL_R_ENUMPRINTERDRIVERS out;
00852 RPC_BUFFER buffer;
00853 fstring server;
00854 uint32 offered;
00855
00856 ZERO_STRUCT(in);
00857 ZERO_STRUCT(out);
00858
00859 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
00860 strupper_m(server);
00861
00862 offered = 0;
00863 rpcbuf_init(&buffer, offered, mem_ctx);
00864 make_spoolss_q_enumprinterdrivers( &in, server, env, level,
00865 &buffer, offered);
00866
00867 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDRIVERS,
00868 in, out,
00869 qbuf, rbuf,
00870 spoolss_io_q_enumprinterdrivers,
00871 spoolss_io_r_enumprinterdrivers,
00872 WERR_GENERAL_FAILURE );
00873
00874 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00875 offered = out.needed;
00876
00877 ZERO_STRUCT(in);
00878 ZERO_STRUCT(out);
00879
00880 rpcbuf_init(&buffer, offered, mem_ctx);
00881 make_spoolss_q_enumprinterdrivers( &in, server, env, level,
00882 &buffer, offered);
00883
00884 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDRIVERS,
00885 in, out,
00886 qbuf, rbuf,
00887 spoolss_io_q_enumprinterdrivers,
00888 spoolss_io_r_enumprinterdrivers,
00889 WERR_GENERAL_FAILURE );
00890 }
00891
00892 *num_drivers = out.returned;
00893
00894 if ( !W_ERROR_IS_OK(out.status) )
00895 return out.status;
00896
00897 if ( out.returned ) {
00898
00899 switch (level) {
00900 case 1:
00901 if (!decode_printer_driver_1(mem_ctx, out.buffer, out.returned, &ctr->info1)) {
00902 return WERR_GENERAL_FAILURE;
00903 }
00904 break;
00905 case 2:
00906 if (!decode_printer_driver_2(mem_ctx, out.buffer, out.returned, &ctr->info2)) {
00907 return WERR_GENERAL_FAILURE;
00908 }
00909 break;
00910 case 3:
00911 if (!decode_printer_driver_3(mem_ctx, out.buffer, out.returned, &ctr->info3)) {
00912 return WERR_GENERAL_FAILURE;
00913 }
00914 break;
00915 default:
00916 return WERR_UNKNOWN_LEVEL;
00917 }
00918 }
00919
00920 return out.status;
00921 }
00922
00923
00924
00925
00926
00927 WERROR rpccli_spoolss_getprinterdriverdir (struct rpc_pipe_client *cli,
00928 TALLOC_CTX *mem_ctx,
00929 uint32 level, char *env,
00930 DRIVER_DIRECTORY_CTR *ctr)
00931 {
00932 prs_struct qbuf, rbuf;
00933 SPOOL_Q_GETPRINTERDRIVERDIR in;
00934 SPOOL_R_GETPRINTERDRIVERDIR out;
00935 RPC_BUFFER buffer;
00936 fstring server;
00937 uint32 offered;
00938
00939 ZERO_STRUCT(in);
00940 ZERO_STRUCT(out);
00941
00942 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
00943 strupper_m(server);
00944
00945 offered = 0;
00946 rpcbuf_init(&buffer, offered, mem_ctx);
00947 make_spoolss_q_getprinterdriverdir( &in, server, env, level,
00948 &buffer, offered );
00949
00950 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
00951 in, out,
00952 qbuf, rbuf,
00953 spoolss_io_q_getprinterdriverdir,
00954 spoolss_io_r_getprinterdriverdir,
00955 WERR_GENERAL_FAILURE );
00956
00957 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00958 offered = out.needed;
00959
00960 ZERO_STRUCT(in);
00961 ZERO_STRUCT(out);
00962
00963 rpcbuf_init(&buffer, offered, mem_ctx);
00964 make_spoolss_q_getprinterdriverdir( &in, server, env, level,
00965 &buffer, offered );
00966
00967 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
00968 in, out,
00969 qbuf, rbuf,
00970 spoolss_io_q_getprinterdriverdir,
00971 spoolss_io_r_getprinterdriverdir,
00972 WERR_GENERAL_FAILURE );
00973 }
00974
00975 if (!W_ERROR_IS_OK(out.status))
00976 return out.status;
00977
00978 if (!decode_printerdriverdir_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
00979 return WERR_GENERAL_FAILURE;
00980 }
00981
00982 return out.status;
00983 }
00984
00985
00986
00987
00988 WERROR rpccli_spoolss_addprinterdriver (struct rpc_pipe_client *cli,
00989 TALLOC_CTX *mem_ctx, uint32 level,
00990 PRINTER_DRIVER_CTR *ctr)
00991 {
00992 prs_struct qbuf, rbuf;
00993 SPOOL_Q_ADDPRINTERDRIVER in;
00994 SPOOL_R_ADDPRINTERDRIVER out;
00995 fstring server;
00996
00997 ZERO_STRUCT(in);
00998 ZERO_STRUCT(out);
00999
01000 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
01001 strupper_m(server);
01002
01003 make_spoolss_q_addprinterdriver( mem_ctx, &in, server, level, ctr );
01004
01005 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDPRINTERDRIVER,
01006 in, out,
01007 qbuf, rbuf,
01008 spoolss_io_q_addprinterdriver,
01009 spoolss_io_r_addprinterdriver,
01010 WERR_GENERAL_FAILURE );
01011
01012 return out.status;
01013 }
01014
01015
01016
01017
01018 WERROR rpccli_spoolss_addprinterex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01019 uint32 level, PRINTER_INFO_CTR*ctr)
01020 {
01021 prs_struct qbuf, rbuf;
01022 SPOOL_Q_ADDPRINTEREX in;
01023 SPOOL_R_ADDPRINTEREX out;
01024 fstring server, client, user;
01025
01026 ZERO_STRUCT(in);
01027 ZERO_STRUCT(out);
01028
01029 slprintf(client, sizeof(fstring)-1, "\\\\%s", global_myname());
01030 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
01031
01032 strupper_m(client);
01033 strupper_m(server);
01034
01035 fstrcpy (user, cli->user_name);
01036
01037 make_spoolss_q_addprinterex( mem_ctx, &in, server, client,
01038 user, level, ctr);
01039
01040 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDPRINTEREX,
01041 in, out,
01042 qbuf, rbuf,
01043 spoolss_io_q_addprinterex,
01044 spoolss_io_r_addprinterex,
01045 WERR_GENERAL_FAILURE );
01046
01047 return out.status;
01048 }
01049
01050
01051
01052
01053 WERROR rpccli_spoolss_deleteprinterdriverex(struct rpc_pipe_client *cli,
01054 TALLOC_CTX *mem_ctx, const char *arch,
01055 const char *driver, int version)
01056 {
01057 prs_struct qbuf, rbuf;
01058 SPOOL_Q_DELETEPRINTERDRIVEREX in;
01059 SPOOL_R_DELETEPRINTERDRIVEREX out;
01060 fstring server;
01061
01062 ZERO_STRUCT(in);
01063 ZERO_STRUCT(out);
01064
01065 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
01066 strupper_m(server);
01067
01068 make_spoolss_q_deleteprinterdriverex( mem_ctx, &in, server, arch, driver, version );
01069
01070 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDRIVEREX,
01071 in, out,
01072 qbuf, rbuf,
01073 spoolss_io_q_deleteprinterdriverex,
01074 spoolss_io_r_deleteprinterdriverex,
01075 WERR_GENERAL_FAILURE );
01076
01077 return out.status;
01078 }
01079
01080
01081
01082
01083 WERROR rpccli_spoolss_deleteprinterdriver (struct rpc_pipe_client *cli,
01084 TALLOC_CTX *mem_ctx, const char *arch,
01085 const char *driver)
01086 {
01087 prs_struct qbuf, rbuf;
01088 SPOOL_Q_DELETEPRINTERDRIVER in;
01089 SPOOL_R_DELETEPRINTERDRIVER out;
01090 fstring server;
01091
01092 ZERO_STRUCT(in);
01093 ZERO_STRUCT(out);
01094
01095 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
01096 strupper_m(server);
01097
01098 make_spoolss_q_deleteprinterdriver( mem_ctx, &in, server, arch, driver );
01099
01100 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDRIVER,
01101 in, out,
01102 qbuf, rbuf,
01103 spoolss_io_q_deleteprinterdriver,
01104 spoolss_io_r_deleteprinterdriver,
01105 WERR_GENERAL_FAILURE );
01106
01107 return out.status;
01108 }
01109
01110
01111
01112
01113 WERROR rpccli_spoolss_getprintprocessordirectory(struct rpc_pipe_client *cli,
01114 TALLOC_CTX *mem_ctx,
01115 char *name, char *environment,
01116 fstring procdir)
01117 {
01118 prs_struct qbuf, rbuf;
01119 SPOOL_Q_GETPRINTPROCESSORDIRECTORY in;
01120 SPOOL_R_GETPRINTPROCESSORDIRECTORY out;
01121 int level = 1;
01122 RPC_BUFFER buffer;
01123 uint32 offered;
01124
01125 ZERO_STRUCT(in);
01126 ZERO_STRUCT(out);
01127
01128 offered = 0;
01129 rpcbuf_init(&buffer, offered, mem_ctx);
01130 make_spoolss_q_getprintprocessordirectory( &in, name,
01131 environment, level, &buffer, offered );
01132
01133 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
01134 in, out,
01135 qbuf, rbuf,
01136 spoolss_io_q_getprintprocessordirectory,
01137 spoolss_io_r_getprintprocessordirectory,
01138 WERR_GENERAL_FAILURE );
01139
01140 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
01141 offered = out.needed;
01142
01143 ZERO_STRUCT(in);
01144 ZERO_STRUCT(out);
01145
01146 rpcbuf_init(&buffer, offered, mem_ctx);
01147 make_spoolss_q_getprintprocessordirectory( &in, name,
01148 environment, level, &buffer, offered );
01149
01150 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
01151 in, out,
01152 qbuf, rbuf,
01153 spoolss_io_q_getprintprocessordirectory,
01154 spoolss_io_r_getprintprocessordirectory,
01155 WERR_GENERAL_FAILURE );
01156 }
01157
01158 if ( !W_ERROR_IS_OK(out.status) )
01159 return out.status;
01160
01161 fstrcpy(procdir, "Not implemented!");
01162
01163 return out.status;
01164 }
01165
01166
01167
01168
01169 WERROR rpccli_spoolss_addform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01170 POLICY_HND *handle, uint32 level, FORM *form)
01171 {
01172 prs_struct qbuf, rbuf;
01173 SPOOL_Q_ADDFORM in;
01174 SPOOL_R_ADDFORM out;
01175
01176 ZERO_STRUCT(in);
01177 ZERO_STRUCT(out);
01178
01179 make_spoolss_q_addform( &in, handle, level, form );
01180
01181 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDFORM,
01182 in, out,
01183 qbuf, rbuf,
01184 spoolss_io_q_addform,
01185 spoolss_io_r_addform,
01186 WERR_GENERAL_FAILURE );
01187
01188 return out.status;
01189 }
01190
01191
01192
01193
01194 WERROR rpccli_spoolss_setform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01195 POLICY_HND *handle, uint32 level,
01196 const char *form_name, FORM *form)
01197 {
01198 prs_struct qbuf, rbuf;
01199 SPOOL_Q_SETFORM in;
01200 SPOOL_R_SETFORM out;
01201
01202 ZERO_STRUCT(in);
01203 ZERO_STRUCT(out);
01204
01205 make_spoolss_q_setform( &in, handle, level, form_name, form );
01206
01207 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETFORM,
01208 in, out,
01209 qbuf, rbuf,
01210 spoolss_io_q_setform,
01211 spoolss_io_r_setform,
01212 WERR_GENERAL_FAILURE );
01213
01214 return out.status;
01215 }
01216
01217
01218
01219
01220 WERROR rpccli_spoolss_getform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01221 POLICY_HND *handle, const char *formname,
01222 uint32 level, FORM_1 *form)
01223 {
01224 prs_struct qbuf, rbuf;
01225 SPOOL_Q_GETFORM in;
01226 SPOOL_R_GETFORM out;
01227 RPC_BUFFER buffer;
01228 uint32 offered;
01229
01230 ZERO_STRUCT(in);
01231 ZERO_STRUCT(out);
01232
01233 offered = 0;
01234 rpcbuf_init(&buffer, offered, mem_ctx);
01235 make_spoolss_q_getform( &in, handle, formname, level, &buffer, offered );
01236
01237 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETFORM,
01238 in, out,
01239 qbuf, rbuf,
01240 spoolss_io_q_getform,
01241 spoolss_io_r_getform,
01242 WERR_GENERAL_FAILURE );
01243
01244 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
01245 offered = out.needed;
01246
01247 ZERO_STRUCT(in);
01248 ZERO_STRUCT(out);
01249
01250 rpcbuf_init(&buffer, offered, mem_ctx);
01251 make_spoolss_q_getform( &in, handle, formname, level, &buffer, offered );
01252
01253 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETFORM,
01254 in, out,
01255 qbuf, rbuf,
01256 spoolss_io_q_getform,
01257 spoolss_io_r_getform,
01258 WERR_GENERAL_FAILURE );
01259 }
01260
01261 if (!W_ERROR_IS_OK(out.status))
01262 return out.status;
01263
01264 if (!smb_io_form_1("", out.buffer, form, 0)) {
01265 return WERR_GENERAL_FAILURE;
01266 }
01267
01268 return out.status;
01269 }
01270
01271
01272
01273
01274 WERROR rpccli_spoolss_deleteform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01275 POLICY_HND *handle, const char *form_name)
01276 {
01277 prs_struct qbuf, rbuf;
01278 SPOOL_Q_DELETEFORM in;
01279 SPOOL_R_DELETEFORM out;
01280
01281 ZERO_STRUCT(in);
01282 ZERO_STRUCT(out);
01283
01284 make_spoolss_q_deleteform( &in, handle, form_name );
01285
01286 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEFORM,
01287 in, out,
01288 qbuf, rbuf,
01289 spoolss_io_q_deleteform,
01290 spoolss_io_r_deleteform,
01291 WERR_GENERAL_FAILURE );
01292
01293 return out.status;
01294 }
01295
01296
01297
01298
01299 WERROR rpccli_spoolss_enumforms(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01300 POLICY_HND *handle, int level, uint32 *num_forms,
01301 FORM_1 **forms)
01302 {
01303 prs_struct qbuf, rbuf;
01304 SPOOL_Q_ENUMFORMS in;
01305 SPOOL_R_ENUMFORMS out;
01306 RPC_BUFFER buffer;
01307 uint32 offered;
01308
01309 ZERO_STRUCT(in);
01310 ZERO_STRUCT(out);
01311
01312 offered = 0;
01313 rpcbuf_init(&buffer, offered, mem_ctx);
01314 make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
01315
01316 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMFORMS,
01317 in, out,
01318 qbuf, rbuf,
01319 spoolss_io_q_enumforms,
01320 spoolss_io_r_enumforms,
01321 WERR_GENERAL_FAILURE );
01322
01323 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
01324 offered = out.needed;
01325
01326 ZERO_STRUCT(in);
01327 ZERO_STRUCT(out);
01328
01329 rpcbuf_init(&buffer, offered, mem_ctx);
01330 make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
01331
01332 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMFORMS,
01333 in, out,
01334 qbuf, rbuf,
01335 spoolss_io_q_enumforms,
01336 spoolss_io_r_enumforms,
01337 WERR_GENERAL_FAILURE );
01338 }
01339
01340 if (!W_ERROR_IS_OK(out.status))
01341 return out.status;
01342
01343 *num_forms = out.numofforms;
01344
01345 if (!decode_forms_1(mem_ctx, out.buffer, *num_forms, forms)) {
01346 return WERR_GENERAL_FAILURE;
01347 }
01348
01349 return out.status;
01350 }
01351
01352
01353
01354
01355 WERROR rpccli_spoolss_enumjobs(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01356 POLICY_HND *hnd, uint32 level, uint32 firstjob,
01357 uint32 num_jobs, uint32 *returned, JOB_INFO_CTR *ctr)
01358 {
01359 prs_struct qbuf, rbuf;
01360 SPOOL_Q_ENUMJOBS in;
01361 SPOOL_R_ENUMJOBS out;
01362 RPC_BUFFER buffer;
01363 uint32 offered;
01364
01365 ZERO_STRUCT(in);
01366 ZERO_STRUCT(out);
01367
01368 offered = 0;
01369 rpcbuf_init(&buffer, offered, mem_ctx);
01370 make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
01371 &buffer, offered );
01372
01373 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMJOBS,
01374 in, out,
01375 qbuf, rbuf,
01376 spoolss_io_q_enumjobs,
01377 spoolss_io_r_enumjobs,
01378 WERR_GENERAL_FAILURE );
01379
01380 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
01381 offered = out.needed;
01382
01383 ZERO_STRUCT(in);
01384 ZERO_STRUCT(out);
01385
01386 rpcbuf_init(&buffer, offered, mem_ctx);
01387 make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
01388 &buffer, offered );
01389
01390 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMJOBS,
01391 in, out,
01392 qbuf, rbuf,
01393 spoolss_io_q_enumjobs,
01394 spoolss_io_r_enumjobs,
01395 WERR_GENERAL_FAILURE );
01396 }
01397
01398 if (!W_ERROR_IS_OK(out.status))
01399 return out.status;
01400
01401 switch(level) {
01402 case 1:
01403 if (!decode_jobs_1(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_1)) {
01404 return WERR_GENERAL_FAILURE;
01405 }
01406 break;
01407 case 2:
01408 if (!decode_jobs_2(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_2)) {
01409 return WERR_GENERAL_FAILURE;
01410 }
01411 break;
01412 default:
01413 DEBUG(3, ("unsupported info level %d", level));
01414 return WERR_UNKNOWN_LEVEL;
01415 }
01416
01417 *returned = out.returned;
01418
01419 return out.status;
01420 }
01421
01422
01423
01424
01425 WERROR rpccli_spoolss_setjob(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01426 POLICY_HND *hnd, uint32 jobid, uint32 level,
01427 uint32 command)
01428 {
01429 prs_struct qbuf, rbuf;
01430 SPOOL_Q_SETJOB in;
01431 SPOOL_R_SETJOB out;
01432
01433 ZERO_STRUCT(in);
01434 ZERO_STRUCT(out);
01435
01436 make_spoolss_q_setjob( &in, hnd, jobid, level, command );
01437
01438 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETJOB,
01439 in, out,
01440 qbuf, rbuf,
01441 spoolss_io_q_setjob,
01442 spoolss_io_r_setjob,
01443 WERR_GENERAL_FAILURE );
01444
01445 return out.status;
01446 }
01447
01448
01449
01450
01451 WERROR rpccli_spoolss_getjob(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01452 POLICY_HND *hnd, uint32 jobid, uint32 level,
01453 JOB_INFO_CTR *ctr)
01454 {
01455 prs_struct qbuf, rbuf;
01456 SPOOL_Q_GETJOB in;
01457 SPOOL_R_GETJOB out;
01458 RPC_BUFFER buffer;
01459 uint32 offered;
01460
01461 ZERO_STRUCT(in);
01462 ZERO_STRUCT(out);
01463
01464 offered = 0;
01465 rpcbuf_init(&buffer, offered, mem_ctx);
01466 make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
01467
01468 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETJOB,
01469 in, out,
01470 qbuf, rbuf,
01471 spoolss_io_q_getjob,
01472 spoolss_io_r_getjob,
01473 WERR_GENERAL_FAILURE );
01474
01475 if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
01476 offered = out.needed;
01477
01478 ZERO_STRUCT(in);
01479 ZERO_STRUCT(out);
01480
01481 rpcbuf_init(&buffer, offered, mem_ctx);
01482 make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
01483
01484 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETJOB,
01485 in, out,
01486 qbuf, rbuf,
01487 spoolss_io_q_getjob,
01488 spoolss_io_r_getjob,
01489 WERR_GENERAL_FAILURE );
01490 }
01491
01492 if (!W_ERROR_IS_OK(out.status))
01493 return out.status;
01494
01495 switch(level) {
01496 case 1:
01497 if (!decode_jobs_1(mem_ctx, out.buffer, 1, &ctr->job.job_info_1)) {
01498 return WERR_GENERAL_FAILURE;
01499 }
01500 break;
01501 case 2:
01502 if (!decode_jobs_2(mem_ctx, out.buffer, 1, &ctr->job.job_info_2)) {
01503 return WERR_GENERAL_FAILURE;
01504 }
01505 break;
01506 default:
01507 return WERR_UNKNOWN_LEVEL;
01508 }
01509
01510 return out.status;
01511 }
01512
01513
01514
01515
01516 WERROR rpccli_spoolss_startpageprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01517 POLICY_HND *hnd)
01518 {
01519 prs_struct qbuf, rbuf;
01520 SPOOL_Q_STARTPAGEPRINTER in;
01521 SPOOL_R_STARTPAGEPRINTER out;
01522
01523 ZERO_STRUCT(in);
01524 ZERO_STRUCT(out);
01525
01526 make_spoolss_q_startpageprinter( &in, hnd );
01527
01528 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_STARTPAGEPRINTER,
01529 in, out,
01530 qbuf, rbuf,
01531 spoolss_io_q_startpageprinter,
01532 spoolss_io_r_startpageprinter,
01533 WERR_GENERAL_FAILURE );
01534
01535 return out.status;
01536 }
01537
01538
01539
01540
01541 WERROR rpccli_spoolss_endpageprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01542 POLICY_HND *hnd)
01543 {
01544 prs_struct qbuf, rbuf;
01545 SPOOL_Q_ENDPAGEPRINTER in;
01546 SPOOL_R_ENDPAGEPRINTER out;
01547
01548 ZERO_STRUCT(in);
01549 ZERO_STRUCT(out);
01550
01551 make_spoolss_q_endpageprinter( &in, hnd );
01552
01553 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENDPAGEPRINTER,
01554 in, out,
01555 qbuf, rbuf,
01556 spoolss_io_q_endpageprinter,
01557 spoolss_io_r_endpageprinter,
01558 WERR_GENERAL_FAILURE );
01559
01560 return out.status;
01561 }
01562
01563
01564
01565
01566 WERROR rpccli_spoolss_startdocprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01567 POLICY_HND *hnd, char *docname,
01568 char *outputfile, char *datatype,
01569 uint32 *jobid)
01570 {
01571 prs_struct qbuf, rbuf;
01572 SPOOL_Q_STARTDOCPRINTER in;
01573 SPOOL_R_STARTDOCPRINTER out;
01574 uint32 level = 1;
01575
01576 ZERO_STRUCT(in);
01577 ZERO_STRUCT(out);
01578
01579 make_spoolss_q_startdocprinter( &in, hnd, level, docname,
01580 outputfile, datatype );
01581
01582 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_STARTDOCPRINTER,
01583 in, out,
01584 qbuf, rbuf,
01585 spoolss_io_q_startdocprinter,
01586 spoolss_io_r_startdocprinter,
01587 WERR_GENERAL_FAILURE );
01588
01589 *jobid = out.jobid;
01590
01591 return out.status;
01592 }
01593
01594
01595
01596
01597 WERROR rpccli_spoolss_enddocprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01598 POLICY_HND *hnd)
01599 {
01600 prs_struct qbuf, rbuf;
01601 SPOOL_Q_ENDDOCPRINTER in;
01602 SPOOL_R_ENDDOCPRINTER out;
01603
01604 ZERO_STRUCT(in);
01605 ZERO_STRUCT(out);
01606
01607 make_spoolss_q_enddocprinter( &in, hnd );
01608
01609 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENDDOCPRINTER,
01610 in, out,
01611 qbuf, rbuf,
01612 spoolss_io_q_enddocprinter,
01613 spoolss_io_r_enddocprinter,
01614 WERR_GENERAL_FAILURE );
01615
01616 return out.status;
01617 }
01618
01619
01620
01621
01622 WERROR rpccli_spoolss_getprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01623 POLICY_HND *hnd, const char *valuename,
01624 REGISTRY_VALUE *value)
01625 {
01626 prs_struct qbuf, rbuf;
01627 SPOOL_Q_GETPRINTERDATA in;
01628 SPOOL_R_GETPRINTERDATA out;
01629 uint32 offered;
01630
01631 ZERO_STRUCT(in);
01632 ZERO_STRUCT(out);
01633
01634 offered = 0;
01635 make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
01636
01637 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATA,
01638 in, out,
01639 qbuf, rbuf,
01640 spoolss_io_q_getprinterdata,
01641 spoolss_io_r_getprinterdata,
01642 WERR_GENERAL_FAILURE );
01643
01644 if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
01645 offered = out.needed;
01646
01647 ZERO_STRUCT(in);
01648 ZERO_STRUCT(out);
01649
01650 make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
01651
01652 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATA,
01653 in, out,
01654 qbuf, rbuf,
01655 spoolss_io_q_getprinterdata,
01656 spoolss_io_r_getprinterdata,
01657 WERR_GENERAL_FAILURE );
01658 }
01659
01660 if (!W_ERROR_IS_OK(out.status))
01661 return out.status;
01662
01663
01664
01665 if (out.needed) {
01666 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
01667 } else {
01668 value->data_p = NULL;
01669 }
01670 value->type = out.type;
01671 value->size = out.size;
01672
01673 return out.status;
01674 }
01675
01676
01677
01678
01679 WERROR rpccli_spoolss_getprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01680 POLICY_HND *hnd, const char *keyname,
01681 const char *valuename,
01682 REGISTRY_VALUE *value)
01683 {
01684 prs_struct qbuf, rbuf;
01685 SPOOL_Q_GETPRINTERDATAEX in;
01686 SPOOL_R_GETPRINTERDATAEX out;
01687 uint32 offered = 0;
01688
01689 ZERO_STRUCT(in);
01690 ZERO_STRUCT(out);
01691
01692 make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
01693
01694 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATAEX,
01695 in, out,
01696 qbuf, rbuf,
01697 spoolss_io_q_getprinterdataex,
01698 spoolss_io_r_getprinterdataex,
01699 WERR_GENERAL_FAILURE );
01700
01701 if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
01702 offered = out.needed;
01703
01704 ZERO_STRUCT(in);
01705 ZERO_STRUCT(out);
01706
01707 make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
01708
01709 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATAEX,
01710 in, out,
01711 qbuf, rbuf,
01712 spoolss_io_q_getprinterdataex,
01713 spoolss_io_r_getprinterdataex,
01714 WERR_GENERAL_FAILURE );
01715 }
01716
01717 if (!W_ERROR_IS_OK(out.status))
01718 return out.status;
01719
01720
01721
01722 if (out.needed) {
01723 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
01724 } else {
01725 value->data_p = NULL;
01726 }
01727 value->type = out.type;
01728 value->size = out.needed;
01729
01730 return out.status;
01731 }
01732
01733
01734
01735
01736 WERROR rpccli_spoolss_setprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01737 POLICY_HND *hnd, REGISTRY_VALUE *value)
01738 {
01739 prs_struct qbuf, rbuf;
01740 SPOOL_Q_SETPRINTERDATA in;
01741 SPOOL_R_SETPRINTERDATA out;
01742
01743 ZERO_STRUCT(in);
01744 ZERO_STRUCT(out);
01745
01746 make_spoolss_q_setprinterdata( &in, hnd, value->valuename,
01747 value->type, (char *)value->data_p, value->size);
01748
01749 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTERDATA,
01750 in, out,
01751 qbuf, rbuf,
01752 spoolss_io_q_setprinterdata,
01753 spoolss_io_r_setprinterdata,
01754 WERR_GENERAL_FAILURE );
01755
01756 return out.status;
01757 }
01758
01759
01760
01761
01762 WERROR rpccli_spoolss_setprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01763 POLICY_HND *hnd, char *keyname,
01764 REGISTRY_VALUE *value)
01765 {
01766 prs_struct qbuf, rbuf;
01767 SPOOL_Q_SETPRINTERDATAEX in;
01768 SPOOL_R_SETPRINTERDATAEX out;
01769
01770 ZERO_STRUCT(in);
01771 ZERO_STRUCT(out);
01772
01773 make_spoolss_q_setprinterdataex( &in, hnd, keyname, value->valuename,
01774 value->type, (char *)value->data_p, value->size);
01775
01776 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTERDATAEX,
01777 in, out,
01778 qbuf, rbuf,
01779 spoolss_io_q_setprinterdataex,
01780 spoolss_io_r_setprinterdataex,
01781 WERR_GENERAL_FAILURE );
01782
01783 return out.status;
01784 }
01785
01786
01787
01788
01789 WERROR rpccli_spoolss_enumprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01790 POLICY_HND *hnd, uint32 ndx,
01791 uint32 value_offered, uint32 data_offered,
01792 uint32 *value_needed, uint32 *data_needed,
01793 REGISTRY_VALUE *value)
01794 {
01795 prs_struct qbuf, rbuf;
01796 SPOOL_Q_ENUMPRINTERDATA in;
01797 SPOOL_R_ENUMPRINTERDATA out;
01798
01799 ZERO_STRUCT(in);
01800 ZERO_STRUCT(out);
01801
01802 make_spoolss_q_enumprinterdata( &in, hnd, ndx, value_offered, data_offered );
01803
01804 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATA,
01805 in, out,
01806 qbuf, rbuf,
01807 spoolss_io_q_enumprinterdata,
01808 spoolss_io_r_enumprinterdata,
01809 WERR_GENERAL_FAILURE );
01810
01811 if ( value_needed )
01812 *value_needed = out.realvaluesize;
01813 if ( data_needed )
01814 *data_needed = out.realdatasize;
01815
01816 if (!W_ERROR_IS_OK(out.status))
01817 return out.status;
01818
01819 if (value) {
01820 rpcstr_pull(value->valuename, out.value, sizeof(value->valuename), -1,
01821 STR_TERMINATE);
01822 if (out.realdatasize) {
01823 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data,
01824 out.realdatasize);
01825 } else {
01826 value->data_p = NULL;
01827 }
01828 value->type = out.type;
01829 value->size = out.realdatasize;
01830 }
01831
01832 return out.status;
01833 }
01834
01835
01836
01837
01838 WERROR rpccli_spoolss_enumprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01839 POLICY_HND *hnd, const char *keyname,
01840 REGVAL_CTR *ctr)
01841 {
01842 prs_struct qbuf, rbuf;
01843 SPOOL_Q_ENUMPRINTERDATAEX in;
01844 SPOOL_R_ENUMPRINTERDATAEX out;
01845 int i;
01846 uint32 offered;
01847
01848 ZERO_STRUCT(in);
01849 ZERO_STRUCT(out);
01850
01851 offered = 0;
01852 make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
01853
01854 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATAEX,
01855 in, out,
01856 qbuf, rbuf,
01857 spoolss_io_q_enumprinterdataex,
01858 spoolss_io_r_enumprinterdataex,
01859 WERR_GENERAL_FAILURE );
01860
01861 if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
01862 offered = out.needed;
01863
01864 ZERO_STRUCT(in);
01865 ZERO_STRUCT(out);
01866
01867 make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
01868
01869 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATAEX,
01870 in, out,
01871 qbuf, rbuf,
01872 spoolss_io_q_enumprinterdataex,
01873 spoolss_io_r_enumprinterdataex,
01874 WERR_GENERAL_FAILURE );
01875 }
01876
01877 if (!W_ERROR_IS_OK(out.status))
01878 return out.status;
01879
01880 for (i = 0; i < out.returned; i++) {
01881 PRINTER_ENUM_VALUES *v = &out.ctr.values[i];
01882 fstring name;
01883
01884 rpcstr_pull(name, v->valuename.buffer, sizeof(name), -1,
01885 STR_TERMINATE);
01886 regval_ctr_addvalue(ctr, name, v->type, (const char *)v->data, v->data_len);
01887 }
01888
01889 return out.status;
01890 }
01891
01892
01893
01894
01895 WERROR rpccli_spoolss_writeprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01896 POLICY_HND *hnd, uint32 data_size, char *data,
01897 uint32 *num_written)
01898 {
01899 prs_struct qbuf, rbuf;
01900 SPOOL_Q_WRITEPRINTER in;
01901 SPOOL_R_WRITEPRINTER out;
01902
01903 ZERO_STRUCT(in);
01904 ZERO_STRUCT(out);
01905
01906 make_spoolss_q_writeprinter( &in, hnd, data_size, data );
01907
01908 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_WRITEPRINTER,
01909 in, out,
01910 qbuf, rbuf,
01911 spoolss_io_q_writeprinter,
01912 spoolss_io_r_writeprinter,
01913 WERR_GENERAL_FAILURE );
01914
01915 if (num_written)
01916 *num_written = out.buffer_written;
01917
01918 return out.status;
01919 }
01920
01921
01922
01923
01924 WERROR rpccli_spoolss_deleteprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01925 POLICY_HND *hnd, char *valuename)
01926 {
01927 prs_struct qbuf, rbuf;
01928 SPOOL_Q_DELETEPRINTERDATA in;
01929 SPOOL_R_DELETEPRINTERDATA out;
01930
01931 ZERO_STRUCT(in);
01932 ZERO_STRUCT(out);
01933
01934 make_spoolss_q_deleteprinterdata( &in, hnd, valuename );
01935
01936 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDATA,
01937 in, out,
01938 qbuf, rbuf,
01939 spoolss_io_q_deleteprinterdata,
01940 spoolss_io_r_deleteprinterdata,
01941 WERR_GENERAL_FAILURE );
01942
01943 return out.status;
01944 }
01945
01946
01947
01948
01949 WERROR rpccli_spoolss_deleteprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01950 POLICY_HND *hnd, char *keyname,
01951 char *valuename)
01952 {
01953 prs_struct qbuf, rbuf;
01954 SPOOL_Q_DELETEPRINTERDATAEX in;
01955 SPOOL_R_DELETEPRINTERDATAEX out;
01956
01957 ZERO_STRUCT(in);
01958 ZERO_STRUCT(out);
01959
01960 make_spoolss_q_deleteprinterdataex( &in, hnd, keyname, valuename );
01961
01962 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDATAEX,
01963 in, out,
01964 qbuf, rbuf,
01965 spoolss_io_q_deleteprinterdataex,
01966 spoolss_io_r_deleteprinterdataex,
01967 WERR_GENERAL_FAILURE );
01968
01969 return out.status;
01970 }
01971
01972
01973
01974
01975 WERROR rpccli_spoolss_enumprinterkey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01976 POLICY_HND *hnd, const char *keyname,
01977 uint16 **keylist, uint32 *len)
01978 {
01979 prs_struct qbuf, rbuf;
01980 SPOOL_Q_ENUMPRINTERKEY in;
01981 SPOOL_R_ENUMPRINTERKEY out;
01982 uint32 offered = 0;
01983
01984 ZERO_STRUCT(in);
01985 ZERO_STRUCT(out);
01986
01987 make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
01988
01989 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERKEY,
01990 in, out,
01991 qbuf, rbuf,
01992 spoolss_io_q_enumprinterkey,
01993 spoolss_io_r_enumprinterkey,
01994 WERR_GENERAL_FAILURE );
01995
01996 if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
01997 offered = out.needed;
01998
01999 ZERO_STRUCT(in);
02000 ZERO_STRUCT(out);
02001
02002 make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
02003
02004 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERKEY,
02005 in, out,
02006 qbuf, rbuf,
02007 spoolss_io_q_enumprinterkey,
02008 spoolss_io_r_enumprinterkey,
02009 WERR_GENERAL_FAILURE );
02010 }
02011
02012 if ( !W_ERROR_IS_OK(out.status) )
02013 return out.status;
02014
02015 if (keylist) {
02016 *keylist = SMB_MALLOC_ARRAY(uint16, out.keys.buf_len);
02017 if (!*keylist) {
02018 return WERR_NOMEM;
02019 }
02020 memcpy(*keylist, out.keys.buffer, out.keys.buf_len * 2);
02021 if (len)
02022 *len = out.keys.buf_len * 2;
02023 }
02024
02025 return out.status;
02026 }
02027
02028
02029
02030
02031 WERROR rpccli_spoolss_deleteprinterkey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
02032 POLICY_HND *hnd, char *keyname)
02033 {
02034 prs_struct qbuf, rbuf;
02035 SPOOL_Q_DELETEPRINTERKEY in;
02036 SPOOL_R_DELETEPRINTERKEY out;
02037
02038 ZERO_STRUCT(in);
02039 ZERO_STRUCT(out);
02040
02041 make_spoolss_q_deleteprinterkey( &in, hnd, keyname );
02042
02043 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERKEY,
02044 in, out,
02045 qbuf, rbuf,
02046 spoolss_io_q_deleteprinterkey,
02047 spoolss_io_r_deleteprinterkey,
02048 WERR_GENERAL_FAILURE );
02049
02050 return out.status;
02051 }
02052
02053
