up, all the errors returned are DOS errors, not NT status codes. */
#include "includes.h"
+#include "../librpc/gen_ndr/srv_spoolss.h"
+#include "../librpc/gen_ndr/cli_spoolss.h"
/* macros stolen from s4 spoolss server */
#define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
reload_services(false);
unbecome_root();
- if ( lp_servicenumber( sharename ) < 0 )
+ if ( lp_servicenumber( sharename ) > 0 )
return WERR_ACCESS_DENIED;
return WERR_OK;
return false;
}
- rpcstr_push(nt_devmode->devicename, devmode->devicename, 31, 0);
- rpcstr_push(nt_devmode->formname, devmode->formname, 31, 0);
+ fstrcpy(nt_devmode->devicename, devmode->devicename);
+ fstrcpy(nt_devmode->formname, devmode->formname);
+
+ nt_devmode->devicename[31] = '\0';
+ nt_devmode->formname[31] = '\0';
nt_devmode->specversion = devmode->specversion;
nt_devmode->driverversion = devmode->driverversion;
return WERR_BADFID;
}
+ if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
+ r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
+ }
+
se_map_standard(&r->in.access_mask, &printer_std_mapping);
/* map an empty access mask to the minimum access mask */
struct spoolss_DeletePrinterDriver *r)
{
- union spoolss_DriverInfo *info = NULL;
- union spoolss_DriverInfo *info_win2k = NULL;
+ struct spoolss_DriverInfo8 *info = NULL;
+ struct spoolss_DriverInfo8 *info_win2k = NULL;
int version;
WERROR status;
WERROR status_win2k = WERR_ACCESS_DENIED;
if ((version = get_version_id(r->in.architecture)) == -1)
return WERR_INVALID_ENVIRONMENT;
- if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, 3, r->in.driver,
+ if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
r->in.architecture,
version)))
{
if ( version == 2 ) {
version = 3;
if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
- &info, 3,
+ &info,
r->in.driver,
r->in.architecture,
version))) {
}
- if (printer_driver_in_use(&info->info3)) {
+ if (printer_driver_in_use(info)) {
status = WERR_PRINTER_DRIVER_IN_USE;
goto done;
}
if ( version == 2 )
{
if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
- &info_win2k, 3,
+ &info_win2k,
r->in.driver,
r->in.architecture, 3)))
{
/* remove the Win2k driver first*/
status_win2k = delete_printer_driver(
- p, &info_win2k->info3, 3, false);
+ p, info_win2k, 3, false);
free_a_printer_driver(info_win2k);
/* this should not have failed---if it did, report to client */
}
}
- status = delete_printer_driver(p, &info->info3, version, false);
+ status = delete_printer_driver(p, info, version, false);
/* if at least one of the deletes succeeded return OK */
WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
struct spoolss_DeletePrinterDriverEx *r)
{
- union spoolss_DriverInfo *info = NULL;
- union spoolss_DriverInfo *info_win2k = NULL;
+ struct spoolss_DriverInfo8 *info = NULL;
+ struct spoolss_DriverInfo8 *info_win2k = NULL;
int version;
bool delete_files;
WERROR status;
if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
version = r->in.version;
- status = get_a_printer_driver(p->mem_ctx, &info, 3, r->in.driver,
+ status = get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
r->in.architecture, version);
if ( !W_ERROR_IS_OK(status) )
/* try for Win2k driver if "Windows NT x86" */
version = 3;
- if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, 3, r->in.driver,
+ if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
r->in.architecture,
version))) {
status = WERR_UNKNOWN_PRINTER_DRIVER;
}
}
- if ( printer_driver_in_use(&info->info3) ) {
+ if (printer_driver_in_use(info)) {
status = WERR_PRINTER_DRIVER_IN_USE;
goto done;
}
/* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
- if ( delete_files && printer_driver_files_in_use(info, &info->info3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
+ if (delete_files && printer_driver_files_in_use(info, info) & (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
/* no idea of the correct error here */
status = WERR_ACCESS_DENIED;
goto done;
/* also check for W32X86/3 if necessary; maybe we already have? */
if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
- if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info_win2k, 3,
+ if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info_win2k,
r->in.driver,
r->in.architecture, 3)))
{
- if ( delete_files && printer_driver_files_in_use(info, &info_win2k->info3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
+ if (delete_files && printer_driver_files_in_use(info, info_win2k) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
/* no idea of the correct error here */
free_a_printer_driver(info_win2k);
status = WERR_ACCESS_DENIED;
/* remove the Win2k driver first*/
status_win2k = delete_printer_driver(
- p, &info_win2k->info3, 3, delete_files);
+ p, info_win2k, 3, delete_files);
free_a_printer_driver(info_win2k);
/* this should not have failed---if it did, report to client */
}
}
- status = delete_printer_driver(p, &info->info3, version, delete_files);
+ status = delete_printer_driver(p, info, version, delete_files);
if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
status = WERR_OK;
if (!StrCaseCmp(value, "Architecture")) {
*type = REG_SZ;
-
- data->string = talloc_strdup(mem_ctx, "Windows NT x86");
+ data->string = talloc_strdup(mem_ctx,
+ lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", SPOOLSS_ARCHITECTURE_NT_X86));
W_ERROR_HAVE_NO_MEMORY(data->string);
return WERR_OK;
return WERR_OK;
}
+ *type = REG_NONE;
+
return WERR_INVALID_PARAM;
}
WERROR _spoolss_GetPrinterData(pipes_struct *p,
struct spoolss_GetPrinterData *r)
{
- WERROR result;
- Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
- NT_PRINTER_INFO_LEVEL *printer = NULL;
- int snum = 0;
-
- /*
- * Reminder: when it's a string, the length is in BYTES
- * even if UNICODE is negociated.
- *
- * JFM, 4/19/1999
- */
-
- /* in case of problem, return some default values */
-
- *r->out.needed = 0;
- *r->out.type = 0;
-
- DEBUG(4,("_spoolss_GetPrinterData\n"));
-
- if (!Printer) {
- DEBUG(2,("_spoolss_GetPrinterData: Invalid handle (%s:%u:%u).\n",
- OUR_HANDLE(r->in.handle)));
- result = WERR_BADFID;
- goto done;
- }
-
- if (Printer->printer_type == SPLHND_SERVER) {
- result = getprinterdata_printer_server(p->mem_ctx,
- r->in.value_name,
- r->out.type,
- r->out.data);
- } else {
- if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
- result = WERR_BADFID;
- goto done;
- }
-
- result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
- if (!W_ERROR_IS_OK(result)) {
- goto done;
- }
-
- /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
-
- if (strequal(r->in.value_name, "ChangeId")) {
- *r->out.type = REG_DWORD;
- r->out.data->value = printer->info_2->changeid;
- result = WERR_OK;
- } else {
- struct regval_blob *v;
- DATA_BLOB blob;
-
- v = get_printer_data(printer->info_2,
- SPOOL_PRINTERDATA_KEY,
- r->in.value_name);
- if (!v) {
- result = WERR_BADFILE;
- goto done;
- }
-
- *r->out.type = v->type;
-
- blob = data_blob_const(v->data_p, v->size);
-
- result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
- r->out.data,
- *r->out.type);
- }
- }
+ struct spoolss_GetPrinterDataEx r2;
- done:
- /* cleanup & exit */
-
- if (printer) {
- free_a_printer(&printer, 2);
- }
-
- if (!W_ERROR_IS_OK(result)) {
- return result;
- }
-
- *r->out.needed = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
- *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
- r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
+ r2.in.handle = r->in.handle;
+ r2.in.key_name = "PrinterDriverData";
+ r2.in.value_name = r->in.value_name;
+ r2.in.offered = r->in.offered;
+ r2.out.type = r->out.type;
+ r2.out.data = r->out.data;
+ r2.out.needed = r->out.needed;
- return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
+ return _spoolss_GetPrinterDataEx(p, &r2);
}
/*********************************************************
NTSTATUS ret;
struct cli_state *the_cli;
struct sockaddr_storage rm_addr;
+ char addr[INET6_ADDRSTRLEN];
if ( is_zero_addr((struct sockaddr *)client_ss) ) {
+ DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
+ remote_machine));
if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
return false;
}
-
- if (ismyaddr((struct sockaddr *)&rm_addr)) {
- DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
- return false;
- }
+ print_sockaddr(addr, sizeof(addr), &rm_addr);
} else {
- char addr[INET6_ADDRSTRLEN];
rm_addr = *client_ss;
print_sockaddr(addr, sizeof(addr), &rm_addr);
DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
addr));
}
- /* setup the connection */
+ if (ismyaddr((struct sockaddr *)&rm_addr)) {
+ DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
+ addr));
+ return false;
+ }
+ /* setup the connection */
ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
&rm_addr, 0, "IPC$", "IPC",
"", /* username */
!get_printer_snum(p, r->in.handle, &snum, NULL) )
return WERR_BADFID;
+ DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
+ "client_address is %s\n", p->client_address));
+
if (!interpret_string_addr(&client_ss, p->client_address,
AI_NUMERICHOST)) {
return WERR_SERVER_UNAVAILABLE;
return devmode;
}
+/********************************************************************
+ * construct_printer_info1
+ * fill a spoolss_PrinterInfo1 struct
+********************************************************************/
+
+static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
+ const NT_PRINTER_INFO_LEVEL *ntprinter,
+ uint32_t flags,
+ struct spoolss_PrinterInfo1 *r,
+ int snum)
+{
+ r->flags = flags;
+
+ r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
+ ntprinter->info_2->printername,
+ ntprinter->info_2->drivername,
+ ntprinter->info_2->location);
+ W_ERROR_HAVE_NO_MEMORY(r->description);
+
+ if (*ntprinter->info_2->comment == '\0') {
+ r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
+ } else {
+ r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
+ }
+ W_ERROR_HAVE_NO_MEMORY(r->comment);
+
+ r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
+ W_ERROR_HAVE_NO_MEMORY(r->name);
+
+ return WERR_OK;
+}
+
+/********************************************************************
+ * construct_printer_info2
+ * fill a spoolss_PrinterInfo2 struct
+********************************************************************/
+
+static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
+ const NT_PRINTER_INFO_LEVEL *ntprinter,
+ struct spoolss_PrinterInfo2 *r,
+ int snum)
+{
+ int count;
+
+ print_status_struct status;
+
+ count = print_queue_length(snum, &status);
+
+ r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
+ W_ERROR_HAVE_NO_MEMORY(r->servername);
+ r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
+ W_ERROR_HAVE_NO_MEMORY(r->printername);
+ r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
+ W_ERROR_HAVE_NO_MEMORY(r->sharename);
+ r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
+ W_ERROR_HAVE_NO_MEMORY(r->portname);
+ r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
+ W_ERROR_HAVE_NO_MEMORY(r->drivername);
+
+ if (*ntprinter->info_2->comment == '\0') {
+ r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
+ } else {
+ r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
+ }
+ W_ERROR_HAVE_NO_MEMORY(r->comment);
+
+ r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
+ W_ERROR_HAVE_NO_MEMORY(r->location);
+ r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
+ W_ERROR_HAVE_NO_MEMORY(r->sepfile);
+ r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
+ W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
+ r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
+ W_ERROR_HAVE_NO_MEMORY(r->datatype);
+ r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
+ W_ERROR_HAVE_NO_MEMORY(r->parameters);
+
+ r->attributes = ntprinter->info_2->attributes;
+
+ r->priority = ntprinter->info_2->priority;
+ r->defaultpriority = ntprinter->info_2->default_priority;
+ r->starttime = ntprinter->info_2->starttime;
+ r->untiltime = ntprinter->info_2->untiltime;
+ r->status = nt_printq_status(status.status);
+ r->cjobs = count;
+ r->averageppm = ntprinter->info_2->averageppm;
+
+ r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
+ if (!r->devmode) {
+ DEBUG(8,("Returning NULL Devicemode!\n"));
+ }
+
+ r->secdesc = NULL;
+
+ if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
+ /* don't use talloc_steal() here unless you do a deep steal of all
+ the SEC_DESC members */
+
+ r->secdesc = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
+ }
+
+ return WERR_OK;
+}
+
/********************************************************************
* construct_printer_info3
* fill a spoolss_PrinterInfo3 struct
/********************************************************************
- * construct_printer_info1
- * fill a spoolss_PrinterInfo1 struct
********************************************************************/
-static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
- uint32_t flags,
- struct spoolss_PrinterInfo1 *r,
- int snum)
+static bool snum_is_shared_printer(int snum)
{
- r->flags = flags;
-
- r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
- ntprinter->info_2->printername,
- ntprinter->info_2->drivername,
- ntprinter->info_2->location);
- W_ERROR_HAVE_NO_MEMORY(r->description);
-
- if (*ntprinter->info_2->comment == '\0') {
- r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
- } else {
- r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
- }
- W_ERROR_HAVE_NO_MEMORY(r->comment);
-
- r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
- W_ERROR_HAVE_NO_MEMORY(r->name);
-
- return WERR_OK;
+ return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
}
/********************************************************************
- * construct_printer_info2
- * fill a spoolss_PrinterInfo2 struct
+ Spoolss_enumprinters.
********************************************************************/
-static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
- struct spoolss_PrinterInfo2 *r,
- int snum)
+static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
+ uint32_t level,
+ uint32_t flags,
+ union spoolss_PrinterInfo **info_p,
+ uint32_t *count_p)
{
- int count;
+ int snum;
+ int n_services = lp_numservices();
+ union spoolss_PrinterInfo *info = NULL;
+ uint32_t count = 0;
+ WERROR result = WERR_OK;
- print_status_struct status;
+ *count_p = 0;
+ *info_p = NULL;
- count = print_queue_length(snum, &status);
+ for (snum = 0; snum < n_services; snum++) {
- r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
- W_ERROR_HAVE_NO_MEMORY(r->servername);
- r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
- W_ERROR_HAVE_NO_MEMORY(r->printername);
- r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
- W_ERROR_HAVE_NO_MEMORY(r->sharename);
- r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
- W_ERROR_HAVE_NO_MEMORY(r->portname);
- r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
- W_ERROR_HAVE_NO_MEMORY(r->drivername);
+ NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
- if (*ntprinter->info_2->comment == '\0') {
- r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
- } else {
- r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
- }
- W_ERROR_HAVE_NO_MEMORY(r->comment);
+ if (!snum_is_shared_printer(snum)) {
+ continue;
+ }
- r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
- W_ERROR_HAVE_NO_MEMORY(r->location);
- r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
- W_ERROR_HAVE_NO_MEMORY(r->sepfile);
- r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
- W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
- r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
- W_ERROR_HAVE_NO_MEMORY(r->datatype);
- r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
- W_ERROR_HAVE_NO_MEMORY(r->parameters);
-
- r->attributes = ntprinter->info_2->attributes;
-
- r->priority = ntprinter->info_2->priority;
- r->defaultpriority = ntprinter->info_2->default_priority;
- r->starttime = ntprinter->info_2->starttime;
- r->untiltime = ntprinter->info_2->untiltime;
- r->status = nt_printq_status(status.status);
- r->cjobs = count;
- r->averageppm = ntprinter->info_2->averageppm;
-
- r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
- if (!r->devmode) {
- DEBUG(8,("Returning NULL Devicemode!\n"));
- }
-
- r->secdesc = NULL;
-
- if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
- /* don't use talloc_steal() here unless you do a deep steal of all
- the SEC_DESC members */
-
- r->secdesc = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
- }
-
- return WERR_OK;
-}
-
-/********************************************************************
-********************************************************************/
-
-static bool snum_is_shared_printer(int snum)
-{
- return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
-}
-
-/********************************************************************
- Spoolss_enumprinters.
-********************************************************************/
-
-static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
- uint32_t level,
- uint32_t flags,
- union spoolss_PrinterInfo **info_p,
- uint32_t *count_p)
-{
- int snum;
- int n_services = lp_numservices();
- union spoolss_PrinterInfo *info = NULL;
- uint32_t count = 0;
- WERROR result = WERR_OK;
-
- *count_p = 0;
- *info_p = NULL;
-
- for (snum = 0; snum < n_services; snum++) {
-
- NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
-
- if (!snum_is_shared_printer(snum)) {
- continue;
- }
-
- DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
- lp_servicename(snum), snum));
+ DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
+ lp_servicename(snum), snum));
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
union spoolss_PrinterInfo,
WERROR _spoolss_EnumPrinters(pipes_struct *p,
struct spoolss_EnumPrinters *r)
{
- const char *name;
+ const char *name = NULL;
WERROR result;
/* that's an [in out] buffer */
* Level 5: same as Level 2
*/
- name = talloc_strdup_upper(p->mem_ctx, r->in.server);
- W_ERROR_HAVE_NO_MEMORY(name);
+ if (r->in.server) {
+ name = talloc_strdup_upper(p->mem_ctx, r->in.server);
+ W_ERROR_HAVE_NO_MEMORY(name);
+ }
switch (r->in.level) {
case 0:
return array;
}
+#define FILL_DRIVER_STRING(mem_ctx, in, out) \
+ do { \
+ if (in && strlen(in)) { \
+ out = talloc_strdup(mem_ctx, in); \
+ W_ERROR_HAVE_NO_MEMORY(out); \
+ } else { \
+ out = NULL; \
+ } \
+ } while (0);
+
+#define FILL_DRIVER_UNC_STRING(mem_ctx, server, in, out) \
+ do { \
+ if (in && strlen(in)) { \
+ out = talloc_asprintf(mem_ctx, "\\\\%s%s", server, in); \
+ } else { \
+ out = talloc_strdup(mem_ctx, ""); \
+ } \
+ W_ERROR_HAVE_NO_MEMORY(out); \
+ } while (0);
+
/********************************************************************
* fill a spoolss_DriverInfo1 struct
********************************************************************/
static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo1 *r,
- const union spoolss_DriverInfo *driver,
- const char *servername,
- const char *architecture)
+ const struct spoolss_DriverInfo8 *driver,
+ const char *servername)
{
- r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
return WERR_OK;
static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo2 *r,
- const union spoolss_DriverInfo *driver,
+ const struct spoolss_DriverInfo8 *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
- r->version = driver->info3.version;
+ r->version = driver->version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
+ r->architecture = talloc_strdup(mem_ctx, driver->architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
- if (strlen(driver->info3.driver_path)) {
- r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.driver_path);
- } else {
- r->driver_path = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->driver_path);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->driver_path,
+ r->driver_path);
- if (strlen(driver->info3.data_file)) {
- r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.data_file);
- } else {
- r->data_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->data_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->data_file,
+ r->data_file);
- if (strlen(driver->info3.config_file)) {
- r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.config_file);
- } else {
- r->config_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->config_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->config_file,
+ r->config_file);
return WERR_OK;
}
static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo3 *r,
- const union spoolss_DriverInfo *driver,
+ const struct spoolss_DriverInfo8 *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
- r->version = driver->info3.version;
+ r->version = driver->version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
+ r->architecture = talloc_strdup(mem_ctx, driver->architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
- if (strlen(driver->info3.driver_path)) {
- r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.driver_path);
- } else {
- r->driver_path = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->driver_path);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->driver_path,
+ r->driver_path);
- if (strlen(driver->info3.data_file)) {
- r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.data_file);
- } else {
- r->data_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->data_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->data_file,
+ r->data_file);
- if (strlen(driver->info3.config_file)) {
- r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.config_file);
- } else {
- r->config_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->config_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->config_file,
+ r->config_file);
- if (strlen(driver->info3.help_file)) {
- r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.help_file);
- } else {
- r->help_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->help_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->help_file,
+ r->help_file);
- r->monitor_name = talloc_strdup(mem_ctx, driver->info3.monitor_name);
- W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
- r->default_datatype = talloc_strdup(mem_ctx, driver->info3.default_datatype);
- W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->monitor_name,
+ r->monitor_name);
+
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->default_datatype,
+ r->default_datatype);
r->dependent_files = string_array_from_driver_info(mem_ctx,
- driver->info3.dependent_files,
+ driver->dependent_files,
cservername);
return WERR_OK;
}
static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo4 *r,
- const union spoolss_DriverInfo *driver,
+ const struct spoolss_DriverInfo8 *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
- r->version = driver->info3.version;
+ r->version = driver->version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
+ r->architecture = talloc_strdup(mem_ctx, driver->architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
- if (strlen(driver->info3.driver_path)) {
- r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.driver_path);
- } else {
- r->driver_path = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->driver_path);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->driver_path,
+ r->driver_path);
- if (strlen(driver->info3.data_file)) {
- r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.data_file);
- } else {
- r->data_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->data_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->data_file,
+ r->data_file);
- if (strlen(driver->info3.config_file)) {
- r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.config_file);
- } else {
- r->config_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->config_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->config_file,
+ r->config_file);
- if (strlen(driver->info3.help_file)) {
- r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.help_file);
- } else {
- r->help_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->help_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->help_file,
+ r->help_file);
r->dependent_files = string_array_from_driver_info(mem_ctx,
- driver->info3.dependent_files,
+ driver->dependent_files,
cservername);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->monitor_name,
+ r->monitor_name);
- r->monitor_name = talloc_strdup(mem_ctx, driver->info3.monitor_name);
- W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
- r->default_datatype = talloc_strdup(mem_ctx, driver->info3.default_datatype);
- W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->default_datatype,
+ r->default_datatype);
r->previous_names = string_array_from_driver_info(mem_ctx,
- NULL,
+ driver->previous_names,
cservername);
return WERR_OK;
static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo5 *r,
- const union spoolss_DriverInfo *driver,
+ const struct spoolss_DriverInfo8 *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
- r->version = driver->info3.version;
+ r->version = driver->version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
+ r->architecture = talloc_strdup(mem_ctx, driver->architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
- if (strlen(driver->info3.driver_path)) {
- r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.driver_path);
- } else {
- r->driver_path = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->driver_path);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->driver_path,
+ r->driver_path);
- if (strlen(driver->info3.data_file)) {
- r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.data_file);
- } else {
- r->data_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->data_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->data_file,
+ r->data_file);
- if (strlen(driver->info3.config_file)) {
- r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.config_file);
- } else {
- r->config_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->config_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->config_file,
+ r->config_file);
r->driver_attributes = 0;
r->config_version = 0;
static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo6 *r,
- const union spoolss_DriverInfo *driver,
+ const struct spoolss_DriverInfo8 *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
- r->version = driver->info3.version;
+ r->version = driver->version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
+ r->architecture = talloc_strdup(mem_ctx, driver->architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
- if (strlen(driver->info3.driver_path)) {
- r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.driver_path);
- } else {
- r->driver_path = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->driver_path);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->driver_path,
+ r->driver_path);
- if (strlen(driver->info3.data_file)) {
- r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.data_file);
- } else {
- r->data_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->data_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->data_file,
+ r->data_file);
- if (strlen(driver->info3.config_file)) {
- r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.config_file);
- } else {
- r->config_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->config_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->config_file,
+ r->config_file);
- if (strlen(driver->info3.help_file)) {
- r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info3.help_file);
- } else {
- r->help_file = talloc_strdup(mem_ctx, "");
- }
- W_ERROR_HAVE_NO_MEMORY(r->help_file);
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->help_file,
+ r->help_file);
- r->monitor_name = talloc_strdup(mem_ctx, driver->info3.monitor_name);
- W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
- r->default_datatype = talloc_strdup(mem_ctx, driver->info3.default_datatype);
- W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->monitor_name,
+ r->monitor_name);
+
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->default_datatype,
+ r->default_datatype);
r->dependent_files = string_array_from_driver_info(mem_ctx,
- driver->info3.dependent_files,
+ driver->dependent_files,
cservername);
r->previous_names = string_array_from_driver_info(mem_ctx,
- NULL,
+ driver->previous_names,
cservername);
- r->driver_date = 0;
- r->driver_version = 0;
+ r->driver_date = driver->driver_date;
+ r->driver_version = driver->driver_version;
+
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->manufacturer_name,
+ r->manufacturer_name);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->manufacturer_url,
+ r->manufacturer_url);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->hardware_id,
+ r->hardware_id);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->provider,
+ r->provider);
+
+ return WERR_OK;
+}
+
+/********************************************************************
+ * fill a spoolss_DriverInfo8 struct
+ ********************************************************************/
+
+static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
+ struct spoolss_DriverInfo8 *r,
+ const struct spoolss_DriverInfo8 *driver,
+ const char *servername)
+{
+ const char *cservername = canon_servername(servername);
+
+ r->version = driver->version;
+
+ r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
+ W_ERROR_HAVE_NO_MEMORY(r->driver_name);
+ r->architecture = talloc_strdup(mem_ctx, driver->architecture);
+ W_ERROR_HAVE_NO_MEMORY(r->architecture);
+
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->driver_path,
+ r->driver_path);
+
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->data_file,
+ r->data_file);
+
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->config_file,
+ r->config_file);
+
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->help_file,
+ r->help_file);
+
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->monitor_name,
+ r->monitor_name);
+
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->default_datatype,
+ r->default_datatype);
+
+ r->dependent_files = string_array_from_driver_info(mem_ctx,
+ driver->dependent_files,
+ cservername);
+ r->previous_names = string_array_from_driver_info(mem_ctx,
+ driver->previous_names,
+ cservername);
+
+ r->driver_date = driver->driver_date;
+ r->driver_version = driver->driver_version;
+
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->manufacturer_name,
+ r->manufacturer_name);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->manufacturer_url,
+ r->manufacturer_url);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->hardware_id,
+ r->hardware_id);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->provider,
+ r->provider);
+
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->print_processor,
+ r->print_processor);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->vendor_setup,
+ r->vendor_setup);
+
+ r->color_profiles = string_array_from_driver_info(mem_ctx,
+ driver->color_profiles,
+ cservername);
- r->manufacturer_name = talloc_strdup(mem_ctx, "");
- W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
- r->manufacturer_url = talloc_strdup(mem_ctx, "");
- W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
- r->hardware_id = talloc_strdup(mem_ctx, "");
- W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
- r->provider = talloc_strdup(mem_ctx, "");
- W_ERROR_HAVE_NO_MEMORY(r->provider);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->inf_path,
+ r->inf_path);
+
+ r->printer_driver_attributes = driver->printer_driver_attributes;
+
+ r->core_driver_dependencies = string_array_from_driver_info(mem_ctx,
+ driver->core_driver_dependencies,
+ cservername);
+
+ r->min_inbox_driver_ver_date = driver->min_inbox_driver_ver_date;
+ r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
return WERR_OK;
}
+#if 0 /* disabled until marshalling issues are resolved - gd */
/********************************************************************
********************************************************************/
********************************************************************/
static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
- const union spoolss_DriverInfo *driver,
+ const struct spoolss_DriverInfo8 *driver,
const char *cservername,
struct spoolss_DriverFileInfo **info_p,
uint32_t *count_p)
*info_p = NULL;
*count_p = 0;
- if (strlen(driver->info3.driver_path)) {
+ if (strlen(driver->driver_path)) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
result = fill_spoolss_DriverFileInfo(info,
&info[count],
cservername,
- driver->info3.driver_path,
+ driver->driver_path,
SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
0);
W_ERROR_NOT_OK_RETURN(result);
count++;
}
- if (strlen(driver->info3.config_file)) {
+ if (strlen(driver->config_file)) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
result = fill_spoolss_DriverFileInfo(info,
&info[count],
cservername,
- driver->info3.config_file,
+ driver->config_file,
SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
0);
W_ERROR_NOT_OK_RETURN(result);
count++;
}
- if (strlen(driver->info3.data_file)) {
+ if (strlen(driver->data_file)) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
result = fill_spoolss_DriverFileInfo(info,
&info[count],
cservername,
- driver->info3.data_file,
+ driver->data_file,
SPOOLSS_DRIVER_FILE_TYPE_DATA,
0);
W_ERROR_NOT_OK_RETURN(result);
count++;
}
- if (strlen(driver->info3.help_file)) {
+ if (strlen(driver->help_file)) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
result = fill_spoolss_DriverFileInfo(info,
&info[count],
cservername,
- driver->info3.help_file,
+ driver->help_file,
SPOOLSS_DRIVER_FILE_TYPE_HELP,
0);
W_ERROR_NOT_OK_RETURN(result);
count++;
}
- for (i=0; driver->info3.dependent_files[i] && driver->info3.dependent_files[i][0] != '\0'; i++) {
+ for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
result = fill_spoolss_DriverFileInfo(info,
&info[count],
cservername,
- driver->info3.dependent_files[i],
+ driver->dependent_files[i],
SPOOLSS_DRIVER_FILE_TYPE_OTHER,
0);
W_ERROR_NOT_OK_RETURN(result);
}
/********************************************************************
- * fill a spoolss_DriverInfo101 sttruct
+ * fill a spoolss_DriverInfo101 struct
********************************************************************/
static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo101 *r,
- const union spoolss_DriverInfo *driver,
+ const struct spoolss_DriverInfo8 *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
WERROR result;
- r->version = driver->info3.version;
+ r->version = driver->version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
+ r->architecture = talloc_strdup(mem_ctx, driver->architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
return result;
}
- r->monitor_name = talloc_strdup(mem_ctx, driver->info3.monitor_name);
- W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->monitor_name,
+ r->monitor_name);
- r->default_datatype = talloc_strdup(mem_ctx, driver->info3.default_datatype);
- W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->default_datatype,
+ r->default_datatype);
r->previous_names = string_array_from_driver_info(mem_ctx,
- NULL,
+ driver->previous_names,
cservername);
- r->driver_date = 0;
- r->driver_version = 0;
-
- r->manufacturer_name = talloc_strdup(mem_ctx, "");
- W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
- r->manufacturer_url = talloc_strdup(mem_ctx, "");
- W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
- r->hardware_id = talloc_strdup(mem_ctx, "");
- W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
- r->provider = talloc_strdup(mem_ctx, "");
- W_ERROR_HAVE_NO_MEMORY(r->provider);
+ r->driver_date = driver->driver_date;
+ r->driver_version = driver->driver_version;
+
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->manufacturer_name,
+ r->manufacturer_name);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->manufacturer_url,
+ r->manufacturer_url);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->hardware_id,
+ r->hardware_id);
+ FILL_DRIVER_STRING(mem_ctx,
+ driver->provider,
+ r->provider);
return WERR_OK;
}
-
-/********************************************************************
- * construct_printer_driver_info_1
- ********************************************************************/
-
-static WERROR construct_printer_driver_info_1(TALLOC_CTX *mem_ctx,
- struct spoolss_DriverInfo1 *r,
- int snum,
- const char *servername,
- const char *architecture,
- uint32_t version)
-{
- NT_PRINTER_INFO_LEVEL *printer = NULL;
- union spoolss_DriverInfo *driver;
- WERROR result;
-
- if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
- return WERR_INVALID_PRINTER_NAME;
-
- if (!W_ERROR_IS_OK(get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername, architecture, version))) {
- free_a_printer(&printer, 2);
- return WERR_UNKNOWN_PRINTER_DRIVER;
- }
-
- result = fill_printer_driver_info1(mem_ctx, r, driver, servername, architecture);
-
- free_a_printer_driver(driver);
- free_a_printer(&printer,2);
-
- return result;
-}
-
+#endif
/********************************************************************
- * construct_printer_driver_info_2
- * fill a printer_info_2 struct
********************************************************************/
-static WERROR construct_printer_driver_info_2(TALLOC_CTX *mem_ctx,
- struct spoolss_DriverInfo2 *r,
- int snum,
- const char *servername,
- const char *architecture,
- uint32_t version)
+static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
+ uint32_t level,
+ union spoolss_DriverInfo *r,
+ int snum,
+ const char *servername,
+ const char *architecture,
+ uint32_t version)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
- union spoolss_DriverInfo *driver;
+ struct spoolss_DriverInfo8 *driver;
WERROR result;
- ZERO_STRUCT(printer);
-
- if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
- return WERR_INVALID_PRINTER_NAME;
-
- if (!W_ERROR_IS_OK(get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername, architecture, version))) {
- free_a_printer(&printer, 2);
- return WERR_UNKNOWN_PRINTER_DRIVER;
- }
-
- result = fill_printer_driver_info2(mem_ctx, r, driver, servername);
-
- free_a_printer_driver(driver);
- free_a_printer(&printer,2);
-
- return result;
-}
-
-/********************************************************************
- * construct_printer_info_3
- * fill a printer_info_3 struct
- ********************************************************************/
-
-static WERROR construct_printer_driver_info_3(TALLOC_CTX *mem_ctx,
- struct spoolss_DriverInfo3 *r,
- int snum,
- const char *servername,
- const char *architecture,
- uint32_t version)
-{
- NT_PRINTER_INFO_LEVEL *printer = NULL;
- union spoolss_DriverInfo *driver;
- WERROR status;
- ZERO_STRUCT(driver);
-
- status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
- DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
- if (!W_ERROR_IS_OK(status))
- return WERR_INVALID_PRINTER_NAME;
-
- status = get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername, architecture, version);
- DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
-
-#if 0 /* JERRY */
-
- /*
- * I put this code in during testing. Helpful when commenting out the
- * support for DRIVER_INFO_6 in regards to win2k. Not needed in general
- * as win2k always queries the driver using an infor level of 6.
- * I've left it in (but ifdef'd out) because I'll probably
- * use it in experimentation again in the future. --jerry 22/01/2002
- */
-
- if (!W_ERROR_IS_OK(status)) {
- /*
- * Is this a W2k client ?
- */
- if (version == 3) {
- /* Yes - try again with a WinNT driver. */
- version = 2;
- status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
- DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
- }
-#endif
-
- if (!W_ERROR_IS_OK(status)) {
- free_a_printer(&printer,2);
- return WERR_UNKNOWN_PRINTER_DRIVER;
- }
-
-#if 0 /* JERRY */
- }
-#endif
-
-
- status = fill_printer_driver_info3(mem_ctx, r, driver, servername);
-
- free_a_printer_driver(driver);
- free_a_printer(&printer,2);
-
- return status;
-}
-
-/********************************************************************
- * construct_printer_info_6
- * fill a printer_info_6 struct
- ********************************************************************/
-
-static WERROR construct_printer_driver_info_6(TALLOC_CTX *mem_ctx,
- struct spoolss_DriverInfo6 *r,
- int snum,
- const char *servername,
- const char *architecture,
- uint32_t version)
-{
- NT_PRINTER_INFO_LEVEL *printer = NULL;
- union spoolss_DriverInfo *driver;
- WERROR status;
-
- status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
-
- DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
-
- if (!W_ERROR_IS_OK(status))
- return WERR_INVALID_PRINTER_NAME;
-
- status = get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername, architecture, version);
-
- DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
-
- if (!W_ERROR_IS_OK(status))
- {
- /*
- * Is this a W2k client ?
- */
-
- if (version < 3) {
- free_a_printer(&printer,2);
- return WERR_UNKNOWN_PRINTER_DRIVER;
- }
-
- /* Yes - try again with a WinNT driver. */
- version = 2;
- status = get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername, architecture, version);
- DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
- if (!W_ERROR_IS_OK(status)) {
- free_a_printer(&printer,2);
- return WERR_UNKNOWN_PRINTER_DRIVER;
- }
- }
-
- status = fill_printer_driver_info6(mem_ctx, r, driver, servername);
-
- free_a_printer(&printer,2);
- free_a_printer_driver(driver);
-
- return status;
-}
-
-/********************************************************************
- * construct_printer_info_101
- * fill a printer_info_101 struct
- ********************************************************************/
-
-static WERROR construct_printer_driver_info_101(TALLOC_CTX *mem_ctx,
- struct spoolss_DriverInfo101 *r,
- int snum,
- const char *servername,
- const char *architecture,
- uint32_t version)
-{
- NT_PRINTER_INFO_LEVEL *printer = NULL;
- union spoolss_DriverInfo *driver;
- WERROR result;
-
result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
- DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
+ DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
win_errstr(result)));
if (!W_ERROR_IS_OK(result)) {
return WERR_INVALID_PRINTER_NAME;
}
- result = get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername,
+ result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
architecture, version);
- DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
+ DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
win_errstr(result)));
if (!W_ERROR_IS_OK(result)) {
/* Yes - try again with a WinNT driver. */
version = 2;
- result = get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername,
+ result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
architecture, version);
- DEBUG(8,("construct_printer_driver_info_6: status: %s\n",
+ DEBUG(8,("construct_printer_driver_level: status: %s\n",
win_errstr(result)));
if (!W_ERROR_IS_OK(result)) {
free_a_printer(&printer, 2);
}
}
- result = fill_printer_driver_info101(mem_ctx, r, driver, servername);
+ switch (level) {
+ case 1:
+ result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
+ break;
+ case 2:
+ result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
+ break;
+ case 3:
+ result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
+ break;
+ case 4:
+ result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
+ break;
+ case 5:
+ result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
+ break;
+ case 6:
+ result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
+ break;
+ case 8:
+ result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
+ break;
+#if 0 /* disabled until marshalling issues are resolved - gd */
+ case 101:
+ result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
+ break;
+#endif
+ default:
+ result = WERR_UNKNOWN_LEVEL;
+ break;
+ }
free_a_printer(&printer, 2);
free_a_printer_driver(driver);
return WERR_BADFID;
}
- switch (r->in.level) {
- case 1:
- result = construct_printer_driver_info_1(p->mem_ctx,
- &r->out.info->info1,
- snum,
- servername,
- r->in.architecture,
- r->in.client_major_version);
- break;
- case 2:
- result = construct_printer_driver_info_2(p->mem_ctx,
- &r->out.info->info2,
- snum,
- servername,
- r->in.architecture,
- r->in.client_major_version);
- break;
- case 3:
- result = construct_printer_driver_info_3(p->mem_ctx,
- &r->out.info->info3,
- snum,
- servername,
- r->in.architecture,
- r->in.client_major_version);
- break;
- case 6:
- result = construct_printer_driver_info_6(p->mem_ctx,
- &r->out.info->info6,
- snum,
- servername,
- r->in.architecture,
- r->in.client_major_version);
- break;
- case 101:
- result = construct_printer_driver_info_101(p->mem_ctx,
- &r->out.info->info101,
- snum,
- servername,
- r->in.architecture,
- r->in.client_major_version);
- break;
- default:
- result = WERR_UNKNOWN_LEVEL;
- break;
- }
-
+ result = construct_printer_driver_info_level(p->mem_ctx, r->in.level,
+ r->out.info, snum,
+ servername,
+ r->in.architecture,
+ r->in.client_major_version);
if (!W_ERROR_IS_OK(result)) {
TALLOC_FREE(r->out.info);
return result;
return WERR_OK;
}
+/****************************************************************************
+fill_job_info3
+****************************************************************************/
+
+static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
+ struct spoolss_JobInfo3 *r,
+ const print_queue_struct *queue,
+ const print_queue_struct *next_queue,
+ int position, int snum,
+ const NT_PRINTER_INFO_LEVEL *ntprinter)
+{
+ r->job_id = queue->job;
+ r->next_job_id = 0;
+ if (next_queue) {
+ r->next_job_id = next_queue->job;
+ }
+ r->reserved = 0;
+
+ return WERR_OK;
+}
+
/****************************************************************************
Enumjobs at level 1.
****************************************************************************/
return WERR_OK;
}
+/****************************************************************************
+ Enumjobs at level 3.
+****************************************************************************/
+
+static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
+ const print_queue_struct *queue,
+ uint32_t num_queues, int snum,
+ const NT_PRINTER_INFO_LEVEL *ntprinter,
+ union spoolss_JobInfo **info_p,
+ uint32_t *count)
+{
+ union spoolss_JobInfo *info;
+ int i;
+ WERROR result = WERR_OK;
+
+ info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
+ W_ERROR_HAVE_NO_MEMORY(info);
+
+ *count = num_queues;
+
+ for (i=0; i<*count; i++) {
+ const print_queue_struct *next_queue = NULL;
+
+ if (i+1 < *count) {
+ next_queue = &queue[i+1];
+ }
+
+ result = fill_job_info3(info,
+ &info[i].info3,
+ &queue[i],
+ next_queue,
+ i,
+ snum,
+ ntprinter);
+ if (!W_ERROR_IS_OK(result)) {
+ goto out;
+ }
+ }
+
+ out:
+ if (!W_ERROR_IS_OK(result)) {
+ TALLOC_FREE(info);
+ *count = 0;
+ return result;
+ }
+
+ *info_p = info;
+
+ return WERR_OK;
+}
+
/****************************************************************
_spoolss_EnumJobs
****************************************************************/
result = enumjobs_level2(p->mem_ctx, queue, count, snum,
ntprinter, r->out.info, r->out.count);
break;
+ case 3:
+ result = enumjobs_level3(p->mem_ctx, queue, count, snum,
+ ntprinter, r->out.info, r->out.count);
+ break;
default:
result = WERR_UNKNOWN_LEVEL;
break;
int ndrivers;
uint32_t version;
fstring *list = NULL;
- union spoolss_DriverInfo *driver;
+ struct spoolss_DriverInfo8 *driver;
union spoolss_DriverInfo *info = NULL;
uint32_t count = 0;
WERROR result = WERR_OK;
union spoolss_DriverInfo,
count + ndrivers);
if (!info) {
- DEBUG(0,("enumprinterdrivers_level1: "
+ DEBUG(0,("enumprinterdrivers_level_by_architecture: "
"failed to enlarge driver info buffer!\n"));
result = WERR_NOMEM;
goto out;
for (i=0; i<ndrivers; i++) {
DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
ZERO_STRUCT(driver);
- result = get_a_printer_driver(mem_ctx, &driver, 3, list[i],
+ result = get_a_printer_driver(mem_ctx, &driver, list[i],
architecture, version);
if (!W_ERROR_IS_OK(result)) {
goto out;
switch (level) {
case 1:
result = fill_printer_driver_info1(info, &info[count+i].info1,
- driver, servername,
- architecture);
+ driver, servername);
break;
case 2:
result = fill_printer_driver_info2(info, &info[count+i].info2,
result = fill_printer_driver_info6(info, &info[count+i].info6,
driver, servername);
break;
+ case 8:
+ result = fill_printer_driver_info8(info, &info[count+i].info8,
+ driver, servername);
+ break;
default:
result = WERR_UNKNOWN_LEVEL;
break;
uint32_t a,i;
WERROR result = WERR_OK;
- if (strequal(architecture, "all")) {
+ if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
for (a=0; archi_table[a].long_archi != NULL; a++) {
count_p);
}
-/****************************************************************************
- Enumerates all printer drivers at level 1.
-****************************************************************************/
-
-static WERROR enumprinterdrivers_level1(TALLOC_CTX *mem_ctx,
- const char *servername,
- const char *architecture,
- union spoolss_DriverInfo **info_p,
- uint32_t *count)
-{
- return enumprinterdrivers_level(mem_ctx, servername, architecture, 1,
- info_p, count);
-}
-
-/****************************************************************************
- Enumerates all printer drivers at level 2.
-****************************************************************************/
-
-static WERROR enumprinterdrivers_level2(TALLOC_CTX *mem_ctx,
- const char *servername,
- const char *architecture,
- union spoolss_DriverInfo **info_p,
- uint32_t *count)
-{
- return enumprinterdrivers_level(mem_ctx, servername, architecture, 2,
- info_p, count);
-}
-
-/****************************************************************************
- Enumerates all printer drivers at level 3.
-****************************************************************************/
-
-static WERROR enumprinterdrivers_level3(TALLOC_CTX *mem_ctx,
- const char *servername,
- const char *architecture,
- union spoolss_DriverInfo **info_p,
- uint32_t *count)
-{
- return enumprinterdrivers_level(mem_ctx, servername, architecture, 3,
- info_p, count);
-}
-
-/****************************************************************************
- Enumerates all printer drivers at level 4.
-****************************************************************************/
-
-static WERROR enumprinterdrivers_level4(TALLOC_CTX *mem_ctx,
- const char *servername,
- const char *architecture,
- union spoolss_DriverInfo **info_p,
- uint32_t *count)
-{
- return enumprinterdrivers_level(mem_ctx, servername, architecture, 4,
- info_p, count);
-}
-
-/****************************************************************************
- Enumerates all printer drivers at level 5.
-****************************************************************************/
-
-static WERROR enumprinterdrivers_level5(TALLOC_CTX *mem_ctx,
- const char *servername,
- const char *architecture,
- union spoolss_DriverInfo **info_p,
- uint32_t *count)
-{
- return enumprinterdrivers_level(mem_ctx, servername, architecture, 5,
- info_p, count);
-}
-
-/****************************************************************************
- Enumerates all printer drivers at level 6.
-****************************************************************************/
-
-static WERROR enumprinterdrivers_level6(TALLOC_CTX *mem_ctx,
- const char *servername,
- const char *architecture,
- union spoolss_DriverInfo **info_p,
- uint32_t *count)
-{
- return enumprinterdrivers_level(mem_ctx, servername, architecture, 6,
- info_p, count);
-}
-
-
/****************************************************************
_spoolss_EnumPrinterDrivers
****************************************************************/
return WERR_UNKNOWN_PRINTER_DRIVER;
}
- switch (r->in.level) {
- case 1:
- result = enumprinterdrivers_level1(p->mem_ctx, cservername,
- r->in.environment,
- r->out.info, r->out.count);
- break;
- case 2:
- result = enumprinterdrivers_level2(p->mem_ctx, cservername,
- r->in.environment,
- r->out.info, r->out.count);
- break;
- case 3:
- result = enumprinterdrivers_level3(p->mem_ctx, cservername,
- r->in.environment,
- r->out.info, r->out.count);
- break;
- case 4:
- result = enumprinterdrivers_level4(p->mem_ctx, cservername,
- r->in.environment,
- r->out.info, r->out.count);
- break;
- case 5:
- result = enumprinterdrivers_level5(p->mem_ctx, cservername,
- r->in.environment,
- r->out.info, r->out.count);
- break;
- case 6:
- result = enumprinterdrivers_level6(p->mem_ctx, cservername,
- r->in.environment,
- r->out.info, r->out.count);
- break;
- default:
- return WERR_UNKNOWN_LEVEL;
- }
-
+ result = enumprinterdrivers_level(p->mem_ctx, cservername,
+ r->in.environment,
+ r->in.level,
+ r->out.info,
+ r->out.count);
if (!W_ERROR_IS_OK(result)) {
return result;
}
return WERR_NOMEM;
}
+ /* samba does not have a concept of local, non-shared printers yet, so
+ * make sure we always setup sharename - gd */
+ if ((printer->info_2->sharename[0] == '\0') && (printer->info_2->printername != '\0')) {
+ DEBUG(5, ("spoolss_addprinterex_level_2: "
+ "no sharename has been set, setting printername %s as sharename\n",
+ printer->info_2->printername));
+ fstrcpy(printer->info_2->sharename, printer->info_2->printername);
+ }
+
/* check to see if the printer already exists */
if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
return WERR_PRINTER_ALREADY_EXISTS;
}
+ if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
+ if ((snum = print_queue_snum(printer->info_2->printername)) != -1) {
+ DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
+ printer->info_2->printername));
+ free_a_printer(&printer, 2);
+ return WERR_PRINTER_ALREADY_EXISTS;
+ }
+ }
+
+ /* validate printer info struct */
+ if (!info_ctr->info.info2->printername ||
+ strlen(info_ctr->info.info2->printername) == 0) {
+ free_a_printer(&printer,2);
+ return WERR_INVALID_PRINTER_NAME;
+ }
+ if (!info_ctr->info.info2->portname ||
+ strlen(info_ctr->info.info2->portname) == 0) {
+ free_a_printer(&printer,2);
+ return WERR_UNKNOWN_PORT;
+ }
+ if (!info_ctr->info.info2->drivername ||
+ strlen(info_ctr->info.info2->drivername) == 0) {
+ free_a_printer(&printer,2);
+ return WERR_UNKNOWN_PRINTER_DRIVER;
+ }
+ if (!info_ctr->info.info2->printprocessor ||
+ strlen(info_ctr->info.info2->printprocessor) == 0) {
+ free_a_printer(&printer,2);
+ return WERR_UNKNOWN_PRINTPROCESSOR;
+ }
+
/* FIXME!!! smbd should check to see if the driver is installed before
trying to add a printer like this --jerry */
*/
case 2:
{
- union spoolss_DriverInfo *driver1;
+ struct spoolss_DriverInfo8 *driver1;
- if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &driver1, 3, driver_name, "Windows NT x86", 3))) {
+ if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &driver1, driver_name, "Windows NT x86", 3))) {
/*
* No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
*/
/* data - counted in bytes */
- if (r->out.data && regval_size(val)) {
- memcpy(r->out.data, regval_data_p(val), regval_size(val));
+ /*
+ * See the section "Dynamically Typed Query Parameters"
+ * in MS-RPRN.
+ */
+
+ if (r->out.data && regval_data_p(val) &&
+ regval_size(val) && r->in.data_offered) {
+ memcpy(r->out.data, regval_data_p(val),
+ MIN(regval_size(val),r->in.data_offered));
}
*r->out.data_needed = regval_size(val);
WERROR _spoolss_SetPrinterData(pipes_struct *p,
struct spoolss_SetPrinterData *r)
{
- NT_PRINTER_INFO_LEVEL *printer = NULL;
- int snum=0;
- WERROR result = WERR_OK;
- Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
- DATA_BLOB blob;
-
- DEBUG(5,("_spoolss_SetPrinterData\n"));
-
- if (!Printer) {
- DEBUG(2,("_spoolss_SetPrinterData: Invalid handle (%s:%u:%u).\n",
- OUR_HANDLE(r->in.handle)));
- return WERR_BADFID;
- }
-
- if (Printer->printer_type == SPLHND_SERVER) {
- DEBUG(10,("_spoolss_SetPrinterData: "
- "Not implemented for server handles yet\n"));
- return WERR_INVALID_PARAM;
- }
-
- if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
- return WERR_BADFID;
- }
-
- /*
- * Access check : NT returns "access denied" if you make a
- * SetPrinterData call without the necessary privildge.
- * we were originally returning OK if nothing changed
- * which made Win2k issue **a lot** of SetPrinterData
- * when connecting to a printer --jerry
- */
-
- if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
- DEBUG(3,("_spoolss_SetPrinterData: "
- "change denied by handle access permissions\n"));
- result = WERR_ACCESS_DENIED;
- goto done;
- }
-
- result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
- if (!W_ERROR_IS_OK(result)) {
- return result;
- }
-
- result = push_spoolss_PrinterData(p->mem_ctx, &blob,
- r->in.type, &r->in.data);
- if (!W_ERROR_IS_OK(result)) {
- goto done;
- }
-
- /*
- * When client side code sets a magic printer data key, detect it and save
- * the current printer data and the magic key's data (its the DEVMODE) for
- * future printer/driver initializations.
- */
- if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
- /* Set devmode and printer initialization info */
- result = save_driver_init(printer, 2, blob.data, blob.length);
-
- srv_spoolss_reset_printerdata(printer->info_2->drivername);
-
- goto done;
- }
+ struct spoolss_SetPrinterDataEx r2;
- result = set_printer_dataex(printer, SPOOL_PRINTERDATA_KEY,
- r->in.value_name, r->in.type,
- blob.data, blob.length);
- if (W_ERROR_IS_OK(result)) {
- result = mod_a_printer(printer, 2);
- }
-
-done:
- free_a_printer(&printer, 2);
+ r2.in.handle = r->in.handle;
+ r2.in.key_name = "PrinterDriverData";
+ r2.in.value_name = r->in.value_name;
+ r2.in.type = r->in.type;
+ r2.in.data = r->in.data;
+ r2.in._offered = r->in._offered;
- return result;
+ return _spoolss_SetPrinterDataEx(p, &r2);
}
/****************************************************************
WERROR _spoolss_DeletePrinterData(pipes_struct *p,
struct spoolss_DeletePrinterData *r)
{
- NT_PRINTER_INFO_LEVEL *printer = NULL;
- int snum=0;
- WERROR status = WERR_OK;
- Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
-
- DEBUG(5,("_spoolss_DeletePrinterData\n"));
-
- if (!Printer) {
- DEBUG(2,("_spoolss_DeletePrinterData: Invalid handle (%s:%u:%u).\n",
- OUR_HANDLE(r->in.handle)));
- return WERR_BADFID;
- }
-
- if (!get_printer_snum(p, r->in.handle, &snum, NULL))
- return WERR_BADFID;
-
- if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
- DEBUG(3, ("_spoolss_DeletePrinterData: "
- "printer properties change denied by handle\n"));
- return WERR_ACCESS_DENIED;
- }
-
- status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
- if (!W_ERROR_IS_OK(status))
- return status;
-
- if (!r->in.value_name) {
- free_a_printer(&printer, 2);
- return WERR_NOMEM;
- }
-
- status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY,
- r->in.value_name );
-
- if ( W_ERROR_IS_OK(status) )
- mod_a_printer( printer, 2 );
+ struct spoolss_DeletePrinterDataEx r2;
- free_a_printer(&printer, 2);
+ r2.in.handle = r->in.handle;
+ r2.in.key_name = "PrinterDriverData";
+ r2.in.value_name = r->in.value_name;
- return status;
+ return _spoolss_DeletePrinterDataEx(p, &r2);
}
/****************************************************************
/****************************************************************
_spoolss_GetPrinterDataEx
-
- From MSDN documentation of GetPrinterDataEx: pass request
- to GetPrinterData if key is "PrinterDriverData".
****************************************************************/
WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
NT_PRINTER_INFO_LEVEL *printer = NULL;
int snum = 0;
WERROR result = WERR_OK;
+ DATA_BLOB blob;
DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
/* Is the handle to a printer or to the server? */
if (Printer->printer_type == SPLHND_SERVER) {
- DEBUG(10,("_spoolss_GetPrinterDataEx: "
- "Not implemented for server handles yet\n"));
- result = WERR_INVALID_PARAM;
+
+ result = getprinterdata_printer_server(p->mem_ctx,
+ r->in.value_name,
+ r->out.type,
+ r->out.data);
goto done;
}
if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
- return WERR_BADFID;
+ result = WERR_BADFID;
+ goto done;
}
result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
goto done;
}
+ /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
+
+ if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
+ strequal(r->in.value_name, "ChangeId")) {
+ *r->out.type = REG_DWORD;
+ *r->out.needed = 4;
+ r->out.data->value = printer->info_2->changeid;
+ result = WERR_OK;
+ goto done;
+ }
+
if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
DEBUG(4,("_spoolss_GetPrinterDataEx: "
"Invalid keyname [%s]\n", r->in.key_name ));
goto done;
}
- /* When given a new keyname, we should just create it */
-
val = get_printer_data(printer->info_2,
r->in.key_name, r->in.value_name);
if (!val) {
}
*r->out.needed = regval_size(val);
-
- if (*r->out.needed > r->in.offered) {
- result = WERR_MORE_DATA;
- goto done;
- }
-
*r->out.type = regval_type(val);
- memcpy(r->out.buffer, regval_data_p(val), regval_size(val));
+ blob = data_blob_const(regval_data_p(val), regval_size(val));
+
+ result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
+ r->out.data,
+ *r->out.type);
done:
if (printer) {
free_a_printer(&printer, 2);
}
- return result;
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
+ *r->out.needed = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
+ *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
+ r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
+
+ return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
}
/****************************************************************
WERROR result = WERR_OK;
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
char *oid_string;
+ DATA_BLOB blob;
DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
oid_string++;
}
+ result = push_spoolss_PrinterData(p->mem_ctx, &blob,
+ r->in.type, &r->in.data);
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
+ }
+
+ /*
+ * When client side code sets a magic printer data key, detect it and save
+ * the current printer data and the magic key's data (its the DEVMODE) for
+ * future printer/driver initializations.
+ */
+ if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
+ /* Set devmode and printer initialization info */
+ result = save_driver_init(printer, 2, blob.data, blob.length);
+
+ srv_spoolss_reset_printerdata(printer->info_2->drivername);
+
+ goto done;
+ }
+
/* save the registry data */
result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
- r->in.type, r->in.buffer, r->in.offered);
+ r->in.type, blob.data, blob.length);
if (W_ERROR_IS_OK(result)) {
/* save the OID if one was specified */
goto done;
}
- /* two byte termination (a multisz) */
-
- *r->out.needed = 2;
-
- array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 1);
+ array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 2);
if (!array) {
result = WERR_NOMEM;
goto done;
}
+ if (!num_keys) {
+ array[0] = talloc_strdup(array, "");
+ if (!array[0]) {
+ result = WERR_NOMEM;
+ goto done;
+ }
+ }
+
for (i=0; i < num_keys; i++) {
DEBUG(10,("_spoolss_EnumPrinterKey: adding keyname: %s\n",
result = WERR_NOMEM;
goto done;
}
-
- *r->out.needed += strlen_m_term(keynames[i]) * 2;
- }
-
- if (r->in.offered < *r->out.needed) {
- result = WERR_MORE_DATA;
- goto done;
}
- result = WERR_OK;
-
if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
result = WERR_NOMEM;
goto done;
}
- if (r->in.offered == blob.length) {
- memcpy(r->out.key_buffer, blob.data, blob.length);
+ *r->out._ndr_size = r->in.offered / 2;
+ *r->out.needed = blob.length;
+
+ if (r->in.offered < *r->out.needed) {
+ result = WERR_MORE_DATA;
+ } else {
+ result = WERR_OK;
+ r->out.key_buffer->string_array = array;
}
done:
*r->out.status_code = 0;
- memcpy(r->out.out_data, out_data.data, out_data.length);
+ if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
+ memcpy(r->out.out_data, out_data.data,
+ MIN(r->in.out_data_size, out_data.length));
+ }
return WERR_OK;
}
git.samba.org / kai / samba.git / blobdiff