#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
-
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 */
-extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
+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 */
+
+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);
}
}
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;
done on the handle already */
result = winreg_delete_printer_key(p->mem_ctx, p->server_info,
- Printer->sharename, "");
+ 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);
static bool set_printer_hnd_name(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
Printer_entry *Printer,
const char *handlename)
{
int n_services=lp_numservices();
char *aprinter;
const char *printername;
- const char *servername;
+ const char *servername = NULL;
fstring sname;
bool found = false;
struct spoolss_PrinterInfo2 *info2 = NULL;
result = winreg_get_printer(mem_ctx,
server_info,
+ msg_ctx,
servername,
sname,
&info2);
if ( !W_ERROR_IS_OK(result) ) {
- DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
+ DEBUG(2,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
sname, win_errstr(result)));
continue;
}
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(p->mem_ctx, p->server_info, new_printer, name)) {
+ if (!set_printer_hnd_name(p->mem_ctx, p->server_info, p->msg_ctx,
+ new_printer, name)) {
close_printer_handle(p, hnd);
return false;
}
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);
continue;
}
- result = winreg_get_printer(tmp_ctx, server_info, NULL,
+ result = winreg_get_printer(tmp_ctx, server_info, msg,
+ NULL,
lp_const_servicename(snum),
&pinfo2);
continue;
}
+ if (!pinfo2->drivername) {
+ continue;
+ }
+
if (strcmp(drivername, pinfo2->drivername) != 0) {
continue;
}
/* 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)) {
_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;
if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
p->server_info->ptok, snum) ||
- !print_access_check(p->server_info, snum,
+ !print_access_check(p->server_info, p->msg_ctx, snum,
r->in.access_mask)) {
DEBUG(3, ("access DENIED for printer open\n"));
close_printer_handle(p, r->out.handle);
winreg_create_printer(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
Printer->servername,
lp_const_servicename(snum));
_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);
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),
"");
}
_spoolss_DeletePrinterDriver
****************************************************************/
-WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
+WERROR _spoolss_DeletePrinterDriver(struct pipes_struct *p,
struct spoolss_DeletePrinterDriver *r)
{
if ((version = get_version_id(r->in.architecture)) == -1)
return WERR_INVALID_ENVIRONMENT;
- status = winreg_get_driver(p->mem_ctx, p->server_info,
+ status = winreg_get_driver(p->mem_ctx, p->server_info, p->msg_ctx,
r->in.architecture, r->in.driver,
version, &info);
if (!W_ERROR_IS_OK(status)) {
version = 3;
status = winreg_get_driver(p->mem_ctx, p->server_info,
+ p->msg_ctx,
r->in.architecture,
r->in.driver,
version, &info);
}
- if (printer_driver_in_use(p->mem_ctx, p->server_info, info)) {
+ if (printer_driver_in_use(p->mem_ctx, p->server_info, p->msg_ctx,
+ info)) {
status = WERR_PRINTER_DRIVER_IN_USE;
goto done;
}
if (version == 2) {
status = winreg_get_driver(p->mem_ctx, p->server_info,
+ p->msg_ctx,
r->in.architecture,
r->in.driver, 3, &info_win2k);
if (W_ERROR_IS_OK(status)) {
status = winreg_del_driver(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
info_win2k, 3);
talloc_free(info_win2k);
}
}
- status = winreg_del_driver(p->mem_ctx, p->server_info, info, version);
+ status = winreg_del_driver(p->mem_ctx, p->server_info, p->msg_ctx,
+ info, version);
done:
talloc_free(info);
_spoolss_DeletePrinterDriverEx
****************************************************************/
-WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
+WERROR _spoolss_DeletePrinterDriverEx(struct pipes_struct *p,
struct spoolss_DeletePrinterDriverEx *r)
{
struct spoolss_DriverInfo8 *info = NULL;
version = r->in.version;
status = winreg_get_driver(p->mem_ctx, p->server_info,
- r->in.architecture, r->in.driver,
- version, &info);
+ p->msg_ctx, r->in.architecture,
+ r->in.driver, version, &info);
if (!W_ERROR_IS_OK(status)) {
status = WERR_UNKNOWN_PRINTER_DRIVER;
/* try for Win2k driver if "Windows NT x86" */
version = 3;
- status = winreg_get_driver(info, p->server_info,
+ status = winreg_get_driver(info, p->server_info, p->msg_ctx,
r->in.architecture,
r->in.driver,
version, &info);
}
}
- if (printer_driver_in_use(info, p->server_info, info)) {
+ if (printer_driver_in_use(info, p->server_info, p->msg_ctx, info)) {
status = WERR_PRINTER_DRIVER_IN_USE;
goto done;
}
if (delete_files &&
(r->in.delete_flags & DPD_DELETE_ALL_FILES) &&
- printer_driver_files_in_use(info, p->server_info, info)) {
+ printer_driver_files_in_use(info, p->server_info, p->msg_ctx,
+ 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) ) {
- status = winreg_get_driver(info, p->server_info,
+ status = winreg_get_driver(info, p->server_info, p->msg_ctx,
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,
+ p->msg_ctx,
info_win2k)) {
/* no idea of the correct error here */
talloc_free(info_win2k);
/* remove the Win2k driver first*/
status = winreg_del_driver(info, p->server_info,
- info_win2k, 3);
+ p->msg_ctx, info_win2k, 3);
/* this should not have failed---if it did, report to client */
}
}
- status = winreg_del_driver(info, p->server_info, info, version);
+ status = winreg_del_driver(info, p->server_info, p->msg_ctx, info,
+ version);
if (!W_ERROR_IS_OK(status)) {
goto done;
}
_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 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)
continue; /* skip */
}
- /* FIXME: should we use a SYSTEM server_info here? */
+ /* 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);
*
********************************************************************/
-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)
{
get_printer_snum(p, hnd, &snum, NULL);
- /* FIXME: should we use a SYSTEM server_info here ? */
- result = winreg_get_printer(mem_ctx, p->server_info,
+ /* 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)) {
_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,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
struct spoolss_PrinterInfo2 *info2,
struct spoolss_PrinterInfo0 *r,
int snum)
r->number_of_processors = 0x1;
r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
r->high_part_total_bytes = 0x0;
- winreg_printer_get_changeid(mem_ctx, server_info, info2->sharename, &r->change_id); /* ChangeID in milliseconds*/
+
+ /* ChangeID in milliseconds*/
+ winreg_printer_get_changeid(mem_ctx, server_info, msg_ctx,
+ info2->sharename, &r->change_id);
+
r->last_error = WERR_OK;
r->status = nt_printq_status(status.status);
r->enumerate_network_printers = 0x0;
static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
uint32_t level,
uint32_t flags,
union spoolss_PrinterInfo **info_p,
result = winreg_create_printer(mem_ctx,
server_info,
+ msg_ctx,
NULL,
printer);
if (!W_ERROR_IS_OK(result)) {
goto out;
}
- result = winreg_get_printer(mem_ctx, server_info,
+ result = winreg_get_printer(mem_ctx, server_info, msg_ctx,
NULL, printer, &info2);
if (!W_ERROR_IS_OK(result)) {
goto out;
switch (level) {
case 0:
- result = construct_printer_info0(info, server_info, info2,
+ result = construct_printer_info0(info, server_info,
+ msg_ctx, info2,
&info[count].info0, snum);
break;
case 1:
static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
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, server_info, 0, flags, info, count);
+ return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
+ 0, flags, info, count);
}
static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
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, server_info, 1, flags, info, count);
+ return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
+ 1, flags, info, count);
}
/********************************************************************
static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
union spoolss_PrinterInfo **info,
uint32_t *count)
{
DEBUG(4,("enum_all_printers_info_1_local\n"));
- return enum_all_printers_info_1(mem_ctx, server_info, PRINTER_ENUM_ICON8, info, count);
+ return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
+ PRINTER_ENUM_ICON8, info, count);
}
/********************************************************************
static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
const char *name,
union spoolss_PrinterInfo **info,
uint32_t *count)
return WERR_INVALID_NAME;
}
- return enum_all_printers_info_1(mem_ctx, server_info, PRINTER_ENUM_ICON8, info, count);
+ return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
+ PRINTER_ENUM_ICON8, info, count);
}
/********************************************************************
static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
const char *name,
union spoolss_PrinterInfo **info,
uint32_t *count)
return WERR_CAN_NOT_COMPLETE;
}
- return enum_all_printers_info_1(mem_ctx, server_info, PRINTER_ENUM_NAME, info, count);
+ return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
+ PRINTER_ENUM_NAME, info, count);
}
/********************************************************************
static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
union spoolss_PrinterInfo **info,
uint32_t *count)
{
DEBUG(4,("enum_all_printers_info_2\n"));
- return enum_all_printers_info_level(mem_ctx, server_info, 2, 0, info, count);
+ return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
+ 2, 0, info, count);
}
/********************************************************************
static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
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, server_info, info, count);
+ return enum_all_printers_info_1_local(mem_ctx, server_info,
+ msg_ctx, info, count);
}
if (flags & PRINTER_ENUM_NAME) {
- return enum_all_printers_info_1_name(mem_ctx, server_info, name, info, count);
+ return enum_all_printers_info_1_name(mem_ctx, server_info,
+ msg_ctx, name, info,
+ count);
}
if (flags & PRINTER_ENUM_NETWORK) {
- return enum_all_printers_info_1_network(mem_ctx, server_info, name, info, count);
+ return enum_all_printers_info_1_network(mem_ctx, server_info,
+ msg_ctx, name, info,
+ count);
}
return WERR_OK; /* NT4sp5 does that */
static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
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, server_info, info, count);
+ return enum_all_printers_info_2(mem_ctx, server_info, msg_ctx,
+ info, count);
}
if (flags & PRINTER_ENUM_NAME) {
return WERR_INVALID_NAME;
}
- return enum_all_printers_info_2(mem_ctx, server_info, info, count);
+ return enum_all_printers_info_2(mem_ctx, server_info, msg_ctx,
+ info, count);
}
if (flags & PRINTER_ENUM_REMOTE) {
static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
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, server_info, 4, flags, info, count);
+ return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
+ 4, flags, info, count);
}
static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
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, server_info, 5, flags, info, count);
+ return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
+ 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, p->server_info,
- r->in.flags, name,
+ p->msg_ctx, r->in.flags, name,
r->out.info, r->out.count);
break;
case 1:
result = enumprinters_level1(p->mem_ctx, p->server_info,
- r->in.flags, name,
+ p->msg_ctx, r->in.flags, name,
r->out.info, r->out.count);
break;
case 2:
result = enumprinters_level2(p->mem_ctx, p->server_info,
- r->in.flags, name,
+ p->msg_ctx, r->in.flags, name,
r->out.info, r->out.count);
break;
case 4:
result = enumprinters_level4(p->mem_ctx, p->server_info,
- r->in.flags, name,
+ p->msg_ctx, r->in.flags, name,
r->out.info, r->out.count);
break;
case 5:
result = enumprinters_level5(p->mem_ctx, p->server_info,
- r->in.flags, name,
+ p->msg_ctx, 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);
result = winreg_get_printer(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
servername,
lp_const_servicename(snum),
&info2);
switch (r->in.level) {
case 0:
result = construct_printer_info0(p->mem_ctx, p->server_info,
- info2,
+ p->msg_ctx, info2,
&r->out.info->info0, snum);
break;
case 1:
do { \
if (in && strlen(in)) { \
out = talloc_strdup(mem_ctx, in); \
- W_ERROR_HAVE_NO_MEMORY(out); \
} else { \
- out = NULL; \
+ 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) \
static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
uint32_t level,
union spoolss_DriverInfo *r,
int snum,
result = winreg_get_printer(mem_ctx,
server_info,
+ msg_ctx,
servername,
lp_const_servicename(snum),
&pinfo2);
return WERR_INVALID_PRINTER_NAME;
}
- result = winreg_get_driver(mem_ctx, server_info, architecture,
+ result = winreg_get_driver(mem_ctx, server_info, msg_ctx,
+ architecture,
pinfo2->drivername, version, &driver);
DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
/* Yes - try again with a WinNT driver. */
version = 2;
- result = winreg_get_driver(mem_ctx, server_info, architecture,
+ result = winreg_get_driver(mem_ctx, server_info, msg_ctx,
+ architecture,
pinfo2->drivername,
version, &driver);
DEBUG(8,("construct_printer_driver_level: status: %s\n",
_spoolss_GetPrinterDriver2
****************************************************************/
-WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
+WERROR _spoolss_GetPrinterDriver2(struct pipes_struct *p,
struct spoolss_GetPrinterDriver2 *r)
{
Printer_entry *printer;
return WERR_BADFID;
}
- result = construct_printer_driver_info_level(p->mem_ctx, p->server_info,
+ result = construct_printer_driver_info_level(p->mem_ctx,
+ p->server_info,
+ p->msg_ctx,
r->in.level, r->out.info,
snum, printer->servername,
r->in.architecture,
_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;
_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);
_spoolss_WritePrinter
****************************************************************/
-WERROR _spoolss_WritePrinter(pipes_struct *p,
+WERROR _spoolss_WritePrinter(struct pipes_struct *p,
struct spoolss_WritePrinter *r)
{
ssize_t buffer_written;
********************************************************************/
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);
********************************************************************/
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);
/****************************************************************************
****************************************************************************/
-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)
static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
int snum,
struct spoolss_SetPrinterInfo2 *printer,
struct spoolss_PrinterInfo2 *old_printer)
push_reg_sz(mem_ctx, &buffer, printer->drivername);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_DRIVERNAME,
push_reg_sz(mem_ctx, &buffer, printer->comment);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_DESCRIPTION,
push_reg_sz(mem_ctx, &buffer, printer->sharename);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTSHARENAME,
push_reg_sz(mem_ctx, &buffer, p);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTERNAME,
push_reg_sz(mem_ctx, &buffer, printer->portname);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PORTNAME,
push_reg_sz(mem_ctx, &buffer, printer->location);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_LOCATION,
push_reg_sz(mem_ctx, &buffer, printer->sepfile);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTSEPARATORFILE,
SIVAL(buffer.data, 0, printer->starttime);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTSTARTTIME,
SIVAL(buffer.data, 0, printer->untiltime);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTENDTIME,
SIVAL(buffer.data, 0, printer->priority);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRIORITY,
PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTKEEPPRINTEDJOBS,
push_reg_sz(mem_ctx, &buffer, spooling);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTSPOOLING,
push_reg_sz(mem_ctx, &buffer, global_myname());
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_SHORTSERVERNAME,
push_reg_sz(mem_ctx, &buffer, longname);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_SERVERNAME,
push_reg_sz(mem_ctx, &buffer, uncname);
winreg_set_printer_dataex(mem_ctx,
server_info,
+ msg_ctx,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_UNCNAME,
* when updating a printer description.
********************************************************************/
-static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
+static WERROR update_printer(struct pipes_struct *p,
+ struct policy_handle *handle,
struct spoolss_SetPrinterInfoCtr *info_ctr,
struct spoolss_DeviceMode *devmode)
{
result = winreg_get_printer(tmp_ctx,
p->server_info,
+ p->msg_ctx,
servername,
lp_const_servicename(snum),
&old_printer);
{
/* add_printer_hook() will call reload_services() */
if (!add_printer_hook(tmp_ctx, p->server_info->ptok,
- printer) ) {
+ printer, p->client_address,
+ p->msg_ctx)) {
result = WERR_ACCESS_DENIED;
goto done;
}
update_dsspooler(tmp_ctx,
p->server_info,
+ p->msg_ctx,
snum,
printer,
old_printer);
}
result = winreg_update_printer(tmp_ctx,
p->server_info,
+ p->msg_ctx,
printer->sharename,
printer_mask,
printer,
/****************************************************************************
****************************************************************************/
-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)
{
if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
- result = winreg_get_printer(p->mem_ctx, p->server_info,
+ 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);
+ nt_printer_publish(pinfo2, p->server_info, p->msg_ctx, pinfo2,
+ info7->action);
TALLOC_FREE(pinfo2);
return WERR_OK;
/********************************************************************
********************************************************************/
-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)) {
_spoolss_EnumJobs
****************************************************************/
-WERROR _spoolss_EnumJobs(pipes_struct *p,
+WERROR _spoolss_EnumJobs(struct pipes_struct *p,
struct spoolss_EnumJobs *r)
{
WERROR result;
return WERR_BADFID;
}
- result = winreg_get_printer(p->mem_ctx, p->server_info, NULL,
- lp_servicename(snum), &pinfo2);
+ 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;
}
_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;
static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
const char *servername,
const char *architecture,
uint32_t level,
*info_p = NULL;
for (version=0; version<DRIVER_MAX_VERSION; version++) {
- result = winreg_get_driver_list(mem_ctx, server_info,
+ result = winreg_get_driver_list(mem_ctx, server_info, msg_ctx,
architecture, version,
&num_drivers, &drivers);
if (!W_ERROR_IS_OK(result)) {
DEBUG(5, ("\tdriver: [%s]\n", drivers[i]));
result = winreg_get_driver(mem_ctx, server_info,
+ msg_ctx,
architecture, drivers[i],
version, &driver);
if (!W_ERROR_IS_OK(result)) {
static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info *server_info,
+ struct messaging_context *msg_ctx,
const char *servername,
const char *architecture,
uint32_t level,
result = enumprinterdrivers_level_by_architecture(mem_ctx,
server_info,
+ msg_ctx,
servername,
archi_table[a].long_archi,
level,
return enumprinterdrivers_level_by_architecture(mem_ctx,
server_info,
+ msg_ctx,
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;
result = enumprinterdrivers_level(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
cservername,
r->in.environment,
r->in.level,
_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;
case 1:
result = winreg_printer_getform1(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
r->in.form_name,
&r->out.info->info1);
break;
_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 {
}
/* you must be a printer admin to add a new printer */
- if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
+ if (!print_access_check(p->server_info, p->msg_ctx, snum,
+ PRINTER_ACCESS_ADMINISTER)) {
return WERR_ACCESS_DENIED;
}
update_dsspooler(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
0,
info2,
NULL);
err = winreg_update_printer(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
info2->sharename,
info2_mask,
info2,
_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;
goto done;
}
- err = winreg_add_driver(p->mem_ctx, p->server_info,
+ err = winreg_add_driver(p->mem_ctx, p->server_info, p->msg_ctx,
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_deleteform1(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
form_name);
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_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_setform1(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
form_name,
form);
if (!W_ERROR_IS_OK(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_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;
_spoolss_GetJob
****************************************************************/
-WERROR _spoolss_GetJob(pipes_struct *p,
+WERROR _spoolss_GetJob(struct pipes_struct *p,
struct spoolss_GetJob *r)
{
WERROR result = WERR_OK;
return WERR_BADFID;
}
- result = winreg_get_printer(p->mem_ctx, p->server_info, NULL,
- lp_servicename(snum), &pinfo2);
+ 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;
}
_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