up, all the errors returned are DOS errors, not NT status codes. */
#include "includes.h"
+#include "nt_printing.h"
#include "srv_spoolss_util.h"
#include "../librpc/gen_ndr/srv_spoolss.h"
#include "../librpc/gen_ndr/cli_spoolss.h"
#include "rpc_client/init_spoolss.h"
#include "librpc/gen_ndr/messaging.h"
+#include "librpc/gen_ndr/ndr_security.h"
#include "registry.h"
#include "registry/reg_objects.h"
+#include "include/printing.h"
+#include "secrets.h"
+#include "../librpc/gen_ndr/netlogon.h"
/* macros stolen from s4 spoolss server */
#define SPOOLSS_BUFFER_UNION(fn,info,level) \
#define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
-
-extern userdom_struct current_user_info;
-
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV
-#ifndef MAX_OPEN_PRINTER_EXS
-#define MAX_OPEN_PRINTER_EXS 50
-#endif
-
-#define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
-
static Printer_entry *printers_list;
typedef struct _counter_printer_0 {
static uint32_t smb_connections = 0;
-/* in printing/nt_printing.c */
+/* Map generic permissions to printer object specific permissions */
+
+const struct standard_mapping printer_std_mapping = {
+ PRINTER_READ,
+ PRINTER_WRITE,
+ PRINTER_EXECUTE,
+ PRINTER_ALL_ACCESS
+};
+
+/* Map generic permissions to print server object specific permissions */
-extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
+const struct standard_mapping printserver_std_mapping = {
+ SERVER_READ,
+ SERVER_WRITE,
+ SERVER_EXECUTE,
+ SERVER_ALL_ACCESS
+};
/* API table for Xcv Monitor functions */
Disconnect from the client
****************************************************************************/
-static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
+static void srv_spoolss_replycloseprinter(
+ int snum, struct policy_handle *handle,
+ struct messaging_context *msg_ctx)
{
WERROR result;
NTSTATUS status;
if (!print_notify_deregister_pid(snum))
DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
- /* weird if the test succeds !!! */
+ /* weird if the test succeeds !!! */
if (smb_connections==0) {
DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
return;
if (smb_connections==1) {
cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
- notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
+ /*
+ * The above call shuts down the pipe also.
+ */
+ notify_cli_pipe = NULL;
- messaging_deregister(smbd_messaging_context(),
- MSG_PRINTER_NOTIFY2, NULL);
+ if (msg_ctx != NULL) {
+ messaging_deregister(msg_ctx, MSG_PRINTER_NOTIFY2,
+ NULL);
- /* Tell the connections db we're no longer interested in
- * printer notify messages. */
+ /*
+ * Tell the serverid.tdb we're no longer
+ * interested in printer notify messages.
+ */
- serverid_register_msg_flags(
- messaging_server_id(smbd_messaging_context()),
- false, FLAG_MSG_PRINT_NOTIFY);
+ serverid_register_msg_flags(
+ messaging_server_id(msg_ctx),
+ false, FLAG_MSG_PRINT_NOTIFY);
+ }
}
smb_connections--;
if ( Printer->printer_type == SPLHND_SERVER) {
snum = -1;
- srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
+ srv_spoolss_replycloseprinter(
+ snum, &Printer->notify.client_hnd,
+ Printer->notify.msg_ctx);
} else if (Printer->printer_type == SPLHND_PRINTER) {
snum = print_queue_snum(Printer->sharename);
if (snum != -1)
- srv_spoolss_replycloseprinter(snum,
- &Printer->notify.client_hnd);
+ srv_spoolss_replycloseprinter(
+ snum, &Printer->notify.client_hnd,
+ Printer->notify.msg_ctx);
}
}
Printer->notify.client_connected = false;
TALLOC_FREE(Printer->devmode);
- free_a_printer( &Printer->printer_info, 2 );
/* Remove from the internal list. */
DLIST_REMOVE(printers_list, Printer);
find printer index by handle
****************************************************************************/
-static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
+static Printer_entry *find_printer_index_by_hnd(struct pipes_struct *p,
struct policy_handle *hnd)
{
Printer_entry *find_printer = NULL;
Close printer index by handle.
****************************************************************************/
-static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
+static bool close_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
Delete a printer given a handle.
****************************************************************************/
-static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename)
+static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
+ const char *sharename,
+ struct messaging_context *msg_ctx)
{
char *cmd = lp_deleteprinter_cmd();
char *command = NULL;
if ( (ret = smbrun(command, NULL)) == 0 ) {
/* Tell everyone we updated smb.conf. */
- message_send_all(smbd_messaging_context(),
- MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
+ message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
}
if ( is_print_op )
Delete a printer given a handle.
****************************************************************************/
-static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
+static WERROR delete_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
+ WERROR result;
if (!Printer) {
DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
/* this does not need a become root since the access check has been
done on the handle already */
- if (del_a_printer( Printer->sharename ) != 0) {
+ result = winreg_delete_printer_key(p->mem_ctx, p->server_info,
+ p->msg_ctx, Printer->sharename, "");
+ if (!W_ERROR_IS_OK(result)) {
DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
return WERR_BADFID;
}
return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
- Printer->sharename );
+ Printer->sharename, p->msg_ctx);
}
/****************************************************************************
Return the snum of a printer corresponding to an handle.
****************************************************************************/
-static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
+static bool get_printer_snum(struct pipes_struct *p, struct policy_handle *hnd,
int *number, struct share_params **params)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
XcvDataPort() interface.
****************************************************************************/
-static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
+static bool set_printer_hnd_name(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
+ Printer_entry *Printer,
+ const char *handlename)
{
int snum;
int n_services=lp_numservices();
- char *aprinter, *printername;
- const char *servername;
+ char *aprinter;
+ const char *printername;
+ const char *servername = NULL;
fstring sname;
bool found = false;
- NT_PRINTER_INFO_LEVEL *printer = NULL;
+ struct spoolss_PrinterInfo2 *info2 = NULL;
WERROR result;
DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
*aprinter = '\0';
aprinter++;
}
- } else {
- servername = global_myname();
- }
-
- /* save the servername to fill in replies on this handle */
-
- if ( !is_myname_or_ipaddr( servername ) )
- return false;
+ if (!is_myname_or_ipaddr(servername)) {
+ return false;
+ }
- fstrcpy( Printer->servername, servername );
+ fstrcpy(Printer->servername, servername);
+ }
- if ( Printer->printer_type == SPLHND_SERVER )
+ if (Printer->printer_type == SPLHND_SERVER) {
return true;
+ }
- if ( Printer->printer_type != SPLHND_PRINTER )
+ if (Printer->printer_type != SPLHND_PRINTER) {
return false;
+ }
- DEBUGADD(5, ("searching for [%s]\n", aprinter ));
+ DEBUGADD(5, ("searching for [%s]\n", aprinter));
/* check for the Port Monitor Interface */
-
if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
Printer->printer_type = SPLHND_PORTMON_TCP;
fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
that calls out to map_username() */
/* do another loop to look for printernames */
-
- for (snum=0; !found && snum<n_services; snum++) {
+ for (snum = 0; !found && snum < n_services; snum++) {
+ const char *printer = lp_const_servicename(snum);
/* no point going on if this is not a printer */
+ if (!(lp_snum_ok(snum) && lp_print_ok(snum))) {
+ continue;
+ }
- if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
+ /* ignore [printers] share */
+ if (strequal(printer, "printers")) {
continue;
+ }
- fstrcpy(sname, lp_servicename(snum));
- if ( strequal( aprinter, sname ) ) {
+ fstrcpy(sname, printer);
+ if (strequal(aprinter, printer)) {
found = true;
break;
}
/* no point looking up the printer object if
we aren't allowing printername != sharename */
-
- if ( lp_force_printername(snum) )
+ if (lp_force_printername(snum)) {
continue;
+ }
- fstrcpy(sname, lp_servicename(snum));
-
- printer = NULL;
-
- /* This call doesn't fill in the location or comment from
- * a CUPS server for efficiency with large numbers of printers.
- * JRA.
- */
-
- result = get_a_printer_search( NULL, &printer, 2, sname );
+ result = winreg_get_printer(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
+ servername,
+ sname,
+ &info2);
if ( !W_ERROR_IS_OK(result) ) {
- DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
- sname, win_errstr(result)));
+ DEBUG(2,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
+ sname, win_errstr(result)));
continue;
}
- /* printername is always returned as \\server\printername */
- if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
- DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
- printer->info_2->printername));
- free_a_printer( &printer, 2);
- continue;
+ printername = strrchr(info2->printername, '\\');
+ if (printername == NULL) {
+ printername = info2->printername;
+ } else {
+ printername++;
}
- printername++;
-
- if ( strequal(printername, aprinter) ) {
- free_a_printer( &printer, 2);
+ if (strequal(printername, aprinter)) {
found = true;
break;
}
DEBUGADD(10, ("printername: %s\n", printername));
- free_a_printer( &printer, 2);
+ TALLOC_FREE(info2);
}
- free_a_printer( &printer, 2);
-
if ( !found ) {
DEBUGADD(4,("Printer not found\n"));
return false;
Find first available printer slot. creates a printer handle for you.
****************************************************************************/
-static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
+static bool open_printer_hnd(struct pipes_struct *p, struct policy_handle *hnd,
const char *name, uint32_t access_granted)
{
Printer_entry *new_printer;
return false;
}
- if (!set_printer_hnd_name(new_printer, name)) {
+ if (!set_printer_hnd_name(p->mem_ctx, p->server_info, new_printer, name)) {
close_printer_handle(p, hnd);
return false;
}
#define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
_data->data.devmode.devmode = _devmode;
-#define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
+#define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _sd) \
_data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
if (!_data->data.sd.sd) { \
_data->data.sd.sd_size = 0; \
} \
- _data->data.sd.sd_size = _size;
+ _data->data.sd.sd_size = \
+ ndr_size_security_descriptor(_data->data.sd.sd, 0);
static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
struct tm *t,
return ctr->num_groups;
}
-void construct_info_data(struct spoolss_Notify *info_data,
- enum spoolss_NotifyType type,
- uint16_t field,
- int id);
+static void construct_info_data(struct spoolss_Notify *info_data,
+ enum spoolss_NotifyType type,
+ uint16_t field, int id);
/***********************************************************************
Send a change notication message on all handles which have a call
driver
********************************************************************/
-static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
+static bool srv_spoolss_drv_upgrade_printer(const char *drivername,
+ struct messaging_context *msg_ctx)
{
int len = strlen(drivername);
DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
drivername));
- messaging_send_buf(smbd_messaging_context(),
- messaging_server_id(smbd_messaging_context()),
+ messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
MSG_PRINTER_DRVUPGRADE,
(uint8_t *)drivername, len+1);
struct server_id server_id,
DATA_BLOB *data)
{
- fstring drivername;
+ TALLOC_CTX *tmp_ctx;
+ struct auth_serversupplied_info *server_info = NULL;
+ struct spoolss_PrinterInfo2 *pinfo2;
+ NTSTATUS status;
+ WERROR result;
+ const char *drivername;
int snum;
int n_services = lp_numservices();
size_t len;
+ tmp_ctx = talloc_new(NULL);
+ if (!tmp_ctx) return;
+
+ status = make_server_info_system(tmp_ctx, &server_info);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0, ("do_drv_upgrade_printer: "
+ "Could not create system server_info\n"));
+ goto done;
+ }
+
len = MIN(data->length,sizeof(drivername)-1);
- strncpy(drivername, (const char *)data->data, len);
+ drivername = talloc_strndup(tmp_ctx, (const char *)data->data, len);
+ if (!drivername) {
+ DEBUG(0, ("do_drv_upgrade_printer: Out of memoery ?!\n"));
+ goto done;
+ }
- DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
+ DEBUG(10, ("do_drv_upgrade_printer: "
+ "Got message for new driver [%s]\n", drivername));
/* Iterate the printer list */
- for (snum=0; snum<n_services; snum++)
- {
- if (lp_snum_ok(snum) && lp_print_ok(snum) )
- {
- WERROR result;
- NT_PRINTER_INFO_LEVEL *printer = NULL;
+ for (snum = 0; snum < n_services; snum++) {
+ if (!lp_snum_ok(snum) || !lp_print_ok(snum)) {
+ continue;
+ }
- result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
- if (!W_ERROR_IS_OK(result))
- continue;
+ result = winreg_get_printer(tmp_ctx, server_info, msg,
+ NULL,
+ lp_const_servicename(snum),
+ &pinfo2);
- if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
- {
- DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
+ if (!W_ERROR_IS_OK(result)) {
+ continue;
+ }
- /* all we care about currently is the change_id */
+ if (!pinfo2->drivername) {
+ continue;
+ }
- result = mod_a_printer(printer, 2);
- if (!W_ERROR_IS_OK(result)) {
- DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
- win_errstr(result)));
- }
- }
+ if (strcmp(drivername, pinfo2->drivername) != 0) {
+ continue;
+ }
+
+ DEBUG(6,("Updating printer [%s]\n", pinfo2->printername));
- free_a_printer(&printer, 2);
+ /* all we care about currently is the change_id */
+ result = winreg_printer_update_changeid(tmp_ctx,
+ server_info,
+ msg,
+ pinfo2->printername);
+
+ if (!W_ERROR_IS_OK(result)) {
+ DEBUG(3, ("do_drv_upgrade_printer: "
+ "Failed to update changeid [%s]\n",
+ win_errstr(result)));
}
}
/* all done */
+done:
+ talloc_free(tmp_ctx);
}
/********************************************************************
_spoolss_OpenPrinter
****************************************************************/
-WERROR _spoolss_OpenPrinter(pipes_struct *p,
+WERROR _spoolss_OpenPrinter(struct pipes_struct *p,
struct spoolss_OpenPrinter *r)
{
struct spoolss_OpenPrinterEx e;
_spoolss_OpenPrinterEx
****************************************************************/
-WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
+WERROR _spoolss_OpenPrinterEx(struct pipes_struct *p,
struct spoolss_OpenPrinterEx *r)
{
int snum;
DEBUGADD(3,("checking name: %s\n", r->in.printername));
if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
+ DEBUG(0,("_spoolss_OpenPrinterEx: Cannot open a printer handle "
+ " for printer %s\n", r->in.printername));
ZERO_STRUCTP(r->out.handle);
return WERR_INVALID_PARAM;
}
DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
+ winreg_create_printer(p->mem_ctx,
+ p->server_info,
+ p->msg_ctx,
+ Printer->servername,
+ lp_const_servicename(snum));
+
break;
default:
return WERR_OK;
}
-/****************************************************************************
-****************************************************************************/
-
-static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
- NT_PRINTER_INFO_LEVEL_2 *d)
-{
- DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
-
- if (!r || !d) {
- return false;
- }
-
- d->attributes = r->attributes;
- d->priority = r->priority;
- d->default_priority = r->defaultpriority;
- d->starttime = r->starttime;
- d->untiltime = r->untiltime;
- d->status = r->status;
- d->cjobs = r->cjobs;
-
- fstrcpy(d->servername, r->servername);
- fstrcpy(d->printername, r->printername);
- fstrcpy(d->sharename, r->sharename);
- fstrcpy(d->portname, r->portname);
- fstrcpy(d->drivername, r->drivername);
- slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
- fstrcpy(d->location, r->location);
- fstrcpy(d->sepfile, r->sepfile);
- fstrcpy(d->printprocessor, r->printprocessor);
- fstrcpy(d->datatype, r->datatype);
- fstrcpy(d->parameters, r->parameters);
-
- return true;
-}
-
/****************************************************************
_spoolss_ClosePrinter
****************************************************************/
-WERROR _spoolss_ClosePrinter(pipes_struct *p,
+WERROR _spoolss_ClosePrinter(struct pipes_struct *p,
struct spoolss_ClosePrinter *r)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
_spoolss_DeletePrinter
****************************************************************/
-WERROR _spoolss_DeletePrinter(pipes_struct *p,
+WERROR _spoolss_DeletePrinter(struct pipes_struct *p,
struct spoolss_DeletePrinter *r)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
WERROR result;
+ int snum;
if (Printer && Printer->document_started) {
struct spoolss_EndDocPrinter e;
_spoolss_EndDocPrinter(p, &e);
}
- result = delete_printer_handle(p, r->in.handle);
+ if (get_printer_snum(p, r->in.handle, &snum, NULL)) {
+ winreg_delete_printer_key(p->mem_ctx,
+ p->server_info,
+ p->msg_ctx,
+ lp_const_servicename(snum),
+ "");
+ }
- update_c_setprinter(false);
+ result = delete_printer_handle(p, r->in.handle);
return result;
}
_spoolss_DeletePrinterDriver
****************************************************************/
-WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
+WERROR _spoolss_DeletePrinterDriver(struct pipes_struct *p,
struct spoolss_DeletePrinterDriver *r)
{
struct spoolss_DriverInfo8 *info_win2k = NULL;
int version;
WERROR status;
- WERROR status_win2k = WERR_ACCESS_DENIED;
SE_PRIV se_printop = SE_PRINT_OPERATOR;
/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
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, r->in.driver,
- r->in.architecture,
- version)))
- {
+ status = winreg_get_driver(p->mem_ctx, p->server_info,
+ r->in.architecture, r->in.driver,
+ version, &info);
+ if (!W_ERROR_IS_OK(status)) {
/* try for Win2k driver if "Windows NT x86" */
if ( version == 2 ) {
version = 3;
- if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
- &info,
- r->in.driver,
- r->in.architecture,
- version))) {
+
+ status = winreg_get_driver(p->mem_ctx, p->server_info,
+ r->in.architecture,
+ r->in.driver,
+ version, &info);
+ if (!W_ERROR_IS_OK(status)) {
status = WERR_UNKNOWN_PRINTER_DRIVER;
goto done;
}
}
- if (printer_driver_in_use(info)) {
+ if (printer_driver_in_use(p->mem_ctx, p->server_info, 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,
- r->in.driver,
- r->in.architecture, 3)))
- {
+ if (version == 2) {
+ status = winreg_get_driver(p->mem_ctx, p->server_info,
+ r->in.architecture,
+ r->in.driver, 3, &info_win2k);
+ if (W_ERROR_IS_OK(status)) {
/* if we get to here, we now have 2 driver info structures to remove */
/* remove the Win2k driver first*/
- status_win2k = delete_printer_driver(
- p, info_win2k, 3, false);
- free_a_printer_driver(info_win2k);
+ status = winreg_del_driver(p->mem_ctx,
+ p->server_info,
+ info_win2k, 3);
+ talloc_free(info_win2k);
/* this should not have failed---if it did, report to client */
- if ( !W_ERROR_IS_OK(status_win2k) )
- {
- status = status_win2k;
+ if (!W_ERROR_IS_OK(status)) {
goto done;
}
}
}
- status = delete_printer_driver(p, info, version, false);
-
- /* if at least one of the deletes succeeded return OK */
-
- if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
- status = WERR_OK;
+ status = winreg_del_driver(p->mem_ctx, p->server_info, info, version);
done:
- free_a_printer_driver(info);
+ talloc_free(info);
return status;
}
_spoolss_DeletePrinterDriverEx
****************************************************************/
-WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
+WERROR _spoolss_DeletePrinterDriverEx(struct pipes_struct *p,
struct spoolss_DeletePrinterDriverEx *r)
{
struct spoolss_DriverInfo8 *info = NULL;
int version;
bool delete_files;
WERROR status;
- WERROR status_win2k = WERR_ACCESS_DENIED;
SE_PRIV se_printop = SE_PRINT_OPERATOR;
/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
version = r->in.version;
- status = get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
- r->in.architecture, version);
+ status = winreg_get_driver(p->mem_ctx, p->server_info,
+ r->in.architecture, r->in.driver,
+ version, &info);
+ if (!W_ERROR_IS_OK(status)) {
+ status = WERR_UNKNOWN_PRINTER_DRIVER;
- if ( !W_ERROR_IS_OK(status) )
- {
/*
* if the client asked for a specific version,
* or this is something other than Windows NT x86,
/* try for Win2k driver if "Windows NT x86" */
version = 3;
- if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
- r->in.architecture,
- version))) {
+ status = winreg_get_driver(info, p->server_info,
+ r->in.architecture,
+ r->in.driver,
+ version, &info);
+ if (!W_ERROR_IS_OK(status)) {
status = WERR_UNKNOWN_PRINTER_DRIVER;
goto done;
}
}
- if (printer_driver_in_use(info)) {
+ if (printer_driver_in_use(info, p->server_info, 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) & (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
+ if (delete_files &&
+ (r->in.delete_flags & DPD_DELETE_ALL_FILES) &&
+ printer_driver_files_in_use(info, p->server_info, info)) {
/* 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,
- r->in.driver,
- r->in.architecture, 3)))
- {
-
- if (delete_files && printer_driver_files_in_use(info, info_win2k) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
+ status = winreg_get_driver(info, p->server_info,
+ r->in.architecture,
+ r->in.driver, 3, &info_win2k);
+ if (W_ERROR_IS_OK(status)) {
+
+ if (delete_files &&
+ (r->in.delete_flags & DPD_DELETE_ALL_FILES) &&
+ printer_driver_files_in_use(info, p->server_info,
+ info_win2k)) {
/* no idea of the correct error here */
- free_a_printer_driver(info_win2k);
+ talloc_free(info_win2k);
status = WERR_ACCESS_DENIED;
goto done;
}
/* if we get to here, we now have 2 driver info structures to remove */
/* remove the Win2k driver first*/
- status_win2k = delete_printer_driver(
- p, info_win2k, 3, delete_files);
- free_a_printer_driver(info_win2k);
+ status = winreg_del_driver(info, p->server_info,
+ info_win2k, 3);
/* this should not have failed---if it did, report to client */
- if ( !W_ERROR_IS_OK(status_win2k) )
+ if (!W_ERROR_IS_OK(status)) {
goto done;
+ }
+
+ /*
+ * now delete any associated files if delete_files is
+ * true. Even if this part failes, we return succes
+ * because the driver doesn not exist any more
+ */
+ if (delete_files) {
+ delete_driver_files(p->server_info,
+ info_win2k);
+ }
}
}
- status = delete_printer_driver(p, info, version, delete_files);
+ status = winreg_del_driver(info, p->server_info, info, version);
+ if (!W_ERROR_IS_OK(status)) {
+ goto done;
+ }
- if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
- status = WERR_OK;
-done:
- free_a_printer_driver(info);
+ /*
+ * now delete any associated files if delete_files is
+ * true. Even if this part failes, we return succes
+ * because the driver doesn not exist any more
+ */
+ if (delete_files) {
+ delete_driver_files(p->server_info, info);
+ }
+done:
+ talloc_free(info);
return status;
}
-/****************************************************************************
- Internal routine for storing printerdata
- ***************************************************************************/
-
-WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
- const char *key, const char *value,
- uint32_t type, uint8_t *data, int real_len)
-{
- /* the registry objects enforce uniqueness based on value name */
-
- return add_printer_data( printer->info_2, key, value, type, data, real_len );
-}
-
/********************************************************************
GetPrinterData on a printer server Handle.
********************************************************************/
_spoolss_GetPrinterData
****************************************************************/
-WERROR _spoolss_GetPrinterData(pipes_struct *p,
+WERROR _spoolss_GetPrinterData(struct pipes_struct *p,
struct spoolss_GetPrinterData *r)
{
struct spoolss_GetPrinterDataEx r2;
addr));
}
- if (ismyaddr((struct sockaddr *)&rm_addr)) {
+ if (ismyaddr((struct sockaddr *)(void *)&rm_addr)) {
DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
addr));
return false;
static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
uint32_t localprinter, uint32_t type,
struct policy_handle *handle,
- struct sockaddr_storage *client_ss)
+ struct sockaddr_storage *client_ss,
+ struct messaging_context *msg_ctx)
{
WERROR result;
NTSTATUS status;
if ( !spoolss_connect_to_client( ¬ify_cli_pipe, client_ss, unix_printer ))
return false;
- messaging_register(smbd_messaging_context(), NULL,
- MSG_PRINTER_NOTIFY2,
+ messaging_register(msg_ctx, NULL, MSG_PRINTER_NOTIFY2,
receive_notify2_message_list);
/* Tell the connections db we're now interested in printer
* notify messages. */
- serverid_register_msg_flags(
- messaging_server_id(smbd_messaging_context()),
- true, FLAG_MSG_PRINT_NOTIFY);
+ serverid_register_msg_flags(messaging_server_id(msg_ctx),
+ true, FLAG_MSG_PRINT_NOTIFY);
}
/*
* called from api_spoolss_rffpcnex
****************************************************************/
-WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
+WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct pipes_struct *p,
struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
{
int snum = -1;
Printer->notify.flags = r->in.flags;
Printer->notify.options = r->in.options;
Printer->notify.printerlocal = r->in.printer_local;
+ Printer->notify.msg_ctx = p->msg_ctx;
TALLOC_FREE(Printer->notify.option);
Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
Printer->notify.printerlocal, 1,
- &Printer->notify.client_hnd, &client_ss))
+ &Printer->notify.client_hnd,
+ &client_ss, p->msg_ctx))
return WERR_SERVER_UNAVAILABLE;
Printer->notify.client_connected = true;
static void spoolss_notify_server_name(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
+ SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->servername);
}
/*******************************************************************
static void spoolss_notify_printer_name(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
/* the notify name should not contain the \\server\ part */
- char *p = strrchr(printer->info_2->printername, '\\');
+ const char *p = strrchr(pinfo2->printername, '\\');
if (!p) {
- p = printer->info_2->printername;
+ p = pinfo2->printername;
} else {
p++;
}
static void spoolss_notify_share_name(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
static void spoolss_notify_port_name(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
+ SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->portname);
}
/*******************************************************************
static void spoolss_notify_driver_name(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
+ SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->drivername);
}
/*******************************************************************
static void spoolss_notify_comment(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- char *p;
+ const char *p;
- if (*printer->info_2->comment == '\0') {
+ if (*pinfo2->comment == '\0') {
p = lp_comment(snum);
} else {
- p = printer->info_2->comment;
+ p = pinfo2->comment;
}
- SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
+ SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
}
/*******************************************************************
static void spoolss_notify_location(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
+ SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->location);
}
/*******************************************************************
static void spoolss_notify_devmode(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
/* for a dummy implementation we have to zero the fields */
static void spoolss_notify_sepfile(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
+ SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->sepfile);
}
/*******************************************************************
static void spoolss_notify_print_processor(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
+ SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->printprocessor);
}
/*******************************************************************
static void spoolss_notify_parameters(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
+ SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->parameters);
}
/*******************************************************************
static void spoolss_notify_datatype(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
+ SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->datatype);
}
/*******************************************************************
static void spoolss_notify_security_desc(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
- printer->info_2->secdesc_buf->sd_size,
- printer->info_2->secdesc_buf->sd);
+ SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data, pinfo2->secdesc);
}
/*******************************************************************
static void spoolss_notify_attributes(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
+ SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->attributes);
}
/*******************************************************************
static void spoolss_notify_priority(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
+ SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->priority);
}
/*******************************************************************
static void spoolss_notify_default_priority(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
+ SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->defaultpriority);
}
/*******************************************************************
static void spoolss_notify_start_time(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
+ SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->starttime);
}
/*******************************************************************
static void spoolss_notify_until_time(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
+ SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->untiltime);
}
/*******************************************************************
static void spoolss_notify_status(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
print_status_struct status;
static void spoolss_notify_cjobs(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
static void spoolss_notify_average_ppm(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
/* always respond 8 pages per minutes */
/* a little hard ! */
- SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
+ SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->averageppm);
}
/*******************************************************************
static void spoolss_notify_username(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
static void spoolss_notify_job_status(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
static void spoolss_notify_job_name(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
static void spoolss_notify_job_status_string(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
/*
static void spoolss_notify_job_time(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
static void spoolss_notify_job_size(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
static void spoolss_notify_total_pages(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
static void spoolss_notify_pages_printed(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
/* Add code when back-end tracks this */
static void spoolss_notify_job_position(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
static void spoolss_notify_submitted_time(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
data->data.string.string = NULL;
enum spoolss_NotifyTable variable_type;
void (*fn) (int snum, struct spoolss_Notify *data,
print_queue_struct *queue,
- NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
+ struct spoolss_PrinterInfo2 *pinfo2,
+ TALLOC_CTX *mem_ctx);
};
/* A table describing the various print notification constants and
/****************************************************************************
****************************************************************************/
-void construct_info_data(struct spoolss_Notify *info_data,
- enum spoolss_NotifyType type,
- uint16_t field,
- int id)
+static void construct_info_data(struct spoolss_Notify *info_data,
+ enum spoolss_NotifyType type,
+ uint16_t field, int id)
{
info_data->type = type;
info_data->field.field = field;
static bool construct_notify_printer_info(Printer_entry *print_hnd,
struct spoolss_NotifyInfo *info,
+ struct spoolss_PrinterInfo2 *pinfo2,
int snum,
const struct spoolss_NotifyOptionType *option_type,
uint32_t id,
uint16_t field;
struct spoolss_Notify *current_data;
- NT_PRINTER_INFO_LEVEL *printer = NULL;
print_queue_struct *queue=NULL;
type = option_type->type;
(type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
option_type->count, lp_servicename(snum)));
- if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
- return false;
-
for(field_num=0; field_num < option_type->count; field_num++) {
field = option_type->fields[field_num].field;
info->count + 1);
if (info->notifies == NULL) {
DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
- free_a_printer(&printer, 2);
return false;
}
construct_info_data(current_data, type, field, id);
- DEBUG(10,("construct_notify_printer_info: calling [%s] snum=%d printername=[%s])\n",
- notify_info_data_table[j].name, snum, printer->info_2->printername ));
+ DEBUG(10, ("construct_notify_printer_info: "
+ "calling [%s] snum=%d printername=[%s])\n",
+ notify_info_data_table[j].name, snum,
+ pinfo2->printername));
notify_info_data_table[j].fn(snum, current_data, queue,
- printer, mem_ctx);
+ pinfo2, mem_ctx);
info->count++;
}
- free_a_printer(&printer, 2);
return true;
}
static bool construct_notify_jobs_info(print_queue_struct *queue,
struct spoolss_NotifyInfo *info,
- NT_PRINTER_INFO_LEVEL *printer,
+ struct spoolss_PrinterInfo2 *pinfo2,
int snum,
const struct spoolss_NotifyOptionType *option_type,
uint32_t id,
construct_info_data(current_data, type, field, id);
notify_info_data_table[j].fn(snum, current_data, queue,
- printer, mem_ctx);
+ pinfo2, mem_ctx);
info->count++;
}
*
********************************************************************/
-static WERROR printserver_notify_info(pipes_struct *p,
+static WERROR printserver_notify_info(struct pipes_struct *p,
struct policy_handle *hnd,
struct spoolss_NotifyInfo *info,
TALLOC_CTX *mem_ctx)
int i;
struct spoolss_NotifyOption *option;
struct spoolss_NotifyOptionType option_type;
+ struct spoolss_PrinterInfo2 *pinfo2 = NULL;
+ WERROR result;
DEBUG(4,("printserver_notify_info\n"));
if (option_type.type != PRINTER_NOTIFY_TYPE)
continue;
- for (snum=0; snum<n_services; snum++)
- {
- if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
- construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
+ for (snum = 0; snum < n_services; snum++) {
+ if (!lp_browseable(snum) ||
+ !lp_snum_ok(snum) ||
+ !lp_print_ok(snum)) {
+ continue; /* skip */
+ }
+
+ /* Maybe we should use the SYSTEM server_info here... */
+ result = winreg_get_printer(mem_ctx, p->server_info,
+ p->msg_ctx,
+ Printer->servername,
+ lp_servicename(snum),
+ &pinfo2);
+ if (!W_ERROR_IS_OK(result)) {
+ DEBUG(4, ("printserver_notify_info: "
+ "Failed to get printer [%s]\n",
+ lp_servicename(snum)));
+ continue;
+ }
+
+
+ construct_notify_printer_info(Printer, info,
+ pinfo2, snum,
+ &option_type, snum,
+ mem_ctx);
+
+ TALLOC_FREE(pinfo2);
}
}
*
********************************************************************/
-static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
+static WERROR printer_notify_info(struct pipes_struct *p,
+ struct policy_handle *hnd,
struct spoolss_NotifyInfo *info,
TALLOC_CTX *mem_ctx)
{
int count,j;
print_queue_struct *queue=NULL;
print_status_struct status;
+ struct spoolss_PrinterInfo2 *pinfo2 = NULL;
+ WERROR result;
DEBUG(4,("printer_notify_info\n"));
get_printer_snum(p, hnd, &snum, NULL);
+ /* Maybe we should use the SYSTEM server_info here... */
+ result = winreg_get_printer(mem_ctx, p->server_info, p->msg_ctx,
+ Printer->servername,
+ lp_servicename(snum), &pinfo2);
+ if (!W_ERROR_IS_OK(result)) {
+ return WERR_BADFID;
+ }
+
for (i=0; i<option->count; i++) {
option_type = option->types[i];
switch (option_type.type) {
case PRINTER_NOTIFY_TYPE:
- if(construct_notify_printer_info(Printer, info, snum,
- &option_type, id,
- mem_ctx))
+ if (construct_notify_printer_info(Printer, info,
+ pinfo2, snum,
+ &option_type, id,
+ mem_ctx)) {
id--;
+ }
break;
- case JOB_NOTIFY_TYPE: {
- NT_PRINTER_INFO_LEVEL *printer = NULL;
+ case JOB_NOTIFY_TYPE:
count = print_queue_status(snum, &queue, &status);
- if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
- goto done;
-
for (j=0; j<count; j++) {
construct_notify_jobs_info(&queue[j], info,
- printer, snum,
+ pinfo2, snum,
&option_type,
queue[j].job,
mem_ctx);
}
- free_a_printer(&printer, 2);
-
- done:
SAFE_FREE(queue);
break;
}
- }
}
/*
info->data[i].id, info->data[i].size, info->data[i].enc_type));
}
*/
+
+ talloc_free(pinfo2);
return WERR_OK;
}
_spoolss_RouterRefreshPrinterChangeNotify
****************************************************************/
-WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
+WERROR _spoolss_RouterRefreshPrinterChangeNotify(struct pipes_struct *p,
struct spoolss_RouterRefreshPrinterChangeNotify *r)
{
struct spoolss_NotifyInfo *info;
********************************************************************/
static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ struct auth_serversupplied_info *server_info,
+ struct spoolss_PrinterInfo2 *info2,
struct spoolss_PrinterInfo0 *r,
int snum)
{
int count;
counter_printer_0 *session_counter;
- time_t setuptime;
+ struct timeval setuptime;
print_status_struct status;
- r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
+ r->printername = talloc_strdup(mem_ctx, info2->printername);
W_ERROR_HAVE_NO_MEMORY(r->printername);
- r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
+ r->servername = talloc_strdup(mem_ctx, info2->servername);
W_ERROR_HAVE_NO_MEMORY(r->servername);
count = print_queue_length(snum, &status);
r->total_jobs = 0;
r->total_bytes = 0;
- setuptime = (time_t)ntprinter->info_2->setuptime;
-
- init_systemtime(&r->time, gmtime(&setuptime));
+ get_startup_time(&setuptime);
+ init_systemtime(&r->time, gmtime(&setuptime.tv_sec));
/* JFM:
* the global_counter should be stored in a TDB as it's common to all the clients
r->number_of_processors = 0x1;
r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
r->high_part_total_bytes = 0x0;
- r->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
+
+ /* ChangeID in milliseconds*/
+ winreg_printer_get_changeid(mem_ctx, server_info,
+ smbd_messaging_context(),
+ info2->sharename, &r->change_id);
+
r->last_error = WERR_OK;
r->status = nt_printq_status(status.status);
r->enumerate_network_printers = 0x0;
- r->c_setprinter = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
+ r->c_setprinter = 0x0;
r->processor_architecture = 0x0;
r->processor_level = 0x6; /* 6 ???*/
r->ref_ic = 0;
}
-/****************************************************************************
- Create a spoolss_DeviceMode struct. Returns talloced memory.
-****************************************************************************/
-
-struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
- const char *servicename)
-{
- NT_PRINTER_INFO_LEVEL *printer = NULL;
- struct spoolss_DeviceMode *devmode = NULL;
-
- DEBUG(7,("construct_dev_mode\n"));
-
- DEBUGADD(8,("getting printer characteristics\n"));
-
- if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
- return NULL;
-
- if (!printer->info_2->devmode) {
- DEBUG(5, ("BONG! There was no device mode!\n"));
- goto done;
- }
-
- devmode = talloc_steal(mem_ctx, printer->info_2->devmode);
-
-done:
- free_a_printer(&printer,2);
-
- 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,
+ const struct spoolss_PrinterInfo2 *info2,
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);
+ info2->printername,
+ info2->drivername,
+ info2->location);
W_ERROR_HAVE_NO_MEMORY(r->description);
- if (*ntprinter->info_2->comment == '\0') {
+ if (info2->comment == NULL || info2->comment[0] == '\0') {
r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
} else {
- r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
+ r->comment = talloc_strdup(mem_ctx, info2->comment); /* saved comment */
}
W_ERROR_HAVE_NO_MEMORY(r->comment);
- r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
+ r->name = talloc_strdup(mem_ctx, info2->printername);
W_ERROR_HAVE_NO_MEMORY(r->name);
return WERR_OK;
********************************************************************/
static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ const struct spoolss_PrinterInfo2 *info2,
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);
+ r->servername = talloc_strdup(mem_ctx, info2->servername);
W_ERROR_HAVE_NO_MEMORY(r->servername);
- r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
+ r->printername = talloc_strdup(mem_ctx, info2->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);
+ r->portname = talloc_strdup(mem_ctx, info2->portname);
W_ERROR_HAVE_NO_MEMORY(r->portname);
- r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
+ r->drivername = talloc_strdup(mem_ctx, info2->drivername);
W_ERROR_HAVE_NO_MEMORY(r->drivername);
- if (*ntprinter->info_2->comment == '\0') {
+ if (info2->comment[0] == '\0') {
r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
} else {
- r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
+ r->comment = talloc_strdup(mem_ctx, info2->comment);
}
W_ERROR_HAVE_NO_MEMORY(r->comment);
- r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
+ r->location = talloc_strdup(mem_ctx, info2->location);
W_ERROR_HAVE_NO_MEMORY(r->location);
- r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
+ r->sepfile = talloc_strdup(mem_ctx, info2->sepfile);
W_ERROR_HAVE_NO_MEMORY(r->sepfile);
- r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
+ r->printprocessor = talloc_strdup(mem_ctx, info2->printprocessor);
W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
- r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
+ r->datatype = talloc_strdup(mem_ctx, info2->datatype);
W_ERROR_HAVE_NO_MEMORY(r->datatype);
- r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
+ r->parameters = talloc_strdup(mem_ctx, info2->parameters);
W_ERROR_HAVE_NO_MEMORY(r->parameters);
- r->attributes = ntprinter->info_2->attributes;
+ r->attributes = info2->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->priority = info2->priority;
+ r->defaultpriority = info2->defaultpriority;
+ r->starttime = info2->starttime;
+ r->untiltime = info2->untiltime;
r->status = nt_printq_status(status.status);
r->cjobs = count;
- r->averageppm = ntprinter->info_2->averageppm;
+ r->averageppm = info2->averageppm;
- r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
+ copy_devicemode(mem_ctx, info2->devmode, &r->devmode);
if (!r->devmode) {
DEBUG(8,("Returning NULL Devicemode!\n"));
}
- r->secdesc = NULL;
+ r->secdesc = NULL;
- if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
+ if (info2->secdesc != NULL) {
/* 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);
+ r->secdesc = dup_sec_desc(mem_ctx, info2->secdesc);
}
return WERR_OK;
********************************************************************/
static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ const struct spoolss_PrinterInfo2 *info2,
struct spoolss_PrinterInfo3 *r,
int snum)
{
/* These are the components of the SD we are returning. */
- if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
+ if (info2->secdesc != NULL) {
/* 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);
+ r->secdesc = dup_sec_desc(mem_ctx, info2->secdesc);
W_ERROR_HAVE_NO_MEMORY(r->secdesc);
}
********************************************************************/
static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ const struct spoolss_PrinterInfo2 *info2,
struct spoolss_PrinterInfo4 *r,
int snum)
{
- r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
+ r->printername = talloc_strdup(mem_ctx, info2->printername);
W_ERROR_HAVE_NO_MEMORY(r->printername);
- r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
+ r->servername = talloc_strdup(mem_ctx, info2->servername);
W_ERROR_HAVE_NO_MEMORY(r->servername);
- r->attributes = ntprinter->info_2->attributes;
+ r->attributes = info2->attributes;
return WERR_OK;
}
********************************************************************/
static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ const struct spoolss_PrinterInfo2 *info2,
struct spoolss_PrinterInfo5 *r,
int snum)
{
- r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
+ r->printername = talloc_strdup(mem_ctx, info2->printername);
W_ERROR_HAVE_NO_MEMORY(r->printername);
- r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
+ r->portname = talloc_strdup(mem_ctx, info2->portname);
W_ERROR_HAVE_NO_MEMORY(r->portname);
- r->attributes = ntprinter->info_2->attributes;
+ r->attributes = info2->attributes;
/* these two are not used by NT+ according to MSDN */
-
r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
********************************************************************/
static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ const struct spoolss_PrinterInfo2 *info2,
struct spoolss_PrinterInfo6 *r,
int snum)
{
struct spoolss_PrinterInfo7 *r,
int snum)
{
+ struct auth_serversupplied_info *server_info;
struct GUID guid;
+ NTSTATUS status;
+
+ status = make_server_info_system(mem_ctx, &server_info);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0, ("construct_printer_info7: "
+ "Could not create system server_info\n"));
+ return WERR_NOMEM;
+ }
- if (is_printer_published(print_hnd, snum, &guid)) {
+ if (is_printer_published(mem_ctx, server_info, print_hnd->servername,
+ lp_servicename(snum), &guid, NULL)) {
r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
r->action = DSPRINT_PUBLISH;
} else {
}
W_ERROR_HAVE_NO_MEMORY(r->guid);
+ TALLOC_FREE(server_info);
return WERR_OK;
}
********************************************************************/
static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ const struct spoolss_PrinterInfo2 *info2,
struct spoolss_DeviceModeInfo *r,
int snum)
{
- r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
+ copy_devicemode(mem_ctx, info2->devmode, &r->devmode);
if (!r->devmode) {
DEBUG(8,("Returning NULL Devicemode!\n"));
}
********************************************************************/
static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
uint32_t level,
uint32_t flags,
union spoolss_PrinterInfo **info_p,
for (snum = 0; snum < n_services; snum++) {
- NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
+ const char *printer;
+ struct spoolss_PrinterInfo2 *info2;
if (!snum_is_shared_printer(snum)) {
continue;
}
+ printer = lp_const_servicename(snum);
+
DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
- lp_servicename(snum), snum));
+ printer, snum));
+
+ result = winreg_create_printer(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
+ NULL,
+ printer);
+ if (!W_ERROR_IS_OK(result)) {
+ goto out;
+ }
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
union spoolss_PrinterInfo,
goto out;
}
- result = get_a_printer(NULL, &ntprinter, 2,
- lp_const_servicename(snum));
+ result = winreg_get_printer(mem_ctx, server_info,
+ smbd_messaging_context(),
+ NULL, printer, &info2);
if (!W_ERROR_IS_OK(result)) {
goto out;
}
switch (level) {
case 0:
- result = construct_printer_info0(info, ntprinter,
+ result = construct_printer_info0(info, server_info, info2,
&info[count].info0, snum);
break;
case 1:
- result = construct_printer_info1(info, ntprinter, flags,
+ result = construct_printer_info1(info, info2, flags,
&info[count].info1, snum);
break;
case 2:
- result = construct_printer_info2(info, ntprinter,
+ result = construct_printer_info2(info, info2,
&info[count].info2, snum);
break;
case 4:
- result = construct_printer_info4(info, ntprinter,
+ result = construct_printer_info4(info, info2,
&info[count].info4, snum);
break;
case 5:
- result = construct_printer_info5(info, ntprinter,
+ result = construct_printer_info5(info, info2,
&info[count].info5, snum);
break;
default:
result = WERR_UNKNOWN_LEVEL;
- free_a_printer(&ntprinter, 2);
goto out;
}
- free_a_printer(&ntprinter, 2);
if (!W_ERROR_IS_OK(result)) {
goto out;
}
********************************************************************/
static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
uint32_t flags,
const char *servername,
union spoolss_PrinterInfo **info,
{
DEBUG(4,("enum_all_printers_info_0\n"));
- return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
+ return enum_all_printers_info_level(mem_ctx, server_info, 0, flags, info, count);
}
********************************************************************/
static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
uint32_t flags,
union spoolss_PrinterInfo **info,
uint32_t *count)
{
DEBUG(4,("enum_all_printers_info_1\n"));
- return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
+ return enum_all_printers_info_level(mem_ctx, server_info, 1, flags, info, count);
}
/********************************************************************
*********************************************************************/
static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
union spoolss_PrinterInfo **info,
uint32_t *count)
{
DEBUG(4,("enum_all_printers_info_1_local\n"));
- return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
+ return enum_all_printers_info_1(mem_ctx, server_info, PRINTER_ENUM_ICON8, info, count);
}
/********************************************************************
*********************************************************************/
static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
const char *name,
union spoolss_PrinterInfo **info,
uint32_t *count)
return WERR_INVALID_NAME;
}
- return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
+ return enum_all_printers_info_1(mem_ctx, server_info, PRINTER_ENUM_ICON8, info, count);
}
/********************************************************************
*********************************************************************/
static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
const char *name,
union spoolss_PrinterInfo **info,
uint32_t *count)
return WERR_CAN_NOT_COMPLETE;
}
- return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
+ return enum_all_printers_info_1(mem_ctx, server_info, PRINTER_ENUM_NAME, info, count);
}
/********************************************************************
********************************************************************/
static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
union spoolss_PrinterInfo **info,
uint32_t *count)
{
DEBUG(4,("enum_all_printers_info_2\n"));
- return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
+ return enum_all_printers_info_level(mem_ctx, server_info, 2, 0, info, count);
}
/********************************************************************
********************************************************************/
static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
uint32_t flags,
const char *name,
union spoolss_PrinterInfo **info,
/* Not all the flags are equals */
if (flags & PRINTER_ENUM_LOCAL) {
- return enum_all_printers_info_1_local(mem_ctx, info, count);
+ return enum_all_printers_info_1_local(mem_ctx, server_info, info, count);
}
if (flags & PRINTER_ENUM_NAME) {
- return enum_all_printers_info_1_name(mem_ctx, name, info, count);
+ return enum_all_printers_info_1_name(mem_ctx, server_info, name, info, count);
}
if (flags & PRINTER_ENUM_NETWORK) {
- return enum_all_printers_info_1_network(mem_ctx, name, info, count);
+ return enum_all_printers_info_1_network(mem_ctx, server_info, name, info, count);
}
return WERR_OK; /* NT4sp5 does that */
********************************************************************/
static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
uint32_t flags,
const char *servername,
union spoolss_PrinterInfo **info,
uint32_t *count)
{
if (flags & PRINTER_ENUM_LOCAL) {
- return enum_all_printers_info_2(mem_ctx, info, count);
+ return enum_all_printers_info_2(mem_ctx, server_info, info, count);
}
if (flags & PRINTER_ENUM_NAME) {
return WERR_INVALID_NAME;
}
- return enum_all_printers_info_2(mem_ctx, info, count);
+ return enum_all_printers_info_2(mem_ctx, server_info, info, count);
}
if (flags & PRINTER_ENUM_REMOTE) {
********************************************************************/
static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
uint32_t flags,
const char *servername,
union spoolss_PrinterInfo **info,
{
DEBUG(4,("enum_all_printers_info_4\n"));
- return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
+ return enum_all_printers_info_level(mem_ctx, server_info, 4, flags, info, count);
}
********************************************************************/
static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
uint32_t flags,
const char *servername,
union spoolss_PrinterInfo **info,
{
DEBUG(4,("enum_all_printers_info_5\n"));
- return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
+ return enum_all_printers_info_level(mem_ctx, server_info, 5, flags, info, count);
}
/****************************************************************
_spoolss_EnumPrinters
****************************************************************/
-WERROR _spoolss_EnumPrinters(pipes_struct *p,
+WERROR _spoolss_EnumPrinters(struct pipes_struct *p,
struct spoolss_EnumPrinters *r)
{
const char *name = NULL;
switch (r->in.level) {
case 0:
- result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
+ result = enumprinters_level0(p->mem_ctx, p->server_info,
+ r->in.flags, name,
r->out.info, r->out.count);
break;
case 1:
- result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
+ result = enumprinters_level1(p->mem_ctx, p->server_info,
+ r->in.flags, name,
r->out.info, r->out.count);
break;
case 2:
- result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
+ result = enumprinters_level2(p->mem_ctx, p->server_info,
+ r->in.flags, name,
r->out.info, r->out.count);
break;
case 4:
- result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
+ result = enumprinters_level4(p->mem_ctx, p->server_info,
+ r->in.flags, name,
r->out.info, r->out.count);
break;
case 5:
- result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
+ result = enumprinters_level5(p->mem_ctx, p->server_info,
+ r->in.flags, name,
r->out.info, r->out.count);
break;
default:
_spoolss_GetPrinter
****************************************************************/
-WERROR _spoolss_GetPrinter(pipes_struct *p,
+WERROR _spoolss_GetPrinter(struct pipes_struct *p,
struct spoolss_GetPrinter *r)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
- NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
+ struct spoolss_PrinterInfo2 *info2 = NULL;
WERROR result = WERR_OK;
-
+ const char *servername = NULL;
int snum;
/* that's an [in out] buffer */
return WERR_BADFID;
}
- result = get_a_printer(Printer, &ntprinter, 2,
- lp_const_servicename(snum));
+ if (Printer != NULL || Printer->servername != NULL) {
+ servername = Printer->servername;
+ }
+
+ result = winreg_get_printer(p->mem_ctx,
+ p->server_info,
+ p->msg_ctx,
+ servername,
+ lp_const_servicename(snum),
+ &info2);
if (!W_ERROR_IS_OK(result)) {
return result;
}
switch (r->in.level) {
case 0:
- result = construct_printer_info0(p->mem_ctx, ntprinter,
+ result = construct_printer_info0(p->mem_ctx, p->server_info,
+ info2,
&r->out.info->info0, snum);
break;
case 1:
- result = construct_printer_info1(p->mem_ctx, ntprinter,
+ result = construct_printer_info1(p->mem_ctx, info2,
PRINTER_ENUM_ICON8,
&r->out.info->info1, snum);
break;
case 2:
- result = construct_printer_info2(p->mem_ctx, ntprinter,
+ result = construct_printer_info2(p->mem_ctx, info2,
&r->out.info->info2, snum);
break;
case 3:
- result = construct_printer_info3(p->mem_ctx, ntprinter,
+ result = construct_printer_info3(p->mem_ctx, info2,
&r->out.info->info3, snum);
break;
case 4:
- result = construct_printer_info4(p->mem_ctx, ntprinter,
+ result = construct_printer_info4(p->mem_ctx, info2,
&r->out.info->info4, snum);
break;
case 5:
- result = construct_printer_info5(p->mem_ctx, ntprinter,
+ result = construct_printer_info5(p->mem_ctx, info2,
&r->out.info->info5, snum);
break;
case 6:
- result = construct_printer_info6(p->mem_ctx, ntprinter,
+ result = construct_printer_info6(p->mem_ctx, info2,
&r->out.info->info6, snum);
break;
case 7:
&r->out.info->info7, snum);
break;
case 8:
- result = construct_printer_info8(p->mem_ctx, ntprinter,
+ result = construct_printer_info8(p->mem_ctx, info2,
&r->out.info->info8, snum);
break;
default:
break;
}
- free_a_printer(&ntprinter, 2);
-
if (!W_ERROR_IS_OK(result)) {
+ DEBUG(0, ("_spoolss_GetPrinter: failed to construct printer info level %d - %s\n",
+ r->in.level, win_errstr(result)));
TALLOC_FREE(r->out.info);
return result;
}
/********************************************************************
********************************************************************/
-static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
+#define FILL_DRIVER_STRING(mem_ctx, in, out) \
+ do { \
+ if (in && strlen(in)) { \
+ out = talloc_strdup(mem_ctx, in); \
+ } else { \
+ out = talloc_strdup(mem_ctx, ""); \
+ } \
+ W_ERROR_HAVE_NO_MEMORY(out); \
+ } while (0);
+
+#define FILL_DRIVER_UNC_STRING(mem_ctx, server, arch, ver, in, out) \
+ do { \
+ if (in && strlen(in)) { \
+ out = talloc_asprintf(mem_ctx, "\\\\%s\\print$\\%s\\%d\\%s", server, get_short_archi(arch), ver, in); \
+ } else { \
+ out = talloc_strdup(mem_ctx, ""); \
+ } \
+ W_ERROR_HAVE_NO_MEMORY(out); \
+ } while (0);
+
+static WERROR string_array_from_driver_info(TALLOC_CTX *mem_ctx,
const char **string_array,
- const char *cservername)
+ const char ***presult,
+ const char *cservername,
+ const char *arch,
+ int version)
{
int i, num_strings = 0;
const char **array = NULL;
- if (!string_array) {
- return NULL;
+ if (string_array == NULL) {
+ return WERR_INVALID_PARAMETER;;
}
for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
+ const char *str = NULL;
- const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, string_array[i]);
- if (!str) {
- TALLOC_FREE(array);
- return NULL;
+ if (cservername == NULL || arch == NULL) {
+ FILL_DRIVER_STRING(mem_ctx, string_array[i], str);
+ } else {
+ FILL_DRIVER_UNC_STRING(mem_ctx, cservername, arch, version, string_array[i], str);
}
-
if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
TALLOC_FREE(array);
- return NULL;
+ return WERR_NOMEM;
}
}
&array, &num_strings);
}
- 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);
+ if (presult) {
+ *presult = array;
+ }
-#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);
+ return WERR_OK;
+}
/********************************************************************
* fill a spoolss_DriverInfo1 struct
W_ERROR_HAVE_NO_MEMORY(r->architecture);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->driver_path,
r->driver_path);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->data_file,
r->data_file);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->config_file,
r->config_file);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->driver_path,
r->driver_path);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->data_file,
r->data_file);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->config_file,
r->config_file);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->help_file,
r->help_file);
driver->default_datatype,
r->default_datatype);
- r->dependent_files = string_array_from_driver_info(mem_ctx,
- driver->dependent_files,
- cservername);
- return WERR_OK;
+ return string_array_from_driver_info(mem_ctx,
+ driver->dependent_files,
+ &r->dependent_files,
+ cservername,
+ driver->architecture,
+ driver->version);
}
/********************************************************************
const char *servername)
{
const char *cservername = canon_servername(servername);
+ WERROR result;
r->version = driver->version;
W_ERROR_HAVE_NO_MEMORY(r->architecture);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->driver_path,
r->driver_path);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->data_file,
r->data_file);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->config_file,
r->config_file);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->help_file,
r->help_file);
- r->dependent_files = string_array_from_driver_info(mem_ctx,
- driver->dependent_files,
- cservername);
+ result = string_array_from_driver_info(mem_ctx,
+ driver->dependent_files,
+ &r->dependent_files,
+ cservername,
+ driver->architecture,
+ driver->version);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
FILL_DRIVER_STRING(mem_ctx,
driver->monitor_name,
driver->default_datatype,
r->default_datatype);
- r->previous_names = string_array_from_driver_info(mem_ctx,
- driver->previous_names,
- cservername);
- return WERR_OK;
+ result = string_array_from_driver_info(mem_ctx,
+ driver->previous_names,
+ &r->previous_names,
+ NULL, NULL, 0);
+
+ return result;
}
/********************************************************************
W_ERROR_HAVE_NO_MEMORY(r->architecture);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->driver_path,
r->driver_path);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->data_file,
r->data_file);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->config_file,
r->config_file);
const char *servername)
{
const char *cservername = canon_servername(servername);
+ WERROR result;
r->version = driver->version;
W_ERROR_HAVE_NO_MEMORY(r->architecture);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->driver_path,
r->driver_path);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->data_file,
r->data_file);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->config_file,
r->config_file);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->help_file,
r->help_file);
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);
+ result = string_array_from_driver_info(mem_ctx,
+ driver->dependent_files,
+ &r->dependent_files,
+ cservername,
+ driver->architecture,
+ driver->version);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
+ result = string_array_from_driver_info(mem_ctx,
+ driver->previous_names,
+ &r->previous_names,
+ NULL, NULL, 0);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
r->driver_date = driver->driver_date;
r->driver_version = driver->driver_version;
const char *servername)
{
const char *cservername = canon_servername(servername);
+ WERROR result;
r->version = driver->version;
W_ERROR_HAVE_NO_MEMORY(r->architecture);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->driver_path,
r->driver_path);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->data_file,
r->data_file);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->config_file,
r->config_file);
FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
+ driver->architecture,
+ driver->version,
driver->help_file,
r->help_file);
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);
+ result = string_array_from_driver_info(mem_ctx,
+ driver->dependent_files,
+ &r->dependent_files,
+ cservername,
+ driver->architecture,
+ driver->version);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
+ result = string_array_from_driver_info(mem_ctx,
+ driver->previous_names,
+ &r->previous_names,
+ NULL, NULL, 0);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
r->driver_date = driver->driver_date;
r->driver_version = driver->driver_version;
driver->vendor_setup,
r->vendor_setup);
- r->color_profiles = string_array_from_driver_info(mem_ctx,
- driver->color_profiles,
- cservername);
+ result = string_array_from_driver_info(mem_ctx,
+ driver->color_profiles,
+ &r->color_profiles,
+ NULL, NULL, 0);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
FILL_DRIVER_STRING(mem_ctx,
driver->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);
+ result = string_array_from_driver_info(mem_ctx,
+ driver->core_driver_dependencies,
+ &r->core_driver_dependencies,
+ NULL, NULL, 0);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
r->min_inbox_driver_ver_date = driver->min_inbox_driver_ver_date;
r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
driver->default_datatype,
r->default_datatype);
- r->previous_names = string_array_from_driver_info(mem_ctx,
- driver->previous_names,
- cservername);
+ result = string_array_from_driver_info(mem_ctx,
+ driver->previous_names,
+ &r->previous_names,
+ NULL, NULL, 0);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
r->driver_date = driver->driver_date;
r->driver_version = driver->driver_version;
********************************************************************/
static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
uint32_t level,
union spoolss_DriverInfo *r,
int snum,
const char *architecture,
uint32_t version)
{
- NT_PRINTER_INFO_LEVEL *printer = NULL;
+ struct spoolss_PrinterInfo2 *pinfo2 = NULL;
struct spoolss_DriverInfo8 *driver;
WERROR result;
- result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
+ result = winreg_get_printer(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
+ servername,
+ lp_const_servicename(snum),
+ &pinfo2);
DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
win_errstr(result)));
return WERR_INVALID_PRINTER_NAME;
}
- result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
- architecture, version);
+ result = winreg_get_driver(mem_ctx, server_info, architecture,
+ pinfo2->drivername, version, &driver);
DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
win_errstr(result)));
*/
if (version < 3) {
- free_a_printer(&printer, 2);
+ talloc_free(pinfo2);
return WERR_UNKNOWN_PRINTER_DRIVER;
}
/* Yes - try again with a WinNT driver. */
version = 2;
- result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
- architecture, version);
+ result = winreg_get_driver(mem_ctx, server_info, architecture,
+ pinfo2->drivername,
+ version, &driver);
DEBUG(8,("construct_printer_driver_level: status: %s\n",
win_errstr(result)));
if (!W_ERROR_IS_OK(result)) {
- free_a_printer(&printer, 2);
+ talloc_free(pinfo2);
return WERR_UNKNOWN_PRINTER_DRIVER;
}
}
break;
}
- free_a_printer(&printer, 2);
- free_a_printer_driver(driver);
+ talloc_free(pinfo2);
+ talloc_free(driver);
return result;
}
_spoolss_GetPrinterDriver2
****************************************************************/
-WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
+WERROR _spoolss_GetPrinterDriver2(struct pipes_struct *p,
struct spoolss_GetPrinterDriver2 *r)
{
Printer_entry *printer;
WERROR result;
- const char *servername;
int snum;
/* that's an [in out] buffer */
*r->out.server_major_version = 0;
*r->out.server_minor_version = 0;
- servername = get_server_name(printer);
-
if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
return WERR_BADFID;
}
- result = construct_printer_driver_info_level(p->mem_ctx, r->in.level,
- r->out.info, snum,
- servername,
+ result = construct_printer_driver_info_level(p->mem_ctx, p->server_info,
+ r->in.level, r->out.info,
+ snum, printer->servername,
r->in.architecture,
r->in.client_major_version);
if (!W_ERROR_IS_OK(result)) {
_spoolss_StartPagePrinter
****************************************************************/
-WERROR _spoolss_StartPagePrinter(pipes_struct *p,
+WERROR _spoolss_StartPagePrinter(struct pipes_struct *p,
struct spoolss_StartPagePrinter *r)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
_spoolss_EndPagePrinter
****************************************************************/
-WERROR _spoolss_EndPagePrinter(pipes_struct *p,
+WERROR _spoolss_EndPagePrinter(struct pipes_struct *p,
struct spoolss_EndPagePrinter *r)
{
int snum;
_spoolss_StartDocPrinter
****************************************************************/
-WERROR _spoolss_StartDocPrinter(pipes_struct *p,
+WERROR _spoolss_StartDocPrinter(struct pipes_struct *p,
struct spoolss_StartDocPrinter *r)
{
struct spoolss_DocumentInfo1 *info_1;
int snum;
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
+ WERROR werr;
if (!Printer) {
DEBUG(2,("_spoolss_StartDocPrinter: "
return WERR_BADFID;
}
+ if (Printer->jobid) {
+ DEBUG(2, ("_spoolss_StartDocPrinter: "
+ "StartDocPrinter called twice! "
+ "(existing jobid = %d)\n", Printer->jobid));
+ return WERR_INVALID_HANDLE;
+ }
+
if (r->in.level != 1) {
return WERR_UNKNOWN_LEVEL;
}
return WERR_BADFID;
}
- Printer->jobid = print_job_start(p->server_info, snum,
- info_1->document_name,
- Printer->devmode);
+ werr = print_job_start(p->server_info, snum,
+ info_1->document_name, info_1->output_file,
+ Printer->devmode, &Printer->jobid);
/* An error occured in print_job_start() so return an appropriate
NT error code. */
- if (Printer->jobid == -1) {
- return map_werror_from_unix(errno);
+ if (!W_ERROR_IS_OK(werr)) {
+ return werr;
}
Printer->document_started = true;
_spoolss_EndDocPrinter
****************************************************************/
-WERROR _spoolss_EndDocPrinter(pipes_struct *p,
+WERROR _spoolss_EndDocPrinter(struct pipes_struct *p,
struct spoolss_EndDocPrinter *r)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
+ NTSTATUS status;
int snum;
if (!Printer) {
}
Printer->document_started = false;
- print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
- /* error codes unhandled so far ... */
+ status = print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(2, ("_spoolss_EndDocPrinter: "
+ "print_job_end failed [%s]\n",
+ nt_errstr(status)));
+ }
- return WERR_OK;
+ Printer->jobid = 0;
+ return ntstatus_to_werror(status);
}
/****************************************************************
_spoolss_WritePrinter
****************************************************************/
-WERROR _spoolss_WritePrinter(pipes_struct *p,
+WERROR _spoolss_WritePrinter(struct pipes_struct *p,
struct spoolss_WritePrinter *r)
{
ssize_t buffer_written;
if (!get_printer_snum(p, r->in.handle, &snum, NULL))
return WERR_BADFID;
+ /* print_job_write takes care of checking for PJOB_SMBD_SPOOLING */
buffer_written = print_job_write(snum, Printer->jobid,
(const char *)r->in.data.data,
(SMB_OFF_T)-1,
********************************************************************/
static WERROR control_printer(struct policy_handle *handle, uint32_t command,
- pipes_struct *p)
+ struct pipes_struct *p)
{
int snum;
WERROR errcode = WERR_BADFUNC;
* for spooling"
****************************************************************/
-WERROR _spoolss_AbortPrinter(pipes_struct *p,
+WERROR _spoolss_AbortPrinter(struct pipes_struct *p,
struct spoolss_AbortPrinter *r)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
if (!get_printer_snum(p, r->in.handle, &snum, NULL))
return WERR_BADFID;
- print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
+ if (!Printer->document_started) {
+ return WERR_SPL_NO_STARTDOC;
+ }
+
+ errcode = print_job_delete(p->server_info, snum, Printer->jobid);
return errcode;
}
********************************************************************/
static WERROR update_printer_sec(struct policy_handle *handle,
- pipes_struct *p, struct sec_desc_buf *secdesc_ctr)
+ struct pipes_struct *p,
+ struct sec_desc_buf *secdesc_ctr)
{
struct spoolss_security_descriptor *new_secdesc = NULL;
struct spoolss_security_descriptor *old_secdesc = NULL;
nothing may have actually changed. */
result = winreg_get_printer_secdesc(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
printer,
&old_secdesc);
if (!W_ERROR_IS_OK(result)) {
struct security_acl *the_acl;
int i;
- the_acl = secdesc_ctr->sd->dacl;
+ the_acl = old_secdesc->dacl;
DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
printer, the_acl->num_aces));
result = winreg_set_printer_secdesc(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
printer,
new_secdesc);
/********************************************************************
Canonicalize printer info from a client
-
- ATTN: It does not matter what we set the servername to hear
- since we do the necessary work in get_a_printer() to set it to
- the correct value based on what the client sent in the
- _spoolss_open_printer_ex().
********************************************************************/
static bool check_printer_ok(TALLOC_CTX *mem_ctx,
/****************************************************************************
****************************************************************************/
-bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
- struct spoolss_SetPrinterInfo2 *info2)
+static bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
+ struct spoolss_SetPrinterInfo2 *info2,
+ const char *remote_machine,
+ struct messaging_context *msg_ctx)
{
char *cmd = lp_addprinter_cmd();
char **qlines;
int fd;
SE_PRIV se_printop = SE_PRINT_OPERATOR;
bool is_print_op = false;
- char *remote_machine = talloc_strdup(ctx, "%m");
if (!remote_machine) {
return false;
}
- remote_machine = talloc_sub_basic(ctx,
- current_user_info.smb_name,
- current_user_info.domain,
- remote_machine);
- if (!remote_machine) {
- return false;
- }
command = talloc_asprintf(ctx,
"%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
if ( (ret = smbrun(command, &fd)) == 0 ) {
/* Tell everyone we updated smb.conf. */
- message_send_all(smbd_messaging_context(),
- MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
+ message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
}
if ( is_print_op )
DEBUGADD(10,("returned [%d]\n", ret));
TALLOC_FREE(command);
- TALLOC_FREE(remote_machine);
if ( ret != 0 ) {
if (fd != -1)
return true;
}
-
-/********************************************************************
- * Called by spoolss_api_setprinter
- * when updating a printer description.
- ********************************************************************/
-
-static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
- struct spoolss_SetPrinterInfoCtr *info_ctr,
- struct spoolss_DeviceMode *devmode)
+static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
+ int snum,
+ struct spoolss_SetPrinterInfo2 *printer,
+ struct spoolss_PrinterInfo2 *old_printer)
{
- uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
- struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
- struct spoolss_PrinterInfo2 *old_printer;
- Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
- int snum;
- WERROR result;
+ bool force_update = (old_printer == NULL);
+ const char *dnsdomname;
+ const char *longname;
+ const char *uncname;
+ const char *spooling;
DATA_BLOB buffer;
- fstring asc_buffer;
-
- DEBUG(8,("update_printer\n"));
+ WERROR result = WERR_OK;
- result = WERR_OK;
+ if (force_update || !strequal(printer->drivername, old_printer->drivername)) {
+ push_reg_sz(mem_ctx, &buffer, printer->drivername);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
+ printer->sharename,
+ SPOOL_DSSPOOLER_KEY,
+ SPOOL_REG_DRIVERNAME,
+ REG_SZ,
+ buffer.data,
+ buffer.length);
- if (!Printer) {
- result = WERR_BADFID;
- goto done;
- }
+ if (!force_update) {
+ DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
+ printer->drivername));
- if (!get_printer_snum(p, handle, &snum, NULL)) {
- result = WERR_BADFID;
- goto done;
+ notify_printer_driver(snum, printer->drivername);
+ }
}
- result = winreg_get_printer(p->mem_ctx,
- p->server_info,
- NULL,
- lp_const_servicename(snum),
- &old_printer);
- if (!W_ERROR_IS_OK(result)) {
- result = WERR_BADFID;
- goto done;
- }
+ if (force_update || !strequal(printer->comment, old_printer->comment)) {
+ push_reg_sz(mem_ctx, &buffer, printer->comment);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
+ printer->sharename,
+ SPOOL_DSSPOOLER_KEY,
+ SPOOL_REG_DESCRIPTION,
+ REG_SZ,
+ buffer.data,
+ buffer.length);
- /* Do sanity check on the requested changes for Samba */
- if (!check_printer_ok(p->mem_ctx, printer, snum)) {
- result = WERR_INVALID_PARAM;
- goto done;
+ if (!force_update) {
+ notify_printer_comment(snum, printer->comment);
+ }
}
- /* FIXME!!! If the driver has changed we really should verify that
- it is installed before doing much else --jerry */
+ if (force_update || !strequal(printer->sharename, old_printer->sharename)) {
+ push_reg_sz(mem_ctx, &buffer, printer->sharename);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
+ printer->sharename,
+ SPOOL_DSSPOOLER_KEY,
+ SPOOL_REG_PRINTSHARENAME,
+ REG_SZ,
+ buffer.data,
+ buffer.length);
- /* Check calling user has permission to update printer description */
- if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
- DEBUG(3, ("update_printer: printer property change denied by handle\n"));
- result = WERR_ACCESS_DENIED;
- goto done;
+ if (!force_update) {
+ notify_printer_sharename(snum, printer->sharename);
+ }
}
- /* Call addprinter hook */
- /* Check changes to see if this is really needed */
+ if (force_update || !strequal(printer->printername, old_printer->printername)) {
+ const char *p;
- if (*lp_addprinter_cmd() &&
- (!strequal(printer->drivername, old_printer->drivername) ||
- !strequal(printer->comment, old_printer->comment) ||
- !strequal(printer->portname, old_printer->portname) ||
- !strequal(printer->location, old_printer->location)) )
- {
- /* add_printer_hook() will call reload_services() */
- if (!add_printer_hook(p->mem_ctx, p->server_info->ptok,
- printer) ) {
- result = WERR_ACCESS_DENIED;
- goto done;
+ p = strrchr(printer->printername, '\\' );
+ if (p != NULL) {
+ p++;
+ } else {
+ p = printer->printername;
}
- }
- /*
- * When a *new* driver is bound to a printer, the drivername is used to
- * lookup previously saved driver initialization info, which is then
- * bound to the printer, simulating what happens in the Windows arch.
- */
- if (!strequal(printer->drivername, old_printer->drivername)) {
- DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
- printer->drivername));
+ push_reg_sz(mem_ctx, &buffer, p);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
+ printer->sharename,
+ SPOOL_DSSPOOLER_KEY,
+ SPOOL_REG_PRINTERNAME,
+ REG_SZ,
+ buffer.data,
+ buffer.length);
- notify_printer_driver(snum, printer->drivername);
+ if (!force_update) {
+ notify_printer_printername(snum, p);
+ }
}
- /*
- * flag which changes actually occured. This is a small subset of
- * all the possible changes. We also have to update things in the
- * DsSpooler key.
- */
- if (!strequal(printer->comment, old_printer->comment)) {
- push_reg_sz(talloc_tos(), &buffer, printer->comment);
- winreg_set_printer_dataex(p->mem_ctx,
- p->server_info,
+ if (force_update || !strequal(printer->portname, old_printer->portname)) {
+ push_reg_sz(mem_ctx, &buffer, printer->portname);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
printer->sharename,
SPOOL_DSSPOOLER_KEY,
- "description",
+ SPOOL_REG_PORTNAME,
REG_SZ,
buffer.data,
buffer.length);
- notify_printer_comment(snum, printer->comment);
+ if (!force_update) {
+ notify_printer_port(snum, printer->portname);
+ }
}
- if (!strequal(printer->sharename, old_printer->sharename)) {
- push_reg_sz(talloc_tos(), &buffer, printer->sharename);
- winreg_set_printer_dataex(p->mem_ctx,
- p->server_info,
+ if (force_update || !strequal(printer->location, old_printer->location)) {
+ push_reg_sz(mem_ctx, &buffer, printer->location);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
printer->sharename,
SPOOL_DSSPOOLER_KEY,
- "shareName",
+ SPOOL_REG_LOCATION,
REG_SZ,
buffer.data,
buffer.length);
- notify_printer_sharename(snum, printer->sharename);
+ if (!force_update) {
+ notify_printer_location(snum, printer->location);
+ }
}
- if (!strequal(printer->printername, old_printer->printername)) {
- const char *pname;
-
- if ( (pname = strchr_m( printer->printername+2, '\\' )) != NULL )
- pname++;
- else
- pname = printer->printername;
-
- push_reg_sz(talloc_tos(), &buffer, pname);
- winreg_set_printer_dataex(p->mem_ctx,
- p->server_info,
+ if (force_update || !strequal(printer->sepfile, old_printer->sepfile)) {
+ push_reg_sz(mem_ctx, &buffer, printer->sepfile);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
printer->sharename,
SPOOL_DSSPOOLER_KEY,
- "printerName",
+ SPOOL_REG_PRINTSEPARATORFILE,
REG_SZ,
buffer.data,
buffer.length);
- notify_printer_printername( snum, pname );
+ if (!force_update) {
+ notify_printer_location(snum, printer->location);
+ }
}
- if (!strequal(printer->portname, old_printer->portname)) {
- push_reg_sz(talloc_tos(), &buffer, printer->portname);
- winreg_set_printer_dataex(p->mem_ctx,
- p->server_info,
+ if (force_update || printer->starttime != old_printer->starttime) {
+ buffer = data_blob_talloc(mem_ctx, NULL, 4);
+ SIVAL(buffer.data, 0, printer->starttime);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
printer->sharename,
SPOOL_DSSPOOLER_KEY,
- "portName",
- REG_SZ,
+ SPOOL_REG_PRINTSTARTTIME,
+ REG_DWORD,
buffer.data,
buffer.length);
-
- notify_printer_port(snum, printer->portname);
}
- if (!strequal(printer->location, old_printer->location)) {
- push_reg_sz(talloc_tos(), &buffer, printer->location);
- winreg_set_printer_dataex(p->mem_ctx,
- p->server_info,
+ if (force_update || printer->untiltime != old_printer->untiltime) {
+ buffer = data_blob_talloc(mem_ctx, NULL, 4);
+ SIVAL(buffer.data, 0, printer->untiltime);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
printer->sharename,
SPOOL_DSSPOOLER_KEY,
- "location",
- REG_SZ,
+ SPOOL_REG_PRINTENDTIME,
+ REG_DWORD,
buffer.data,
buffer.length);
+ }
- notify_printer_location(snum, printer->location);
+ if (force_update || printer->priority != old_printer->priority) {
+ buffer = data_blob_talloc(mem_ctx, NULL, 4);
+ SIVAL(buffer.data, 0, printer->priority);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
+ printer->sharename,
+ SPOOL_DSSPOOLER_KEY,
+ SPOOL_REG_PRIORITY,
+ REG_DWORD,
+ buffer.data,
+ buffer.length);
}
- /* here we need to update some more DsSpooler keys */
- /* uNCName, serverName, shortServerName */
+ if (force_update || printer->attributes != old_printer->attributes) {
+ buffer = data_blob_talloc(mem_ctx, NULL, 4);
+ SIVAL(buffer.data, 0, (printer->attributes &
+ PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
+ printer->sharename,
+ SPOOL_DSSPOOLER_KEY,
+ SPOOL_REG_PRINTKEEPPRINTEDJOBS,
+ REG_DWORD,
+ buffer.data,
+ buffer.length);
- push_reg_sz(talloc_tos(), &buffer, global_myname());
- winreg_set_printer_dataex(p->mem_ctx,
- p->server_info,
+ switch (printer->attributes & 0x3) {
+ case 0:
+ spooling = SPOOL_REGVAL_PRINTWHILESPOOLING;
+ break;
+ case 1:
+ spooling = SPOOL_REGVAL_PRINTAFTERSPOOLED;
+ break;
+ case 2:
+ spooling = SPOOL_REGVAL_PRINTDIRECT;
+ break;
+ default:
+ spooling = "unknown";
+ }
+ push_reg_sz(mem_ctx, &buffer, spooling);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
+ printer->sharename,
+ SPOOL_DSSPOOLER_KEY,
+ SPOOL_REG_PRINTSPOOLING,
+ REG_SZ,
+ buffer.data,
+ buffer.length);
+ }
+
+ push_reg_sz(mem_ctx, &buffer, global_myname());
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
printer->sharename,
SPOOL_DSSPOOLER_KEY,
- "serverName",
+ SPOOL_REG_SHORTSERVERNAME,
REG_SZ,
buffer.data,
buffer.length);
- winreg_set_printer_dataex(p->mem_ctx,
- p->server_info,
+
+ dnsdomname = get_mydnsfullname();
+ if (dnsdomname != NULL && dnsdomname[0] != '\0') {
+ longname = talloc_strdup(mem_ctx, dnsdomname);
+ } else {
+ longname = talloc_strdup(mem_ctx, global_myname());
+ }
+ if (longname == NULL) {
+ result = WERR_NOMEM;
+ goto done;
+ }
+
+ push_reg_sz(mem_ctx, &buffer, longname);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
printer->sharename,
SPOOL_DSSPOOLER_KEY,
- "shortServerName",
+ SPOOL_REG_SERVERNAME,
REG_SZ,
buffer.data,
buffer.length);
- slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
- global_myname(), printer->sharename );
- push_reg_sz(talloc_tos(), &buffer, asc_buffer);
- winreg_set_printer_dataex(p->mem_ctx,
- p->server_info,
+ uncname = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
+ global_myname(), printer->sharename);
+ push_reg_sz(mem_ctx, &buffer, uncname);
+ winreg_set_printer_dataex(mem_ctx,
+ server_info,
+ smbd_messaging_context(),
printer->sharename,
SPOOL_DSSPOOLER_KEY,
- "uNCName",
+ SPOOL_REG_UNCNAME,
REG_SZ,
buffer.data,
buffer.length);
+done:
+ return result;
+}
+
+/********************************************************************
+ * Called by spoolss_api_setprinter
+ * when updating a printer description.
+ ********************************************************************/
+
+static WERROR update_printer(struct pipes_struct *p,
+ struct policy_handle *handle,
+ struct spoolss_SetPrinterInfoCtr *info_ctr,
+ struct spoolss_DeviceMode *devmode)
+{
+ uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
+ struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
+ struct spoolss_PrinterInfo2 *old_printer;
+ Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
+ const char *servername = NULL;
+ int snum;
+ WERROR result = WERR_OK;
+ TALLOC_CTX *tmp_ctx;
+
+ DEBUG(8,("update_printer\n"));
+
+ tmp_ctx = talloc_new(p->mem_ctx);
+ if (tmp_ctx == NULL) {
+ return WERR_NOMEM;
+ }
+
+ if (!Printer) {
+ result = WERR_BADFID;
+ goto done;
+ }
+
+ if (!get_printer_snum(p, handle, &snum, NULL)) {
+ result = WERR_BADFID;
+ goto done;
+ }
+
+ if (Printer != NULL || Printer->servername != NULL) {
+ servername = Printer->servername;
+ }
+
+ result = winreg_get_printer(tmp_ctx,
+ p->server_info,
+ p->msg_ctx,
+ servername,
+ lp_const_servicename(snum),
+ &old_printer);
+ if (!W_ERROR_IS_OK(result)) {
+ result = WERR_BADFID;
+ goto done;
+ }
+
+ /* Do sanity check on the requested changes for Samba */
+ if (!check_printer_ok(tmp_ctx, printer, snum)) {
+ result = WERR_INVALID_PARAM;
+ goto done;
+ }
+
+ /* FIXME!!! If the driver has changed we really should verify that
+ it is installed before doing much else --jerry */
+
+ /* Check calling user has permission to update printer description */
+ if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
+ DEBUG(3, ("update_printer: printer property change denied by handle\n"));
+ result = WERR_ACCESS_DENIED;
+ goto done;
+ }
+
+ /* Call addprinter hook */
+ /* Check changes to see if this is really needed */
+
+ if (*lp_addprinter_cmd() &&
+ (!strequal(printer->drivername, old_printer->drivername) ||
+ !strequal(printer->comment, old_printer->comment) ||
+ !strequal(printer->portname, old_printer->portname) ||
+ !strequal(printer->location, old_printer->location)) )
+ {
+ /* add_printer_hook() will call reload_services() */
+ if (!add_printer_hook(tmp_ctx, p->server_info->ptok,
+ printer, p->client_address,
+ p->msg_ctx)) {
+ result = WERR_ACCESS_DENIED;
+ goto done;
+ }
+ }
+
+ update_dsspooler(tmp_ctx,
+ p->server_info,
+ snum,
+ printer,
+ old_printer);
+
printer_mask &= ~SPOOLSS_PRINTER_INFO_SECDESC;
if (devmode == NULL) {
printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
}
- result = winreg_update_printer(p->mem_ctx,
+ result = winreg_update_printer(tmp_ctx,
p->server_info,
+ p->msg_ctx,
printer->sharename,
printer_mask,
printer,
NULL);
done:
- talloc_free(old_printer);
+ talloc_free(tmp_ctx);
return result;
}
/****************************************************************************
****************************************************************************/
-static WERROR publish_or_unpublish_printer(pipes_struct *p,
+static WERROR publish_or_unpublish_printer(struct pipes_struct *p,
struct policy_handle *handle,
struct spoolss_SetPrinterInfo7 *info7)
{
#ifdef HAVE_ADS
+ struct spoolss_PrinterInfo2 *pinfo2 = NULL;
+ WERROR result;
int snum;
Printer_entry *Printer;
if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
- nt_printer_publish(Printer, snum, info7->action);
+ result = winreg_get_printer(p->mem_ctx, p->server_info, p->msg_ctx,
+ Printer->servername,
+ lp_servicename(snum), &pinfo2);
+ if (!W_ERROR_IS_OK(result)) {
+ return WERR_BADFID;
+ }
+
+ nt_printer_publish(pinfo2, p->server_info, pinfo2, info7->action);
+ TALLOC_FREE(pinfo2);
return WERR_OK;
#else
return WERR_UNKNOWN_LEVEL;
/********************************************************************
********************************************************************/
-static WERROR update_printer_devmode(pipes_struct *p, struct policy_handle *handle,
+static WERROR update_printer_devmode(struct pipes_struct *p,
+ struct policy_handle *handle,
struct spoolss_DeviceMode *devmode)
{
int snum;
return winreg_update_printer(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
lp_const_servicename(snum),
info2_mask,
NULL,
_spoolss_SetPrinter
****************************************************************/
-WERROR _spoolss_SetPrinter(pipes_struct *p,
+WERROR _spoolss_SetPrinter(struct pipes_struct *p,
struct spoolss_SetPrinter *r)
{
WERROR result;
_spoolss_FindClosePrinterNotify
****************************************************************/
-WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
+WERROR _spoolss_FindClosePrinterNotify(struct pipes_struct *p,
struct spoolss_FindClosePrinterNotify *r)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
!get_printer_snum(p, r->in.handle, &snum, NULL) )
return WERR_BADFID;
- srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
+ srv_spoolss_replycloseprinter(
+ snum, &Printer->notify.client_hnd, p->msg_ctx);
}
Printer->notify.flags=0;
_spoolss_AddJob
****************************************************************/
-WERROR _spoolss_AddJob(pipes_struct *p,
+WERROR _spoolss_AddJob(struct pipes_struct *p,
struct spoolss_AddJob *r)
{
if (!r->in.buffer && (r->in.offered != 0)) {
struct spoolss_JobInfo1 *r,
const print_queue_struct *queue,
int position, int snum,
- const NT_PRINTER_INFO_LEVEL *ntprinter)
+ struct spoolss_PrinterInfo2 *pinfo2)
{
struct tm *t;
r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
W_ERROR_HAVE_NO_MEMORY(r->printer_name);
- r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
+ r->server_name = talloc_strdup(mem_ctx, pinfo2->servername);
W_ERROR_HAVE_NO_MEMORY(r->server_name);
r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
W_ERROR_HAVE_NO_MEMORY(r->user_name);
struct spoolss_JobInfo2 *r,
const print_queue_struct *queue,
int position, int snum,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ struct spoolss_PrinterInfo2 *pinfo2,
struct spoolss_DeviceMode *devmode)
{
struct tm *t;
r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
W_ERROR_HAVE_NO_MEMORY(r->printer_name);
- r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
+ r->server_name = talloc_strdup(mem_ctx, pinfo2->servername);
W_ERROR_HAVE_NO_MEMORY(r->server_name);
r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
W_ERROR_HAVE_NO_MEMORY(r->user_name);
W_ERROR_HAVE_NO_MEMORY(r->print_processor);
r->parameters = talloc_strdup(mem_ctx, "");
W_ERROR_HAVE_NO_MEMORY(r->parameters);
- r->driver_name = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
+ r->driver_name = talloc_strdup(mem_ctx, pinfo2->drivername);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
r->devmode = devmode;
const print_queue_struct *queue,
const print_queue_struct *next_queue,
int position, int snum,
- const NT_PRINTER_INFO_LEVEL *ntprinter)
+ struct spoolss_PrinterInfo2 *pinfo2)
{
r->job_id = queue->job;
r->next_job_id = 0;
static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
const print_queue_struct *queue,
uint32_t num_queues, int snum,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ struct spoolss_PrinterInfo2 *pinfo2,
union spoolss_JobInfo **info_p,
uint32_t *count)
{
&queue[i],
i,
snum,
- ntprinter);
+ pinfo2);
if (!W_ERROR_IS_OK(result)) {
goto out;
}
static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
const print_queue_struct *queue,
uint32_t num_queues, int snum,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ struct spoolss_PrinterInfo2 *pinfo2,
union spoolss_JobInfo **info_p,
uint32_t *count)
{
*count = num_queues;
for (i=0; i<*count; i++) {
-
struct spoolss_DeviceMode *devmode;
- devmode = construct_dev_mode(info, lp_const_servicename(snum));
- if (!devmode) {
- result = WERR_NOMEM;
+ result = spoolss_create_default_devmode(info,
+ pinfo2->printername,
+ &devmode);
+ if (!W_ERROR_IS_OK(result)) {
+ DEBUG(3, ("Can't proceed w/o a devmode!"));
goto out;
}
&queue[i],
i,
snum,
- ntprinter,
+ pinfo2,
devmode);
if (!W_ERROR_IS_OK(result)) {
goto out;
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,
+ struct spoolss_PrinterInfo2 *pinfo2,
union spoolss_JobInfo **info_p,
uint32_t *count)
{
next_queue,
i,
snum,
- ntprinter);
+ pinfo2);
if (!W_ERROR_IS_OK(result)) {
goto out;
}
_spoolss_EnumJobs
****************************************************************/
-WERROR _spoolss_EnumJobs(pipes_struct *p,
+WERROR _spoolss_EnumJobs(struct pipes_struct *p,
struct spoolss_EnumJobs *r)
{
WERROR result;
- NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
+ struct spoolss_PrinterInfo2 *pinfo2 = NULL;
int snum;
print_status_struct prt_status;
print_queue_struct *queue = NULL;
return WERR_BADFID;
}
- result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
+ result = winreg_get_printer(p->mem_ctx, p->server_info, p->msg_ctx,
+ NULL, lp_servicename(snum), &pinfo2);
if (!W_ERROR_IS_OK(result)) {
return result;
}
if (count == 0) {
SAFE_FREE(queue);
- free_a_printer(&ntprinter, 2);
+ TALLOC_FREE(pinfo2);
return WERR_OK;
}
switch (r->in.level) {
case 1:
result = enumjobs_level1(p->mem_ctx, queue, count, snum,
- ntprinter, r->out.info, r->out.count);
+ pinfo2, r->out.info, r->out.count);
break;
case 2:
result = enumjobs_level2(p->mem_ctx, queue, count, snum,
- ntprinter, r->out.info, r->out.count);
+ pinfo2, 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);
+ pinfo2, r->out.info, r->out.count);
break;
default:
result = WERR_UNKNOWN_LEVEL;
}
SAFE_FREE(queue);
- free_a_printer(&ntprinter, 2);
+ TALLOC_FREE(pinfo2);
if (!W_ERROR_IS_OK(result)) {
return result;
_spoolss_ScheduleJob
****************************************************************/
-WERROR _spoolss_ScheduleJob(pipes_struct *p,
+WERROR _spoolss_ScheduleJob(struct pipes_struct *p,
struct spoolss_ScheduleJob *r)
{
return WERR_OK;
_spoolss_SetJob
****************************************************************/
-WERROR _spoolss_SetJob(pipes_struct *p,
+WERROR _spoolss_SetJob(struct pipes_struct *p,
struct spoolss_SetJob *r)
{
int snum;
switch (r->in.command) {
case SPOOLSS_JOB_CONTROL_CANCEL:
case SPOOLSS_JOB_CONTROL_DELETE:
- if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
+ errcode = print_job_delete(p->server_info,
+ snum, r->in.job_id);
+ if (W_ERROR_EQUAL(errcode, WERR_PRINTER_HAS_JOBS_QUEUED)) {
errcode = WERR_OK;
}
break;
****************************************************************************/
static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
const char *servername,
const char *architecture,
uint32_t level,
uint32_t *count_p)
{
int i;
- int ndrivers;
uint32_t version;
- fstring *list = NULL;
struct spoolss_DriverInfo8 *driver;
union spoolss_DriverInfo *info = NULL;
uint32_t count = 0;
WERROR result = WERR_OK;
+ uint32_t num_drivers;
+ const char **drivers;
*count_p = 0;
*info_p = NULL;
for (version=0; version<DRIVER_MAX_VERSION; version++) {
- list = NULL;
- ndrivers = get_ntdrivers(&list, architecture, version);
- DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
- ndrivers, architecture, version));
-
- if (ndrivers == -1) {
- result = WERR_NOMEM;
+ result = winreg_get_driver_list(mem_ctx, server_info,
+ architecture, version,
+ &num_drivers, &drivers);
+ if (!W_ERROR_IS_OK(result)) {
goto out;
}
+ DEBUG(4, ("we have:[%d] drivers in environment"
+ " [%s] and version [%d]\n",
+ num_drivers, architecture, version));
- if (ndrivers != 0) {
+ if (num_drivers != 0) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
union spoolss_DriverInfo,
- count + ndrivers);
+ count + num_drivers);
if (!info) {
DEBUG(0,("enumprinterdrivers_level_by_architecture: "
"failed to enlarge driver info buffer!\n"));
}
}
- for (i=0; i<ndrivers; i++) {
- DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
- ZERO_STRUCT(driver);
- result = get_a_printer_driver(mem_ctx, &driver, list[i],
- architecture, version);
+ for (i = 0; i < num_drivers; i++) {
+ DEBUG(5, ("\tdriver: [%s]\n", drivers[i]));
+
+ result = winreg_get_driver(mem_ctx, server_info,
+ architecture, drivers[i],
+ version, &driver);
if (!W_ERROR_IS_OK(result)) {
goto out;
}
break;
}
- free_a_printer_driver(driver);
+ TALLOC_FREE(driver);
if (!W_ERROR_IS_OK(result)) {
goto out;
}
}
- count += ndrivers;
- SAFE_FREE(list);
+ count += num_drivers;
+ TALLOC_FREE(drivers);
}
out:
- SAFE_FREE(list);
+ TALLOC_FREE(drivers);
if (!W_ERROR_IS_OK(result)) {
TALLOC_FREE(info);
****************************************************************************/
static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
const char *servername,
const char *architecture,
uint32_t level,
uint32_t count = 0;
result = enumprinterdrivers_level_by_architecture(mem_ctx,
+ server_info,
servername,
archi_table[a].long_archi,
level,
}
return enumprinterdrivers_level_by_architecture(mem_ctx,
+ server_info,
servername,
architecture,
level,
_spoolss_EnumPrinterDrivers
****************************************************************/
-WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
+WERROR _spoolss_EnumPrinterDrivers(struct pipes_struct *p,
struct spoolss_EnumPrinterDrivers *r)
{
const char *cservername;
return WERR_UNKNOWN_PRINTER_DRIVER;
}
- result = enumprinterdrivers_level(p->mem_ctx, cservername,
+ result = enumprinterdrivers_level(p->mem_ctx,
+ p->server_info,
+ cservername,
r->in.environment,
r->in.level,
r->out.info,
_spoolss_EnumForms
****************************************************************/
-WERROR _spoolss_EnumForms(pipes_struct *p,
+WERROR _spoolss_EnumForms(struct pipes_struct *p,
struct spoolss_EnumForms *r)
{
WERROR result;
case 1:
result = winreg_printer_enumforms1(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
r->out.count,
r->out.info);
break;
_spoolss_GetForm
****************************************************************/
-WERROR _spoolss_GetForm(pipes_struct *p,
+WERROR _spoolss_GetForm(struct pipes_struct *p,
struct spoolss_GetForm *r)
{
WERROR result;
_spoolss_EnumPorts
****************************************************************/
-WERROR _spoolss_EnumPorts(pipes_struct *p,
+WERROR _spoolss_EnumPorts(struct pipes_struct *p,
struct spoolss_EnumPorts *r)
{
WERROR result;
/****************************************************************************
****************************************************************************/
-static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
+static WERROR spoolss_addprinterex_level_2(struct pipes_struct *p,
const char *server,
struct spoolss_SetPrinterInfoCtr *info_ctr,
struct spoolss_DeviceMode *devmode,
if (*lp_addprinter_cmd() ) {
if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
- info2) ) {
+ info2, p->client_address,
+ p->msg_ctx) ) {
return WERR_ACCESS_DENIED;
}
} else {
info2_mask = ~SPOOLSS_PRINTER_INFO_DEVMODE;
}
+ update_dsspooler(p->mem_ctx,
+ p->server_info,
+ 0,
+ info2,
+ NULL);
+
err = winreg_update_printer(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
info2->sharename,
info2_mask,
info2,
return WERR_ACCESS_DENIED;
}
- update_c_setprinter(false);
-
return WERR_OK;
}
_spoolss_AddPrinterEx
****************************************************************/
-WERROR _spoolss_AddPrinterEx(pipes_struct *p,
+WERROR _spoolss_AddPrinterEx(struct pipes_struct *p,
struct spoolss_AddPrinterEx *r)
{
switch (r->in.info_ctr->level) {
_spoolss_AddPrinter
****************************************************************/
-WERROR _spoolss_AddPrinter(pipes_struct *p,
+WERROR _spoolss_AddPrinter(struct pipes_struct *p,
struct spoolss_AddPrinter *r)
{
struct spoolss_AddPrinterEx a;
_spoolss_AddPrinterDriverEx
****************************************************************/
-WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
+WERROR _spoolss_AddPrinterDriverEx(struct pipes_struct *p,
struct spoolss_AddPrinterDriverEx *r)
{
WERROR err = WERR_OK;
- char *driver_name = NULL;
+ const char *driver_name = NULL;
uint32_t version;
const char *fn;
goto done;
}
- if (add_a_printer_driver(p->mem_ctx, r->in.info_ctr, &driver_name, &version)!=0) {
- err = WERR_ACCESS_DENIED;
+ err = winreg_add_driver(p->mem_ctx, p->server_info,
+ r->in.info_ctr, &driver_name, &version);
+ if (!W_ERROR_IS_OK(err)) {
goto done;
}
* to update each printer bound to this driver. --jerry
*/
- if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
+ if (!srv_spoolss_drv_upgrade_printer(driver_name, p->msg_ctx)) {
DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
fn, driver_name));
}
_spoolss_AddPrinterDriver
****************************************************************/
-WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
+WERROR _spoolss_AddPrinterDriver(struct pipes_struct *p,
struct spoolss_AddPrinterDriver *r)
{
struct spoolss_AddPrinterDriverEx a;
_spoolss_GetPrinterDriverDirectory
****************************************************************/
-WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
+WERROR _spoolss_GetPrinterDriverDirectory(struct pipes_struct *p,
struct spoolss_GetPrinterDriverDirectory *r)
{
WERROR werror;
_spoolss_EnumPrinterData
****************************************************************/
-WERROR _spoolss_EnumPrinterData(pipes_struct *p,
+WERROR _spoolss_EnumPrinterData(struct pipes_struct *p,
struct spoolss_EnumPrinterData *r)
{
WERROR result;
_spoolss_SetPrinterData
****************************************************************/
-WERROR _spoolss_SetPrinterData(pipes_struct *p,
+WERROR _spoolss_SetPrinterData(struct pipes_struct *p,
struct spoolss_SetPrinterData *r)
{
struct spoolss_SetPrinterDataEx r2;
_spoolss_ResetPrinter
****************************************************************/
-WERROR _spoolss_ResetPrinter(pipes_struct *p,
+WERROR _spoolss_ResetPrinter(struct pipes_struct *p,
struct spoolss_ResetPrinter *r)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
_spoolss_DeletePrinterData
****************************************************************/
-WERROR _spoolss_DeletePrinterData(pipes_struct *p,
+WERROR _spoolss_DeletePrinterData(struct pipes_struct *p,
struct spoolss_DeletePrinterData *r)
{
struct spoolss_DeletePrinterDataEx r2;
_spoolss_AddForm
****************************************************************/
-WERROR _spoolss_AddForm(pipes_struct *p,
+WERROR _spoolss_AddForm(struct pipes_struct *p,
struct spoolss_AddForm *r)
{
struct spoolss_AddFormInfo1 *form = r->in.info.info1;
return WERR_INVALID_PARAM;
}
- status = winreg_printer_addform1(p->mem_ctx, p->server_info, form);
+ status = winreg_printer_addform1(p->mem_ctx, p->server_info,
+ p->msg_ctx, form);
if (!W_ERROR_IS_OK(status)) {
return status;
}
status = winreg_printer_update_changeid(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
lp_const_servicename(snum));
if (!W_ERROR_IS_OK(status)) {
return status;
_spoolss_DeleteForm
****************************************************************/
-WERROR _spoolss_DeleteForm(pipes_struct *p,
+WERROR _spoolss_DeleteForm(struct pipes_struct *p,
struct spoolss_DeleteForm *r)
{
const char *form_name = r->in.form_name;
status = winreg_printer_update_changeid(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
lp_const_servicename(snum));
if (!W_ERROR_IS_OK(status)) {
return status;
_spoolss_SetForm
****************************************************************/
-WERROR _spoolss_SetForm(pipes_struct *p,
+WERROR _spoolss_SetForm(struct pipes_struct *p,
struct spoolss_SetForm *r)
{
struct spoolss_AddFormInfo1 *form = r->in.info.info1;
status = winreg_printer_update_changeid(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
lp_const_servicename(snum));
if (!W_ERROR_IS_OK(status)) {
return status;
_spoolss_EnumPrintProcessors
****************************************************************/
-WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
+WERROR _spoolss_EnumPrintProcessors(struct pipes_struct *p,
struct spoolss_EnumPrintProcessors *r)
{
WERROR result;
_spoolss_EnumPrintProcDataTypes
****************************************************************/
-WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
+WERROR _spoolss_EnumPrintProcDataTypes(struct pipes_struct *p,
struct spoolss_EnumPrintProcDataTypes *r)
{
WERROR result;
_spoolss_EnumMonitors
****************************************************************/
-WERROR _spoolss_EnumMonitors(pipes_struct *p,
+WERROR _spoolss_EnumMonitors(struct pipes_struct *p,
struct spoolss_EnumMonitors *r)
{
WERROR result;
static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
const print_queue_struct *queue,
int count, int snum,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ struct spoolss_PrinterInfo2 *pinfo2,
uint32_t jobid,
struct spoolss_JobInfo1 *r)
{
&queue[i],
i,
snum,
- ntprinter);
+ pinfo2);
}
/****************************************************************************
static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
const print_queue_struct *queue,
int count, int snum,
- const NT_PRINTER_INFO_LEVEL *ntprinter,
+ struct spoolss_PrinterInfo2 *pinfo2,
uint32_t jobid,
struct spoolss_JobInfo2 *r)
{
int i = 0;
bool found = false;
struct spoolss_DeviceMode *devmode;
+ WERROR result;
for (i=0; i<count; i++) {
if (queue[i].job == (int)jobid) {
devmode = print_job_devmode(lp_const_servicename(snum), jobid);
if (!devmode) {
- devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
- W_ERROR_HAVE_NO_MEMORY(devmode);
+ result = spoolss_create_default_devmode(mem_ctx,
+ pinfo2->printername,
+ &devmode);
+ if (!W_ERROR_IS_OK(result)) {
+ DEBUG(3, ("Can't proceed w/o a devmode!"));
+ return result;
+ }
}
return fill_job_info2(mem_ctx,
&queue[i],
i,
snum,
- ntprinter,
+ pinfo2,
devmode);
}
_spoolss_GetJob
****************************************************************/
-WERROR _spoolss_GetJob(pipes_struct *p,
+WERROR _spoolss_GetJob(struct pipes_struct *p,
struct spoolss_GetJob *r)
{
WERROR result = WERR_OK;
- NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
+ struct spoolss_PrinterInfo2 *pinfo2 = NULL;
int snum;
int count;
print_queue_struct *queue = NULL;
return WERR_BADFID;
}
- result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
+ result = winreg_get_printer(p->mem_ctx, p->server_info, p->msg_ctx,
+ NULL, lp_servicename(snum), &pinfo2);
if (!W_ERROR_IS_OK(result)) {
return result;
}
switch (r->in.level) {
case 1:
result = getjob_level_1(p->mem_ctx,
- queue, count, snum, ntprinter,
+ queue, count, snum, pinfo2,
r->in.job_id, &r->out.info->info1);
break;
case 2:
result = getjob_level_2(p->mem_ctx,
- queue, count, snum, ntprinter,
+ queue, count, snum, pinfo2,
r->in.job_id, &r->out.info->info2);
break;
default:
}
SAFE_FREE(queue);
- free_a_printer(&ntprinter, 2);
+ TALLOC_FREE(pinfo2);
if (!W_ERROR_IS_OK(result)) {
TALLOC_FREE(r->out.info);
_spoolss_GetPrinterDataEx
****************************************************************/
-WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
+WERROR _spoolss_GetPrinterDataEx(struct pipes_struct *p,
struct spoolss_GetPrinterDataEx *r)
{
result = winreg_printer_get_changeid(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
printer,
&changeid);
if (!W_ERROR_IS_OK(result)) {
result = winreg_get_printer_dataex(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
printer,
r->in.key_name,
r->in.value_name,
_spoolss_SetPrinterDataEx
****************************************************************/
-WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
+WERROR _spoolss_SetPrinterDataEx(struct pipes_struct *p,
struct spoolss_SetPrinterDataEx *r)
{
struct spoolss_PrinterInfo2 *pinfo2 = NULL;
return WERR_ACCESS_DENIED;
}
- result = winreg_get_printer(Printer, p->server_info,
+ result = winreg_get_printer(Printer, p->server_info, p->msg_ctx,
Printer->servername,
lp_servicename(snum),
&pinfo2);
result = winreg_set_printer_dataex(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
pinfo2->sharename,
r->in.key_name,
r->in.value_name,
*/
winreg_set_printer_dataex(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
pinfo2->sharename,
str,
r->in.value_name,
result = winreg_printer_update_changeid(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
lp_const_servicename(snum));
}
_spoolss_DeletePrinterDataEx
****************************************************************/
-WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
+WERROR _spoolss_DeletePrinterDataEx(struct pipes_struct *p,
struct spoolss_DeletePrinterDataEx *r)
{
const char *printer;
status = winreg_delete_printer_dataex(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
printer,
r->in.key_name,
r->in.value_name);
if (W_ERROR_IS_OK(status)) {
status = winreg_printer_update_changeid(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
printer);
}
_spoolss_EnumPrinterKey
****************************************************************/
-WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
+WERROR _spoolss_EnumPrinterKey(struct pipes_struct *p,
struct spoolss_EnumPrinterKey *r)
{
uint32_t num_keys;
result = winreg_enum_printer_key(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
lp_const_servicename(snum),
r->in.key_name,
&num_keys,
_spoolss_DeletePrinterKey
****************************************************************/
-WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
+WERROR _spoolss_DeletePrinterKey(struct pipes_struct *p,
struct spoolss_DeletePrinterKey *r)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
/* delete the key and all subkeys */
status = winreg_delete_printer_key(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
printer,
r->in.key_name);
if (W_ERROR_IS_OK(status)) {
status = winreg_printer_update_changeid(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
printer);
}
_spoolss_EnumPrinterDataEx
****************************************************************/
-WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
+WERROR _spoolss_EnumPrinterDataEx(struct pipes_struct *p,
struct spoolss_EnumPrinterDataEx *r)
{
uint32_t count = 0;
/* now look for a match on the key name */
result = winreg_enum_printer_dataex(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
lp_const_servicename(snum),
r->in.key_name,
&count,
_spoolss_GetPrintProcessorDirectory
****************************************************************/
-WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
+WERROR _spoolss_GetPrintProcessorDirectory(struct pipes_struct *p,
struct spoolss_GetPrintProcessorDirectory *r)
{
WERROR result;
_spoolss_XcvData
****************************************************************/
-WERROR _spoolss_XcvData(pipes_struct *p,
+WERROR _spoolss_XcvData(struct pipes_struct *p,
struct spoolss_XcvData *r)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
_spoolss_AddPrintProcessor
****************************************************************/
-WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
+WERROR _spoolss_AddPrintProcessor(struct pipes_struct *p,
struct spoolss_AddPrintProcessor *r)
{
/* for now, just indicate success and ignore the add. We'll
_spoolss_AddPort
****************************************************************/
-WERROR _spoolss_AddPort(pipes_struct *p,
+WERROR _spoolss_AddPort(struct pipes_struct *p,
struct spoolss_AddPort *r)
{
/* do what w2k3 does */
_spoolss_GetPrinterDriver
****************************************************************/
-WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
+WERROR _spoolss_GetPrinterDriver(struct pipes_struct *p,
struct spoolss_GetPrinterDriver *r)
{
p->rng_fault_state = true;
_spoolss_ReadPrinter
****************************************************************/
-WERROR _spoolss_ReadPrinter(pipes_struct *p,
+WERROR _spoolss_ReadPrinter(struct pipes_struct *p,
struct spoolss_ReadPrinter *r)
{
p->rng_fault_state = true;
_spoolss_WaitForPrinterChange
****************************************************************/
-WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
+WERROR _spoolss_WaitForPrinterChange(struct pipes_struct *p,
struct spoolss_WaitForPrinterChange *r)
{
p->rng_fault_state = true;
_spoolss_ConfigurePort
****************************************************************/
-WERROR _spoolss_ConfigurePort(pipes_struct *p,
+WERROR _spoolss_ConfigurePort(struct pipes_struct *p,
struct spoolss_ConfigurePort *r)
{
p->rng_fault_state = true;
_spoolss_DeletePort
****************************************************************/
-WERROR _spoolss_DeletePort(pipes_struct *p,
+WERROR _spoolss_DeletePort(struct pipes_struct *p,
struct spoolss_DeletePort *r)
{
p->rng_fault_state = true;
_spoolss_CreatePrinterIC
****************************************************************/
-WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
+WERROR _spoolss_CreatePrinterIC(struct pipes_struct *p,
struct spoolss_CreatePrinterIC *r)
{
p->rng_fault_state = true;
_spoolss_PlayGDIScriptOnPrinterIC
****************************************************************/
-WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
+WERROR _spoolss_PlayGDIScriptOnPrinterIC(struct pipes_struct *p,
struct spoolss_PlayGDIScriptOnPrinterIC *r)
{
p->rng_fault_state = true;
_spoolss_DeletePrinterIC
****************************************************************/
-WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
+WERROR _spoolss_DeletePrinterIC(struct pipes_struct *p,
struct spoolss_DeletePrinterIC *r)
{
p->rng_fault_state = true;
_spoolss_AddPrinterConnection
****************************************************************/
-WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
+WERROR _spoolss_AddPrinterConnection(struct pipes_struct *p,
struct spoolss_AddPrinterConnection *r)
{
p->rng_fault_state = true;
_spoolss_DeletePrinterConnection
****************************************************************/
-WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
+WERROR _spoolss_DeletePrinterConnection(struct pipes_struct *p,
struct spoolss_DeletePrinterConnection *r)
{
p->rng_fault_state = true;
_spoolss_PrinterMessageBox
****************************************************************/
-WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
+WERROR _spoolss_PrinterMessageBox(struct pipes_struct *p,
struct spoolss_PrinterMessageBox *r)
{
p->rng_fault_state = true;
_spoolss_AddMonitor
****************************************************************/
-WERROR _spoolss_AddMonitor(pipes_struct *p,
+WERROR _spoolss_AddMonitor(struct pipes_struct *p,
struct spoolss_AddMonitor *r)
{
p->rng_fault_state = true;
_spoolss_DeleteMonitor
****************************************************************/
-WERROR _spoolss_DeleteMonitor(pipes_struct *p,
+WERROR _spoolss_DeleteMonitor(struct pipes_struct *p,
struct spoolss_DeleteMonitor *r)
{
p->rng_fault_state = true;
_spoolss_DeletePrintProcessor
****************************************************************/
-WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
+WERROR _spoolss_DeletePrintProcessor(struct pipes_struct *p,
struct spoolss_DeletePrintProcessor *r)
{
p->rng_fault_state = true;
_spoolss_AddPrintProvidor
****************************************************************/
-WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
+WERROR _spoolss_AddPrintProvidor(struct pipes_struct *p,
struct spoolss_AddPrintProvidor *r)
{
p->rng_fault_state = true;
_spoolss_DeletePrintProvidor
****************************************************************/
-WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
+WERROR _spoolss_DeletePrintProvidor(struct pipes_struct *p,
struct spoolss_DeletePrintProvidor *r)
{
p->rng_fault_state = true;
_spoolss_FindFirstPrinterChangeNotification
****************************************************************/
-WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
+WERROR _spoolss_FindFirstPrinterChangeNotification(struct pipes_struct *p,
struct spoolss_FindFirstPrinterChangeNotification *r)
{
p->rng_fault_state = true;
_spoolss_FindNextPrinterChangeNotification
****************************************************************/
-WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
+WERROR _spoolss_FindNextPrinterChangeNotification(struct pipes_struct *p,
struct spoolss_FindNextPrinterChangeNotification *r)
{
p->rng_fault_state = true;
_spoolss_RouterFindFirstPrinterChangeNotificationOld
****************************************************************/
-WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
+WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(struct pipes_struct *p,
struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
{
p->rng_fault_state = true;
_spoolss_ReplyOpenPrinter
****************************************************************/
-WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
+WERROR _spoolss_ReplyOpenPrinter(struct pipes_struct *p,
struct spoolss_ReplyOpenPrinter *r)
{
p->rng_fault_state = true;
_spoolss_RouterReplyPrinter
****************************************************************/
-WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
+WERROR _spoolss_RouterReplyPrinter(struct pipes_struct *p,
struct spoolss_RouterReplyPrinter *r)
{
p->rng_fault_state = true;
_spoolss_ReplyClosePrinter
****************************************************************/
-WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
+WERROR _spoolss_ReplyClosePrinter(struct pipes_struct *p,
struct spoolss_ReplyClosePrinter *r)
{
p->rng_fault_state = true;
_spoolss_AddPortEx
****************************************************************/
-WERROR _spoolss_AddPortEx(pipes_struct *p,
+WERROR _spoolss_AddPortEx(struct pipes_struct *p,
struct spoolss_AddPortEx *r)
{
p->rng_fault_state = true;
_spoolss_RouterFindFirstPrinterChangeNotification
****************************************************************/
-WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
+WERROR _spoolss_RouterFindFirstPrinterChangeNotification(struct pipes_struct *p,
struct spoolss_RouterFindFirstPrinterChangeNotification *r)
{
p->rng_fault_state = true;
_spoolss_SpoolerInit
****************************************************************/
-WERROR _spoolss_SpoolerInit(pipes_struct *p,
+WERROR _spoolss_SpoolerInit(struct pipes_struct *p,
struct spoolss_SpoolerInit *r)
{
p->rng_fault_state = true;
_spoolss_ResetPrinterEx
****************************************************************/
-WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
+WERROR _spoolss_ResetPrinterEx(struct pipes_struct *p,
struct spoolss_ResetPrinterEx *r)
{
p->rng_fault_state = true;
_spoolss_RouterReplyPrinterEx
****************************************************************/
-WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
+WERROR _spoolss_RouterReplyPrinterEx(struct pipes_struct *p,
struct spoolss_RouterReplyPrinterEx *r)
{
p->rng_fault_state = true;
_spoolss_44
****************************************************************/
-WERROR _spoolss_44(pipes_struct *p,
+WERROR _spoolss_44(struct pipes_struct *p,
struct spoolss_44 *r)
{
p->rng_fault_state = true;
_spoolss_47
****************************************************************/
-WERROR _spoolss_47(pipes_struct *p,
+WERROR _spoolss_47(struct pipes_struct *p,
struct spoolss_47 *r)
{
p->rng_fault_state = true;
_spoolss_4a
****************************************************************/
-WERROR _spoolss_4a(pipes_struct *p,
+WERROR _spoolss_4a(struct pipes_struct *p,
struct spoolss_4a *r)
{
p->rng_fault_state = true;
_spoolss_4b
****************************************************************/
-WERROR _spoolss_4b(pipes_struct *p,
+WERROR _spoolss_4b(struct pipes_struct *p,
struct spoolss_4b *r)
{
p->rng_fault_state = true;
_spoolss_4c
****************************************************************/
-WERROR _spoolss_4c(pipes_struct *p,
+WERROR _spoolss_4c(struct pipes_struct *p,
struct spoolss_4c *r)
{
p->rng_fault_state = true;
_spoolss_53
****************************************************************/
-WERROR _spoolss_53(pipes_struct *p,
+WERROR _spoolss_53(struct pipes_struct *p,
struct spoolss_53 *r)
{
p->rng_fault_state = true;
_spoolss_55
****************************************************************/
-WERROR _spoolss_55(pipes_struct *p,
+WERROR _spoolss_55(struct pipes_struct *p,
struct spoolss_55 *r)
{
p->rng_fault_state = true;
_spoolss_56
****************************************************************/
-WERROR _spoolss_56(pipes_struct *p,
+WERROR _spoolss_56(struct pipes_struct *p,
struct spoolss_56 *r)
{
p->rng_fault_state = true;
_spoolss_57
****************************************************************/
-WERROR _spoolss_57(pipes_struct *p,
+WERROR _spoolss_57(struct pipes_struct *p,
struct spoolss_57 *r)
{
p->rng_fault_state = true;
_spoolss_5a
****************************************************************/
-WERROR _spoolss_5a(pipes_struct *p,
+WERROR _spoolss_5a(struct pipes_struct *p,
struct spoolss_5a *r)
{
p->rng_fault_state = true;
_spoolss_5b
****************************************************************/
-WERROR _spoolss_5b(pipes_struct *p,
+WERROR _spoolss_5b(struct pipes_struct *p,
struct spoolss_5b *r)
{
p->rng_fault_state = true;
_spoolss_5c
****************************************************************/
-WERROR _spoolss_5c(pipes_struct *p,
+WERROR _spoolss_5c(struct pipes_struct *p,
struct spoolss_5c *r)
{
p->rng_fault_state = true;
_spoolss_5d
****************************************************************/
-WERROR _spoolss_5d(pipes_struct *p,
+WERROR _spoolss_5d(struct pipes_struct *p,
struct spoolss_5d *r)
{
p->rng_fault_state = true;
_spoolss_5e
****************************************************************/
-WERROR _spoolss_5e(pipes_struct *p,
+WERROR _spoolss_5e(struct pipes_struct *p,
struct spoolss_5e *r)
{
p->rng_fault_state = true;
_spoolss_5f
****************************************************************/
-WERROR _spoolss_5f(pipes_struct *p,
+WERROR _spoolss_5f(struct pipes_struct *p,
struct spoolss_5f *r)
{
p->rng_fault_state = true;
_spoolss_60
****************************************************************/
-WERROR _spoolss_60(pipes_struct *p,
+WERROR _spoolss_60(struct pipes_struct *p,
struct spoolss_60 *r)
{
p->rng_fault_state = true;
_spoolss_61
****************************************************************/
-WERROR _spoolss_61(pipes_struct *p,
+WERROR _spoolss_61(struct pipes_struct *p,
struct spoolss_61 *r)
{
p->rng_fault_state = true;
_spoolss_62
****************************************************************/
-WERROR _spoolss_62(pipes_struct *p,
+WERROR _spoolss_62(struct pipes_struct *p,
struct spoolss_62 *r)
{
p->rng_fault_state = true;
_spoolss_63
****************************************************************/
-WERROR _spoolss_63(pipes_struct *p,
+WERROR _spoolss_63(struct pipes_struct *p,
struct spoolss_63 *r)
{
p->rng_fault_state = true;
_spoolss_64
****************************************************************/
-WERROR _spoolss_64(pipes_struct *p,
+WERROR _spoolss_64(struct pipes_struct *p,
struct spoolss_64 *r)
{
p->rng_fault_state = true;
_spoolss_65
****************************************************************/
-WERROR _spoolss_65(pipes_struct *p,
+WERROR _spoolss_65(struct pipes_struct *p,
struct spoolss_65 *r)
{
p->rng_fault_state = true;
_spoolss_GetCorePrinterDrivers
****************************************************************/
-WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p,
+WERROR _spoolss_GetCorePrinterDrivers(struct pipes_struct *p,
struct spoolss_GetCorePrinterDrivers *r)
{
p->rng_fault_state = true;
_spoolss_67
****************************************************************/
-WERROR _spoolss_67(pipes_struct *p,
+WERROR _spoolss_67(struct pipes_struct *p,
struct spoolss_67 *r)
{
p->rng_fault_state = true;
_spoolss_GetPrinterDriverPackagePath
****************************************************************/
-WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p,
+WERROR _spoolss_GetPrinterDriverPackagePath(struct pipes_struct *p,
struct spoolss_GetPrinterDriverPackagePath *r)
{
p->rng_fault_state = true;
_spoolss_69
****************************************************************/
-WERROR _spoolss_69(pipes_struct *p,
+WERROR _spoolss_69(struct pipes_struct *p,
struct spoolss_69 *r)
{
p->rng_fault_state = true;
_spoolss_6a
****************************************************************/
-WERROR _spoolss_6a(pipes_struct *p,
+WERROR _spoolss_6a(struct pipes_struct *p,
struct spoolss_6a *r)
{
p->rng_fault_state = true;
_spoolss_6b
****************************************************************/
-WERROR _spoolss_6b(pipes_struct *p,
+WERROR _spoolss_6b(struct pipes_struct *p,
struct spoolss_6b *r)
{
p->rng_fault_state = true;
_spoolss_6c
****************************************************************/
-WERROR _spoolss_6c(pipes_struct *p,
+WERROR _spoolss_6c(struct pipes_struct *p,
struct spoolss_6c *r)
{
p->rng_fault_state = true;
_spoolss_6d
****************************************************************/
-WERROR _spoolss_6d(pipes_struct *p,
+WERROR _spoolss_6d(struct pipes_struct *p,
struct spoolss_6d *r)
{
p->rng_fault_state = true;
git.samba.org / amitay / samba.git / blobdiff