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);
}
}
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 )
/* go ahead and re-read the services immediately */
become_root();
- reload_services(false);
+ reload_services(msg_ctx, smbd_server_fd(), false);
unbecome_root();
if ( lp_servicenumber( sharename ) > 0 )
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);
}
/****************************************************************************
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)
{
result = winreg_get_printer(mem_ctx,
server_info,
+ msg_ctx,
servername,
sname,
&info2);
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);
/* 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)) {
connection
********************************************************************/
-void update_monitored_printq_cache( void )
+void update_monitored_printq_cache(struct messaging_context *msg_ctx)
{
Printer_entry *printer = printers_list;
int snum;
&& printer->notify.client_connected )
{
snum = print_queue_snum(printer->sharename);
- print_queue_status( snum, NULL, NULL );
+ print_queue_status(msg_ctx, snum, NULL, NULL );
}
printer = printer->next;
/* check smb.conf parameters and the the sec_desc */
- if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
+ if (!allow_access(lp_hostsdeny(snum), lp_hostsallow(snum),
+ p->client_id->name, p->client_id->addr)) {
DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
ZERO_STRUCTP(r->out.handle);
return WERR_ACCESS_DENIED;
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));
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),
"");
}
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);
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;
}
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);
}
/*
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);
return WERR_BADFID;
DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
- "client_address is %s\n", p->client_address));
+ "client_address is %s\n", p->client_id->addr));
- if (!interpret_string_addr(&client_ss, p->client_address,
+ if (!interpret_string_addr(&client_ss, p->client_id->addr,
AI_NUMERICHOST)) {
return WERR_SERVER_UNAVAILABLE;
}
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;
* fill a notify_info_data with the servername
********************************************************************/
-static void spoolss_notify_server_name(int snum,
+static void spoolss_notify_server_name(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with the printername (not including the servername).
********************************************************************/
-static void spoolss_notify_printer_name(int snum,
+static void spoolss_notify_printer_name(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with the servicename
********************************************************************/
-static void spoolss_notify_share_name(int snum,
+static void spoolss_notify_share_name(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with the port name
********************************************************************/
-static void spoolss_notify_port_name(int snum,
+static void spoolss_notify_port_name(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* but it doesn't exist, have to see what to do
********************************************************************/
-static void spoolss_notify_driver_name(int snum,
+static void spoolss_notify_driver_name(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with the comment
********************************************************************/
-static void spoolss_notify_comment(int snum,
+static void spoolss_notify_comment(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* location = "Room 1, floor 2, building 3"
********************************************************************/
-static void spoolss_notify_location(int snum,
+static void spoolss_notify_location(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* jfm:xxxx don't to it for know but that's a real problem !!!
********************************************************************/
-static void spoolss_notify_devmode(int snum,
+static void spoolss_notify_devmode(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with the separator file name
********************************************************************/
-static void spoolss_notify_sepfile(int snum,
+static void spoolss_notify_sepfile(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* jfm:xxxx return always winprint to indicate we don't do anything to it
********************************************************************/
-static void spoolss_notify_print_processor(int snum,
+static void spoolss_notify_print_processor(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* jfm:xxxx send an empty string
********************************************************************/
-static void spoolss_notify_parameters(int snum,
+static void spoolss_notify_parameters(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* jfm:xxxx always send RAW as data type
********************************************************************/
-static void spoolss_notify_datatype(int snum,
+static void spoolss_notify_datatype(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* have to implement security before !
********************************************************************/
-static void spoolss_notify_security_desc(int snum,
+static void spoolss_notify_security_desc(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* jfm:xxxx a samba printer is always shared
********************************************************************/
-static void spoolss_notify_attributes(int snum,
+static void spoolss_notify_attributes(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with the priority
********************************************************************/
-static void spoolss_notify_priority(int snum,
+static void spoolss_notify_priority(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with the default priority
********************************************************************/
-static void spoolss_notify_default_priority(int snum,
+static void spoolss_notify_default_priority(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with the start time
********************************************************************/
-static void spoolss_notify_start_time(int snum,
+static void spoolss_notify_start_time(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with the until time
********************************************************************/
-static void spoolss_notify_until_time(int snum,
+static void spoolss_notify_until_time(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with the status
********************************************************************/
-static void spoolss_notify_status(int snum,
+static void spoolss_notify_status(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
{
print_status_struct status;
- print_queue_length(snum, &status);
+ print_queue_length(msg_ctx, snum, &status);
SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
}
* fill a notify_info_data with the number of jobs queued
********************************************************************/
-static void spoolss_notify_cjobs(int snum,
+static void spoolss_notify_cjobs(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
+ SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(
+ data, print_queue_length(msg_ctx, snum, NULL));
}
/*******************************************************************
* fill a notify_info_data with the average ppm
********************************************************************/
-static void spoolss_notify_average_ppm(int snum,
+static void spoolss_notify_average_ppm(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with username
********************************************************************/
-static void spoolss_notify_username(int snum,
+static void spoolss_notify_username(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with job status
********************************************************************/
-static void spoolss_notify_job_status(int snum,
+static void spoolss_notify_job_status(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with job name
********************************************************************/
-static void spoolss_notify_job_name(int snum,
+static void spoolss_notify_job_name(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with job status
********************************************************************/
-static void spoolss_notify_job_status_string(int snum,
+static void spoolss_notify_job_status_string(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with job time
********************************************************************/
-static void spoolss_notify_job_time(int snum,
+static void spoolss_notify_job_time(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
* fill a notify_info_data with job size
********************************************************************/
-static void spoolss_notify_job_size(int snum,
+static void spoolss_notify_job_size(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
/*******************************************************************
* fill a notify_info_data with page info
********************************************************************/
-static void spoolss_notify_total_pages(int snum,
+static void spoolss_notify_total_pages(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
/*******************************************************************
* fill a notify_info_data with pages printed info.
********************************************************************/
-static void spoolss_notify_pages_printed(int snum,
+static void spoolss_notify_pages_printed(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
Fill a notify_info_data with job position.
********************************************************************/
-static void spoolss_notify_job_position(int snum,
+static void spoolss_notify_job_position(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
Fill a notify_info_data with submitted time.
********************************************************************/
-static void spoolss_notify_submitted_time(int snum,
+static void spoolss_notify_submitted_time(struct messaging_context *msg_ctx,
+ int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
uint16_t field;
const char *name;
enum spoolss_NotifyTable variable_type;
- void (*fn) (int snum, struct spoolss_Notify *data,
+ void (*fn) (struct messaging_context *msg_ctx,
+ int snum, struct spoolss_Notify *data,
print_queue_struct *queue,
struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx);
*
********************************************************************/
-static bool construct_notify_printer_info(Printer_entry *print_hnd,
+static bool construct_notify_printer_info(struct messaging_context *msg_ctx,
+ Printer_entry *print_hnd,
struct spoolss_NotifyInfo *info,
struct spoolss_PrinterInfo2 *pinfo2,
int snum,
notify_info_data_table[j].name, snum,
pinfo2->printername));
- notify_info_data_table[j].fn(snum, current_data, queue,
- pinfo2, mem_ctx);
+ notify_info_data_table[j].fn(msg_ctx, snum, current_data,
+ queue, pinfo2, mem_ctx);
info->count++;
}
*
********************************************************************/
-static bool construct_notify_jobs_info(print_queue_struct *queue,
+static bool construct_notify_jobs_info(struct messaging_context *msg_ctx,
+ print_queue_struct *queue,
struct spoolss_NotifyInfo *info,
struct spoolss_PrinterInfo2 *pinfo2,
int snum,
current_data=&(info->notifies[info->count]);
construct_info_data(current_data, type, field, id);
- notify_info_data_table[j].fn(snum, current_data, queue,
- pinfo2, mem_ctx);
+ notify_info_data_table[j].fn(msg_ctx, snum, current_data,
+ queue, pinfo2, mem_ctx);
info->count++;
}
/* 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);
}
- construct_notify_printer_info(Printer, info,
+ construct_notify_printer_info(p->msg_ctx,
+ Printer, info,
pinfo2, snum,
&option_type, snum,
mem_ctx);
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,
+ result = winreg_get_printer(mem_ctx, p->server_info, p->msg_ctx,
Printer->servername,
lp_servicename(snum), &pinfo2);
if (!W_ERROR_IS_OK(result)) {
switch (option_type.type) {
case PRINTER_NOTIFY_TYPE:
- if (construct_notify_printer_info(Printer, info,
+ if (construct_notify_printer_info(p->msg_ctx,
+ Printer, info,
pinfo2, snum,
&option_type, id,
mem_ctx)) {
case JOB_NOTIFY_TYPE:
- count = print_queue_status(snum, &queue, &status);
+ count = print_queue_status(p->msg_ctx, snum, &queue,
+ &status);
for (j=0; j<count; j++) {
- construct_notify_jobs_info(&queue[j], info,
+ construct_notify_jobs_info(p->msg_ctx,
+ &queue[j], info,
pinfo2, snum,
&option_type,
queue[j].job,
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->servername = talloc_strdup(mem_ctx, info2->servername);
W_ERROR_HAVE_NO_MEMORY(r->servername);
- count = print_queue_length(snum, &status);
+ count = print_queue_length(msg_ctx, snum, &status);
/* check if we already have a counter for this printer */
for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
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 construct_printer_info2(TALLOC_CTX *mem_ctx,
+ struct messaging_context *msg_ctx,
const struct spoolss_PrinterInfo2 *info2,
struct spoolss_PrinterInfo2 *r,
int snum)
int count;
print_status_struct status;
- count = print_queue_length(snum, &status);
+ count = print_queue_length(msg_ctx, snum, &status);
r->servername = talloc_strdup(mem_ctx, info2->servername);
W_ERROR_HAVE_NO_MEMORY(r->servername);
********************************************************************/
static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
+ struct messaging_context *msg_ctx,
const struct spoolss_PrinterInfo2 *info2,
struct spoolss_PrinterInfo6 *r,
int snum)
int count;
print_status_struct status;
- count = print_queue_length(snum, &status);
+ count = print_queue_length(msg_ctx, snum, &status);
r->status = nt_printq_status(status.status);
********************************************************************/
static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
+ struct messaging_context *msg_ctx,
Printer_entry *print_hnd,
struct spoolss_PrinterInfo7 *r,
int snum)
return WERR_NOMEM;
}
- if (is_printer_published(mem_ctx, server_info, print_hnd->servername,
+ if (is_printer_published(mem_ctx, server_info, msg_ctx,
+ print_hnd->servername,
lp_servicename(snum), &guid, NULL)) {
r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
r->action = DSPRINT_PUBLISH;
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:
&info[count].info1, snum);
break;
case 2:
- result = construct_printer_info2(info, info2,
+ result = construct_printer_info2(info, msg_ctx, info2,
&info[count].info2, snum);
break;
case 4:
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);
}
/****************************************************************
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:
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:
&r->out.info->info1, snum);
break;
case 2:
- result = construct_printer_info2(p->mem_ctx, info2,
+ result = construct_printer_info2(p->mem_ctx, p->msg_ctx, info2,
&r->out.info->info2, snum);
break;
case 3:
&r->out.info->info5, snum);
break;
case 6:
- result = construct_printer_info6(p->mem_ctx, info2,
+ result = construct_printer_info6(p->mem_ctx, p->msg_ctx, info2,
&r->out.info->info6, snum);
break;
case 7:
- result = construct_printer_info7(p->mem_ctx, Printer,
+ result = construct_printer_info7(p->mem_ctx, p->msg_ctx,
+ Printer,
&r->out.info->info7, snum);
break;
case 8:
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",
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,
return WERR_BADFID;
Printer->page_started = false;
- print_job_endpage(snum, Printer->jobid);
+ print_job_endpage(p->msg_ctx, snum, Printer->jobid);
return WERR_OK;
}
return WERR_BADFID;
}
- werr = print_job_start(p->server_info, snum,
+ werr = print_job_start(p->server_info, p->msg_ctx,
+ p->client_id->name, snum,
info_1->document_name, info_1->output_file,
Printer->devmode, &Printer->jobid);
}
Printer->document_started = false;
- status = print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
+ status = print_job_end(p->msg_ctx, snum, Printer->jobid, NORMAL_CLOSE);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(2, ("_spoolss_EndDocPrinter: "
"print_job_end failed [%s]\n",
return WERR_BADFID;
/* print_job_write takes care of checking for PJOB_SMBD_SPOOLING */
- buffer_written = print_job_write(snum, Printer->jobid,
+ buffer_written = print_job_write(server_event_context(),p->msg_ctx,
+ snum, Printer->jobid,
(const char *)r->in.data.data,
- (SMB_OFF_T)-1,
(size_t)r->in._data_size);
if (buffer_written == (ssize_t)-1) {
*r->out.num_written = 0;
switch (command) {
case SPOOLSS_PRINTER_CONTROL_PAUSE:
- errcode = print_queue_pause(p->server_info, snum);
+ errcode = print_queue_pause(p->server_info, p->msg_ctx, snum);
break;
case SPOOLSS_PRINTER_CONTROL_RESUME:
case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
- errcode = print_queue_resume(p->server_info, snum);
+ errcode = print_queue_resume(p->server_info, p->msg_ctx, snum);
break;
case SPOOLSS_PRINTER_CONTROL_PURGE:
- errcode = print_queue_purge(p->server_info, snum);
+ errcode = print_queue_purge(p->server_info, p->msg_ctx, snum);
break;
default:
return WERR_UNKNOWN_LEVEL;
return WERR_SPL_NO_STARTDOC;
}
- errcode = print_job_delete(p->server_info, snum, Printer->jobid);
+ errcode = print_job_delete(p->server_info, p->msg_ctx, snum,
+ Printer->jobid);
return errcode;
}
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)) {
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,
- const char *remote_machine)
+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;
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 )
/* reload our services immediately */
become_root();
- reload_services(false);
+ reload_services(msg_ctx, smbd_server_fd(), false);
unbecome_root();
numlines = 0;
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,
DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
printer->drivername));
- notify_printer_driver(snum, printer->drivername);
+ notify_printer_driver(server_event_context(), msg_ctx,
+ snum, printer->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,
buffer.length);
if (!force_update) {
- notify_printer_comment(snum, printer->comment);
+ notify_printer_comment(server_event_context(), msg_ctx,
+ snum, printer->comment);
}
}
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,
buffer.length);
if (!force_update) {
- notify_printer_sharename(snum, printer->sharename);
+ notify_printer_sharename(server_event_context(),
+ msg_ctx,
+ snum, printer->sharename);
}
}
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,
buffer.length);
if (!force_update) {
- notify_printer_printername(snum, p);
+ notify_printer_printername(server_event_context(),
+ msg_ctx, snum, p);
}
}
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,
buffer.length);
if (!force_update) {
- notify_printer_port(snum, printer->portname);
+ notify_printer_port(server_event_context(),
+ msg_ctx, snum, printer->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,
buffer.length);
if (!force_update) {
- notify_printer_location(snum, printer->location);
+ notify_printer_location(server_event_context(),
+ msg_ctx, snum,
+ printer->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,
buffer.length);
if (!force_update) {
- notify_printer_location(snum, printer->location);
+ notify_printer_location(server_event_context(),
+ msg_ctx, snum,
+ printer->location);
}
}
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,
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, p->client_address) ) {
+ printer, p->client_id->addr,
+ 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,
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;
return winreg_update_printer(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
lp_const_servicename(snum),
info2_mask,
NULL,
!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;
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;
}
- count = print_queue_status(snum, &queue, &prt_status);
+ count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
count, prt_status.status, prt_status.message));
****************************************************************/
static WERROR spoolss_setjob_1(TALLOC_CTX *mem_ctx,
+ struct messaging_context *msg_ctx,
const char *printer_name,
uint32_t job_id,
struct spoolss_SetJobInfo1 *r)
return WERR_OK;
}
- if (!print_job_set_name(printer_name, job_id, r->document_name)) {
+ if (!print_job_set_name(server_event_context(), msg_ctx,
+ printer_name, job_id, r->document_name)) {
return WERR_BADFID;
}
switch (r->in.command) {
case SPOOLSS_JOB_CONTROL_CANCEL:
case SPOOLSS_JOB_CONTROL_DELETE:
- errcode = print_job_delete(p->server_info,
+ errcode = print_job_delete(p->server_info, p->msg_ctx,
snum, r->in.job_id);
if (W_ERROR_EQUAL(errcode, WERR_PRINTER_HAS_JOBS_QUEUED)) {
errcode = WERR_OK;
}
break;
case SPOOLSS_JOB_CONTROL_PAUSE:
- if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
+ if (print_job_pause(p->server_info, p->msg_ctx,
+ snum, r->in.job_id, &errcode)) {
errcode = WERR_OK;
}
break;
case SPOOLSS_JOB_CONTROL_RESTART:
case SPOOLSS_JOB_CONTROL_RESUME:
- if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
+ if (print_job_resume(p->server_info, p->msg_ctx,
+ snum, r->in.job_id, &errcode)) {
errcode = WERR_OK;
}
break;
switch (r->in.ctr->level) {
case 1:
- errcode = spoolss_setjob_1(p->mem_ctx, lp_const_servicename(snum),
+ errcode = spoolss_setjob_1(p->mem_ctx, p->msg_ctx,
+ lp_const_servicename(snum),
r->in.job_id,
r->in.ctr->info.info1);
break;
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,
result = enumprinterdrivers_level(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
cservername,
r->in.environment,
r->in.level,
case 1:
result = winreg_printer_enumforms1(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
r->out.count,
r->out.info);
break;
case 1:
result = winreg_printer_getform1(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
r->in.form_name,
&r->out.info->info1);
break;
if (*lp_addprinter_cmd() ) {
if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
- info2, p->client_address) ) {
+ info2, p->client_id->addr,
+ 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,
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));
}
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;
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;
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;
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;
}
- count = print_queue_status(snum, &queue, &prt_status);
+ count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
count, prt_status.status, prt_status.message));
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,
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));
}
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);
}
result = winreg_enum_printer_key(p->mem_ctx,
p->server_info,
+ p->msg_ctx,
lp_const_servicename(snum),
r->in.key_name,
&num_keys,
/* 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);
}
/* 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,
git.samba.org / nivanova / samba.git / blobdiff