/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_open_printer_ex(struct cli_state *cli,
+static WERROR cmd_spoolss_open_printer_ex(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
if (!cli)
return WERR_GENERAL_FAILURE;
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
fstrcpy(user, cli->user_name);
fstrcpy(printername, argv[1]);
/* Open the printer handle */
- werror = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
+ werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
"", PRINTER_ALL_ACCESS,
servername, user, &hnd);
if (W_ERROR_IS_OK(werror)) {
printf("Printer %s opened successfully\n", printername);
- werror = cli_spoolss_close_printer(cli, mem_ctx, &hnd);
+ werror = rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
if (!W_ERROR_IS_OK(werror)) {
printf("Error closing printer handle! (%s)\n",
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_printers(struct cli_state *cli,
+static WERROR cmd_spoolss_enum_printers(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
if (argc == 3)
fstrcpy(name, argv[2]);
else {
- slprintf(name, sizeof(name)-1, "\\\\%s", cli->desthost);
+ slprintf(name, sizeof(name)-1, "\\\\%s", cli->cli->desthost);
strupper_m(name);
}
ZERO_STRUCT(ctr);
- result = cli_spoolss_enum_printers(cli, mem_ctx, name, PRINTER_ENUM_LOCAL,
+ result = rpccli_spoolss_enum_printers(cli, mem_ctx, name, PRINTER_ENUM_LOCAL,
info_level, &num_printers, &ctr);
if (W_ERROR_IS_OK(result)) {
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_ports(struct cli_state *cli,
+static WERROR cmd_spoolss_enum_ports(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
ZERO_STRUCT(ctr);
- result = cli_spoolss_enum_ports(cli, mem_ctx, info_level, &returned, &ctr);
+ result = rpccli_spoolss_enum_ports(cli, mem_ctx, info_level, &returned, &ctr);
if (W_ERROR_IS_OK(result)) {
int i;
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_setprinter(struct cli_state *cli,
+static WERROR cmd_spoolss_setprinter(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
fstrcpy(comment, argv[2]);
}
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
fstrcpy(user, cli->user_name);
/* get a printer handle */
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
PRINTER_ALL_ACCESS, servername,
user, &pol);
opened_hnd = True;
/* Get printer info */
- result = cli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
+ result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
if (!W_ERROR_IS_OK(result))
goto done;
ctr.printers_2->devmode = NULL;
ctr.printers_2->secdesc = NULL;
- result = cli_spoolss_setprinter(cli, mem_ctx, &pol, info_level, &ctr, 0);
+ result = rpccli_spoolss_setprinter(cli, mem_ctx, &pol, info_level, &ctr, 0);
if (W_ERROR_IS_OK(result))
printf("Success in setting comment.\n");
done:
if (opened_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &pol);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_setprintername(struct cli_state *cli,
+static WERROR cmd_spoolss_setprintername(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
fstrcpy(new_printername, argv[2]);
}
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
fstrcpy(user, cli->user_name);
/* get a printer handle */
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
PRINTER_ALL_ACCESS, servername,
user, &pol);
opened_hnd = True;
/* Get printer info */
- result = cli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
+ result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
if (!W_ERROR_IS_OK(result))
goto done;
ctr.printers_2->devmode = NULL;
ctr.printers_2->secdesc = NULL;
- result = cli_spoolss_setprinter(cli, mem_ctx, &pol, info_level, &ctr, 0);
+ result = rpccli_spoolss_setprinter(cli, mem_ctx, &pol, info_level, &ctr, 0);
if (W_ERROR_IS_OK(result))
printf("Success in setting printername.\n");
done:
if (opened_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &pol);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_getprinter(struct cli_state *cli,
+static WERROR cmd_spoolss_getprinter(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
info_level = atoi(argv[2]);
}
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
fstrcpy(user, cli->user_name);
/* get a printer handle */
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
"", MAXIMUM_ALLOWED_ACCESS,
servername, user, &pol);
/* Get printer info */
- result = cli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
+ result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
if (!W_ERROR_IS_OK(result))
goto done;
done:
if (opened_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &pol);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
return result;
}
STR_TERMINATE);
printf("%s: REG_SZ: %s\n", value.valuename, text);
break;
- case REG_BINARY:
- printf("%s: REG_BINARY: unknown length value not displayed\n",
- value.valuename);
+ case REG_BINARY: {
+ char *hex = hex_encode(NULL, value.data_p, value.size);
+ size_t i, len;
+ printf("%s: REG_BINARY:", value.valuename);
+ 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: {
uint16 *curstr = (uint16 *) value.data_p;
uint8 *start = value.data_p;
printf("%s: REG_MULTI_SZ:\n", value.valuename);
- while ((*curstr != 0) &&
- ((uint8 *) curstr < start + value.size)) {
+ while (((uint8 *) curstr < start + value.size)) {
rpcstr_pull(text, curstr, sizeof(text), -1,
STR_TERMINATE);
- printf(" %s\n", text);
+ printf(" %s\n", *text != 0 ? text : "NULL");
curstr += strlen(text) + 1;
}
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_getprinterdata(struct cli_state *cli,
+static WERROR cmd_spoolss_getprinterdata(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
/* Open a printer handle */
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
if (strncmp(argv[1], ".", sizeof(".")) == 0)
fstrcpy(printername, servername);
/* get a printer handle */
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
"", MAXIMUM_ALLOWED_ACCESS,
servername, user, &pol);
/* Get printer info */
- result = cli_spoolss_getprinterdata(cli, mem_ctx, &pol, valuename, &value);
+ result = rpccli_spoolss_getprinterdata(cli, mem_ctx, &pol, valuename, &value);
if (!W_ERROR_IS_OK(result))
goto done;
done:
if (opened_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &pol);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_getprinterdataex(struct cli_state *cli,
+static WERROR cmd_spoolss_getprinterdataex(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
/* Open a printer handle */
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
if (strncmp(argv[1], ".", sizeof(".")) == 0)
fstrcpy(printername, servername);
/* get a printer handle */
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
"", MAXIMUM_ALLOWED_ACCESS,
servername, user, &pol);
/* Get printer info */
- result = cli_spoolss_getprinterdataex(cli, mem_ctx, &pol, keyname,
+ result = rpccli_spoolss_getprinterdataex(cli, mem_ctx, &pol, keyname,
valuename, &value);
if (!W_ERROR_IS_OK(result))
done:
if (opened_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &pol);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_getdriver(struct cli_state *cli,
+static WERROR cmd_spoolss_getdriver(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
}
/* get the arguments need to open the printer handle */
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
fstrcpy(user, cli->user_name);
slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
/* Open a printer handle */
- werror = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
+ werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
PRINTER_ACCESS_USE,
servername, user, &pol);
for (i=0; archi_table[i].long_archi!=NULL; i++) {
- werror = cli_spoolss_getprinterdriver( cli, mem_ctx, &pol, info_level,
+ werror = rpccli_spoolss_getprinterdriver( cli, mem_ctx, &pol, info_level,
archi_table[i].long_archi, archi_table[i].version,
&ctr);
/* Cleanup */
if (opened_hnd)
- cli_spoolss_close_printer (cli, mem_ctx, &pol);
+ rpccli_spoolss_close_printer (cli, mem_ctx, &pol);
if ( success )
werror = WERR_OK;
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_drivers(struct cli_state *cli,
+static WERROR cmd_spoolss_enum_drivers(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
if ( i>0 && strequal(archi_table[i].long_archi, archi_table[i-1].long_archi) )
continue;
- werror = cli_spoolss_enumprinterdrivers(
+ werror = rpccli_spoolss_enumprinterdrivers(
cli, mem_ctx, info_level,
archi_table[i].long_archi, &returned, &ctr);
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_getdriverdir(struct cli_state *cli,
+static WERROR cmd_spoolss_getdriverdir(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
/* Get the directory. Only use Info level 1 */
- result = cli_spoolss_getprinterdriverdir(cli, mem_ctx, 1, env, &ctr);
+ result = rpccli_spoolss_getprinterdriverdir(cli, mem_ctx, 1, env, &ctr);
if (W_ERROR_IS_OK(result))
display_printdriverdir_1(ctr.info1);
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_addprinterdriver(struct cli_state *cli,
+static WERROR cmd_spoolss_addprinterdriver(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
ctr.info3 = &info3;
- result = cli_spoolss_addprinterdriver (cli, mem_ctx, level, &ctr);
+ result = rpccli_spoolss_addprinterdriver (cli, mem_ctx, level, &ctr);
if (W_ERROR_IS_OK(result)) {
rpcstr_pull(driver_name, info3.name.buffer,
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_addprinterex(struct cli_state *cli,
+static WERROR cmd_spoolss_addprinterex(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
return WERR_OK;
}
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
/* Fill in the DRIVER_INFO_2 struct */
*/
ctr.printers_2 = &info2;
- result = cli_spoolss_addprinterex (cli, mem_ctx, level, &ctr);
+ result = rpccli_spoolss_addprinterex (cli, mem_ctx, level, &ctr);
if (W_ERROR_IS_OK(result))
printf ("Printer %s successfully installed.\n", argv[1]);
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_setdriver(struct cli_state *cli,
+static WERROR cmd_spoolss_setdriver(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
return WERR_OK;
}
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
fstrcpy(user, cli->user_name);
/* Get a printer handle */
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
PRINTER_ALL_ACCESS,
servername, user, &pol);
ZERO_STRUCT (info2);
ctr.printers_2 = &info2;
- result = cli_spoolss_getprinter(cli, mem_ctx, &pol, level, &ctr);
+ result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, level, &ctr);
if (!W_ERROR_IS_OK(result)) {
printf ("Unable to retrieve printer information!\n");
init_unistr(&ctr.printers_2->drivername, argv[2]);
- result = cli_spoolss_setprinter(cli, mem_ctx, &pol, level, &ctr, 0);
+ result = rpccli_spoolss_setprinter(cli, mem_ctx, &pol, level, &ctr, 0);
if (!W_ERROR_IS_OK(result)) {
printf("SetPrinter call failed!\n");
/* Cleanup */
if (opened_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &pol);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_deletedriverex(struct cli_state *cli,
+static WERROR cmd_spoolss_deletedriverex(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
continue;
/* make the call to remove the driver */
- result = cli_spoolss_deleteprinterdriverex(
+ result = rpccli_spoolss_deleteprinterdriverex(
cli, mem_ctx, archi_table[i].long_archi, argv[1], archi_table[i].version);
if ( !W_ERROR_IS_OK(result) )
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_deletedriver(struct cli_state *cli,
+static WERROR cmd_spoolss_deletedriver(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
return WERR_OK;
}
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
/* delete the driver for all architectures */
for (i=0; archi_table[i].long_archi; i++)
{
/* make the call to remove the driver */
- result = cli_spoolss_deleteprinterdriver(
+ result = rpccli_spoolss_deleteprinterdriver(
cli, mem_ctx, archi_table[i].long_archi, argv[1]);
if ( !W_ERROR_IS_OK(result) ) {
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_getprintprocdir(struct cli_state *cli,
+static WERROR cmd_spoolss_getprintprocdir(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
return WERR_OK;
}
- if (asprintf(&servername, "\\\\%s", cli->desthost) < 0)
+ if (asprintf(&servername, "\\\\%s", cli->cli->desthost) < 0)
return WERR_NOMEM;
strupper_m(servername);
return WERR_NOMEM;
}
- result = cli_spoolss_getprintprocessordirectory(
+ result = rpccli_spoolss_getprintprocessordirectory(
cli, mem_ctx, servername, environment, procdir);
if (W_ERROR_IS_OK(result))
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_addform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+static WERROR cmd_spoolss_addform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
POLICY_HND handle;
/* Get a printer handle */
- asprintf(&servername, "\\\\%s", cli->desthost);
+ asprintf(&servername, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
asprintf(&printername, "%s\\%s", servername, argv[1]);
- werror = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
+ werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
PRINTER_ALL_ACCESS,
servername, cli->user_name, &handle);
/* Add the form */
- werror = cli_spoolss_addform(cli, mem_ctx, &handle, 1, &form);
+ werror = rpccli_spoolss_addform(cli, mem_ctx, &handle, 1, &form);
done:
if (got_handle)
- cli_spoolss_close_printer(cli, mem_ctx, &handle);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
SAFE_FREE(servername);
SAFE_FREE(printername);
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_setform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+static WERROR cmd_spoolss_setform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
POLICY_HND handle;
/* Get a printer handle */
- asprintf(&servername, "\\\\%s", cli->desthost);
+ asprintf(&servername, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
asprintf(&printername, "%s\\%s", servername, argv[1]);
- werror = cli_spoolss_open_printer_ex(
+ werror = rpccli_spoolss_open_printer_ex(
cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
servername, cli->user_name, &handle);
/* Set the form */
- werror = cli_spoolss_setform(cli, mem_ctx, &handle, 1, argv[2], &form);
+ werror = rpccli_spoolss_setform(cli, mem_ctx, &handle, 1, argv[2], &form);
done:
if (got_handle)
- cli_spoolss_close_printer(cli, mem_ctx, &handle);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
SAFE_FREE(servername);
SAFE_FREE(printername);
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_getform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+static WERROR cmd_spoolss_getform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
POLICY_HND handle;
/* Get a printer handle */
- asprintf(&servername, "\\\\%s", cli->desthost);
+ asprintf(&servername, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
asprintf(&printername, "%s\\%s", servername, argv[1]);
- werror = cli_spoolss_open_printer_ex(
+ werror = rpccli_spoolss_open_printer_ex(
cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
servername, cli->user_name, &handle);
/* Get the form */
- werror = cli_spoolss_getform(cli, mem_ctx, &handle, argv[2], 1, &form);
+ werror = rpccli_spoolss_getform(cli, mem_ctx, &handle, argv[2], 1, &form);
if (!W_ERROR_IS_OK(werror))
goto done;
done:
if (got_handle)
- cli_spoolss_close_printer(cli, mem_ctx, &handle);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
SAFE_FREE(servername);
SAFE_FREE(printername);
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_deleteform(struct cli_state *cli,
+static WERROR cmd_spoolss_deleteform(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
/* Get a printer handle */
- asprintf(&servername, "\\\\%s", cli->desthost);
+ asprintf(&servername, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
asprintf(&printername, "%s\\%s", servername, argv[1]);
- werror = cli_spoolss_open_printer_ex(
+ werror = rpccli_spoolss_open_printer_ex(
cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
servername, cli->user_name, &handle);
/* Delete the form */
- werror = cli_spoolss_deleteform(cli, mem_ctx, &handle, argv[2]);
+ werror = rpccli_spoolss_deleteform(cli, mem_ctx, &handle, argv[2]);
done:
if (got_handle)
- cli_spoolss_close_printer(cli, mem_ctx, &handle);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
SAFE_FREE(servername);
SAFE_FREE(printername);
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_forms(struct cli_state *cli,
+static WERROR cmd_spoolss_enum_forms(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
/* Get a printer handle */
- asprintf(&servername, "\\\\%s", cli->desthost);
+ asprintf(&servername, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
asprintf(&printername, "%s\\%s", servername, argv[1]);
- werror = cli_spoolss_open_printer_ex(
+ werror = rpccli_spoolss_open_printer_ex(
cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
servername, cli->user_name, &handle);
/* Enumerate forms */
offered = needed = 0;
- werror = cli_spoolss_enumforms(cli, mem_ctx, &handle, level, &num_forms, &forms);
+ werror = rpccli_spoolss_enumforms(cli, mem_ctx, &handle, level, &num_forms, &forms);
if (!W_ERROR_IS_OK(werror))
goto done;
done:
if (got_handle)
- cli_spoolss_close_printer(cli, mem_ctx, &handle);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
SAFE_FREE(servername);
SAFE_FREE(printername);
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_setprinterdata(struct cli_state *cli,
+static WERROR cmd_spoolss_setprinterdata(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
PRINTER_INFO_CTR ctr;
PRINTER_INFO_0 info;
REGISTRY_VALUE value;
- UNISTR2 data;
/* parse the command arguements */
- if (argc != 4) {
- printf ("Usage: %s <printer> <value> <data>\n", argv[0]);
- return WERR_OK;
+ if (argc < 5) {
+ printf ("Usage: %s <printer> <string|binary|dword|multistring>"
+ " <value> <data>\n",
+ argv[0]);
+ return WERR_INVALID_PARAM;
}
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
fstrcpy(user, cli->user_name);
+ value.type = REG_NONE;
+
+ if (strequal(argv[2], "string")) {
+ value.type = REG_SZ;
+ }
+
+ if (strequal(argv[2], "binary")) {
+ value.type = REG_BINARY;
+ }
+
+ if (strequal(argv[2], "dword")) {
+ value.type = REG_DWORD;
+ }
+
+ if (strequal(argv[2], "multistring")) {
+ value.type = REG_MULTI_SZ;
+ }
+
+ if (value.type == REG_NONE) {
+ printf("Unknown data type: %s\n", argv[2]);
+ return WERR_INVALID_PARAM;
+ }
+
/* get a printer handle */
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
MAXIMUM_ALLOWED_ACCESS, servername,
user, &pol);
if (!W_ERROR_IS_OK(result))
ctr.printers_0 = &info;
- result = cli_spoolss_getprinter(cli, mem_ctx, &pol, 0, &ctr);
+ result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, 0, &ctr);
if (!W_ERROR_IS_OK(result))
goto done;
/* Set the printer data */
- init_unistr2(&data, argv[3], UNI_STR_TERMINATE);
- fstrcpy(value.valuename, argv[2]);
- value.type = REG_SZ;
- value.size = data.uni_str_len * 2;
- value.data_p = TALLOC_MEMDUP(mem_ctx, data.buffer, value.size);
+ 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;
+ value.data_p = TALLOC_MEMDUP(mem_ctx, data.buffer, value.size);
+ break;
+ }
+ case REG_DWORD: {
+ uint32 data = strtoul(argv[4], NULL, 10);
+ value.size = sizeof(data);
+ value.data_p = TALLOC_MEMDUP(mem_ctx, &data, sizeof(data));
+ break;
+ }
+ case REG_BINARY: {
+ DATA_BLOB data = strhex_to_data_blob(mem_ctx, argv[4]);
+ value.data_p = data.data;
+ value.size = data.length;
+ break;
+ }
+ case REG_MULTI_SZ: {
+ int i;
+ size_t len = 0;
+ char *p;
+
+ for (i=4; i<argc; i++) {
+ if (strcmp(argv[i], "NULL") == 0) {
+ argv[i] = "";
+ }
+ len += strlen(argv[i])+1;
+ }
- result = cli_spoolss_setprinterdata(cli, mem_ctx, &pol, &value);
+ value.size = len*2;
+ value.data_p = TALLOC_ARRAY(mem_ctx, char, value.size);
+ if (value.data_p == NULL) {
+ result = WERR_NOMEM;
+ goto done;
+ }
+
+ p = 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;
+ }
+ 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);
if (!W_ERROR_IS_OK(result)) {
- printf ("Unable to set [%s=%s]!\n", argv[2], argv[3]);
+ printf ("Unable to set [%s=%s]!\n", argv[3], argv[4]);
goto done;
}
- printf("\tSetPrinterData succeeded [%s: %s]\n", argv[2], argv[3]);
+ printf("\tSetPrinterData succeeded [%s: %s]\n", argv[3], argv[4]);
- result = cli_spoolss_getprinter(cli, mem_ctx, &pol, 0, &ctr);
+ result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, 0, &ctr);
if (!W_ERROR_IS_OK(result))
goto done;
done:
/* cleanup */
if (opened_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &pol);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_jobs(struct cli_state *cli,
+static WERROR cmd_spoolss_enum_jobs(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
/* Open printer handle */
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
fstrcpy(user, cli->user_name);
- slprintf(printername, sizeof(servername)-1, "\\\\%s\\", cli->desthost);
+ slprintf(printername, sizeof(servername)-1, "\\\\%s\\", cli->cli->desthost);
strupper_m(printername);
pstrcat(printername, argv[1]);
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
"", MAXIMUM_ALLOWED_ACCESS,
servername, user, &hnd);
/* Enumerate ports */
offered = needed = 0;
- result = cli_spoolss_enumjobs(cli, mem_ctx, &hnd, level, 0, 1000,
+ result = rpccli_spoolss_enumjobs(cli, mem_ctx, &hnd, level, 0, 1000,
&num_jobs, &ctr);
if (!W_ERROR_IS_OK(result))
done:
if (got_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &hnd);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_data( struct cli_state *cli,
+static WERROR cmd_spoolss_enum_data( struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
/* Open printer handle */
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
fstrcpy(user, cli->user_name);
- slprintf(printername, sizeof(printername)-1, "\\\\%s\\", cli->desthost);
+ slprintf(printername, sizeof(printername)-1, "\\\\%s\\", cli->cli->desthost);
strupper_m(printername);
pstrcat(printername, argv[1]);
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
"", MAXIMUM_ALLOWED_ACCESS,
servername, user, &hnd);
/* Enumerate data */
- result = cli_spoolss_enumprinterdata(cli, mem_ctx, &hnd, i, 0, 0,
+ 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 = cli_spoolss_enumprinterdata(
+ result = rpccli_spoolss_enumprinterdata(
cli, mem_ctx, &hnd, i++, val_needed,
data_needed, 0, 0, &value);
if (W_ERROR_IS_OK(result))
done:
if (got_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &hnd);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_data_ex( struct cli_state *cli,
+static WERROR cmd_spoolss_enum_data_ex( struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
fstring servername, user;
const char *keyname = NULL;
POLICY_HND hnd;
- REGVAL_CTR ctr;
+ REGVAL_CTR *ctr = NULL;
if (argc != 3) {
printf("Usage: %s printername <keyname>\n", argv[0]);
/* Open printer handle */
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
fstrcpy(user, cli->user_name);
- slprintf(printername, sizeof(printername)-1, "\\\\%s\\", cli->desthost);
+ slprintf(printername, sizeof(printername)-1, "\\\\%s\\", cli->cli->desthost);
strupper_m(printername);
pstrcat(printername, argv[1]);
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
"", MAXIMUM_ALLOWED_ACCESS,
servername, user, &hnd);
/* Enumerate subkeys */
- result = cli_spoolss_enumprinterdataex(cli, mem_ctx, &hnd, keyname, &ctr);
+ 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))
goto done;
- for (i=0; i < ctr.num_values; i++) {
- display_reg_value(*(ctr.values[i]));
+ for (i=0; i < ctr->num_values; i++) {
+ display_reg_value(*(ctr->values[i]));
}
- regval_ctr_destroy(&ctr);
+ TALLOC_FREE( ctr );
done:
if (got_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &hnd);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_enum_printerkey( struct cli_state *cli,
+static WERROR cmd_spoolss_enum_printerkey( struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
/* Open printer handle */
- slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
fstrcpy(user, cli->user_name);
- slprintf(printername, sizeof(printername)-1, "\\\\%s\\", cli->desthost);
+ slprintf(printername, sizeof(printername)-1, "\\\\%s\\", cli->cli->desthost);
strupper_m(printername);
pstrcat(printername, argv[1]);
- result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
+ result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
"", MAXIMUM_ALLOWED_ACCESS,
servername, user, &hnd);
/* Enumerate subkeys */
- result = cli_spoolss_enumprinterkey(cli, mem_ctx, &hnd, keyname, &keylist, NULL);
+ result = rpccli_spoolss_enumprinterkey(cli, mem_ctx, &hnd, keyname, &keylist, NULL);
if (!W_ERROR_IS_OK(result))
goto done;
done:
if (got_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &hnd);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR cmd_spoolss_rffpcnex(struct cli_state *cli,
+static WERROR cmd_spoolss_rffpcnex(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
/* Open printer */
- slprintf(servername, sizeof(servername) - 1, "\\\\%s", cli->desthost);
+ slprintf(servername, sizeof(servername) - 1, "\\\\%s", cli->cli->desthost);
strupper_m(servername);
- slprintf(printername, sizeof(printername) - 1, "\\\\%s\\%s", cli->desthost,
+ slprintf(printername, sizeof(printername) - 1, "\\\\%s\\%s", cli->cli->desthost,
argv[1]);
strupper_m(printername);
- result = cli_spoolss_open_printer_ex(
+ result = rpccli_spoolss_open_printer_ex(
cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
servername, cli->user_name, &hnd);
slprintf(servername, sizeof(servername) - 1, "\\\\%s", myhostname());
strupper_m(servername);
- result = cli_spoolss_rffpcnex(
+ result = rpccli_spoolss_rffpcnex(
cli, mem_ctx, &hnd, 0, 0, servername, 123, &option);
if (!W_ERROR_IS_OK(result)) {
done:
if (got_hnd)
- cli_spoolss_close_printer(cli, mem_ctx, &hnd);
+ rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
return result;
}
+/****************************************************************************
+****************************************************************************/
+
+static BOOL compare_printer( struct rpc_pipe_client *cli1, POLICY_HND *hnd1,
+ struct rpc_pipe_client *cli2, POLICY_HND *hnd2 )
+{
+ PRINTER_INFO_CTR ctr1, ctr2;
+ WERROR werror;
+ TALLOC_CTX *mem_ctx = talloc_init("compare_printer");
+
+ printf("Retrieving printer propertiesfor %s...", cli1->cli->desthost);
+ werror = rpccli_spoolss_getprinter( cli1, mem_ctx, hnd1, 2, &ctr1);
+ if ( !W_ERROR_IS_OK(werror) ) {
+ printf("failed (%s)\n", dos_errstr(werror));
+ talloc_destroy(mem_ctx);
+ return False;
+ }
+ printf("ok\n");
+
+ printf("Retrieving printer properties for %s...", cli2->cli->desthost);
+ werror = rpccli_spoolss_getprinter( cli2, mem_ctx, hnd2, 2, &ctr2);
+ if ( !W_ERROR_IS_OK(werror) ) {
+ printf("failed (%s)\n", dos_errstr(werror));
+ talloc_destroy(mem_ctx);
+ return False;
+ }
+ printf("ok\n");
+
+ talloc_destroy(mem_ctx);
+
+ return True;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL compare_printer_secdesc( struct rpc_pipe_client *cli1, POLICY_HND *hnd1,
+ struct rpc_pipe_client *cli2, POLICY_HND *hnd2 )
+{
+ PRINTER_INFO_CTR ctr1, ctr2;
+ WERROR werror;
+ TALLOC_CTX *mem_ctx = talloc_init("compare_printer_secdesc");
+ SEC_DESC *sd1, *sd2;
+ BOOL result = True;
+
+
+ printf("Retreiving printer security for %s...", cli1->cli->desthost);
+ werror = rpccli_spoolss_getprinter( cli1, mem_ctx, hnd1, 3, &ctr1);
+ if ( !W_ERROR_IS_OK(werror) ) {
+ printf("failed (%s)\n", dos_errstr(werror));
+ result = False;
+ goto done;
+ }
+ printf("ok\n");
+
+ printf("Retrieving printer security for %s...", cli2->cli->desthost);
+ werror = rpccli_spoolss_getprinter( cli2, mem_ctx, hnd2, 3, &ctr2);
+ if ( !W_ERROR_IS_OK(werror) ) {
+ printf("failed (%s)\n", dos_errstr(werror));
+ result = False;
+ goto done;
+ }
+ printf("ok\n");
+
+
+ printf("++ ");
+
+ if ( (ctr1.printers_3 != ctr2.printers_3) && (!ctr1.printers_3 || !ctr2.printers_3) ) {
+ printf("NULL PRINTER_INFO_3!\n");
+ result = False;
+ goto done;
+ }
+
+ sd1 = ctr1.printers_3->secdesc;
+ sd2 = ctr2.printers_3->secdesc;
+
+ if ( (sd1 != sd2) && ( !sd1 || !sd2 ) ) {
+ printf("NULL secdesc!\n");
+ result = False;
+ goto done;
+ }
+
+ if ( (ctr1.printers_3->flags != ctr1.printers_3->flags ) || !sec_desc_equal( sd1, sd2 ) ) {
+ printf("Security Descriptors *not* equal!\n");
+ result = False;
+ goto done;
+ }
+
+ printf("Security descriptors match\n");
+
+done:
+ talloc_destroy(mem_ctx);
+ return result;
+}
+
+
+/****************************************************************************
+****************************************************************************/
+
+static WERROR cmd_spoolss_printercmp(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx, int argc,
+ const char **argv)
+{
+ fstring printername, servername1, servername2;
+ pstring printername_path;
+ struct cli_state *cli_server1 = cli->cli;
+ struct cli_state *cli_server2 = NULL;
+ struct rpc_pipe_client *cli2 = NULL;
+ POLICY_HND hPrinter1, hPrinter2;
+ NTSTATUS nt_status;
+ WERROR werror;
+
+ if ( argc != 3 ) {
+ printf("Usage: %s <printer> <server>\n", argv[0]);
+ return WERR_OK;
+ }
+
+ fstrcpy( printername, argv[1] );
+
+ fstr_sprintf( servername1, cli->cli->desthost );
+ fstrcpy( servername2, argv[2] );
+ strupper_m( servername1 );
+ strupper_m( servername2 );
+
+
+ /* first get the connection to the remote server */
+
+ nt_status = cli_full_connection(&cli_server2, global_myname(), servername2,
+ NULL, 0,
+ "IPC$", "IPC",
+ cmdline_auth_info.username,
+ lp_workgroup(),
+ cmdline_auth_info.password,
+ cmdline_auth_info.use_kerberos ? CLI_FULL_CONNECTION_USE_KERBEROS : 0,
+ cmdline_auth_info.signing_state, NULL);
+
+ if ( !NT_STATUS_IS_OK(nt_status) )
+ return WERR_GENERAL_FAILURE;
+
+ cli2 = cli_rpc_pipe_open_noauth(cli_server2, PI_SPOOLSS, &nt_status);
+ if (!cli2) {
+ printf("failed to open spoolss pipe on server %s (%s)\n",
+ servername2, nt_errstr(nt_status));
+ return WERR_GENERAL_FAILURE;
+ }
+
+ /* now open up both printers */
+
+ pstr_sprintf( printername_path, "\\\\%s\\%s", servername1, printername );
+ printf("Opening %s...", printername_path);
+ werror = rpccli_spoolss_open_printer_ex( cli, mem_ctx, printername_path,
+ "", PRINTER_ALL_ACCESS, servername1, cli_server1->user_name, &hPrinter1);
+ if ( !W_ERROR_IS_OK(werror) ) {
+ printf("failed (%s)\n", dos_errstr(werror));
+ goto done;
+ }
+ printf("ok\n");
+
+ pstr_sprintf( printername_path, "\\\\%s\\%s", servername2, printername );
+ printf("Opening %s...", printername_path);
+ werror = rpccli_spoolss_open_printer_ex( cli2, mem_ctx, printername_path,
+ "", PRINTER_ALL_ACCESS, servername2, cli_server2->user_name, &hPrinter2 );
+ if ( !W_ERROR_IS_OK(werror) ) {
+ printf("failed (%s)\n", dos_errstr(werror));
+ goto done;
+ }
+ printf("ok\n");
+
+
+ compare_printer( cli, &hPrinter1, cli2, &hPrinter2 );
+ compare_printer_secdesc( cli, &hPrinter1, cli2, &hPrinter2 );
+#if 0
+ compare_printerdata( cli_server1, &hPrinter1, cli_server2, &hPrinter2 );
+#endif
+
+
+done:
+ /* cleanup */
+
+ printf("Closing printers...");
+ rpccli_spoolss_close_printer( cli, mem_ctx, &hPrinter1 );
+ rpccli_spoolss_close_printer( cli2, mem_ctx, &hPrinter2 );
+ printf("ok\n");
+
+ /* close the second remote connection */
+
+ cli_shutdown( cli_server2 );
+
+ return WERR_OK;
+}
+
/* List of commands exported by this module */
struct cmd_set spoolss_commands[] = {
{ "SPOOLSS" },
- { "adddriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterdriver, PI_SPOOLSS, "Add a print driver", "" },
- { "addprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterex, PI_SPOOLSS, "Add a printer", "" },
- { "deldriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriver, PI_SPOOLSS, "Delete a printer driver", "" },
- { "deldriverex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriverex, PI_SPOOLSS, "Delete a printer driver with files", "" },
- { "enumdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data, PI_SPOOLSS, "Enumerate printer data", "" },
- { "enumdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data_ex, PI_SPOOLSS, "Enumerate printer data for a key", "" },
- { "enumkey", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printerkey, PI_SPOOLSS, "Enumerate printer keys", "" },
- { "enumjobs", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_jobs, PI_SPOOLSS, "Enumerate print jobs", "" },
- { "enumports", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_ports, PI_SPOOLSS, "Enumerate printer ports", "" },
- { "enumdrivers", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_drivers, PI_SPOOLSS, "Enumerate installed printer drivers", "" },
- { "enumprinters", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printers, PI_SPOOLSS, "Enumerate printers", "" },
- { "getdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdata, PI_SPOOLSS, "Get print driver data", "" },
- { "getdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdataex, PI_SPOOLSS, "Get printer driver data with keyname", ""},
- { "getdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriver, PI_SPOOLSS, "Get print driver information", "" },
- { "getdriverdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriverdir, PI_SPOOLSS, "Get print driver upload directory", "" },
- { "getprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinter, PI_SPOOLSS, "Get printer info", "" },
- { "openprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer_ex, PI_SPOOLSS, "Open printer handle", "" },
- { "setdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setdriver, PI_SPOOLSS, "Set printer driver", "" },
- { "getprintprocdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir, PI_SPOOLSS, "Get print processor directory", "" },
- { "addform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addform, PI_SPOOLSS, "Add form", "" },
- { "setform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setform, PI_SPOOLSS, "Set form", "" },
- { "getform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getform, PI_SPOOLSS, "Get form", "" },
- { "deleteform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deleteform, PI_SPOOLSS, "Delete form", "" },
- { "enumforms", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_forms, PI_SPOOLSS, "Enumerate forms", "" },
- { "setprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinter, PI_SPOOLSS, "Set printer comment", "" },
- { "setprintername", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprintername, PI_SPOOLSS, "Set printername", "" },
- { "setprinterdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinterdata, PI_SPOOLSS, "Set REG_SZ printer data", "" },
- { "rffpcnex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_rffpcnex, PI_SPOOLSS, "Rffpcnex test", "" },
+ { "adddriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterdriver, PI_SPOOLSS, NULL, "Add a print driver", "" },
+ { "addprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterex, PI_SPOOLSS, NULL, "Add a printer", "" },
+ { "deldriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriver, PI_SPOOLSS, NULL, "Delete a printer driver", "" },
+ { "deldriverex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriverex, PI_SPOOLSS, NULL, "Delete a printer driver with files", "" },
+ { "enumdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data, PI_SPOOLSS, NULL, "Enumerate printer data", "" },
+ { "enumdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data_ex, PI_SPOOLSS, NULL, "Enumerate printer data for a key", "" },
+ { "enumkey", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printerkey, PI_SPOOLSS, NULL, "Enumerate printer keys", "" },
+ { "enumjobs", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_jobs, PI_SPOOLSS, NULL, "Enumerate print jobs", "" },
+ { "enumports", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_ports, PI_SPOOLSS, NULL, "Enumerate printer ports", "" },
+ { "enumdrivers", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_drivers, PI_SPOOLSS, NULL, "Enumerate installed printer drivers", "" },
+ { "enumprinters", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printers, PI_SPOOLSS, NULL, "Enumerate printers", "" },
+ { "getdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdata, PI_SPOOLSS, NULL, "Get print driver data", "" },
+ { "getdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdataex, PI_SPOOLSS, NULL, "Get printer driver data with keyname", ""},
+ { "getdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriver, PI_SPOOLSS, NULL, "Get print driver information", "" },
+ { "getdriverdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriverdir, PI_SPOOLSS, NULL, "Get print driver upload directory", "" },
+ { "getprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinter, PI_SPOOLSS, NULL, "Get printer info", "" },
+ { "openprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer_ex, PI_SPOOLSS, NULL, "Open printer handle", "" },
+ { "setdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setdriver, PI_SPOOLSS, NULL, "Set printer driver", "" },
+ { "getprintprocdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir, PI_SPOOLSS, NULL, "Get print processor directory", "" },
+ { "addform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addform, PI_SPOOLSS, NULL, "Add form", "" },
+ { "setform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setform, PI_SPOOLSS, NULL, "Set form", "" },
+ { "getform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getform, PI_SPOOLSS, NULL, "Get form", "" },
+ { "deleteform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deleteform, PI_SPOOLSS, NULL, "Delete form", "" },
+ { "enumforms", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_forms, PI_SPOOLSS, NULL, "Enumerate forms", "" },
+ { "setprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinter, PI_SPOOLSS, NULL, "Set printer comment", "" },
+ { "setprintername", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprintername, PI_SPOOLSS, NULL, "Set printername", "" },
+ { "setprinterdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinterdata, PI_SPOOLSS, NULL, "Set REG_SZ printer data", "" },
+ { "rffpcnex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_rffpcnex, PI_SPOOLSS, NULL, "Rffpcnex test", "" },
+ { "printercmp", RPC_RTYPE_WERROR, NULL, cmd_spoolss_printercmp, PI_SPOOLSS, NULL, "Printer comparison test", "" },
{ NULL }
};
git.samba.org / amitay / samba.git / blobdiff