Copyright (C) Tim Potter 2000
Copyright (C) Andrew Tridgell 1992-1999
Copyright (C) Luke Kenneth Casson Leighton 1996-1999
+ Copyright (C) Guenther Deschner 2009
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "includes.h"
#include "rpcclient.h"
+#include "../librpc/gen_ndr/cli_spoolss.h"
+#include "rpc_client/cli_spoolss.h"
+#include "rpc_client/init_spoolss.h"
+#include "registry.h"
+#include "registry/reg_objects.h"
+#include "nt_printing.h"
#define RPCCLIENT_PRINTERNAME(_printername, _cli, _arg) \
{ \
W_ERROR_HAVE_NO_MEMORY(_printername); \
}
-struct table_node {
- const char *long_archi;
- const char *short_archi;
- int version;
-};
-
/* The version int is used by getdrivers. Note that
all architecture strings that support mutliple
versions must be grouped together since enumdrivers
enumdriver calls for the same arch */
-static const struct table_node archi_table[]= {
+static const struct print_architecture_table_node archi_table[]= {
{"Windows 4.0", "WIN40", 0 },
{"Windows NT x86", "W32X86", 2 },
int argc, const char **argv)
{
WERROR werror;
- POLICY_HND hnd;
+ struct policy_handle hnd;
+ uint32_t access_mask = PRINTER_ALL_ACCESS;
- if (argc != 2) {
- printf("Usage: %s <printername>\n", argv[0]);
+ if (argc < 2) {
+ printf("Usage: %s <printername> [access_mask]\n", argv[0]);
return WERR_OK;
}
- if (!cli)
- return WERR_GENERAL_FAILURE;
+ if (argc >= 3) {
+ sscanf(argv[2], "%x", &access_mask);
+ }
/* Open the printer handle */
werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
argv[1],
- PRINTER_ALL_ACCESS,
+ access_mask,
&hnd);
if (W_ERROR_IS_OK(werror)) {
printf("Printer %s opened successfully\n", argv[1]);
/****************************************************************************
****************************************************************************/
-static void display_print_info_0(PRINTER_INFO_0 *i0)
+static void display_print_info0(struct spoolss_PrinterInfo0 *r)
{
- fstring name = "";
- fstring servername = "";
-
- if (!i0)
+ if (!r)
return;
- rpcstr_pull(name, i0->printername.buffer, sizeof(name), -1, STR_TERMINATE);
-
- rpcstr_pull(servername, i0->servername.buffer, sizeof(servername), -1,STR_TERMINATE);
-
- printf("\tprintername:[%s]\n", name);
- printf("\tservername:[%s]\n", servername);
- printf("\tcjobs:[0x%x]\n", i0->cjobs);
- printf("\ttotal_jobs:[0x%x]\n", i0->total_jobs);
-
- printf("\t:date: [%d]-[%d]-[%d] (%d)\n", i0->year, i0->month,
- i0->day, i0->dayofweek);
- printf("\t:time: [%d]-[%d]-[%d]-[%d]\n", i0->hour, i0->minute,
- i0->second, i0->milliseconds);
-
- printf("\tglobal_counter:[0x%x]\n", i0->global_counter);
- printf("\ttotal_pages:[0x%x]\n", i0->total_pages);
-
- printf("\tmajorversion:[0x%x]\n", i0->major_version);
- printf("\tbuildversion:[0x%x]\n", i0->build_version);
-
- printf("\tunknown7:[0x%x]\n", i0->unknown7);
- printf("\tunknown8:[0x%x]\n", i0->unknown8);
- printf("\tunknown9:[0x%x]\n", i0->unknown9);
- printf("\tsession_counter:[0x%x]\n", i0->session_counter);
- printf("\tunknown11:[0x%x]\n", i0->unknown11);
- printf("\tprinter_errors:[0x%x]\n", i0->printer_errors);
- printf("\tunknown13:[0x%x]\n", i0->unknown13);
- printf("\tunknown14:[0x%x]\n", i0->unknown14);
- printf("\tunknown15:[0x%x]\n", i0->unknown15);
- printf("\tunknown16:[0x%x]\n", i0->unknown16);
- printf("\tchange_id:[0x%x]\n", i0->change_id);
- printf("\tunknown18:[0x%x]\n", i0->unknown18);
- printf("\tstatus:[0x%x]\n", i0->status);
- printf("\tunknown20:[0x%x]\n", i0->unknown20);
- printf("\tc_setprinter:[0x%x]\n", i0->c_setprinter);
- printf("\tunknown22:[0x%x]\n", i0->unknown22);
- printf("\tunknown23:[0x%x]\n", i0->unknown23);
- printf("\tunknown24:[0x%x]\n", i0->unknown24);
- printf("\tunknown25:[0x%x]\n", i0->unknown25);
- printf("\tunknown26:[0x%x]\n", i0->unknown26);
- printf("\tunknown27:[0x%x]\n", i0->unknown27);
- printf("\tunknown28:[0x%x]\n", i0->unknown28);
- printf("\tunknown29:[0x%x]\n", i0->unknown29);
+ printf("\tprintername:[%s]\n", r->printername);
+ printf("\tservername:[%s]\n", r->servername);
+ printf("\tcjobs:[0x%x]\n", r->cjobs);
+ printf("\ttotal_jobs:[0x%x]\n", r->total_jobs);
+ printf("\ttotal_bytes:[0x%x]\n", r->total_bytes);
+ printf("\t:date: [%d]-[%d]-[%d] (%d)\n", r->time.year, r->time.month,
+ r->time.day, r->time.day_of_week);
+ printf("\t:time: [%d]-[%d]-[%d]-[%d]\n", r->time.hour, r->time.minute,
+ r->time.second, r->time.millisecond);
+
+ printf("\tglobal_counter:[0x%x]\n", r->global_counter);
+ printf("\ttotal_pages:[0x%x]\n", r->total_pages);
+
+ printf("\tversion:[0x%x]\n", r->version);
+ printf("\tfree_build:[0x%x]\n", r->free_build);
+ printf("\tspooling:[0x%x]\n", r->spooling);
+ printf("\tmax_spooling:[0x%x]\n", r->max_spooling);
+ printf("\tsession_counter:[0x%x]\n", r->session_counter);
+ printf("\tnum_error_out_of_paper:[0x%x]\n", r->num_error_out_of_paper);
+ printf("\tnum_error_not_ready:[0x%x]\n", r->num_error_not_ready);
+ printf("\tjob_error:[0x%x]\n", r->job_error);
+ printf("\tnumber_of_processors:[0x%x]\n", r->number_of_processors);
+ printf("\tprocessor_type:[0x%x]\n", r->processor_type);
+ printf("\thigh_part_total_bytes:[0x%x]\n", r->high_part_total_bytes);
+ printf("\tchange_id:[0x%x]\n", r->change_id);
+ printf("\tlast_error: %s\n", win_errstr(r->last_error));
+ printf("\tstatus:[0x%x]\n", r->status);
+ printf("\tenumerate_network_printers:[0x%x]\n", r->enumerate_network_printers);
+ printf("\tc_setprinter:[0x%x]\n", r->c_setprinter);
+ printf("\tprocessor_architecture:[0x%x]\n", r->processor_architecture);
+ printf("\tprocessor_level:[0x%x]\n", r->processor_level);
+ printf("\tref_ic:[0x%x]\n", r->ref_ic);
+ printf("\treserved2:[0x%x]\n", r->reserved2);
+ printf("\treserved3:[0x%x]\n", r->reserved3);
printf("\n");
}
/****************************************************************************
****************************************************************************/
-static void display_print_info_1(PRINTER_INFO_1 *i1)
+static void display_print_info1(struct spoolss_PrinterInfo1 *r)
{
- fstring desc = "";
- fstring name = "";
- fstring comm = "";
+ printf("\tflags:[0x%x]\n", r->flags);
+ printf("\tname:[%s]\n", r->name);
+ printf("\tdescription:[%s]\n", r->description);
+ printf("\tcomment:[%s]\n", r->comment);
- rpcstr_pull(desc, i1->description.buffer, sizeof(desc), -1,
- STR_TERMINATE);
+ printf("\n");
+}
- rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
- rpcstr_pull(comm, i1->comment.buffer, sizeof(comm), -1, STR_TERMINATE);
+/****************************************************************************
+****************************************************************************/
- printf("\tflags:[0x%x]\n", i1->flags);
- printf("\tname:[%s]\n", name);
- printf("\tdescription:[%s]\n", desc);
- printf("\tcomment:[%s]\n", comm);
+static void display_print_info2(struct spoolss_PrinterInfo2 *r)
+{
+ printf("\tservername:[%s]\n", r->servername);
+ printf("\tprintername:[%s]\n", r->printername);
+ printf("\tsharename:[%s]\n", r->sharename);
+ printf("\tportname:[%s]\n", r->portname);
+ printf("\tdrivername:[%s]\n", r->drivername);
+ printf("\tcomment:[%s]\n", r->comment);
+ printf("\tlocation:[%s]\n", r->location);
+ printf("\tsepfile:[%s]\n", r->sepfile);
+ printf("\tprintprocessor:[%s]\n", r->printprocessor);
+ printf("\tdatatype:[%s]\n", r->datatype);
+ printf("\tparameters:[%s]\n", r->parameters);
+ printf("\tattributes:[0x%x]\n", r->attributes);
+ printf("\tpriority:[0x%x]\n", r->priority);
+ printf("\tdefaultpriority:[0x%x]\n", r->defaultpriority);
+ printf("\tstarttime:[0x%x]\n", r->starttime);
+ printf("\tuntiltime:[0x%x]\n", r->untiltime);
+ printf("\tstatus:[0x%x]\n", r->status);
+ printf("\tcjobs:[0x%x]\n", r->cjobs);
+ printf("\taverageppm:[0x%x]\n", r->averageppm);
+
+ if (r->secdesc)
+ display_sec_desc(r->secdesc);
printf("\n");
}
/****************************************************************************
****************************************************************************/
-static void display_print_info_2(PRINTER_INFO_2 *i2)
-{
- fstring servername = "";
- fstring printername = "";
- fstring sharename = "";
- fstring portname = "";
- fstring drivername = "";
- fstring comment = "";
- fstring location = "";
- fstring sepfile = "";
- fstring printprocessor = "";
- fstring datatype = "";
- fstring parameters = "";
-
- rpcstr_pull(servername, i2->servername.buffer,sizeof(servername), -1, STR_TERMINATE);
- rpcstr_pull(printername, i2->printername.buffer,sizeof(printername), -1, STR_TERMINATE);
- rpcstr_pull(sharename, i2->sharename.buffer,sizeof(sharename), -1, STR_TERMINATE);
- rpcstr_pull(portname, i2->portname.buffer,sizeof(portname), -1, STR_TERMINATE);
- rpcstr_pull(drivername, i2->drivername.buffer,sizeof(drivername), -1, STR_TERMINATE);
- rpcstr_pull(comment, i2->comment.buffer,sizeof(comment), -1, STR_TERMINATE);
- rpcstr_pull(location, i2->location.buffer,sizeof(location), -1, STR_TERMINATE);
- rpcstr_pull(sepfile, i2->sepfile.buffer,sizeof(sepfile), -1, STR_TERMINATE);
- rpcstr_pull(printprocessor, i2->printprocessor.buffer,sizeof(printprocessor), -1, STR_TERMINATE);
- rpcstr_pull(datatype, i2->datatype.buffer,sizeof(datatype), -1, STR_TERMINATE);
- rpcstr_pull(parameters, i2->parameters.buffer,sizeof(parameters), -1, STR_TERMINATE);
-
- printf("\tservername:[%s]\n", servername);
- printf("\tprintername:[%s]\n", printername);
- printf("\tsharename:[%s]\n", sharename);
- printf("\tportname:[%s]\n", portname);
- printf("\tdrivername:[%s]\n", drivername);
- printf("\tcomment:[%s]\n", comment);
- printf("\tlocation:[%s]\n", location);
- printf("\tsepfile:[%s]\n", sepfile);
- printf("\tprintprocessor:[%s]\n", printprocessor);
- printf("\tdatatype:[%s]\n", datatype);
- printf("\tparameters:[%s]\n", parameters);
- printf("\tattributes:[0x%x]\n", i2->attributes);
- printf("\tpriority:[0x%x]\n", i2->priority);
- printf("\tdefaultpriority:[0x%x]\n", i2->defaultpriority);
- printf("\tstarttime:[0x%x]\n", i2->starttime);
- printf("\tuntiltime:[0x%x]\n", i2->untiltime);
- printf("\tstatus:[0x%x]\n", i2->status);
- printf("\tcjobs:[0x%x]\n", i2->cjobs);
- printf("\taverageppm:[0x%x]\n", i2->averageppm);
-
- if (i2->secdesc)
- display_sec_desc(i2->secdesc);
+static void display_print_info3(struct spoolss_PrinterInfo3 *r)
+{
+ display_sec_desc(r->secdesc);
+
+ printf("\n");
+}
+
+/****************************************************************************
+****************************************************************************/
+static void display_print_info4(struct spoolss_PrinterInfo4 *r)
+{
+ printf("\tservername:[%s]\n", r->servername);
+ printf("\tprintername:[%s]\n", r->printername);
+ printf("\tattributes:[0x%x]\n", r->attributes);
printf("\n");
}
/****************************************************************************
****************************************************************************/
-static void display_print_info_3(PRINTER_INFO_3 *i3)
+static void display_print_info5(struct spoolss_PrinterInfo5 *r)
{
- display_sec_desc(i3->secdesc);
+ printf("\tprintername:[%s]\n", r->printername);
+ printf("\tportname:[%s]\n", r->portname);
+ printf("\tattributes:[0x%x]\n", r->attributes);
+ printf("\tdevice_not_selected_timeout:[0x%x]\n", r->device_not_selected_timeout);
+ printf("\ttransmission_retry_timeout:[0x%x]\n", r->transmission_retry_timeout);
+ printf("\n");
+}
+
+/****************************************************************************
+****************************************************************************/
+static void display_print_info6(struct spoolss_PrinterInfo6 *r)
+{
+ printf("\tstatus:[0x%x]\n", r->status);
printf("\n");
}
{
printf("\tguid:[%s]\n", r->guid);
printf("\taction:[0x%x]\n", r->action);
+ printf("\n");
}
-
/****************************************************************************
****************************************************************************/
static WERROR cmd_spoolss_enum_printers(struct rpc_pipe_client *cli,
- TALLOC_CTX *mem_ctx,
- int argc, const char **argv)
+ TALLOC_CTX *mem_ctx,
+ int argc, const char **argv)
{
WERROR result;
- uint32 info_level = 1;
- PRINTER_INFO_CTR ctr;
- uint32 i = 0, num_printers;
- fstring name;
-
- if (argc > 3)
- {
- printf("Usage: %s [level] [name]\n", argv[0]);
+ uint32_t level = 1;
+ union spoolss_PrinterInfo *info;
+ uint32_t i, count;
+ const char *name;
+ uint32_t flags = PRINTER_ENUM_LOCAL;
+
+ if (argc > 4) {
+ printf("Usage: %s [level] [name] [flags]\n", argv[0]);
return WERR_OK;
}
- if (argc >= 2)
- info_level = atoi(argv[1]);
-
- if (argc == 3)
- fstrcpy(name, argv[2]);
- else {
- slprintf(name, sizeof(name)-1, "\\\\%s", cli->desthost);
- strupper_m(name);
+ if (argc >= 2) {
+ level = atoi(argv[1]);
}
- ZERO_STRUCT(ctr);
+ if (argc >= 3) {
+ name = argv[2];
+ } else {
+ name = cli->srv_name_slash;
+ }
- result = rpccli_spoolss_enum_printers(cli, mem_ctx, name, PRINTER_ENUM_LOCAL,
- info_level, &num_printers, &ctr);
+ if (argc == 4) {
+ flags = atoi(argv[3]);
+ }
+ result = rpccli_spoolss_enumprinters(cli, mem_ctx,
+ flags,
+ name,
+ level,
+ 0,
+ &count,
+ &info);
if (W_ERROR_IS_OK(result)) {
- if (!num_printers) {
+ if (!count) {
printf ("No printers returned.\n");
goto done;
}
- for (i = 0; i < num_printers; i++) {
- switch(info_level) {
+ for (i = 0; i < count; i++) {
+ switch (level) {
case 0:
- display_print_info_0(&ctr.printers_0[i]);
+ display_print_info0(&info[i].info0);
break;
case 1:
- display_print_info_1(&ctr.printers_1[i]);
+ display_print_info1(&info[i].info1);
break;
case 2:
- display_print_info_2(&ctr.printers_2[i]);
+ display_print_info2(&info[i].info2);
break;
case 3:
- display_print_info_3(&ctr.printers_3[i]);
+ display_print_info3(&info[i].info3);
+ break;
+ case 4:
+ display_print_info4(&info[i].info4);
+ break;
+ case 5:
+ display_print_info5(&info[i].info5);
+ break;
+ case 6:
+ display_print_info6(&info[i].info6);
break;
default:
- printf("unknown info level %d\n", info_level);
+ printf("unknown info level %d\n", level);
goto done;
}
}
}
- done:
+ done:
return result;
}
/****************************************************************************
****************************************************************************/
-static void display_port_info_1(PORT_INFO_1 *i1)
+static void display_port_info_1(struct spoolss_PortInfo1 *r)
{
- fstring buffer;
-
- rpcstr_pull(buffer, i1->port_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
- printf("\tPort Name:\t[%s]\n", buffer);
+ printf("\tPort Name:\t[%s]\n", r->port_name);
}
/****************************************************************************
****************************************************************************/
-static void display_port_info_2(PORT_INFO_2 *i2)
+static void display_port_info_2(struct spoolss_PortInfo2 *r)
{
- fstring buffer;
-
- rpcstr_pull(buffer, i2->port_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
- printf("\tPort Name:\t[%s]\n", buffer);
- rpcstr_pull(buffer, i2->monitor_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
-
- printf("\tMonitor Name:\t[%s]\n", buffer);
- rpcstr_pull(buffer, i2->description.buffer, sizeof(buffer), -1, STR_TERMINATE);
-
- printf("\tDescription:\t[%s]\n", buffer);
+ printf("\tPort Name:\t[%s]\n", r->port_name);
+ printf("\tMonitor Name:\t[%s]\n", r->monitor_name);
+ printf("\tDescription:\t[%s]\n", r->description);
printf("\tPort Type:\t" );
- if ( i2->port_type ) {
+ if (r->port_type) {
int comma = 0; /* hack */
printf( "[" );
- if ( i2->port_type & PORT_TYPE_READ ) {
+ if (r->port_type & SPOOLSS_PORT_TYPE_READ) {
printf( "Read" );
comma = 1;
}
- if ( i2->port_type & PORT_TYPE_WRITE ) {
+ if (r->port_type & SPOOLSS_PORT_TYPE_WRITE) {
printf( "%sWrite", comma ? ", " : "" );
comma = 1;
}
/* These two have slightly different interpretations
on 95/98/ME but I'm disregarding that for now */
- if ( i2->port_type & PORT_TYPE_REDIRECTED ) {
+ if (r->port_type & SPOOLSS_PORT_TYPE_REDIRECTED) {
printf( "%sRedirected", comma ? ", " : "" );
comma = 1;
}
- if ( i2->port_type & PORT_TYPE_NET_ATTACHED ) {
+ if (r->port_type & SPOOLSS_PORT_TYPE_NET_ATTACHED) {
printf( "%sNet-Attached", comma ? ", " : "" );
}
printf( "]\n" );
} else {
printf( "[Unset]\n" );
}
- printf("\tReserved:\t[%d]\n", i2->reserved);
+ printf("\tReserved:\t[%d]\n", r->reserved);
printf("\n");
}
const char **argv)
{
WERROR result;
- uint32 info_level = 1;
- PORT_INFO_CTR ctr;
- uint32 returned;
+ uint32_t level = 1;
+ uint32_t count;
+ union spoolss_PortInfo *info;
if (argc > 2) {
printf("Usage: %s [level]\n", argv[0]);
return WERR_OK;
}
- if (argc == 2)
- info_level = atoi(argv[1]);
+ if (argc == 2) {
+ level = atoi(argv[1]);
+ }
/* Enumerate ports */
- ZERO_STRUCT(ctr);
-
- result = rpccli_spoolss_enum_ports(cli, mem_ctx, info_level, &returned, &ctr);
-
+ result = rpccli_spoolss_enumports(cli, mem_ctx,
+ cli->srv_name_slash,
+ level,
+ 0,
+ &count,
+ &info);
if (W_ERROR_IS_OK(result)) {
int i;
- for (i = 0; i < returned; i++) {
- switch (info_level) {
+ for (i = 0; i < count; i++) {
+ switch (level) {
case 1:
- display_port_info_1(&ctr.port.info_1[i]);
+ display_port_info_1(&info[i].info1);
break;
case 2:
- display_port_info_2(&ctr.port.info_2[i]);
+ display_port_info_2(&info[i].info2);
break;
default:
- printf("unknown info level %d\n", info_level);
+ printf("unknown info level %d\n", level);
break;
}
}
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- POLICY_HND pol;
+ struct policy_handle pol;
WERROR result;
NTSTATUS status;
- uint32 info_level = 2;
+ uint32_t info_level = 2;
union spoolss_PrinterInfo info;
struct spoolss_SetPrinterInfoCtr info_ctr;
+ struct spoolss_SetPrinterInfo2 info2;
const char *printername, *comment = NULL;
struct spoolss_DevmodeContainer devmode_ctr;
struct sec_desc_buf secdesc_ctr;
/* Modify the comment. */
- info.info2.comment = comment;
- info.info2.secdesc = NULL;
- info.info2.devmode = NULL;
+ spoolss_printerinfo2_to_setprinterinfo2(&info.info2, &info2);
+ info2.comment = comment;
info_ctr.level = 2;
- info_ctr.info.info2 = (struct spoolss_SetPrinterInfo2 *)&info.info2;
+ info_ctr.info.info2 = &info2;
status = rpccli_spoolss_SetPrinter(cli, mem_ctx,
&pol,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- POLICY_HND pol;
+ struct policy_handle pol;
WERROR result;
NTSTATUS status;
- uint32 info_level = 2;
+ uint32_t info_level = 2;
union spoolss_PrinterInfo info;
const char *printername,
*new_printername = NULL;
struct spoolss_SetPrinterInfoCtr info_ctr;
+ struct spoolss_SetPrinterInfo2 info2;
struct spoolss_DevmodeContainer devmode_ctr;
struct sec_desc_buf secdesc_ctr;
goto done;
/* Modify the printername. */
- info.info2.printername = new_printername;
- info.info2.devmode = NULL;
- info.info2.secdesc = NULL;
+ spoolss_printerinfo2_to_setprinterinfo2(&info.info2, &info2);
+ info2.printername = new_printername;
- info_ctr.level = info_level;
- info_ctr.info.info2 = (struct spoolss_SetPrinterInfo2 *)&info.info2;
+ info_ctr.level = 2;
+ info_ctr.info.info2 = &info2;
status = rpccli_spoolss_SetPrinter(cli, mem_ctx,
&pol,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- POLICY_HND pol;
+ struct policy_handle pol;
WERROR result;
- uint32 info_level = 1;
+ uint32_t level = 1;
const char *printername;
union spoolss_PrinterInfo info;
/* Open a printer handle */
if (argc == 3) {
- info_level = atoi(argv[2]);
+ level = atoi(argv[2]);
}
RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
printername,
SEC_FLAG_MAXIMUM_ALLOWED,
&pol);
- if (!W_ERROR_IS_OK(result))
+ if (!W_ERROR_IS_OK(result)) {
goto done;
+ }
/* Get printer info */
result = rpccli_spoolss_getprinter(cli, mem_ctx,
&pol,
- info_level,
+ level,
0,
&info);
- if (!W_ERROR_IS_OK(result))
+ if (!W_ERROR_IS_OK(result)) {
goto done;
+ }
/* Display printer info */
- switch (info_level) {
-#if 0 /* FIXME GD */
+ switch (level) {
case 0:
- display_print_info_0(ctr.printers_0);
+ display_print_info0(&info.info0);
break;
case 1:
- display_print_info_1(ctr.printers_1);
+ display_print_info1(&info.info1);
break;
case 2:
- display_print_info_2(ctr.printers_2);
+ display_print_info2(&info.info2);
break;
case 3:
- display_print_info_3(ctr.printers_3);
+ display_print_info3(&info.info3);
+ break;
+ case 4:
+ display_print_info4(&info.info4);
+ break;
+ case 5:
+ display_print_info5(&info.info5);
+ break;
+ case 6:
+ display_print_info6(&info.info6);
break;
-#endif
case 7:
display_print_info7(&info.info7);
break;
default:
- printf("unknown info level %d\n", info_level);
+ printf("unknown info level %d\n", level);
break;
}
done:
- if (is_valid_policy_hnd(&pol))
+ if (is_valid_policy_hnd(&pol)) {
rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
+ }
return result;
}
/****************************************************************************
****************************************************************************/
-static void display_reg_value(REGISTRY_VALUE value)
+static void display_reg_value(struct regval_blob *value)
{
- char *text = NULL;
+ const char *text = NULL;
+ DATA_BLOB blob;
- switch(value.type) {
+ switch(regval_type(value)) {
case REG_DWORD:
- printf("%s: REG_DWORD: 0x%08x\n", value.valuename,
- *((uint32 *) value.data_p));
+ printf("%s: REG_DWORD: 0x%08x\n", regval_name(value),
+ *((uint32_t *) regval_data_p(value)));
break;
case REG_SZ:
- rpcstr_pull_talloc(talloc_tos(),
- &text,
- value.data_p,
- value.size,
- STR_TERMINATE);
- printf("%s: REG_SZ: %s\n", value.valuename, text ? text : "");
+ blob = data_blob_const(regval_data_p(value), regval_size(value));
+ pull_reg_sz(talloc_tos(), &blob, &text);
+ printf("%s: REG_SZ: %s\n", regval_name(value), text ? text : "");
break;
case REG_BINARY: {
- char *hex = hex_encode_talloc(NULL, value.data_p, value.size);
+ char *hex = hex_encode_talloc(NULL, regval_data_p(value), regval_size(value));
size_t i, len;
- printf("%s: REG_BINARY:", value.valuename);
+ printf("%s: REG_BINARY:", regval_name(value));
len = strlen(hex);
for (i=0; i<len; i++) {
if (hex[i] == '\0') {
break;
}
case REG_MULTI_SZ: {
- uint32 i, num_values;
- char **values;
+ uint32_t i;
+ const char **values;
+ blob = data_blob_const(regval_data_p(value), regval_size(value));
- if (!W_ERROR_IS_OK(reg_pull_multi_sz(NULL, value.data_p,
- value.size, &num_values,
- &values))) {
- d_printf("reg_pull_multi_sz failed\n");
+ if (!pull_reg_multi_sz(NULL, &blob, &values)) {
+ d_printf("pull_reg_multi_sz failed\n");
break;
}
- for (i=0; i<num_values; i++) {
+ printf("%s: REG_MULTI_SZ: \n", regval_name(value));
+ for (i=0; values[i] != NULL; i++) {
d_printf("%s\n", values[i]);
}
TALLOC_FREE(values);
break;
}
default:
- printf("%s: unknown type %d\n", value.valuename, value.type);
+ printf("%s: unknown type %d\n", regval_name(value), regval_type(value));
+ }
+
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static void display_printer_data(const char *v,
+ enum winreg_Type type,
+ uint8_t *data,
+ uint32_t length)
+{
+ int i;
+ union spoolss_PrinterData r;
+ DATA_BLOB blob = data_blob_const(data, length);
+ WERROR result;
+
+ result = pull_spoolss_PrinterData(talloc_tos(), &blob, &r, type);
+ if (!W_ERROR_IS_OK(result)) {
+ return;
}
+ switch (type) {
+ case REG_DWORD:
+ printf("%s: REG_DWORD: 0x%08x\n", v, r.value);
+ break;
+ case REG_SZ:
+ printf("%s: REG_SZ: %s\n", v, r.string);
+ break;
+ case REG_BINARY: {
+ char *hex = hex_encode_talloc(NULL,
+ r.binary.data, r.binary.length);
+ size_t len;
+ printf("%s: REG_BINARY:", v);
+ len = strlen(hex);
+ for (i=0; i<len; i++) {
+ if (hex[i] == '\0') {
+ break;
+ }
+ if (i%40 == 0) {
+ putchar('\n');
+ }
+ putchar(hex[i]);
+ }
+ TALLOC_FREE(hex);
+ putchar('\n');
+ break;
+ }
+ case REG_MULTI_SZ:
+ printf("%s: REG_MULTI_SZ: ", v);
+ for (i=0; r.string_array[i] != NULL; i++) {
+ printf("%s ", r.string_array[i]);
+ }
+ printf("\n");
+ break;
+ default:
+ printf("%s: unknown type 0x%02x:\n", v, type);
+ break;
+ }
}
/****************************************************************************
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- POLICY_HND pol;
+ struct policy_handle pol;
WERROR result;
fstring printername;
const char *valuename;
- REGISTRY_VALUE value;
+ enum winreg_Type type;
+ uint8_t *data;
+ uint32_t needed;
if (argc != 3) {
printf("Usage: %s <printername> <valuename>\n", argv[0]);
/* Get printer info */
- result = rpccli_spoolss_getprinterdata(cli, mem_ctx, &pol, valuename, &value);
-
+ result = rpccli_spoolss_getprinterdata(cli, mem_ctx,
+ &pol,
+ valuename,
+ 0,
+ &type,
+ &needed,
+ &data);
if (!W_ERROR_IS_OK(result))
goto done;
/* Display printer data */
- fstrcpy(value.valuename, valuename);
- display_reg_value(value);
-
+ display_printer_data(valuename, type, data, needed);
done:
if (is_valid_policy_hnd(&pol))
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- POLICY_HND pol;
+ struct policy_handle pol;
WERROR result;
NTSTATUS status;
fstring printername;
const char *valuename, *keyname;
- REGISTRY_VALUE value;
- uint32_t type;
- uint8_t *buffer = NULL;
+ enum winreg_Type type;
+ uint8_t *data = NULL;
uint32_t offered = 0;
uint32_t needed;
/* Get printer info */
+ data = talloc_zero_array(mem_ctx, uint8_t, offered);
+ if (!data) {
+ goto done;
+ }
+
status = rpccli_spoolss_GetPrinterDataEx(cli, mem_ctx,
&pol,
keyname,
valuename,
&type,
- buffer,
+ data,
offered,
&needed,
&result);
if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
offered = needed;
- buffer = talloc_array(mem_ctx, uint8_t, needed);
+ data = talloc_zero_array(mem_ctx, uint8_t, offered);
+ if (!data) {
+ goto done;
+ }
status = rpccli_spoolss_GetPrinterDataEx(cli, mem_ctx,
&pol,
keyname,
valuename,
&type,
- buffer,
+ data,
offered,
&needed,
&result);
goto done;
}
- if (!W_ERROR_IS_OK(result)) {
- goto done;
- }
-
-
if (!W_ERROR_IS_OK(result))
goto done;
/* Display printer data */
- fstrcpy(value.valuename, valuename);
- value.type = type;
- value.size = needed;
- value.data_p = buffer;
+ display_printer_data(valuename, type, data, needed);
- display_reg_value(value);
done:
if (is_valid_policy_hnd(&pol))
/****************************************************************************
****************************************************************************/
-static void display_print_driver_1(DRIVER_INFO_1 *i1)
+static void display_print_driver1(struct spoolss_DriverInfo1 *r)
{
- fstring name;
- if (i1 == NULL)
+ if (!r) {
return;
+ }
- rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
+ printf("Printer Driver Info 1:\n");
+ printf("\tDriver Name: [%s]\n", r->driver_name);
+ printf("\n");
+}
- printf ("Printer Driver Info 1:\n");
- printf ("\tDriver Name: [%s]\n\n", name);
+/****************************************************************************
+****************************************************************************/
- return;
+static void display_print_driver2(struct spoolss_DriverInfo2 *r)
+{
+ if (!r) {
+ return;
+ }
+
+ printf("Printer Driver Info 2:\n");
+ printf("\tVersion: [%x]\n", r->version);
+ printf("\tDriver Name: [%s]\n", r->driver_name);
+ printf("\tArchitecture: [%s]\n", r->architecture);
+ printf("\tDriver Path: [%s]\n", r->driver_path);
+ printf("\tDatafile: [%s]\n", r->data_file);
+ printf("\tConfigfile: [%s]\n", r->config_file);
+ printf("\n");
}
/****************************************************************************
****************************************************************************/
-static void display_print_driver_2(DRIVER_INFO_2 *i1)
+static void display_print_driver3(struct spoolss_DriverInfo3 *r)
{
- fstring name;
- fstring architecture;
- fstring driverpath;
- fstring datafile;
- fstring configfile;
- if (i1 == NULL)
+ int i;
+
+ if (!r) {
return;
+ }
- rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
- rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), -1, STR_TERMINATE);
- rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), -1, STR_TERMINATE);
- rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), -1, STR_TERMINATE);
- rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), -1, STR_TERMINATE);
+ printf("Printer Driver Info 3:\n");
+ printf("\tVersion: [%x]\n", r->version);
+ printf("\tDriver Name: [%s]\n", r->driver_name);
+ printf("\tArchitecture: [%s]\n", r->architecture);
+ printf("\tDriver Path: [%s]\n", r->driver_path);
+ printf("\tDatafile: [%s]\n", r->data_file);
+ printf("\tConfigfile: [%s]\n", r->config_file);
+ printf("\tHelpfile: [%s]\n", r->help_file);
- printf ("Printer Driver Info 2:\n");
- printf ("\tVersion: [%x]\n", i1->version);
- printf ("\tDriver Name: [%s]\n", name);
- printf ("\tArchitecture: [%s]\n", architecture);
- printf ("\tDriver Path: [%s]\n", driverpath);
- printf ("\tDatafile: [%s]\n", datafile);
- printf ("\tConfigfile: [%s]\n\n", configfile);
+ for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
+ printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
+ }
- return;
+ printf("\tMonitorname: [%s]\n", r->monitor_name);
+ printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
+ printf("\n");
}
/****************************************************************************
****************************************************************************/
-static void display_print_driver_3(DRIVER_INFO_3 *i1)
+static void display_print_driver4(struct spoolss_DriverInfo4 *r)
{
- fstring name = "";
- fstring architecture = "";
- fstring driverpath = "";
- fstring datafile = "";
- fstring configfile = "";
- fstring helpfile = "";
- fstring dependentfiles = "";
- fstring monitorname = "";
- fstring defaultdatatype = "";
-
- int length=0;
- bool valid = True;
+ int i;
- if (i1 == NULL)
+ if (!r) {
return;
+ }
- rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
- rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), -1, STR_TERMINATE);
- rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), -1, STR_TERMINATE);
- rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), -1, STR_TERMINATE);
- rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), -1, STR_TERMINATE);
- rpcstr_pull(helpfile, i1->helpfile.buffer, sizeof(helpfile), -1, STR_TERMINATE);
- rpcstr_pull(monitorname, i1->monitorname.buffer, sizeof(monitorname), -1, STR_TERMINATE);
- rpcstr_pull(defaultdatatype, i1->defaultdatatype.buffer, sizeof(defaultdatatype), -1, STR_TERMINATE);
-
- printf ("Printer Driver Info 3:\n");
- printf ("\tVersion: [%x]\n", i1->version);
- printf ("\tDriver Name: [%s]\n",name);
- printf ("\tArchitecture: [%s]\n", architecture);
- printf ("\tDriver Path: [%s]\n", driverpath);
- printf ("\tDatafile: [%s]\n", datafile);
- printf ("\tConfigfile: [%s]\n", configfile);
- printf ("\tHelpfile: [%s]\n\n", helpfile);
-
- while (valid)
- {
- rpcstr_pull(dependentfiles, i1->dependentfiles+length, sizeof(dependentfiles), -1, STR_TERMINATE);
-
- length+=strlen(dependentfiles)+1;
+ printf("Printer Driver Info 4:\n");
+ printf("\tVersion: [%x]\n", r->version);
+ printf("\tDriver Name: [%s]\n", r->driver_name);
+ printf("\tArchitecture: [%s]\n", r->architecture);
+ printf("\tDriver Path: [%s]\n", r->driver_path);
+ printf("\tDatafile: [%s]\n", r->data_file);
+ printf("\tConfigfile: [%s]\n", r->config_file);
+ printf("\tHelpfile: [%s]\n", r->help_file);
- if (strlen(dependentfiles) > 0)
- {
- printf ("\tDependentfiles: [%s]\n", dependentfiles);
- }
- else
- {
- valid = False;
- }
+ for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
+ printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
}
- printf ("\n");
-
- printf ("\tMonitorname: [%s]\n", monitorname);
- printf ("\tDefaultdatatype: [%s]\n\n", defaultdatatype);
+ printf("\tMonitorname: [%s]\n", r->monitor_name);
+ printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
- return;
+ for (i=0; r->previous_names && r->previous_names[i] != NULL; i++) {
+ printf("\tPrevious Names: [%s]\n", r->previous_names[i]);
+ }
+ printf("\n");
}
/****************************************************************************
****************************************************************************/
-static void display_print_driver1(struct spoolss_DriverInfo1 *r)
+static void display_print_driver5(struct spoolss_DriverInfo5 *r)
{
if (!r) {
return;
}
- printf("Printer Driver Info 1:\n");
- printf("\tDriver Name: [%s]\n\n", r->driver_name);
+ printf("Printer Driver Info 5:\n");
+ printf("\tVersion: [%x]\n", r->version);
+ printf("\tDriver Name: [%s]\n", r->driver_name);
+ printf("\tArchitecture: [%s]\n", r->architecture);
+ printf("\tDriver Path: [%s]\n", r->driver_path);
+ printf("\tDatafile: [%s]\n", r->data_file);
+ printf("\tConfigfile: [%s]\n", r->config_file);
+ printf("\tDriver Attributes: [0x%x]\n", r->driver_attributes);
+ printf("\tConfig Version: [0x%x]\n", r->config_version);
+ printf("\tDriver Version: [0x%x]\n", r->driver_version);
+ printf("\n");
}
/****************************************************************************
****************************************************************************/
-static void display_print_driver2(struct spoolss_DriverInfo2 *r)
+static void display_print_driver6(struct spoolss_DriverInfo6 *r)
{
+ int i;
+
if (!r) {
return;
}
- printf("Printer Driver Info 2:\n");
+ printf("Printer Driver Info 6:\n");
printf("\tVersion: [%x]\n", r->version);
printf("\tDriver Name: [%s]\n", r->driver_name);
printf("\tArchitecture: [%s]\n", r->architecture);
printf("\tDriver Path: [%s]\n", r->driver_path);
printf("\tDatafile: [%s]\n", r->data_file);
- printf("\tConfigfile: [%s]\n\n", r->config_file);
+ printf("\tConfigfile: [%s]\n", r->config_file);
+ printf("\tHelpfile: [%s]\n", r->help_file);
+
+ for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
+ printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
+ }
+
+ printf("\tMonitorname: [%s]\n", r->monitor_name);
+ printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
+
+ for (i=0; r->previous_names && r->previous_names[i] != NULL; i++) {
+ printf("\tPrevious Names: [%s]\n", r->previous_names[i]);
+ }
+
+ printf("\tDriver Date: [%s]\n", nt_time_string(talloc_tos(), r->driver_date));
+ printf("\tDriver Version: [0x%016llx]\n", (long long unsigned int)r->driver_version);
+ printf("\tManufacturer Name: [%s]\n", r->manufacturer_name);
+ printf("\tManufacturer Url: [%s]\n", r->manufacturer_url);
+ printf("\tHardware ID: [%s]\n", r->hardware_id);
+ printf("\tProvider: [%s]\n", r->provider);
+
+ printf("\n");
}
/****************************************************************************
****************************************************************************/
-static void display_print_driver3(struct spoolss_DriverInfo3 *r)
+static void display_print_driver8(struct spoolss_DriverInfo8 *r)
{
int i;
return;
}
- printf("Printer Driver Info 3:\n");
+ printf("Printer Driver Info 8:\n");
printf("\tVersion: [%x]\n", r->version);
printf("\tDriver Name: [%s]\n", r->driver_name);
printf("\tArchitecture: [%s]\n", r->architecture);
printf("\tDriver Path: [%s]\n", r->driver_path);
printf("\tDatafile: [%s]\n", r->data_file);
- printf("\tConfigfile: [%s]\n\n", r->config_file);
- printf("\tHelpfile: [%s]\n\n", r->help_file);
+ printf("\tConfigfile: [%s]\n", r->config_file);
+ printf("\tHelpfile: [%s]\n", r->help_file);
+ printf("\tMonitorname: [%s]\n", r->monitor_name);
+ printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
- for (i=0; r->dependent_files[i] != NULL; i++) {
+ for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
}
- printf("\n");
+ for (i=0; r->previous_names && r->previous_names[i] != NULL; i++) {
+ printf("\tPrevious Names: [%s]\n", r->previous_names[i]);
+ }
- printf("\tMonitorname: [%s]\n", r->monitor_name);
- printf("\tDefaultdatatype: [%s]\n\n", r->default_datatype);
-}
+ printf("\tDriver Date: [%s]\n", nt_time_string(talloc_tos(), r->driver_date));
+ printf("\tDriver Version: [0x%016llx]\n", (long long unsigned int)r->driver_version);
+ printf("\tManufacturer Name: [%s]\n", r->manufacturer_name);
+ printf("\tManufacturer Url: [%s]\n", r->manufacturer_url);
+ printf("\tHardware ID: [%s]\n", r->hardware_id);
+ printf("\tProvider: [%s]\n", r->provider);
+ printf("\tPrint Processor: [%s]\n", r->print_processor);
+ printf("\tVendor Setup: [%s]\n", r->vendor_setup);
+ for (i=0; r->color_profiles && r->color_profiles[i] != NULL; i++) {
+ printf("\tColor Profiles: [%s]\n", r->color_profiles[i]);
+ }
+ printf("\tInf Path: [%s]\n", r->inf_path);
+ printf("\tPrinter Driver Attributes: [0x%x]\n", r->printer_driver_attributes);
+ for (i=0; r->core_driver_dependencies && r->core_driver_dependencies[i] != NULL; i++) {
+ printf("\tCore Driver Dependencies: [%s]\n", r->core_driver_dependencies[i]);
+ }
+ printf("\tMin Driver Inbox Driver Version Date: [%s]\n", nt_time_string(talloc_tos(), r->min_inbox_driver_ver_date));
+ printf("\tMin Driver Inbox Driver Version Version: [0x%016llx]\n",
+ (long long unsigned int)r->min_inbox_driver_ver_version);
+ printf("\n");
+}
/****************************************************************************
****************************************************************************/
static WERROR cmd_spoolss_getdriver(struct rpc_pipe_client *cli,
- TALLOC_CTX *mem_ctx,
- int argc, const char **argv)
+ TALLOC_CTX *mem_ctx,
+ int argc, const char **argv)
{
- POLICY_HND pol;
+ struct policy_handle pol;
WERROR werror;
- uint32 info_level = 3;
+ uint32_t level = 3;
const char *printername;
- uint32 i;
- bool success = False;
+ uint32_t i;
+ bool success = false;
union spoolss_DriverInfo info;
uint32_t server_major_version;
uint32_t server_minor_version;
- if ((argc == 1) || (argc > 3))
- {
+ if ((argc == 1) || (argc > 3)) {
printf("Usage: %s <printername> [level]\n", argv[0]);
return WERR_OK;
}
RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
- if (argc == 3)
- info_level = atoi(argv[2]);
+ if (argc == 3) {
+ level = atoi(argv[2]);
+ }
/* Open a printer handle */
werror = rpccli_spoolss_getprinterdriver2(cli, mem_ctx,
&pol,
archi_table[i].long_archi,
- info_level,
+ level,
0, /* offered */
archi_table[i].version,
2,
&info,
&server_major_version,
&server_minor_version);
- if (!W_ERROR_IS_OK(werror))
+ if (!W_ERROR_IS_OK(werror)) {
continue;
+ }
/* need at least one success */
- success = True;
+ success = true;
- printf ("\n[%s]\n", archi_table[i].long_archi);
+ printf("\n[%s]\n", archi_table[i].long_archi);
- switch (info_level) {
+ switch (level) {
case 1:
display_print_driver1(&info.info1);
break;
case 3:
display_print_driver3(&info.info3);
break;
+ case 4:
+ display_print_driver4(&info.info4);
+ break;
+ case 5:
+ display_print_driver5(&info.info5);
+ break;
+ case 6:
+ display_print_driver6(&info.info6);
+ break;
+ case 8:
+ display_print_driver8(&info.info8);
+ break;
default:
- printf("unknown info level %d\n", info_level);
+ printf("unknown info level %d\n", level);
break;
}
}
/* Cleanup */
- if (is_valid_policy_hnd(&pol))
+ if (is_valid_policy_hnd(&pol)) {
rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
+ }
- if ( success )
+ if (success) {
werror = WERR_OK;
+ }
return werror;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_drivers(struct rpc_pipe_client *cli,
- TALLOC_CTX *mem_ctx,
- int argc, const char **argv)
+static WERROR enum_driver_by_architecture(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ const char *architecture,
+ uint32_t level)
{
- WERROR werror = WERR_OK;
- uint32 info_level = 1;
- PRINTER_DRIVER_CTR ctr;
- uint32 i, j,
- returned;
-
- if (argc > 2) {
- printf("Usage: enumdrivers [level]\n");
+ WERROR werror;
+ uint32_t count = 0;
+ union spoolss_DriverInfo *info = NULL;
+ uint32_t j;
+
+ werror = rpccli_spoolss_enumprinterdrivers(cli, mem_ctx,
+ cli->srv_name_slash,
+ architecture,
+ level,
+ 0,
+ &count,
+ &info);
+
+ if (W_ERROR_EQUAL(werror, WERR_INVALID_ENVIRONMENT)) {
+ printf("Server does not support environment [%s]\n",
+ architecture);
return WERR_OK;
}
- if (argc == 2)
- info_level = atoi(argv[1]);
-
-
- /* loop through and print driver info level for each architecture */
- for (i=0; archi_table[i].long_archi!=NULL; i++) {
- /* check to see if we already asked for this architecture string */
-
- if ( i>0 && strequal(archi_table[i].long_archi, archi_table[i-1].long_archi) )
- continue;
-
- werror = rpccli_spoolss_enumprinterdrivers(
- cli, mem_ctx, info_level,
- archi_table[i].long_archi, &returned, &ctr);
+ if (count == 0) {
+ return WERR_OK;
+ }
- if (W_ERROR_V(werror) == W_ERROR_V(WERR_INVALID_ENVIRONMENT)) {
- printf ("Server does not support environment [%s]\n",
- archi_table[i].long_archi);
- werror = WERR_OK;
- continue;
- }
+ if (!W_ERROR_IS_OK(werror)) {
+ printf("Error getting driver for environment [%s] - %s\n",
+ architecture, win_errstr(werror));
+ return werror;
+ }
- if (returned == 0)
- continue;
+ printf("\n[%s]\n", architecture);
- if (!W_ERROR_IS_OK(werror)) {
- printf ("Error getting driver for environment [%s] - %d\n",
- archi_table[i].long_archi, W_ERROR_V(werror));
- continue;
+ switch (level) {
+ case 1:
+ for (j=0; j < count; j++) {
+ display_print_driver1(&info[j].info1);
}
+ break;
+ case 2:
+ for (j=0; j < count; j++) {
+ display_print_driver2(&info[j].info2);
+ }
+ break;
+ case 3:
+ for (j=0; j < count; j++) {
+ display_print_driver3(&info[j].info3);
+ }
+ break;
+ case 4:
+ for (j=0; j < count; j++) {
+ display_print_driver4(&info[j].info4);
+ }
+ break;
+ case 5:
+ for (j=0; j < count; j++) {
+ display_print_driver5(&info[j].info5);
+ }
+ break;
+ case 6:
+ for (j=0; j < count; j++) {
+ display_print_driver6(&info[j].info6);
+ }
+ break;
+ case 8:
+ for (j=0; j < count; j++) {
+ display_print_driver8(&info[j].info8);
+ }
+ break;
+ default:
+ printf("unknown info level %d\n", level);
+ return WERR_UNKNOWN_LEVEL;
+ }
- printf ("\n[%s]\n", archi_table[i].long_archi);
- switch (info_level)
- {
+ return werror;
+}
- case 1:
- for (j=0; j < returned; j++) {
- display_print_driver_1 (&ctr.info1[j]);
- }
- break;
- case 2:
- for (j=0; j < returned; j++) {
- display_print_driver_2 (&ctr.info2[j]);
- }
- break;
- case 3:
- for (j=0; j < returned; j++) {
- display_print_driver_3 (&ctr.info3[j]);
- }
+static WERROR cmd_spoolss_enum_drivers(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ int argc, const char **argv)
+{
+ WERROR werror = WERR_OK;
+ uint32_t level = 1;
+ uint32_t i;
+ const char *architecture = NULL;
+
+ if (argc > 3) {
+ printf("Usage: enumdrivers [level] [architecture]\n");
+ return WERR_OK;
+ }
+
+ if (argc >= 2) {
+ level = atoi(argv[1]);
+ }
+
+ if (argc == 3) {
+ architecture = argv[2];
+ }
+
+ if (architecture) {
+ return enum_driver_by_architecture(cli, mem_ctx,
+ architecture,
+ level);
+ }
+
+ /* loop through and print driver info level for each architecture */
+ for (i=0; archi_table[i].long_archi!=NULL; i++) {
+ /* check to see if we already asked for this architecture string */
+
+ if (i>0 && strequal(archi_table[i].long_archi, archi_table[i-1].long_archi)) {
+ continue;
+ }
+
+ werror = enum_driver_by_architecture(cli, mem_ctx,
+ archi_table[i].long_archi,
+ level);
+ if (!W_ERROR_IS_OK(werror)) {
break;
- default:
- printf("unknown info level %d\n", info_level);
- return WERR_UNKNOWN_LEVEL;
}
}
{
WERROR result;
NTSTATUS status;
- uint32 level = 3;
+ uint32_t level = 3;
struct spoolss_AddDriverInfoCtr info_ctr;
struct spoolss_AddDriverInfo3 info3;
const char *arch;
info2.comment = "Created by rpcclient";
info2.printprocessor = "winprint";
info2.datatype = "RAW";
- info2.devmode = NULL;
- info2.secdesc = NULL;
+ info2.devmode_ptr = 0;
+ info2.secdesc_ptr = 0;
info2.attributes = PRINTER_ATTRIBUTE_SHARED;
info2.priority = 0;
info2.defaultpriority = 0;
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- POLICY_HND pol;
+ struct policy_handle pol;
WERROR result;
NTSTATUS status;
- uint32 level = 2;
+ uint32_t level = 2;
const char *printername;
union spoolss_PrinterInfo info;
struct spoolss_SetPrinterInfoCtr info_ctr;
+ struct spoolss_SetPrinterInfo2 info2;
struct spoolss_DevmodeContainer devmode_ctr;
struct sec_desc_buf secdesc_ctr;
/* Set the printer driver */
- info.info2.drivername = argv[2];
- info.info2.devmode = NULL;
- info.info2.secdesc = NULL;
+ spoolss_printerinfo2_to_setprinterinfo2(&info.info2, &info2);
+ info2.drivername = argv[2];
info_ctr.level = 2;
- info_ctr.info.info2 = (struct spoolss_SetPrinterInfo2 *)&info.info2;
+ info_ctr.info.info2 = &info2;
status = rpccli_spoolss_SetPrinter(cli, mem_ctx,
&pol,
static WERROR cmd_spoolss_addform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- POLICY_HND handle;
+ struct policy_handle handle;
WERROR werror;
NTSTATUS status;
const char *printername;
switch (level) {
case 1:
- info1.flags = FORM_USER;
+ info1.flags = SPOOLSS_FORM_USER;
info1.form_name = argv[2];
info1.size.width = 100;
info1.size.height = 100;
break;
case 2:
- info2.flags = FORM_USER;
+ info2.flags = SPOOLSS_FORM_USER;
info2.form_name = argv[2];
info2.size.width = 100;
info2.size.height = 100;
static WERROR cmd_spoolss_setform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- POLICY_HND handle;
+ struct policy_handle handle;
WERROR werror;
NTSTATUS status;
const char *printername;
/* Dummy up some values for the form data */
- info1.flags = FORM_PRINTER;
+ info1.flags = SPOOLSS_FORM_PRINTER;
info1.size.width = 100;
info1.size.height = 100;
info1.area.left = 0;
static const char *get_form_flag(int form_flag)
{
switch (form_flag) {
- case FORM_USER:
+ case SPOOLSS_FORM_USER:
return "FORM_USER";
- case FORM_BUILTIN:
+ case SPOOLSS_FORM_BUILTIN:
return "FORM_BUILTIN";
- case FORM_PRINTER:
+ case SPOOLSS_FORM_PRINTER:
return "FORM_PRINTER";
default:
return "unknown";
/****************************************************************************
****************************************************************************/
-static void display_form(FORM_1 *form)
-{
- fstring form_name = "";
-
- if (form->name.buffer)
- rpcstr_pull(form_name, form->name.buffer,
- sizeof(form_name), -1, STR_TERMINATE);
-
- printf("%s\n" \
- "\tflag: %s (%d)\n" \
- "\twidth: %d, length: %d\n" \
- "\tleft: %d, right: %d, top: %d, bottom: %d\n\n",
- form_name, get_form_flag(form->flag), form->flag,
- form->width, form->length,
- form->left, form->right,
- form->top, form->bottom);
-}
-
-/****************************************************************************
-****************************************************************************/
-
static void display_form_info1(struct spoolss_FormInfo1 *r)
{
printf("%s\n" \
static WERROR cmd_spoolss_getform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
- POLICY_HND handle;
+ struct policy_handle handle;
WERROR werror;
NTSTATUS status;
const char *printername;
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
- POLICY_HND handle;
+ struct policy_handle handle;
WERROR werror;
NTSTATUS status;
const char *printername;
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
- POLICY_HND handle;
+ struct policy_handle handle;
WERROR werror;
const char *printername;
- uint32 num_forms, level = 1, i;
- FORM_1 *forms;
+ uint32_t num_forms, level = 1, i;
+ union spoolss_FormInfo *forms;
/* Parse the command arguments */
- if (argc != 2) {
- printf ("Usage: %s <printer>\n", argv[0]);
+ if (argc < 2 || argc > 4) {
+ printf ("Usage: %s <printer> [level]\n", argv[0]);
return WERR_OK;
}
if (!W_ERROR_IS_OK(werror))
goto done;
+ if (argc == 3) {
+ level = atoi(argv[2]);
+ }
+
/* Enumerate forms */
- werror = rpccli_spoolss_enumforms(cli, mem_ctx, &handle, level, &num_forms, &forms);
+ werror = rpccli_spoolss_enumforms(cli, mem_ctx,
+ &handle,
+ level,
+ 0,
+ &num_forms,
+ &forms);
if (!W_ERROR_IS_OK(werror))
goto done;
/* Display output */
for (i = 0; i < num_forms; i++) {
-
- display_form(&forms[i]);
-
+ switch (level) {
+ case 1:
+ display_form_info1(&forms[i].info1);
+ break;
+ case 2:
+ display_form_info2(&forms[i].info2);
+ break;
+ }
}
done:
int argc, const char **argv)
{
WERROR result;
+ NTSTATUS status;
const char *printername;
- POLICY_HND pol;
+ struct policy_handle pol;
union spoolss_PrinterInfo info;
- REGISTRY_VALUE value;
- TALLOC_CTX *tmp_ctx = talloc_stackframe();
+ enum winreg_Type type;
+ union spoolss_PrinterData data;
+ DATA_BLOB blob;
/* parse the command arguments */
if (argc < 5) {
printf ("Usage: %s <printer> <string|binary|dword|multistring>"
" <value> <data>\n",
argv[0]);
- result = WERR_INVALID_PARAM;
- goto done;
+ return WERR_OK;
}
RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
- value.type = REG_NONE;
+ type = REG_NONE;
if (strequal(argv[2], "string")) {
- value.type = REG_SZ;
+ type = REG_SZ;
}
if (strequal(argv[2], "binary")) {
- value.type = REG_BINARY;
+ type = REG_BINARY;
}
if (strequal(argv[2], "dword")) {
- value.type = REG_DWORD;
+ type = REG_DWORD;
}
if (strequal(argv[2], "multistring")) {
- value.type = REG_MULTI_SZ;
+ type = REG_MULTI_SZ;
}
- if (value.type == REG_NONE) {
+ if (type == REG_NONE) {
printf("Unknown data type: %s\n", argv[2]);
result = WERR_INVALID_PARAM;
goto done;
printername,
SEC_FLAG_MAXIMUM_ALLOWED,
&pol);
- if (!W_ERROR_IS_OK(result))
+ if (!W_ERROR_IS_OK(result)) {
goto done;
+ }
result = rpccli_spoolss_getprinter(cli, mem_ctx,
&pol,
0,
0,
&info);
- if (!W_ERROR_IS_OK(result))
+ if (!W_ERROR_IS_OK(result)) {
goto done;
+ }
- printf("%s\n", current_timestring(tmp_ctx, True));
+ printf("%s\n", current_timestring(mem_ctx, true));
printf("\tchange_id (before set)\t:[0x%x]\n", info.info0.change_id);
/* Set the printer data */
- fstrcpy(value.valuename, argv[3]);
-
- switch (value.type) {
- case REG_SZ: {
- UNISTR2 data;
- init_unistr2(&data, argv[4], UNI_STR_TERMINATE);
- value.size = data.uni_str_len * 2;
- if (value.size) {
- value.data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, data.buffer,
- value.size);
- } else {
- value.data_p = NULL;
- }
+ switch (type) {
+ case REG_SZ:
+ data.string = talloc_strdup(mem_ctx, argv[4]);
+ W_ERROR_HAVE_NO_MEMORY(data.string);
break;
- }
- case REG_DWORD: {
- uint32 data = strtoul(argv[4], NULL, 10);
- value.size = sizeof(data);
- if (sizeof(data)) {
- value.data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, &data,
- sizeof(data));
- } else {
- value.data_p = NULL;
- }
+ case REG_DWORD:
+ data.value = strtoul(argv[4], NULL, 10);
break;
- }
- case REG_BINARY: {
- DATA_BLOB data = strhex_to_data_blob(mem_ctx, argv[4]);
- value.data_p = data.data;
- value.size = data.length;
+ case REG_BINARY:
+ data.binary = strhex_to_data_blob(mem_ctx, argv[4]);
break;
- }
case REG_MULTI_SZ: {
- int i;
- size_t len = 0;
- char *p;
+ int i, num_strings;
+ const char **strings = NULL;
for (i=4; i<argc; i++) {
if (strcmp(argv[i], "NULL") == 0) {
argv[i] = "";
}
- len += strlen(argv[i])+1;
+ if (!add_string_to_array(mem_ctx, argv[i],
+ &strings,
+ &num_strings)) {
+ result = WERR_NOMEM;
+ goto done;
+ }
}
-
- value.size = len*2;
- value.data_p = TALLOC_ARRAY(mem_ctx, unsigned char, value.size);
- if (value.data_p == NULL) {
+ data.string_array = talloc_zero_array(mem_ctx, const char *, num_strings + 1);
+ if (!data.string_array) {
result = WERR_NOMEM;
goto done;
}
-
- p = (char *)value.data_p;
- len = value.size;
- for (i=4; i<argc; i++) {
- size_t l = (strlen(argv[i])+1)*2;
- rpcstr_push(p, argv[i], len, STR_TERMINATE);
- p += l;
- len -= l;
+ for (i=0; i < num_strings; i++) {
+ data.string_array[i] = strings[i];
}
- SMB_ASSERT(len == 0);
break;
- }
+ }
default:
printf("Unknown data type: %s\n", argv[2]);
result = WERR_INVALID_PARAM;
goto done;
}
- result = rpccli_spoolss_setprinterdata(cli, mem_ctx, &pol, &value);
+ result = push_spoolss_PrinterData(mem_ctx, &blob, type, &data);
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
+ }
+ status = rpccli_spoolss_SetPrinterData(cli, mem_ctx,
+ &pol,
+ argv[3], /* value_name */
+ type,
+ blob.data,
+ blob.length,
+ &result);
if (!W_ERROR_IS_OK(result)) {
printf ("Unable to set [%s=%s]!\n", argv[3], argv[4]);
goto done;
0,
0,
&info);
- if (!W_ERROR_IS_OK(result))
+ if (!W_ERROR_IS_OK(result)) {
goto done;
+ }
- printf("%s\n", current_timestring(tmp_ctx, True));
+ printf("%s\n", current_timestring(mem_ctx, true));
printf("\tchange_id (after set)\t:[0x%x]\n", info.info0.change_id);
done:
/* cleanup */
- TALLOC_FREE(tmp_ctx);
- if (is_valid_policy_hnd(&pol))
+ if (is_valid_policy_hnd(&pol)) {
rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
+ }
return result;
}
/****************************************************************************
****************************************************************************/
-static void display_job_info_1(JOB_INFO_1 *job)
-{
- fstring username = "", document = "", text_status = "";
-
- rpcstr_pull(username, job->username.buffer,
- sizeof(username), -1, STR_TERMINATE);
-
- rpcstr_pull(document, job->document.buffer,
- sizeof(document), -1, STR_TERMINATE);
-
- rpcstr_pull(text_status, job->text_status.buffer,
- sizeof(text_status), -1, STR_TERMINATE);
-
- printf("%d: jobid[%d]: %s %s %s %d/%d pages\n", job->position, job->jobid,
- username, document, text_status, job->pagesprinted,
- job->totalpages);
-}
-
-/****************************************************************************
-****************************************************************************/
-
-static void display_job_info_2(JOB_INFO_2 *job)
-{
- fstring username = "", document = "", text_status = "";
-
- rpcstr_pull(username, job->username.buffer,
- sizeof(username), -1, STR_TERMINATE);
-
- rpcstr_pull(document, job->document.buffer,
- sizeof(document), -1, STR_TERMINATE);
-
- rpcstr_pull(text_status, job->text_status.buffer,
- sizeof(text_status), -1, STR_TERMINATE);
-
- printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d bytes\n", job->position, job->jobid,
- username, document, text_status, job->pagesprinted,
- job->totalpages, job->size);
-}
-
-/****************************************************************************
-****************************************************************************/
-
static void display_job_info1(struct spoolss_JobInfo1 *r)
{
printf("%d: jobid[%d]: %s %s %s %d/%d pages\n", r->position, r->job_id,
const char **argv)
{
WERROR result;
- uint32 level = 1, num_jobs, i;
+ uint32_t level = 1, count, i;
const char *printername;
- POLICY_HND hnd;
- JOB_INFO_CTR ctr;
+ struct policy_handle hnd;
+ union spoolss_JobInfo *info;
if (argc < 2 || argc > 3) {
printf("Usage: %s printername [level]\n", argv[0]);
return WERR_OK;
}
- if (argc == 3)
+ if (argc == 3) {
level = atoi(argv[2]);
+ }
/* Open printer handle */
/* Enumerate ports */
- result = rpccli_spoolss_enumjobs(cli, mem_ctx, &hnd, level, 0, 1000,
- &num_jobs, &ctr);
-
- if (!W_ERROR_IS_OK(result))
+ result = rpccli_spoolss_enumjobs(cli, mem_ctx,
+ &hnd,
+ 0, /* firstjob */
+ 1000, /* numjobs */
+ level,
+ 0,
+ &count,
+ &info);
+ if (!W_ERROR_IS_OK(result)) {
goto done;
+ }
- for (i = 0; i < num_jobs; i++) {
- switch(level) {
+ for (i = 0; i < count; i++) {
+ switch (level) {
case 1:
- display_job_info_1(&ctr.job.job_info_1[i]);
+ display_job_info1(&info[i].info1);
break;
case 2:
- display_job_info_2(&ctr.job.job_info_2[i]);
+ display_job_info2(&info[i].info2);
break;
default:
d_printf("unknown info level %d\n", level);
}
done:
- if (is_valid_policy_hnd(&hnd))
+ if (is_valid_policy_hnd(&hnd)) {
rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
+ }
return result;
}
return result;
}
+/****************************************************************************
+****************************************************************************/
+
+static struct {
+ const char *name;
+ enum spoolss_JobControl val;
+} cmdvals[] = {
+ {"PAUSE", SPOOLSS_JOB_CONTROL_PAUSE},
+ {"RESUME", SPOOLSS_JOB_CONTROL_RESUME},
+ {"CANCEL", SPOOLSS_JOB_CONTROL_CANCEL},
+ {"RESTART", SPOOLSS_JOB_CONTROL_RESTART},
+ {"DELETE", SPOOLSS_JOB_CONTROL_DELETE},
+ {"SEND_TO_PRINTER", SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER},
+ {"EJECTED", SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED},
+ {"RETAIN", SPOOLSS_JOB_CONTROL_RETAIN},
+ {"RELEASE", SPOOLSS_JOB_CONTROL_RELEASE}
+};
+
+static enum spoolss_JobControl parse_setjob_command(const char *cmd)
+{
+ int i;
+
+ for (i = 0; i < sizeof(cmdvals)/sizeof(cmdvals[0]); i++) {
+ if (strequal(cmdvals[i].name, cmd)) {
+ return cmdvals[i].val;
+ }
+ }
+ return (enum spoolss_JobControl)atoi(cmd);
+}
+
+static WERROR cmd_spoolss_set_job(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx, int argc,
+ const char **argv)
+{
+ WERROR result;
+ NTSTATUS status;
+ const char *printername;
+ struct policy_handle hnd;
+ uint32_t job_id;
+ enum spoolss_JobControl command;
+
+ if (argc != 4) {
+ printf("Usage: %s printername job_id command\n", argv[0]);
+ printf("command = [PAUSE|RESUME|CANCEL|RESTART|DELETE|"
+ "SEND_TO_PRINTER|EJECTED|RETAIN|RELEASE]\n");
+ return WERR_OK;
+ }
+
+ job_id = atoi(argv[2]);
+ command = parse_setjob_command(argv[3]);
+
+ /* Open printer handle */
+
+ RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
+
+ result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
+ printername,
+ SEC_FLAG_MAXIMUM_ALLOWED,
+ &hnd);
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
+ }
+
+ /* Set Job */
+
+ status = rpccli_spoolss_SetJob(cli, mem_ctx,
+ &hnd,
+ job_id,
+ NULL,
+ command,
+ &result);
+
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
+ }
+
+done:
+ if (is_valid_policy_hnd(&hnd)) {
+ rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
+ }
+
+ return result;
+}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_data( struct rpc_pipe_client *cli,
- TALLOC_CTX *mem_ctx, int argc,
- const char **argv)
+static WERROR cmd_spoolss_enum_data(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx, int argc,
+ const char **argv)
{
WERROR result;
- uint32 i=0, val_needed, data_needed;
+ NTSTATUS status;
+ uint32_t i = 0;
const char *printername;
- POLICY_HND hnd;
+ struct policy_handle hnd;
+ uint32_t value_offered = 0;
+ const char *value_name = NULL;
+ uint32_t value_needed;
+ enum winreg_Type type;
+ uint8_t *data = NULL;
+ uint32_t data_offered = 0;
+ uint32_t data_needed;
if (argc != 2) {
printf("Usage: %s printername\n", argv[0]);
printername,
SEC_FLAG_MAXIMUM_ALLOWED,
&hnd);
- if (!W_ERROR_IS_OK(result))
+ if (!W_ERROR_IS_OK(result)) {
goto done;
+ }
/* Enumerate data */
- result = rpccli_spoolss_enumprinterdata(cli, mem_ctx, &hnd, i, 0, 0,
- &val_needed, &data_needed,
- NULL);
- while (W_ERROR_IS_OK(result)) {
- REGISTRY_VALUE value;
- result = rpccli_spoolss_enumprinterdata(
- cli, mem_ctx, &hnd, i++, val_needed,
- data_needed, 0, 0, &value);
- if (W_ERROR_IS_OK(result))
- display_reg_value(value);
- }
- if (W_ERROR_V(result) == ERRnomoreitems)
+ status = rpccli_spoolss_EnumPrinterData(cli, mem_ctx,
+ &hnd,
+ i,
+ value_name,
+ value_offered,
+ &value_needed,
+ &type,
+ data,
+ data_offered,
+ &data_needed,
+ &result);
+
+ data_offered = data_needed;
+ value_offered = value_needed;
+ data = talloc_zero_array(mem_ctx, uint8_t, data_needed);
+ value_name = talloc_zero_array(mem_ctx, char, value_needed);
+
+ while (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(result)) {
+
+ status = rpccli_spoolss_EnumPrinterData(cli, mem_ctx,
+ &hnd,
+ i++,
+ value_name,
+ value_offered,
+ &value_needed,
+ &type,
+ data,
+ data_offered,
+ &data_needed,
+ &result);
+ if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(result)) {
+ struct regval_blob *v;
+
+ v = regval_compose(talloc_tos(),
+ value_name,
+ type,
+ data,
+ data_offered);
+ if (v == NULL) {
+ result = WERR_NOMEM;
+ goto done;
+ }
+
+ display_reg_value(v);
+ talloc_free(v);
+ }
+ }
+
+ if (W_ERROR_V(result) == ERRnomoreitems) {
result = W_ERROR(ERRsuccess);
+ }
done:
- if (is_valid_policy_hnd(&hnd))
+ if (is_valid_policy_hnd(&hnd)) {
rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
+ }
return result;
}
const char **argv)
{
WERROR result;
- uint32 i;
+ uint32_t i;
const char *printername;
- const char *keyname = NULL;
- POLICY_HND hnd;
- REGVAL_CTR *ctr = NULL;
+ struct policy_handle hnd;
+ uint32_t count;
+ struct spoolss_PrinterEnumValues *info;
if (argc != 3) {
printf("Usage: %s printername <keyname>\n", argv[0]);
return WERR_OK;
}
- keyname = argv[2];
-
/* Open printer handle */
RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
printername,
SEC_FLAG_MAXIMUM_ALLOWED,
&hnd);
- if (!W_ERROR_IS_OK(result))
+ if (!W_ERROR_IS_OK(result)) {
goto done;
+ }
/* Enumerate subkeys */
- if ( !(ctr = TALLOC_ZERO_P( mem_ctx, REGVAL_CTR )) )
- return WERR_NOMEM;
-
- result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &hnd, keyname, ctr);
-
- if (!W_ERROR_IS_OK(result))
+ result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx,
+ &hnd,
+ argv[2],
+ 0,
+ &count,
+ &info);
+ if (!W_ERROR_IS_OK(result)) {
goto done;
-
- for (i=0; i < ctr->num_values; i++) {
- display_reg_value(*(ctr->values[i]));
}
- TALLOC_FREE( ctr );
+ for (i=0; i < count; i++) {
+ display_printer_data(info[i].value_name,
+ info[i].type,
+ info[i].data->data,
+ info[i].data->length);
+ }
-done:
- if (is_valid_policy_hnd(&hnd))
+ done:
+ if (is_valid_policy_hnd(&hnd)) {
rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
+ }
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_printerkey( struct rpc_pipe_client *cli,
- TALLOC_CTX *mem_ctx, int argc,
- const char **argv)
+static WERROR cmd_spoolss_enum_printerkey(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx, int argc,
+ const char **argv)
{
WERROR result;
const char *printername;
const char *keyname = NULL;
- POLICY_HND hnd;
- uint16 *keylist = NULL, *curkey;
+ struct policy_handle hnd;
+ const char **key_buffer = NULL;
+ int i;
+ uint32_t offered = 0;
- if (argc < 2 || argc > 3) {
- printf("Usage: %s printername [keyname]\n", argv[0]);
+ if (argc < 2 || argc > 4) {
+ printf("Usage: %s printername [keyname] [offered]\n", argv[0]);
return WERR_OK;
}
- if (argc == 3)
+ if (argc >= 3) {
keyname = argv[2];
- else
+ } else {
keyname = "";
+ }
+
+ if (argc == 4) {
+ offered = atoi(argv[3]);
+ }
/* Open printer handle */
printername,
SEC_FLAG_MAXIMUM_ALLOWED,
&hnd);
- if (!W_ERROR_IS_OK(result))
+ if (!W_ERROR_IS_OK(result)) {
goto done;
+ }
/* Enumerate subkeys */
- result = rpccli_spoolss_enumprinterkey(cli, mem_ctx, &hnd, keyname, &keylist, NULL);
+ result = rpccli_spoolss_enumprinterkey(cli, mem_ctx,
+ &hnd,
+ keyname,
+ &key_buffer,
+ offered);
- if (!W_ERROR_IS_OK(result))
+ if (!W_ERROR_IS_OK(result)) {
goto done;
-
- curkey = keylist;
- while (*curkey != 0) {
- char *subkey = NULL;
- rpcstr_pull_talloc(mem_ctx, &subkey, curkey, -1,
- STR_TERMINATE);
- if (!subkey) {
- break;
- }
- printf("%s\n", subkey);
- curkey += strlen(subkey) + 1;
}
-done:
+ for (i=0; key_buffer && key_buffer[i]; i++) {
+ printf("%s\n", key_buffer[i]);
+ }
- SAFE_FREE(keylist);
+ done:
- if (is_valid_policy_hnd(&hnd))
+ if (is_valid_policy_hnd(&hnd)) {
rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
+ }
return result;
}
{
const char *printername;
const char *clientname;
- POLICY_HND hnd;
+ struct policy_handle hnd;
WERROR result;
NTSTATUS status;
struct spoolss_NotifyOption option;
option.types[0].type = PRINTER_NOTIFY_TYPE;
option.types[0].count = 1;
- option.types[0].fields = talloc_array(mem_ctx, enum spoolss_Field, 1);
+ option.types[0].fields = talloc_array(mem_ctx, union spoolss_Field, 1);
if (option.types[0].fields == NULL) {
result = WERR_NOMEM;
goto done;
}
- option.types[0].fields[0] = PRINTER_NOTIFY_SERVER_NAME;
+ option.types[0].fields[0].field = PRINTER_NOTIFY_FIELD_SERVER_NAME;
option.types[1].type = JOB_NOTIFY_TYPE;
option.types[1].count = 1;
- option.types[1].fields = talloc_array(mem_ctx, enum spoolss_Field, 1);
+ option.types[1].fields = talloc_array(mem_ctx, union spoolss_Field, 1);
if (option.types[1].fields == NULL) {
result = WERR_NOMEM;
goto done;
}
- option.types[1].fields[0] = JOB_NOTIFY_PRINTER_NAME;
+ option.types[1].fields[0].field = JOB_NOTIFY_FIELD_PRINTER_NAME;
clientname = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
if (!clientname) {
/****************************************************************************
****************************************************************************/
-static bool compare_printer( struct rpc_pipe_client *cli1, POLICY_HND *hnd1,
- struct rpc_pipe_client *cli2, POLICY_HND *hnd2 )
+static bool compare_printer( struct rpc_pipe_client *cli1, struct policy_handle *hnd1,
+ struct rpc_pipe_client *cli2, struct policy_handle *hnd2 )
{
union spoolss_PrinterInfo info1, info2;
WERROR werror;
if ( !W_ERROR_IS_OK(werror) ) {
printf("failed (%s)\n", win_errstr(werror));
talloc_destroy(mem_ctx);
- return False;
+ return false;
}
printf("ok\n");
if ( !W_ERROR_IS_OK(werror) ) {
printf("failed (%s)\n", win_errstr(werror));
talloc_destroy(mem_ctx);
- return False;
+ return false;
}
printf("ok\n");
talloc_destroy(mem_ctx);
- return True;
+ return true;
}
/****************************************************************************
****************************************************************************/
-static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, POLICY_HND *hnd1,
- struct rpc_pipe_client *cli2, POLICY_HND *hnd2 )
+static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, struct policy_handle *hnd1,
+ struct rpc_pipe_client *cli2, struct policy_handle *hnd2 )
{
union spoolss_PrinterInfo info1, info2;
WERROR werror;
TALLOC_CTX *mem_ctx = talloc_init("compare_printer_secdesc");
- SEC_DESC *sd1, *sd2;
- bool result = True;
+ struct security_descriptor *sd1, *sd2;
+ bool result = true;
printf("Retrieving printer security for %s...", cli1->desthost);
&info1);
if ( !W_ERROR_IS_OK(werror) ) {
printf("failed (%s)\n", win_errstr(werror));
- result = False;
+ result = false;
goto done;
}
printf("ok\n");
&info2);
if ( !W_ERROR_IS_OK(werror) ) {
printf("failed (%s)\n", win_errstr(werror));
- result = False;
+ result = false;
goto done;
}
printf("ok\n");
if ( (sd1 != sd2) && ( !sd1 || !sd2 ) ) {
printf("NULL secdesc!\n");
- result = False;
+ result = false;
goto done;
}
- if (!sec_desc_equal( sd1, sd2 ) ) {
+ if (!security_descriptor_equal( sd1, sd2 ) ) {
printf("Security Descriptors *not* equal!\n");
- result = False;
+ result = false;
goto done;
}
char *printername_path = NULL;
struct cli_state *cli_server2 = NULL;
struct rpc_pipe_client *cli2 = NULL;
- POLICY_HND hPrinter1, hPrinter2;
+ struct policy_handle hPrinter1, hPrinter2;
NTSTATUS nt_status;
WERROR werror;
if ( !NT_STATUS_IS_OK(nt_status) )
return WERR_GENERAL_FAILURE;
- nt_status = cli_rpc_pipe_open_noauth(cli_server2, &syntax_spoolss,
+ nt_status = cli_rpc_pipe_open_noauth(cli_server2, &ndr_table_spoolss.syntax_id,
&cli2);
if (!NT_STATUS_IS_OK(nt_status)) {
printf("failed to open spoolss pipe on server %s (%s)\n",
return WERR_OK;
}
+static void display_proc_info1(struct spoolss_PrintProcessorInfo1 *r)
+{
+ printf("print_processor_name: %s\n", r->print_processor_name);
+}
+
+static WERROR cmd_spoolss_enum_procs(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx, int argc,
+ const char **argv)
+{
+ WERROR werror;
+ const char *environment = SPOOLSS_ARCHITECTURE_NT_X86;
+ uint32_t num_procs, level = 1, i;
+ union spoolss_PrintProcessorInfo *procs;
+
+ /* Parse the command arguments */
+
+ if (argc < 1 || argc > 4) {
+ printf ("Usage: %s [environment] [level]\n", argv[0]);
+ return WERR_OK;
+ }
+
+ if (argc >= 2) {
+ environment = argv[1];
+ }
+
+ if (argc == 3) {
+ level = atoi(argv[2]);
+ }
+
+ /* Enumerate Print Processors */
+
+ werror = rpccli_spoolss_enumprintprocessors(cli, mem_ctx,
+ cli->srv_name_slash,
+ environment,
+ level,
+ 0,
+ &num_procs,
+ &procs);
+ if (!W_ERROR_IS_OK(werror))
+ goto done;
+
+ /* Display output */
+
+ for (i = 0; i < num_procs; i++) {
+ switch (level) {
+ case 1:
+ display_proc_info1(&procs[i].info1);
+ break;
+ }
+ }
+
+ done:
+ return werror;
+}
+
+static void display_proc_data_types_info1(struct spoolss_PrintProcDataTypesInfo1 *r)
+{
+ printf("name_array: %s\n", r->name_array);
+}
+
+static WERROR cmd_spoolss_enum_proc_data_types(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx, int argc,
+ const char **argv)
+{
+ WERROR werror;
+ const char *print_processor_name = "winprint";
+ uint32_t num_procs, level = 1, i;
+ union spoolss_PrintProcDataTypesInfo *procs;
+
+ /* Parse the command arguments */
+
+ if (argc < 1 || argc > 4) {
+ printf ("Usage: %s [environment] [level]\n", argv[0]);
+ return WERR_OK;
+ }
+
+ if (argc >= 2) {
+ print_processor_name = argv[1];
+ }
+
+ if (argc == 3) {
+ level = atoi(argv[2]);
+ }
+
+ /* Enumerate Print Processor Data Types */
+
+ werror = rpccli_spoolss_enumprintprocessordatatypes(cli, mem_ctx,
+ cli->srv_name_slash,
+ print_processor_name,
+ level,
+ 0,
+ &num_procs,
+ &procs);
+ if (!W_ERROR_IS_OK(werror))
+ goto done;
+
+ /* Display output */
+
+ for (i = 0; i < num_procs; i++) {
+ switch (level) {
+ case 1:
+ display_proc_data_types_info1(&procs[i].info1);
+ break;
+ }
+ }
+
+ done:
+ return werror;
+}
+
+static void display_monitor1(const struct spoolss_MonitorInfo1 *r)
+{
+ printf("monitor_name: %s\n", r->monitor_name);
+}
+
+static void display_monitor2(const struct spoolss_MonitorInfo2 *r)
+{
+ printf("monitor_name: %s\n", r->monitor_name);
+ printf("environment: %s\n", r->environment);
+ printf("dll_name: %s\n", r->dll_name);
+}
+
+static WERROR cmd_spoolss_enum_monitors(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx, int argc,
+ const char **argv)
+{
+ WERROR werror;
+ uint32_t count, level = 1, i;
+ union spoolss_MonitorInfo *info;
+
+ /* Parse the command arguments */
+
+ if (argc > 2) {
+ printf("Usage: %s [level]\n", argv[0]);
+ return WERR_OK;
+ }
+
+ if (argc == 2) {
+ level = atoi(argv[1]);
+ }
+
+ /* Enumerate Print Monitors */
+
+ werror = rpccli_spoolss_enummonitors(cli, mem_ctx,
+ cli->srv_name_slash,
+ level,
+ 0,
+ &count,
+ &info);
+ if (!W_ERROR_IS_OK(werror)) {
+ goto done;
+ }
+
+ /* Display output */
+
+ for (i = 0; i < count; i++) {
+ switch (level) {
+ case 1:
+ display_monitor1(&info[i].info1);
+ break;
+ case 2:
+ display_monitor2(&info[i].info2);
+ break;
+ }
+ }
+
+ done:
+ return werror;
+}
+
+static WERROR cmd_spoolss_create_printer_ic(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx, int argc,
+ const char **argv)
+{
+ WERROR result;
+ NTSTATUS status;
+ struct policy_handle handle, gdi_handle;
+ const char *printername;
+ struct spoolss_DevmodeContainer devmode_ctr;
+
+ RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
+
+ result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
+ printername,
+ SEC_FLAG_MAXIMUM_ALLOWED,
+ &handle);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
+ ZERO_STRUCT(devmode_ctr);
+
+ status = rpccli_spoolss_CreatePrinterIC(cli, mem_ctx,
+ &handle,
+ &gdi_handle,
+ &devmode_ctr,
+ &result);
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
+ }
+
+ done:
+ if (is_valid_policy_hnd(&gdi_handle)) {
+ rpccli_spoolss_DeletePrinterIC(cli, mem_ctx, &gdi_handle, NULL);
+ }
+ if (is_valid_policy_hnd(&handle)) {
+ rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
+ }
+
+ return result;
+}
+
/* List of commands exported by this module */
struct cmd_set spoolss_commands[] = {
{ "SPOOLSS" },
- { "adddriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterdriver, &syntax_spoolss, NULL, "Add a print driver", "" },
- { "addprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterex, &syntax_spoolss, NULL, "Add a printer", "" },
- { "deldriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriver, &syntax_spoolss, NULL, "Delete a printer driver", "" },
- { "deldriverex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriverex, &syntax_spoolss, NULL, "Delete a printer driver with files", "" },
- { "enumdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data, &syntax_spoolss, NULL, "Enumerate printer data", "" },
- { "enumdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data_ex, &syntax_spoolss, NULL, "Enumerate printer data for a key", "" },
- { "enumkey", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printerkey, &syntax_spoolss, NULL, "Enumerate printer keys", "" },
- { "enumjobs", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_jobs, &syntax_spoolss, NULL, "Enumerate print jobs", "" },
- { "getjob", RPC_RTYPE_WERROR, NULL, cmd_spoolss_get_job, &syntax_spoolss, NULL, "Get print job", "" },
- { "enumports", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_ports, &syntax_spoolss, NULL, "Enumerate printer ports", "" },
- { "enumdrivers", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_drivers, &syntax_spoolss, NULL, "Enumerate installed printer drivers", "" },
- { "enumprinters", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printers, &syntax_spoolss, NULL, "Enumerate printers", "" },
- { "getdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdata, &syntax_spoolss, NULL, "Get print driver data", "" },
- { "getdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdataex, &syntax_spoolss, NULL, "Get printer driver data with keyname", ""},
- { "getdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriver, &syntax_spoolss, NULL, "Get print driver information", "" },
- { "getdriverdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriverdir, &syntax_spoolss, NULL, "Get print driver upload directory", "" },
- { "getprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinter, &syntax_spoolss, NULL, "Get printer info", "" },
- { "openprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer_ex, &syntax_spoolss, NULL, "Open printer handle", "" },
- { "setdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setdriver, &syntax_spoolss, NULL, "Set printer driver", "" },
- { "getprintprocdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir, &syntax_spoolss, NULL, "Get print processor directory", "" },
- { "addform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addform, &syntax_spoolss, NULL, "Add form", "" },
- { "setform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setform, &syntax_spoolss, NULL, "Set form", "" },
- { "getform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getform, &syntax_spoolss, NULL, "Get form", "" },
- { "deleteform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deleteform, &syntax_spoolss, NULL, "Delete form", "" },
- { "enumforms", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_forms, &syntax_spoolss, NULL, "Enumerate forms", "" },
- { "setprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinter, &syntax_spoolss, NULL, "Set printer comment", "" },
- { "setprintername", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprintername, &syntax_spoolss, NULL, "Set printername", "" },
- { "setprinterdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinterdata, &syntax_spoolss, NULL, "Set REG_SZ printer data", "" },
- { "rffpcnex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_rffpcnex, &syntax_spoolss, NULL, "Rffpcnex test", "" },
- { "printercmp", RPC_RTYPE_WERROR, NULL, cmd_spoolss_printercmp, &syntax_spoolss, NULL, "Printer comparison test", "" },
+ { "adddriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterdriver, &ndr_table_spoolss.syntax_id, NULL, "Add a print driver", "" },
+ { "addprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterex, &ndr_table_spoolss.syntax_id, NULL, "Add a printer", "" },
+ { "deldriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriver, &ndr_table_spoolss.syntax_id, NULL, "Delete a printer driver", "" },
+ { "deldriverex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriverex, &ndr_table_spoolss.syntax_id, NULL, "Delete a printer driver with files", "" },
+ { "enumdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data, &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer data", "" },
+ { "enumdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data_ex, &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer data for a key", "" },
+ { "enumkey", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printerkey, &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer keys", "" },
+ { "enumjobs", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_jobs, &ndr_table_spoolss.syntax_id, NULL, "Enumerate print jobs", "" },
+ { "getjob", RPC_RTYPE_WERROR, NULL, cmd_spoolss_get_job, &ndr_table_spoolss.syntax_id, NULL, "Get print job", "" },
+ { "setjob", RPC_RTYPE_WERROR, NULL, cmd_spoolss_set_job, &ndr_table_spoolss.syntax_id, NULL, "Set print job", "" },
+ { "enumports", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_ports, &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer ports", "" },
+ { "enumdrivers", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_drivers, &ndr_table_spoolss.syntax_id, NULL, "Enumerate installed printer drivers", "" },
+ { "enumprinters", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printers, &ndr_table_spoolss.syntax_id, NULL, "Enumerate printers", "" },
+ { "getdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdata, &ndr_table_spoolss.syntax_id, NULL, "Get print driver data", "" },
+ { "getdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdataex, &ndr_table_spoolss.syntax_id, NULL, "Get printer driver data with keyname", ""},
+ { "getdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriver, &ndr_table_spoolss.syntax_id, NULL, "Get print driver information", "" },
+ { "getdriverdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriverdir, &ndr_table_spoolss.syntax_id, NULL, "Get print driver upload directory", "" },
+ { "getprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinter, &ndr_table_spoolss.syntax_id, NULL, "Get printer info", "" },
+ { "openprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer_ex, &ndr_table_spoolss.syntax_id, NULL, "Open printer handle", "" },
+ { "setdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setdriver, &ndr_table_spoolss.syntax_id, NULL, "Set printer driver", "" },
+ { "getprintprocdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir, &ndr_table_spoolss.syntax_id, NULL, "Get print processor directory", "" },
+ { "addform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addform, &ndr_table_spoolss.syntax_id, NULL, "Add form", "" },
+ { "setform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setform, &ndr_table_spoolss.syntax_id, NULL, "Set form", "" },
+ { "getform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getform, &ndr_table_spoolss.syntax_id, NULL, "Get form", "" },
+ { "deleteform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deleteform, &ndr_table_spoolss.syntax_id, NULL, "Delete form", "" },
+ { "enumforms", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_forms, &ndr_table_spoolss.syntax_id, NULL, "Enumerate forms", "" },
+ { "setprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinter, &ndr_table_spoolss.syntax_id, NULL, "Set printer comment", "" },
+ { "setprintername", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprintername, &ndr_table_spoolss.syntax_id, NULL, "Set printername", "" },
+ { "setprinterdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinterdata, &ndr_table_spoolss.syntax_id, NULL, "Set REG_SZ printer data", "" },
+ { "rffpcnex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_rffpcnex, &ndr_table_spoolss.syntax_id, NULL, "Rffpcnex test", "" },
+ { "printercmp", RPC_RTYPE_WERROR, NULL, cmd_spoolss_printercmp, &ndr_table_spoolss.syntax_id, NULL, "Printer comparison test", "" },
+ { "enumprocs", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_procs, &ndr_table_spoolss.syntax_id, NULL, "Enumerate Print Processors", "" },
+ { "enumprocdatatypes", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_proc_data_types, &ndr_table_spoolss.syntax_id, NULL, "Enumerate Print Processor Data Types", "" },
+ { "enummonitors", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_monitors, &ndr_table_spoolss.syntax_id, NULL, "Enumerate Print Monitors", "" },
+ { "createprinteric", RPC_RTYPE_WERROR, NULL, cmd_spoolss_create_printer_ic, &ndr_table_spoolss.syntax_id, NULL, "Create Printer IC", "" },
{ NULL }
};
git.samba.org / vlendec / samba-autobuild / .git / blobdiff