#define MAX_OPEN_PRINTER_EXS 50
#endif
+struct notify_back_channel;
+
/* structure to store the printer handles */
/* and a reference to what it's pointing to */
/* and the notify info asked about */
bool page_started;
uint32 jobid; /* jobid in printing backend */
int printer_type;
- fstring servername;
+ const char *servername;
fstring sharename;
uint32 type;
uint32 access_granted;
fstring localmachine;
uint32 printerlocal;
struct spoolss_NotifyOption *option;
- struct policy_handle client_hnd;
- bool client_connected;
+ struct policy_handle cli_hnd;
+ struct notify_back_channel *cli_chan;
uint32 change;
/* are we in a FindNextPrinterChangeNotify() call? */
bool fnpcn;
static struct printer_session_counter *counter_list;
struct notify_back_channel {
+ struct notify_back_channel *prev, *next;
+
+ /* associated client */
+ struct sockaddr_storage client_address;
+
/* print notify back-channel pipe handle*/
struct rpc_pipe_client *cli_pipe;
- uint32_t active_channels;
+ uint32_t active_connections;
};
-static struct notify_back_channel back_channel = { NULL, 0 };
+static struct notify_back_channel *back_channels;
/* Map generic permissions to printer object specific permissions */
struct xcv_api_table {
const char *name;
- WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
+ WERROR(*fn) (TALLOC_CTX *mem_ctx, struct security_token *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
};
static void prune_printername_cache(void);
Disconnect from the client
****************************************************************************/
-static void srv_spoolss_replycloseprinter(
- int snum, struct policy_handle *handle,
- struct messaging_context *msg_ctx)
+static void srv_spoolss_replycloseprinter(int snum,
+ struct printer_handle *prn_hnd)
{
WERROR result;
NTSTATUS status;
* by deregistering our PID.
*/
- 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) ));
+ if (!print_notify_deregister_pid(snum)) {
+ DEBUG(0, ("Failed to register our pid for printer %s\n",
+ lp_const_servicename(snum)));
+ }
/* weird if the test succeeds !!! */
- if (back_channel.active_channels == 0) {
- DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
+ if (prn_hnd->notify.cli_chan == NULL ||
+ prn_hnd->notify.cli_chan->active_connections == 0) {
+ DEBUG(0, ("Trying to close unexisting backchannel!\n"));
+ DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
+ TALLOC_FREE(prn_hnd->notify.cli_chan);
return;
}
- status = rpccli_spoolss_ReplyClosePrinter(back_channel.cli_pipe, talloc_tos(),
- handle,
- &result);
- if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
- DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
- win_errstr(result)));
+ status = rpccli_spoolss_ReplyClosePrinter(
+ prn_hnd->notify.cli_chan->cli_pipe,
+ talloc_tos(),
+ &prn_hnd->notify.cli_hnd,
+ &result);
+ if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
+ DEBUG(0, ("reply_close_printer failed [%s].\n",
+ win_errstr(result)));
+ }
/* if it's the last connection, deconnect the IPC$ share */
- if (back_channel.active_channels == 1) {
+ if (prn_hnd->notify.cli_chan->active_connections == 1) {
- cli_shutdown(rpc_pipe_np_smb_conn(back_channel.cli_pipe));
- /*
- * The above call shuts down the pipe also.
- */
- back_channel.cli_pipe = NULL;
+ cli_shutdown(rpc_pipe_np_smb_conn(prn_hnd->notify.cli_chan->cli_pipe));
+ DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
+ TALLOC_FREE(prn_hnd->notify.cli_chan);
- if (msg_ctx != NULL) {
- messaging_deregister(msg_ctx, MSG_PRINTER_NOTIFY2,
- NULL);
+ if (prn_hnd->notify.msg_ctx != NULL) {
+ messaging_deregister(prn_hnd->notify.msg_ctx,
+ MSG_PRINTER_NOTIFY2, NULL);
/*
* Tell the serverid.tdb we're no longer
*/
serverid_register_msg_flags(
- messaging_server_id(msg_ctx),
+ messaging_server_id(prn_hnd->notify.msg_ctx),
false, FLAG_MSG_PRINT_NOTIFY);
}
}
- back_channel.active_channels--;
+ if (prn_hnd->notify.cli_chan) {
+ prn_hnd->notify.cli_chan->active_connections--;
+ }
}
/****************************************************************************
static int printer_entry_destructor(struct printer_handle *Printer)
{
- if (Printer->notify.client_connected == true) {
+ if (Printer->notify.cli_chan != NULL &&
+ Printer->notify.cli_chan->active_connections > 0) {
int snum = -1;
- if ( Printer->printer_type == SPLHND_SERVER) {
- snum = -1;
- srv_spoolss_replycloseprinter(
- snum, &Printer->notify.client_hnd,
- Printer->notify.msg_ctx);
- } else if (Printer->printer_type == SPLHND_PRINTER) {
+ switch(Printer->printer_type) {
+ case SPLHND_SERVER:
+ srv_spoolss_replycloseprinter(snum, Printer);
+ break;
+
+ case SPLHND_PRINTER:
snum = print_queue_snum(Printer->sharename);
- if (snum != -1)
- srv_spoolss_replycloseprinter(
- snum, &Printer->notify.client_hnd,
- Printer->notify.msg_ctx);
+ if (snum != -1) {
+ srv_spoolss_replycloseprinter(snum, Printer);
+ }
+ break;
+ default:
+ break;
}
}
Printer->notify.localmachine[0]='\0';
Printer->notify.printerlocal=0;
TALLOC_FREE(Printer->notify.option);
- Printer->notify.client_connected = false;
-
TALLOC_FREE(Printer->devmode);
/* Remove from the internal list. */
Delete a printer given a handle.
****************************************************************************/
-static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
+static WERROR delete_printer_hook(TALLOC_CTX *ctx, struct security_token *token,
const char *sharename,
struct messaging_context *msg_ctx)
{
char *cmd = lp_deleteprinter_cmd();
char *command = NULL;
int ret;
- SE_PRIV se_printop = SE_PRINT_OPERATOR;
bool is_print_op = false;
/* can't fail if we don't try */
return WERR_NOMEM;
}
if ( token )
- is_print_op = user_has_privileges( token, &se_printop );
+ is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
DEBUG(10,("Running [%s]\n", command));
reload_services(msg_ctx, -1, false);
unbecome_root();
- if ( lp_servicenumber( sharename ) > 0 )
+ if ( lp_servicenumber( sharename ) >= 0 )
return WERR_ACCESS_DENIED;
return WERR_OK;
bool found = false;
struct spoolss_PrinterInfo2 *info2 = NULL;
WERROR result;
+ char *p;
/*
* Hopefully nobody names his printers like this. Maybe \ or ,
if (!is_myname_or_ipaddr(servername)) {
return false;
}
-
- fstrcpy(Printer->servername, servername);
+ Printer->servername = talloc_asprintf(Printer, "\\\\%s", servername);
+ if (Printer->servername == NULL) {
+ return false;
+ }
}
if (Printer->printer_type == SPLHND_SERVER) {
DEBUGADD(5, ("searching for [%s]\n", aprinter));
+ if ((p = strchr(aprinter, ',')) != NULL) {
+ if (*p == ' ')
+ p++;
+ if (strnequal(p+1, "DrvConvert", strlen("DrvConvert")) ||
+ strnequal(p+1, " DrvConvert", strlen(" DrvConvert"))) {
+ *p = '\0';
+ } else if (strnequal(p+1, "LocalOnly", strlen("LocalOnly")) ||
+ strnequal(p+1, " LocalOnly", strlen(" LocalOnly"))) {
+ *p = '\0';
+ }
+ }
+
/* check for the Port Monitor Interface */
if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
Printer->printer_type = SPLHND_PORTMON_TCP;
result = winreg_get_printer(mem_ctx,
server_info,
msg_ctx,
- servername,
sname,
&info2);
if ( !W_ERROR_IS_OK(result) ) {
back registered
**********************************************************************/
-static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
+static int build_notify2_messages(TALLOC_CTX *mem_ctx,
+ struct printer_handle *prn_hnd,
+ SPOOLSS_NOTIFY_MSG *messages,
+ uint32_t num_msgs,
+ struct spoolss_Notify **_notifies,
+ int *_count)
{
- struct printer_handle *p;
- TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
- SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
- SPOOLSS_NOTIFY_MSG *messages;
- int sending_msg_count;
-
- if ( !msg_group ) {
- DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
- return;
- }
-
- messages = msg_group->msgs;
+ struct spoolss_Notify *notifies;
+ SPOOLSS_NOTIFY_MSG *msg;
+ int count = 0;
+ uint32_t id;
+ int i;
- if ( !messages ) {
- DEBUG(5,("send_notify2_changes() called with no messages!\n"));
- return;
+ notifies = talloc_zero_array(mem_ctx,
+ struct spoolss_Notify, num_msgs);
+ if (!notifies) {
+ return ENOMEM;
}
- DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
-
- /* loop over all printers */
+ for (i = 0; i < num_msgs; i++) {
- for (p = printers_list; p; p = p->next) {
- struct spoolss_Notify *notifies;
- uint32_t count = 0;
- uint32_t id;
- int i;
+ msg = &messages[i];
- /* Is there notification on this handle? */
+ /* Are we monitoring this event? */
- if ( !p->notify.client_connected )
+ if (!is_monitoring_event(prn_hnd, msg->type, msg->field)) {
continue;
+ }
- DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
+ DEBUG(10, ("Sending message type [0x%x] field [0x%2x] "
+ "for printer [%s]\n",
+ msg->type, msg->field, prn_hnd->sharename));
- /* For this printer? Print servers always receive
- notifications. */
+ /*
+ * if the is a printer notification handle and not a job
+ * notification type, then set the id to 0.
+ * Otherwise just use what was specified in the message.
+ *
+ * When registering change notification on a print server
+ * handle we always need to send back the id (snum) matching
+ * the printer for which the change took place.
+ * For change notify registered on a printer handle,
+ * this does not matter and the id should be 0.
+ *
+ * --jerry
+ */
- if ( ( p->printer_type == SPLHND_PRINTER ) &&
- ( !strequal(msg_group->printername, p->sharename) ) )
- continue;
+ if ((msg->type == PRINTER_NOTIFY_TYPE) &&
+ (prn_hnd->printer_type == SPLHND_PRINTER)) {
+ id = 0;
+ } else {
+ id = msg->id;
+ }
- DEBUG(10,("Our printer\n"));
+ /* Convert unix jobid to smb jobid */
- /* allocate the max entries possible */
+ if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
+ id = sysjob_to_jobid(msg->id);
- notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
- if (!notifies) {
- return;
+ if (id == -1) {
+ DEBUG(3, ("no such unix jobid %d\n",
+ msg->id));
+ continue;
+ }
}
- /* build the array of change notifications */
+ construct_info_data(¬ifies[count],
+ msg->type, msg->field, id);
- sending_msg_count = 0;
+ switch(msg->type) {
+ case PRINTER_NOTIFY_TYPE:
+ if (printer_notify_table[msg->field].fn) {
+ printer_notify_table[msg->field].fn(msg,
+ ¬ifies[count], mem_ctx);
+ }
+ break;
- for ( i=0; i<msg_group->num_msgs; i++ ) {
- SPOOLSS_NOTIFY_MSG *msg = &messages[i];
+ case JOB_NOTIFY_TYPE:
+ if (job_notify_table[msg->field].fn) {
+ job_notify_table[msg->field].fn(msg,
+ ¬ifies[count], mem_ctx);
+ }
+ break;
- /* Are we monitoring this event? */
+ default:
+ DEBUG(5, ("Unknown notification type %d\n",
+ msg->type));
+ continue;
+ }
- if (!is_monitoring_event(p, msg->type, msg->field))
- continue;
+ count++;
+ }
- sending_msg_count++;
+ *_notifies = notifies;
+ *_count = count;
+ return 0;
+}
- DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
- msg->type, msg->field, p->sharename));
+static int send_notify2_printer(TALLOC_CTX *mem_ctx,
+ struct printer_handle *prn_hnd,
+ SPOOLSS_NOTIFY_MSG_GROUP *msg_group)
+{
+ struct spoolss_Notify *notifies;
+ int count = 0;
+ union spoolss_ReplyPrinterInfo info;
+ struct spoolss_NotifyInfo info0;
+ uint32_t reply_result;
+ NTSTATUS status;
+ WERROR werr;
+ int ret;
- /*
- * if the is a printer notification handle and not a job notification
- * type, then set the id to 0. Other wise just use what was specified
- * in the message.
- *
- * When registering change notification on a print server handle
- * we always need to send back the id (snum) matching the printer
- * for which the change took place. For change notify registered
- * on a printer handle, this does not matter and the id should be 0.
- *
- * --jerry
- */
+ /* Is there notification on this handle? */
+ if (prn_hnd->notify.cli_chan == NULL ||
+ prn_hnd->notify.cli_chan->active_connections == 0) {
+ return 0;
+ }
- if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
- id = 0;
- else
- id = msg->id;
+ DEBUG(10, ("Client connected! [\\\\%s\\%s]\n",
+ prn_hnd->servername, prn_hnd->sharename));
+ /* For this printer? Print servers always receive notifications. */
+ if ((prn_hnd->printer_type == SPLHND_PRINTER) &&
+ (!strequal(msg_group->printername, prn_hnd->sharename))) {
+ return 0;
+ }
- /* Convert unix jobid to smb jobid */
+ DEBUG(10,("Our printer\n"));
+
+ /* build the array of change notifications */
+ ret = build_notify2_messages(mem_ctx, prn_hnd,
+ msg_group->msgs,
+ msg_group->num_msgs,
+ ¬ifies, &count);
+ if (ret) {
+ return ret;
+ }
+
+ info0.version = 0x2;
+ info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
+ info0.count = count;
+ info0.notifies = notifies;
+
+ info.info0 = &info0;
+
+ status = rpccli_spoolss_RouterReplyPrinterEx(
+ prn_hnd->notify.cli_chan->cli_pipe,
+ mem_ctx,
+ &prn_hnd->notify.cli_hnd,
+ prn_hnd->notify.change, /* color */
+ prn_hnd->notify.flags,
+ &reply_result,
+ 0, /* reply_type, must be 0 */
+ info, &werr);
+ if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
+ DEBUG(1, ("RouterReplyPrinterEx to client: %s "
+ "failed: %s\n",
+ prn_hnd->notify.cli_chan->cli_pipe->srv_name_slash,
+ win_errstr(werr)));
+ }
+ switch (reply_result) {
+ case 0:
+ break;
+ case PRINTER_NOTIFY_INFO_DISCARDED:
+ case PRINTER_NOTIFY_INFO_DISCARDNOTED:
+ case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
+ break;
+ default:
+ break;
+ }
- if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
- id = sysjob_to_jobid(msg->id);
+ return 0;
+}
- if (id == -1) {
- DEBUG(3, ("no such unix jobid %d\n", msg->id));
- goto done;
- }
- }
+static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
+{
+ struct printer_handle *p;
+ TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
+ SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
+ int ret;
- construct_info_data(¬ifies[count],
- (enum spoolss_NotifyType) msg->type,
- msg->field,
- id);
+ if ( !msg_group ) {
+ DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
+ return;
+ }
- switch(msg->type) {
- case PRINTER_NOTIFY_TYPE:
- if ( printer_notify_table[msg->field].fn )
- printer_notify_table[msg->field].fn(msg, ¬ifies[count], mem_ctx);
- break;
+ if (!msg_group->msgs) {
+ DEBUG(5, ("send_notify2_changes() called with no messages!\n"));
+ return;
+ }
- case JOB_NOTIFY_TYPE:
- if ( job_notify_table[msg->field].fn )
- job_notify_table[msg->field].fn(msg, ¬ifies[count], mem_ctx);
- break;
+ DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
- default:
- DEBUG(5, ("Unknown notification type %d\n", msg->type));
- goto done;
- }
+ /* loop over all printers */
- count++;
- }
-
- if ( sending_msg_count ) {
- NTSTATUS status;
- WERROR werr;
- union spoolss_ReplyPrinterInfo info;
- struct spoolss_NotifyInfo info0;
- uint32_t reply_result;
-
- info0.version = 0x2;
- info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
- info0.count = count;
- info0.notifies = notifies;
-
- info.info0 = &info0;
-
- status = rpccli_spoolss_RouterReplyPrinterEx(back_channel.cli_pipe, mem_ctx,
- &p->notify.client_hnd,
- p->notify.change, /* color */
- p->notify.flags,
- &reply_result,
- 0, /* reply_type, must be 0 */
- info,
- &werr);
- if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
- DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
- back_channel.cli_pipe->srv_name_slash,
- win_errstr(werr)));
- }
- switch (reply_result) {
- case 0:
- break;
- case PRINTER_NOTIFY_INFO_DISCARDED:
- case PRINTER_NOTIFY_INFO_DISCARDNOTED:
- case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
- break;
- default:
- break;
- }
+ for (p = printers_list; p; p = p->next) {
+ ret = send_notify2_printer(mem_ctx, p, msg_group);
+ if (ret) {
+ goto done;
}
}
return true;
}
+void srv_spoolss_cleanup(void)
+{
+ struct printer_session_counter *session_counter;
+
+ for (session_counter = counter_list;
+ session_counter != NULL;
+ session_counter = counter_list) {
+ DLIST_REMOVE(counter_list, session_counter);
+ TALLOC_FREE(session_counter);
+ }
+}
+
/**********************************************************************
callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
over all printers, upgrading ones as necessary
const char *drivername;
int snum;
int n_services = lp_numservices();
- size_t len;
tmp_ctx = talloc_new(NULL);
if (!tmp_ctx) return;
goto done;
}
- len = MIN(data->length,sizeof(drivername)-1);
- drivername = talloc_strndup(tmp_ctx, (const char *)data->data, len);
+ drivername = talloc_strndup(tmp_ctx, (const char *)data->data, data->length);
if (!drivername) {
DEBUG(0, ("do_drv_upgrade_printer: Out of memoery ?!\n"));
goto done;
continue;
}
+ /* ignore [printers] share */
+ if (strequal(lp_const_servicename(snum), "printers")) {
+ continue;
+ }
+
result = winreg_get_printer(tmp_ctx, server_info, msg,
- NULL,
lp_const_servicename(snum),
&pinfo2);
int snum;
/* loop through all printers and update the cache where
- client_connected == true */
- while ( printer )
- {
- if ( (printer->printer_type == SPLHND_PRINTER)
- && printer->notify.client_connected )
- {
+ a client is connected */
+ while (printer) {
+ if ((printer->printer_type == SPLHND_PRINTER) &&
+ ((printer->notify.cli_chan != NULL) &&
+ (printer->notify.cli_chan->active_connections > 0))) {
snum = print_queue_snum(printer->sharename);
- print_queue_status(msg_ctx, snum, NULL, NULL );
+ print_queue_status(msg_ctx, snum, NULL, NULL);
}
printer = printer->next;
if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
{
- SE_PRIV se_printop = SE_PRINT_OPERATOR;
-
if (!lp_ms_add_printer_wizard()) {
close_printer_handle(p, r->out.handle);
ZERO_STRUCTP(r->out.handle);
and not a printer admin, then fail */
if ((p->server_info->utok.uid != sec_initial_uid()) &&
- !user_has_privileges(p->server_info->ptok,
- &se_printop ) &&
+ !security_token_has_privilege(p->server_info->ptok, SEC_PRIV_PRINT_OPERATOR) &&
!token_contains_name_in_list(
uidtoname(p->server_info->utok.uid),
p->server_info->info3->base.domain.string,
if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
p->server_info->ptok, snum) ||
- !print_access_check(get_server_info_system(),
+ !print_access_check(p->server_info,
p->msg_ctx,
snum,
r->in.access_mask)) {
winreg_create_printer(p->mem_ctx,
get_server_info_system(),
p->msg_ctx,
- Printer->servername,
lp_const_servicename(snum));
break;
struct spoolss_DriverInfo8 *info_win2k = NULL;
int version;
WERROR status;
- SE_PRIV se_printop = SE_PRINT_OPERATOR;
/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
and not a printer admin, then fail */
if ( (p->server_info->utok.uid != sec_initial_uid())
- && !user_has_privileges(p->server_info->ptok, &se_printop )
+ && !security_token_has_privilege(p->server_info->ptok, SEC_PRIV_PRINT_OPERATOR)
&& !token_contains_name_in_list(
uidtoname(p->server_info->utok.uid),
p->server_info->info3->base.domain.string,
int version;
bool delete_files;
WERROR status;
- SE_PRIV se_printop = SE_PRINT_OPERATOR;
/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
and not a printer admin, then fail */
if ( (p->server_info->utok.uid != sec_initial_uid())
- && !user_has_privileges(p->server_info->ptok, &se_printop )
+ && !security_token_has_privilege(p->server_info->ptok, SEC_PRIV_PRINT_OPERATOR)
&& !token_contains_name_in_list(
uidtoname(p->server_info->utok.uid),
p->server_info->info3->base.domain.string,
uint32_t localprinter,
enum winreg_Type type,
struct policy_handle *handle,
+ struct notify_back_channel **_chan,
struct sockaddr_storage *client_ss,
struct messaging_context *msg_ctx)
{
WERROR result;
NTSTATUS status;
+ struct notify_back_channel *chan;
+
+ for (chan = back_channels; chan; chan = chan->next) {
+ if (memcmp(&chan->client_address, client_ss,
+ sizeof(struct sockaddr_storage)) == 0) {
+ break;
+ }
+ }
/*
* If it's the first connection, contact the client
* and connect to the IPC$ share anonymously
*/
- if (back_channel.active_channels == 0) {
+ if (!chan) {
fstring unix_printer;
- fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
+ /* the +2 is to strip the leading 2 backslashs */
+ fstrcpy(unix_printer, printer + 2);
- if ( !spoolss_connect_to_client( &back_channel.cli_pipe, client_ss, unix_printer ))
+ chan = talloc_zero(back_channels, struct notify_back_channel);
+ if (!chan) {
return false;
+ }
+ chan->client_address = *client_ss;
+
+ if (!spoolss_connect_to_client(&chan->cli_pipe, client_ss, unix_printer)) {
+ TALLOC_FREE(chan);
+ return false;
+ }
+
+ DLIST_ADD(back_channels, chan);
messaging_register(msg_ctx, NULL, MSG_PRINTER_NOTIFY2,
receive_notify2_message_list);
* by registering our PID.
*/
- if (!print_notify_register_pid(snum))
- DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
-
- back_channel.active_channels++;
+ if (!print_notify_register_pid(snum)) {
+ DEBUG(0, ("Failed to register our pid for printer %s\n",
+ printer));
+ }
- status = rpccli_spoolss_ReplyOpenPrinter(back_channel.cli_pipe, talloc_tos(),
+ status = rpccli_spoolss_ReplyOpenPrinter(chan->cli_pipe, talloc_tos(),
printer,
localprinter,
type,
NULL,
handle,
&result);
- if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
- DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
- win_errstr(result)));
+ if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
+ DEBUG(5, ("Client RPC returned [%s]\n", win_errstr(result)));
+ }
+
+ chan->active_connections++;
+ *_chan = chan;
return (W_ERROR_IS_OK(result));
}
if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
Printer->notify.printerlocal, REG_SZ,
- &Printer->notify.client_hnd,
- &client_ss, p->msg_ctx))
+ &Printer->notify.cli_hnd,
+ &Printer->notify.cli_chan,
+ &client_ss, p->msg_ctx)) {
return WERR_SERVER_UNAVAILABLE;
-
- Printer->notify.client_connected = true;
+ }
return WERR_OK;
}
result = winreg_get_printer(mem_ctx,
get_server_info_system(),
p->msg_ctx,
- Printer->servername,
lp_servicename(snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
result = winreg_get_printer(mem_ctx,
get_server_info_system(),
p->msg_ctx,
- Printer->servername,
lp_servicename(snum), &pinfo2);
if (!W_ERROR_IS_OK(result)) {
return WERR_BADFID;
Printer->notify.fnpcn = true;
- if (Printer->notify.client_connected) {
+ if (Printer->notify.cli_chan != NULL &&
+ Printer->notify.cli_chan->active_connections > 0) {
DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
"Saving change value in request [%x]\n",
r->in.change_low));
return result;
}
+/********************************************************************
+ ********************************************************************/
+
+static WERROR create_printername(TALLOC_CTX *mem_ctx,
+ const char *servername,
+ const char *printername,
+ const char **printername_p)
+{
+ /* FIXME: add lp_force_printername() */
+
+ if (servername == NULL) {
+ *printername_p = talloc_strdup(mem_ctx, printername);
+ W_ERROR_HAVE_NO_MEMORY(*printername_p);
+ return WERR_OK;
+ }
+
+ if (servername[0] == '\\' && servername[1] == '\\') {
+ servername += 2;
+ }
+
+ *printername_p = talloc_asprintf(mem_ctx, "\\\\%s\\%s", servername, printername);
+ W_ERROR_HAVE_NO_MEMORY(*printername_p);
+
+ return WERR_OK;
+}
+
+/********************************************************************
+ ********************************************************************/
+
+static void compose_devicemode_devicename(struct spoolss_DeviceMode *dm,
+ const char *printername)
+{
+ if (dm == NULL) {
+ return;
+ }
+
+ dm->devicename = talloc_strndup(dm, printername,
+ MIN(strlen(printername), 31));
+}
+
/********************************************************************
* construct_printer_info_0
* fill a printer_info_0 struct
const struct auth_serversupplied_info *server_info,
struct messaging_context *msg_ctx,
struct spoolss_PrinterInfo2 *info2,
+ const char *servername,
struct spoolss_PrinterInfo0 *r,
int snum)
{
struct printer_session_counter *session_counter;
struct timeval setuptime;
print_status_struct status;
+ WERROR result;
- r->printername = talloc_strdup(mem_ctx, info2->printername);
- W_ERROR_HAVE_NO_MEMORY(r->printername);
+ result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
- r->servername = talloc_strdup(mem_ctx, info2->servername);
- W_ERROR_HAVE_NO_MEMORY(r->servername);
+ if (servername) {
+ r->servername = talloc_strdup(mem_ctx, servername);
+ W_ERROR_HAVE_NO_MEMORY(r->servername);
+ } else {
+ r->servername = NULL;
+ }
count = print_queue_length(msg_ctx, snum, &status);
static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
const struct spoolss_PrinterInfo2 *info2,
uint32_t flags,
+ const char *servername,
struct spoolss_PrinterInfo1 *r,
int snum)
{
- r->flags = flags;
+ WERROR result;
- r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
- info2->printername,
- info2->drivername,
- info2->location);
- W_ERROR_HAVE_NO_MEMORY(r->description);
+ r->flags = flags;
if (info2->comment == NULL || info2->comment[0] == '\0') {
r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
}
W_ERROR_HAVE_NO_MEMORY(r->comment);
- r->name = talloc_strdup(mem_ctx, info2->printername);
- W_ERROR_HAVE_NO_MEMORY(r->name);
+ result = create_printername(mem_ctx, servername, info2->printername, &r->name);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
+ r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
+ r->name,
+ info2->drivername,
+ r->comment);
+ W_ERROR_HAVE_NO_MEMORY(r->description);
return WERR_OK;
}
static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
struct messaging_context *msg_ctx,
const struct spoolss_PrinterInfo2 *info2,
+ const char *servername,
struct spoolss_PrinterInfo2 *r,
int snum)
{
int count;
print_status_struct status;
+ WERROR result;
count = print_queue_length(msg_ctx, snum, &status);
- r->servername = talloc_strdup(mem_ctx, info2->servername);
- W_ERROR_HAVE_NO_MEMORY(r->servername);
- r->printername = talloc_strdup(mem_ctx, info2->printername);
- W_ERROR_HAVE_NO_MEMORY(r->printername);
+ if (servername) {
+ r->servername = talloc_strdup(mem_ctx, servername);
+ W_ERROR_HAVE_NO_MEMORY(r->servername);
+ } else {
+ r->servername = NULL;
+ }
+
+ result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
W_ERROR_HAVE_NO_MEMORY(r->sharename);
r->portname = talloc_strdup(mem_ctx, info2->portname);
DEBUG(8,("Returning NULL Devicemode!\n"));
}
+ compose_devicemode_devicename(r->devmode, r->printername);
+
r->secdesc = NULL;
if (info2->secdesc != NULL) {
static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
const struct spoolss_PrinterInfo2 *info2,
+ const char *servername,
struct spoolss_PrinterInfo3 *r,
int snum)
{
static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
const struct spoolss_PrinterInfo2 *info2,
+ const char *servername,
struct spoolss_PrinterInfo4 *r,
int snum)
{
- r->printername = talloc_strdup(mem_ctx, info2->printername);
- W_ERROR_HAVE_NO_MEMORY(r->printername);
- r->servername = talloc_strdup(mem_ctx, info2->servername);
- W_ERROR_HAVE_NO_MEMORY(r->servername);
+ WERROR result;
+
+ result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
+ if (servername) {
+ r->servername = talloc_strdup(mem_ctx, servername);
+ W_ERROR_HAVE_NO_MEMORY(r->servername);
+ } else {
+ r->servername = NULL;
+ }
r->attributes = info2->attributes;
static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
const struct spoolss_PrinterInfo2 *info2,
+ const char *servername,
struct spoolss_PrinterInfo5 *r,
int snum)
{
- r->printername = talloc_strdup(mem_ctx, info2->printername);
- W_ERROR_HAVE_NO_MEMORY(r->printername);
+ WERROR result;
+
+ result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
r->portname = talloc_strdup(mem_ctx, info2->portname);
W_ERROR_HAVE_NO_MEMORY(r->portname);
static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
struct messaging_context *msg_ctx,
const struct spoolss_PrinterInfo2 *info2,
+ const char *servername,
struct spoolss_PrinterInfo6 *r,
int snum)
{
static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
struct messaging_context *msg_ctx,
- struct printer_handle *print_hnd,
+ const char *servername,
struct spoolss_PrinterInfo7 *r,
int snum)
{
}
if (is_printer_published(mem_ctx, server_info, msg_ctx,
- print_hnd->servername,
+ servername,
lp_servicename(snum), &guid, NULL)) {
r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
r->action = DSPRINT_PUBLISH;
static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
const struct spoolss_PrinterInfo2 *info2,
+ const char *servername,
struct spoolss_DeviceModeInfo *r,
int snum)
{
+ WERROR result;
+ const char *printername;
+
+ result = create_printername(mem_ctx, servername, info2->printername, &printername);
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
copy_devicemode(mem_ctx, info2->devmode, &r->devmode);
if (!r->devmode) {
DEBUG(8,("Returning NULL Devicemode!\n"));
}
+ compose_devicemode_devicename(r->devmode, printername);
+
return WERR_OK;
}
static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
const struct auth_serversupplied_info *server_info,
struct messaging_context *msg_ctx,
+ const char *servername,
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, msg_ctx,
- NULL, printer, &info2);
+ printer, &info2);
if (!W_ERROR_IS_OK(result)) {
goto out;
}
case 0:
result = construct_printer_info0(info, server_info,
msg_ctx, info2,
+ servername,
&info[count].info0, snum);
break;
case 1:
result = construct_printer_info1(info, info2, flags,
+ servername,
&info[count].info1, snum);
break;
case 2:
result = construct_printer_info2(info, msg_ctx, info2,
+ servername,
&info[count].info2, snum);
break;
case 4:
result = construct_printer_info4(info, info2,
+ servername,
&info[count].info4, snum);
break;
case 5:
result = construct_printer_info5(info, info2,
+ servername,
&info[count].info5, snum);
break;
DEBUG(4,("enum_all_printers_info_0\n"));
return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
- 0, flags, info, count);
+ servername, 0, flags, info, count);
}
static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
const struct auth_serversupplied_info *server_info,
struct messaging_context *msg_ctx,
+ const char *servername,
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, msg_ctx,
- 1, flags, info, count);
+ servername, 1, flags, info, count);
}
/********************************************************************
static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
const struct auth_serversupplied_info *server_info,
struct messaging_context *msg_ctx,
+ const char *servername,
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, msg_ctx,
- PRINTER_ENUM_ICON8, info, count);
+ servername, PRINTER_ENUM_ICON8, info, count);
}
/********************************************************************
static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
const struct auth_serversupplied_info *server_info,
struct messaging_context *msg_ctx,
- const char *name,
+ const char *servername,
union spoolss_PrinterInfo **info,
uint32_t *count)
{
- const char *s = name;
+ const char *s = servername;
DEBUG(4,("enum_all_printers_info_1_name\n"));
- if ((name[0] == '\\') && (name[1] == '\\')) {
- s = name + 2;
+ if ((servername[0] == '\\') && (servername[1] == '\\')) {
+ s = servername + 2;
}
if (!is_myname_or_ipaddr(s)) {
}
return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
- PRINTER_ENUM_ICON8, info, count);
+ servername, PRINTER_ENUM_ICON8, info, count);
}
/********************************************************************
static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
const struct auth_serversupplied_info *server_info,
struct messaging_context *msg_ctx,
- const char *name,
+ const char *servername,
union spoolss_PrinterInfo **info,
uint32_t *count)
{
- const char *s = name;
+ const char *s = servername;
DEBUG(4,("enum_all_printers_info_1_network\n"));
listed. Windows responds to this call with a
WERR_CAN_NOT_COMPLETE so we should do the same. */
- if (name[0] == '\\' && name[1] == '\\') {
- s = name + 2;
+ if (servername[0] == '\\' && servername[1] == '\\') {
+ s = servername + 2;
}
if (is_myname_or_ipaddr(s)) {
}
return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
- PRINTER_ENUM_NAME, info, count);
+ servername, PRINTER_ENUM_NAME, info, count);
}
/********************************************************************
static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
const struct auth_serversupplied_info *server_info,
struct messaging_context *msg_ctx,
+ const char *servername,
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, msg_ctx,
- 2, 0, info, count);
+ servername, 2, 0, info, count);
}
/********************************************************************
const struct auth_serversupplied_info *server_info,
struct messaging_context *msg_ctx,
uint32_t flags,
- const char *name,
+ const char *servername,
union spoolss_PrinterInfo **info,
uint32_t *count)
{
if (flags & PRINTER_ENUM_LOCAL) {
return enum_all_printers_info_1_local(mem_ctx, server_info,
- msg_ctx, info, count);
+ msg_ctx, servername, info, count);
}
if (flags & PRINTER_ENUM_NAME) {
return enum_all_printers_info_1_name(mem_ctx, server_info,
- msg_ctx, name, info,
+ msg_ctx, servername, info,
count);
}
if (flags & PRINTER_ENUM_NETWORK) {
return enum_all_printers_info_1_network(mem_ctx, server_info,
- msg_ctx, name, info,
+ msg_ctx, servername, info,
count);
}
uint32_t *count)
{
if (flags & PRINTER_ENUM_LOCAL) {
+
return enum_all_printers_info_2(mem_ctx, server_info, msg_ctx,
+ servername,
info, count);
}
if (flags & PRINTER_ENUM_NAME) {
- if (!is_myname_or_ipaddr(canon_servername(servername))) {
+ if (servername && !is_myname_or_ipaddr(canon_servername(servername))) {
return WERR_INVALID_NAME;
}
return enum_all_printers_info_2(mem_ctx, server_info, msg_ctx,
+ servername,
info, count);
}
DEBUG(4,("enum_all_printers_info_4\n"));
return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
- 4, flags, info, count);
+ servername, 4, flags, info, count);
}
DEBUG(4,("enum_all_printers_info_5\n"));
return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
- 5, flags, info, count);
+ servername, 5, flags, info, count);
}
/****************************************************************
struct spoolss_EnumPrinters *r)
{
const struct auth_serversupplied_info *server_info = get_server_info_system();
- const char *name = NULL;
WERROR result;
/* that's an [in out] buffer */
* Level 5: same as Level 2
*/
- if (r->in.server) {
- name = talloc_strdup_upper(p->mem_ctx, r->in.server);
- W_ERROR_HAVE_NO_MEMORY(name);
+ if (r->in.server && r->in.server[0] == '\0') {
+ r->in.server = NULL;
}
switch (r->in.level) {
case 0:
result = enumprinters_level0(p->mem_ctx, server_info,
- p->msg_ctx, r->in.flags, name,
+ p->msg_ctx, r->in.flags,
+ r->in.server,
r->out.info, r->out.count);
break;
case 1:
result = enumprinters_level1(p->mem_ctx, server_info,
- p->msg_ctx, r->in.flags, name,
+ p->msg_ctx, r->in.flags,
+ r->in.server,
r->out.info, r->out.count);
break;
case 2:
result = enumprinters_level2(p->mem_ctx, server_info,
- p->msg_ctx, r->in.flags, name,
+ p->msg_ctx, r->in.flags,
+ r->in.server,
r->out.info, r->out.count);
break;
case 4:
result = enumprinters_level4(p->mem_ctx, server_info,
- p->msg_ctx, r->in.flags, name,
+ p->msg_ctx, r->in.flags,
+ r->in.server,
r->out.info, r->out.count);
break;
case 5:
result = enumprinters_level5(p->mem_ctx, server_info,
- p->msg_ctx, r->in.flags, name,
+ p->msg_ctx, r->in.flags,
+ r->in.server,
r->out.info, r->out.count);
break;
default:
struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
struct spoolss_PrinterInfo2 *info2 = NULL;
WERROR result = WERR_OK;
- const char *servername = NULL;
int snum;
/* that's an [in out] buffer */
*r->out.needed = 0;
- if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
+ if (Printer == NULL) {
return WERR_BADFID;
}
- if (Printer != NULL || Printer->servername != NULL) {
- servername = Printer->servername;
+ if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
+ return WERR_BADFID;
}
result = winreg_get_printer(p->mem_ctx,
get_server_info_system(),
p->msg_ctx,
- servername,
lp_const_servicename(snum),
&info2);
if (!W_ERROR_IS_OK(result)) {
- return result;
+ goto out;
}
switch (r->in.level) {
get_server_info_system(),
p->msg_ctx,
info2,
+ Printer->servername,
&r->out.info->info0,
snum);
break;
case 1:
result = construct_printer_info1(p->mem_ctx, info2,
PRINTER_ENUM_ICON8,
+ Printer->servername,
&r->out.info->info1, snum);
break;
case 2:
result = construct_printer_info2(p->mem_ctx, p->msg_ctx, info2,
+ Printer->servername,
&r->out.info->info2, snum);
break;
case 3:
result = construct_printer_info3(p->mem_ctx, info2,
+ Printer->servername,
&r->out.info->info3, snum);
break;
case 4:
result = construct_printer_info4(p->mem_ctx, info2,
+ Printer->servername,
&r->out.info->info4, snum);
break;
case 5:
result = construct_printer_info5(p->mem_ctx, info2,
+ Printer->servername,
&r->out.info->info5, snum);
break;
case 6:
result = construct_printer_info6(p->mem_ctx, p->msg_ctx, info2,
+ Printer->servername,
&r->out.info->info6, snum);
break;
case 7:
result = construct_printer_info7(p->mem_ctx, p->msg_ctx,
- Printer,
+ Printer->servername,
&r->out.info->info7, snum);
break;
case 8:
result = construct_printer_info8(p->mem_ctx, info2,
+ Printer->servername,
&r->out.info->info8, snum);
break;
default:
break;
}
+ out:
if (!W_ERROR_IS_OK(result)) {
DEBUG(0, ("_spoolss_GetPrinter: failed to construct printer info level %d - %s\n",
r->in.level, win_errstr(result)));
struct spoolss_DriverInfo8 *driver;
WERROR result;
+ if (level == 101) {
+ return WERR_UNKNOWN_LEVEL;
+ }
+
result = winreg_get_printer(mem_ctx,
server_info,
msg_ctx,
- servername,
lp_const_servicename(snum),
&pinfo2);
return WERR_BADFID;
}
- werr = print_job_start(get_server_info_system(),
+ werr = print_job_start(p->server_info,
p->msg_ctx,
p->client_id->name,
snum,
static WERROR control_printer(struct policy_handle *handle, uint32_t command,
struct pipes_struct *p)
{
- const struct auth_serversupplied_info *server_info = get_server_info_system();
+ const struct auth_serversupplied_info *server_info = p->server_info;
int snum;
WERROR errcode = WERR_BADFUNC;
struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
return WERR_SPL_NO_STARTDOC;
}
- errcode = print_job_delete(get_server_info_system(),
+ errcode = print_job_delete(p->server_info,
p->msg_ctx,
snum,
Printer->jobid);
/****************************************************************************
****************************************************************************/
-static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
+static WERROR add_port_hook(TALLOC_CTX *ctx, struct security_token *token, const char *portname, const char *uri)
{
char *cmd = lp_addport_cmd();
char *command = NULL;
int ret;
- SE_PRIV se_printop = SE_PRINT_OPERATOR;
bool is_print_op = false;
if ( !*cmd ) {
}
if ( token )
- is_print_op = user_has_privileges( token, &se_printop );
+ is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
DEBUG(10,("Running [%s]\n", command));
/****************************************************************************
****************************************************************************/
-static bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
+static bool add_printer_hook(TALLOC_CTX *ctx, struct security_token *token,
struct spoolss_SetPrinterInfo2 *info2,
const char *remote_machine,
struct messaging_context *msg_ctx)
int numlines;
int ret;
int fd;
- SE_PRIV se_printop = SE_PRINT_OPERATOR;
bool is_print_op = false;
if (!remote_machine) {
}
if ( token )
- is_print_op = user_has_privileges( token, &se_printop );
+ is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
DEBUG(10,("Running [%s]\n", command));
printer->drivername));
notify_printer_driver(server_event_context(), msg_ctx,
- snum, printer->drivername);
+ snum, printer->drivername ?
+ printer->drivername : "");
}
}
if (!force_update) {
notify_printer_comment(server_event_context(), msg_ctx,
- snum, printer->comment);
+ snum, printer->comment ?
+ printer->comment : "");
}
}
if (!force_update) {
notify_printer_sharename(server_event_context(),
msg_ctx,
- snum, printer->sharename);
+ snum, printer->sharename ?
+ printer->sharename : "");
}
}
if (!force_update) {
notify_printer_printername(server_event_context(),
- msg_ctx, snum, p);
+ msg_ctx, snum, p ? p : "");
}
}
if (!force_update) {
notify_printer_port(server_event_context(),
- msg_ctx, snum, printer->portname);
+ msg_ctx, snum, printer->portname ?
+ printer->portname : "");
}
}
if (!force_update) {
notify_printer_location(server_event_context(),
msg_ctx, snum,
- printer->location);
+ printer->location ?
+ printer->location : "");
}
}
buffer.length);
if (!force_update) {
- notify_printer_location(server_event_context(),
- msg_ctx, snum,
- printer->location);
+ notify_printer_sepfile(server_event_context(),
+ msg_ctx, snum,
+ printer->sepfile ?
+ printer->sepfile : "");
}
}
struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
struct spoolss_PrinterInfo2 *old_printer;
struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
- const char *servername = NULL;
int snum;
WERROR result = WERR_OK;
TALLOC_CTX *tmp_ctx;
goto done;
}
- if (Printer != NULL || Printer->servername != NULL) {
- servername = Printer->servername;
- }
-
result = winreg_get_printer(tmp_ctx,
get_server_info_system(),
p->msg_ctx,
- servername,
lp_const_servicename(snum),
&old_printer);
if (!W_ERROR_IS_OK(result)) {
result = winreg_get_printer(p->mem_ctx,
get_server_info_system(),
p->msg_ctx,
- Printer->servername,
lp_servicename(snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
return WERR_BADFID;
}
- if (Printer->notify.client_connected == true) {
+ if (Printer->notify.cli_chan != NULL &&
+ Printer->notify.cli_chan->active_connections > 0) {
int snum = -1;
- if ( Printer->printer_type == SPLHND_SERVER)
- snum = -1;
- else if ( (Printer->printer_type == SPLHND_PRINTER) &&
- !get_printer_snum(p, r->in.handle, &snum, NULL) )
- return WERR_BADFID;
+ if (Printer->printer_type == SPLHND_PRINTER) {
+ if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
+ return WERR_BADFID;
+ }
+ }
- srv_spoolss_replycloseprinter(
- snum, &Printer->notify.client_hnd, p->msg_ctx);
+ srv_spoolss_replycloseprinter(snum, Printer);
}
Printer->notify.flags=0;
Printer->notify.localmachine[0]='\0';
Printer->notify.printerlocal=0;
TALLOC_FREE(Printer->notify.option);
- Printer->notify.client_connected = false;
return WERR_OK;
}
result = winreg_get_printer(p->mem_ctx,
get_server_info_system(),
p->msg_ctx,
- NULL,
lp_const_servicename(snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
WERROR _spoolss_SetJob(struct pipes_struct *p,
struct spoolss_SetJob *r)
{
- const struct auth_serversupplied_info *server_info = get_server_info_system();
+ const struct auth_serversupplied_info *server_info = p->server_info;
int snum;
WERROR errcode = WERR_BADFUNC;
}
/* you must be a printer admin to add a new printer */
- if (!print_access_check(get_server_info_system(),
+ if (!print_access_check(p->server_info,
p->msg_ctx,
snum,
PRINTER_ACCESS_ADMINISTER)) {
struct spoolss_AddFormInfo1 *form = r->in.info.info1;
int snum = -1;
WERROR status = WERR_OK;
- SE_PRIV se_printop = SE_PRINT_OPERATOR;
struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
and not a printer admin, then fail */
if ((p->server_info->utok.uid != sec_initial_uid()) &&
- !user_has_privileges(p->server_info->ptok, &se_printop) &&
- !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
+ !security_token_has_privilege(p->server_info->ptok, SEC_PRIV_PRINT_OPERATOR) &&
+ !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
p->server_info->info3->base.domain.string,
NULL,
p->server_info->ptok,
struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
int snum = -1;
WERROR status = WERR_OK;
- SE_PRIV se_printop = SE_PRINT_OPERATOR;
DEBUG(5,("_spoolss_DeleteForm\n"));
}
if ((p->server_info->utok.uid != sec_initial_uid()) &&
- !user_has_privileges(p->server_info->ptok, &se_printop) &&
- !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
+ !security_token_has_privilege(p->server_info->ptok, SEC_PRIV_PRINT_OPERATOR) &&
+ !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
p->server_info->info3->base.domain.string,
NULL,
p->server_info->ptok,
const char *form_name = r->in.form_name;
int snum = -1;
WERROR status = WERR_OK;
- SE_PRIV se_printop = SE_PRINT_OPERATOR;
struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
and not a printer admin, then fail */
if ((p->server_info->utok.uid != sec_initial_uid()) &&
- !user_has_privileges(p->server_info->ptok, &se_printop) &&
+ !security_token_has_privilege(p->server_info->ptok, SEC_PRIV_PRINT_OPERATOR) &&
!token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
p->server_info->info3->base.domain.string,
NULL,
*r->out.needed = 0;
*r->out.info = NULL;
+ if (!get_short_archi(r->in.environment)) {
+ return WERR_INVALID_ENVIRONMENT;
+ }
+
switch (r->in.level) {
case 1:
result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
*r->out.needed = 0;
*r->out.info = NULL;
+ if (r->in.print_processor_name == NULL ||
+ !strequal(r->in.print_processor_name, "winprint")) {
+ return WERR_UNKNOWN_PRINTPROCESSOR;
+ }
+
switch (r->in.level) {
case 1:
result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
result = winreg_get_printer(p->mem_ctx,
get_server_info_system(),
p->msg_ctx,
- NULL,
lp_const_servicename(snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
result = winreg_get_printer(Printer,
get_server_info_system(),
p->msg_ctx,
- Printer->servername,
lp_servicename(snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
struct spoolss_GetPrintProcessorDirectory *r)
{
WERROR result;
+ fstring prnproc_share;
+ bool prnproc_share_exists = false;
+ int snum;
/* that's an [in out] buffer */
/* We always should reply with a local print processor directory so that
* users are not forced to have a [prnproc$] share on the Samba spoolss
- * server - Guenther */
+ * server, if users decide to do so, lets announce it though - Guenther */
+
+ fstrcpy(prnproc_share, "prnproc$");
+
+ snum = find_service(prnproc_share);
+ if (snum != -1) {
+ prnproc_share_exists = true;
+ }
result = getprintprocessordirectory_level_1(p->mem_ctx,
- NULL, /* r->in.server */
+ prnproc_share_exists ? r->in.server : NULL,
r->in.environment,
&r->out.info->info1);
if (!W_ERROR_IS_OK(result)) {
*******************************************************************/
static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
- NT_USER_TOKEN *token, DATA_BLOB *in,
+ struct security_token *token, DATA_BLOB *in,
DATA_BLOB *out, uint32_t *needed)
{
const char *dllname = "tcpmonui.dll";
*******************************************************************/
static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
- NT_USER_TOKEN *token, DATA_BLOB *in,
+ struct security_token *token, DATA_BLOB *in,
DATA_BLOB *out, uint32_t *needed)
{
struct spoolss_PortData1 port1;
};
static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
- NT_USER_TOKEN *token, const char *command,
+ struct security_token *token, const char *command,
DATA_BLOB *inbuf,
DATA_BLOB *outbuf,
uint32_t *needed )
#if 0 /* don't support management using the "Local Port" monitor */
static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
- NT_USER_TOKEN *token, DATA_BLOB *in,
+ struct security_token *token, DATA_BLOB *in,
DATA_BLOB *out, uint32_t *needed)
{
const char *dllname = "localui.dll";
*******************************************************************/
static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
- NT_USER_TOKEN *token, const char *command,
+ struct security_token *token, const char *command,
DATA_BLOB *inbuf, DATA_BLOB *outbuf,
uint32_t *needed)
{
}
/****************************************************************
- _spoolss_47
+ _spoolss_SetPort
****************************************************************/
-WERROR _spoolss_47(struct pipes_struct *p,
- struct spoolss_47 *r)
+WERROR _spoolss_SetPort(struct pipes_struct *p,
+ struct spoolss_SetPort *r)
{
p->rng_fault_state = true;
return WERR_NOT_SUPPORTED;
git.samba.org / mat / samba.git / blobdiff