2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-2000,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6 * Copyright (C) Jean François Micouleau 1998-2000,
7 * Copyright (C) Jeremy Allison 2001-2002,
8 * Copyright (C) Gerald Carter 2000-2004,
9 * Copyright (C) Tim Potter 2001-2002.
10 * Copyright (C) Guenther Deschner 2009-2010.
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 3 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <http://www.gnu.org/licenses/>.
26 /* Since the SPOOLSS rpc routines are basically DOS 16-bit calls wrapped
27 up, all the errors returned are DOS errors, not NT status codes. */
30 #include "../librpc/gen_ndr/srv_spoolss.h"
31 #include "../librpc/gen_ndr/cli_spoolss.h"
33 /* macros stolen from s4 spoolss server */
34 #define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
35 ((info)?ndr_size_##fn(info, level, ic, 0):0)
37 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,ic,info,level,count) \
38 ((info)?ndr_size_##fn##_info(mem_ctx, ic, level, count, info):0)
40 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,ic,info,count) \
41 ((info)?ndr_size_##fn##_info(mem_ctx, ic, count, info):0)
43 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
46 extern userdom_struct current_user_info;
49 #define DBGC_CLASS DBGC_RPC_SRV
51 #ifndef MAX_OPEN_PRINTER_EXS
52 #define MAX_OPEN_PRINTER_EXS 50
55 #define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
56 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
58 static Printer_entry *printers_list;
60 typedef struct _counter_printer_0 {
61 struct _counter_printer_0 *next;
62 struct _counter_printer_0 *prev;
68 static counter_printer_0 *counter_list;
70 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
71 static uint32_t smb_connections = 0;
74 /* in printing/nt_printing.c */
76 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
78 /* API table for Xcv Monitor functions */
80 struct xcv_api_table {
82 WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
85 /********************************************************************
86 * Canonicalize servername.
87 ********************************************************************/
89 static const char *canon_servername(const char *servername)
91 const char *pservername = servername;
92 while (*pservername == '\\') {
98 /* translate between internal status numbers and NT status numbers */
99 static int nt_printj_status(int v)
105 return JOB_STATUS_PAUSED;
107 return JOB_STATUS_SPOOLING;
109 return JOB_STATUS_PRINTING;
111 return JOB_STATUS_ERROR;
113 return JOB_STATUS_DELETING;
115 return JOB_STATUS_OFFLINE;
117 return JOB_STATUS_PAPEROUT;
119 return JOB_STATUS_PRINTED;
121 return JOB_STATUS_DELETED;
123 return JOB_STATUS_BLOCKED_DEVQ;
124 case LPQ_USER_INTERVENTION:
125 return JOB_STATUS_USER_INTERVENTION;
130 static int nt_printq_status(int v)
134 return PRINTER_STATUS_PAUSED;
143 /***************************************************************************
144 Disconnect from the client
145 ****************************************************************************/
147 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
153 * Tell the specific printing tdb we no longer want messages for this printer
154 * by deregistering our PID.
157 if (!print_notify_deregister_pid(snum))
158 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
160 /* weird if the test succeds !!! */
161 if (smb_connections==0) {
162 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
166 status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
169 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
170 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
171 win_errstr(result)));
173 /* if it's the last connection, deconnect the IPC$ share */
174 if (smb_connections==1) {
176 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
177 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
179 messaging_deregister(smbd_messaging_context(),
180 MSG_PRINTER_NOTIFY2, NULL);
182 /* Tell the connections db we're no longer interested in
183 * printer notify messages. */
185 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
191 /****************************************************************************
192 Functions to free a printer entry datastruct.
193 ****************************************************************************/
195 static int printer_entry_destructor(Printer_entry *Printer)
197 if (Printer->notify.client_connected == true) {
200 if ( Printer->printer_type == SPLHND_SERVER) {
202 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
203 } else if (Printer->printer_type == SPLHND_PRINTER) {
204 snum = print_queue_snum(Printer->sharename);
206 srv_spoolss_replycloseprinter(snum,
207 &Printer->notify.client_hnd);
211 Printer->notify.flags=0;
212 Printer->notify.options=0;
213 Printer->notify.localmachine[0]='\0';
214 Printer->notify.printerlocal=0;
215 TALLOC_FREE(Printer->notify.option);
216 Printer->notify.client_connected = false;
218 free_nt_devicemode( &Printer->nt_devmode );
219 free_a_printer( &Printer->printer_info, 2 );
221 /* Remove from the internal list. */
222 DLIST_REMOVE(printers_list, Printer);
226 /****************************************************************************
227 find printer index by handle
228 ****************************************************************************/
230 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
231 struct policy_handle *hnd)
233 Printer_entry *find_printer = NULL;
235 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
236 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
243 /****************************************************************************
244 Close printer index by handle.
245 ****************************************************************************/
247 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
249 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
252 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
257 close_policy_hnd(p, hnd);
262 /****************************************************************************
263 Delete a printer given a handle.
264 ****************************************************************************/
266 static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename)
268 char *cmd = lp_deleteprinter_cmd();
269 char *command = NULL;
271 SE_PRIV se_printop = SE_PRINT_OPERATOR;
272 bool is_print_op = false;
274 /* can't fail if we don't try */
279 command = talloc_asprintf(ctx,
286 is_print_op = user_has_privileges( token, &se_printop );
288 DEBUG(10,("Running [%s]\n", command));
290 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
295 if ( (ret = smbrun(command, NULL)) == 0 ) {
296 /* Tell everyone we updated smb.conf. */
297 message_send_all(smbd_messaging_context(),
298 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
304 /********** END SePrintOperatorPrivlege BLOCK **********/
306 DEBUGADD(10,("returned [%d]\n", ret));
308 TALLOC_FREE(command);
311 return WERR_BADFID; /* What to return here? */
313 /* go ahead and re-read the services immediately */
315 reload_services(false);
318 if ( lp_servicenumber( sharename ) > 0 )
319 return WERR_ACCESS_DENIED;
324 /****************************************************************************
325 Delete a printer given a handle.
326 ****************************************************************************/
328 static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
330 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
333 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
339 * It turns out that Windows allows delete printer on a handle
340 * opened by an admin user, then used on a pipe handle created
341 * by an anonymous user..... but they're working on security.... riiight !
345 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
346 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
347 return WERR_ACCESS_DENIED;
350 /* this does not need a become root since the access check has been
351 done on the handle already */
353 if (del_a_printer( Printer->sharename ) != 0) {
354 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
358 return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
359 Printer->sharename );
362 /****************************************************************************
363 Return the snum of a printer corresponding to an handle.
364 ****************************************************************************/
366 static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
367 int *number, struct share_params **params)
369 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
372 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
377 switch (Printer->printer_type) {
379 DEBUG(4,("short name:%s\n", Printer->sharename));
380 *number = print_queue_snum(Printer->sharename);
381 return (*number != -1);
389 /****************************************************************************
390 Set printer handle type.
391 Check if it's \\server or \\server\printer
392 ****************************************************************************/
394 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
396 DEBUG(3,("Setting printer type=%s\n", handlename));
398 if ( strlen(handlename) < 3 ) {
399 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
403 /* it's a print server */
404 if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
405 DEBUGADD(4,("Printer is a print server\n"));
406 Printer->printer_type = SPLHND_SERVER;
408 /* it's a printer (set_printer_hnd_name() will handle port monitors */
410 DEBUGADD(4,("Printer is a printer\n"));
411 Printer->printer_type = SPLHND_PRINTER;
417 /****************************************************************************
418 Set printer handle name.. Accept names like \\server, \\server\printer,
419 \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port" See
420 the MSDN docs regarding OpenPrinter() for details on the XcvData() and
421 XcvDataPort() interface.
422 ****************************************************************************/
424 static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
427 int n_services=lp_numservices();
428 char *aprinter, *printername;
429 const char *servername;
432 NT_PRINTER_INFO_LEVEL *printer = NULL;
435 DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
436 (unsigned long)strlen(handlename)));
438 aprinter = CONST_DISCARD(char *, handlename);
439 if ( *handlename == '\\' ) {
440 servername = canon_servername(handlename);
441 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
446 servername = global_myname();
449 /* save the servername to fill in replies on this handle */
451 if ( !is_myname_or_ipaddr( servername ) )
454 fstrcpy( Printer->servername, servername );
456 if ( Printer->printer_type == SPLHND_SERVER )
459 if ( Printer->printer_type != SPLHND_PRINTER )
462 DEBUGADD(5, ("searching for [%s]\n", aprinter ));
464 /* check for the Port Monitor Interface */
466 if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
467 Printer->printer_type = SPLHND_PORTMON_TCP;
468 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
471 else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
472 Printer->printer_type = SPLHND_PORTMON_LOCAL;
473 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
477 /* Search all sharenames first as this is easier than pulling
478 the printer_info_2 off of disk. Don't use find_service() since
479 that calls out to map_username() */
481 /* do another loop to look for printernames */
483 for (snum=0; !found && snum<n_services; snum++) {
485 /* no point going on if this is not a printer */
487 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
490 fstrcpy(sname, lp_servicename(snum));
491 if ( strequal( aprinter, sname ) ) {
496 /* no point looking up the printer object if
497 we aren't allowing printername != sharename */
499 if ( lp_force_printername(snum) )
502 fstrcpy(sname, lp_servicename(snum));
506 /* This call doesn't fill in the location or comment from
507 * a CUPS server for efficiency with large numbers of printers.
511 result = get_a_printer_search( NULL, &printer, 2, sname );
512 if ( !W_ERROR_IS_OK(result) ) {
513 DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
514 sname, win_errstr(result)));
518 /* printername is always returned as \\server\printername */
519 if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
520 DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
521 printer->info_2->printername));
522 free_a_printer( &printer, 2);
528 if ( strequal(printername, aprinter) ) {
529 free_a_printer( &printer, 2);
534 DEBUGADD(10, ("printername: %s\n", printername));
536 free_a_printer( &printer, 2);
539 free_a_printer( &printer, 2);
542 DEBUGADD(4,("Printer not found\n"));
546 DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
548 fstrcpy(Printer->sharename, sname);
553 /****************************************************************************
554 Find first available printer slot. creates a printer handle for you.
555 ****************************************************************************/
557 static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
558 const char *name, uint32_t access_granted)
560 Printer_entry *new_printer;
562 DEBUG(10,("open_printer_hnd: name [%s]\n", name));
564 new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
565 if (new_printer == NULL) {
568 talloc_set_destructor(new_printer, printer_entry_destructor);
570 if (!create_policy_hnd(p, hnd, new_printer)) {
571 TALLOC_FREE(new_printer);
575 /* Add to the internal list. */
576 DLIST_ADD(printers_list, new_printer);
578 new_printer->notify.option=NULL;
580 if (!set_printer_hnd_printertype(new_printer, name)) {
581 close_printer_handle(p, hnd);
585 if (!set_printer_hnd_name(new_printer, name)) {
586 close_printer_handle(p, hnd);
590 new_printer->access_granted = access_granted;
592 DEBUG(5, ("%d printer handles active\n",
593 (int)num_pipe_handles(p->pipe_handles)));
598 /***************************************************************************
599 check to see if the client motify handle is monitoring the notification
600 given by (notify_type, notify_field).
601 **************************************************************************/
603 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
604 uint16_t notify_field)
609 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
610 uint16_t notify_field)
612 struct spoolss_NotifyOption *option = p->notify.option;
616 * Flags should always be zero when the change notify
617 * is registered by the client's spooler. A user Win32 app
618 * might use the flags though instead of the NOTIFY_OPTION_INFO
627 return is_monitoring_event_flags(
628 p->notify.flags, notify_type, notify_field);
630 for (i = 0; i < option->count; i++) {
632 /* Check match for notify_type */
634 if (option->types[i].type != notify_type)
637 /* Check match for field */
639 for (j = 0; j < option->types[i].count; j++) {
640 if (option->types[i].fields[j].field == notify_field) {
646 DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
647 p->servername, p->sharename, notify_type, notify_field));
652 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
653 _data->data.integer[0] = _integer; \
654 _data->data.integer[1] = 0;
657 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
658 _data->data.string.string = talloc_strdup(mem_ctx, _p); \
659 if (!_data->data.string.string) {\
660 _data->data.string.size = 0; \
662 _data->data.string.size = strlen_m_term(_p) * 2;
664 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
665 _data->data.devmode.devmode = _devmode;
667 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
668 _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
669 if (!_data->data.sd.sd) { \
670 _data->data.sd.sd_size = 0; \
672 _data->data.sd.sd_size = _size;
674 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
679 struct spoolss_Time st;
683 if (!init_systemtime(&st, t)) {
687 p = talloc_array(mem_ctx, char, len);
693 * Systemtime must be linearized as a set of UINT16's.
694 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
697 SSVAL(p, 0, st.year);
698 SSVAL(p, 2, st.month);
699 SSVAL(p, 4, st.day_of_week);
701 SSVAL(p, 8, st.hour);
702 SSVAL(p, 10, st.minute);
703 SSVAL(p, 12, st.second);
704 SSVAL(p, 14, st.millisecond);
710 /* Convert a notification message to a struct spoolss_Notify */
712 static void notify_one_value(struct spoolss_notify_msg *msg,
713 struct spoolss_Notify *data,
716 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
719 static void notify_string(struct spoolss_notify_msg *msg,
720 struct spoolss_Notify *data,
723 /* The length of the message includes the trailing \0 */
725 data->data.string.size = msg->len * 2;
726 data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
727 if (!data->data.string.string) {
728 data->data.string.size = 0;
733 static void notify_system_time(struct spoolss_notify_msg *msg,
734 struct spoolss_Notify *data,
737 data->data.string.string = NULL;
738 data->data.string.size = 0;
740 if (msg->len != sizeof(time_t)) {
741 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
746 init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
747 &data->data.string.string,
748 &data->data.string.size);
751 struct notify2_message_table {
753 void (*fn)(struct spoolss_notify_msg *msg,
754 struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
757 static struct notify2_message_table printer_notify_table[] = {
758 /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
759 /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
760 /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
761 /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
762 /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
763 /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
764 /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
765 /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
766 /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
767 /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
768 /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
769 /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
770 /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
771 /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
772 /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
773 /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
774 /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
775 /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
776 /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
779 static struct notify2_message_table job_notify_table[] = {
780 /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
781 /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
782 /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
783 /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
784 /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
785 /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
786 /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
787 /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
788 /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
789 /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
790 /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
791 /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
792 /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
793 /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
794 /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
795 /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
796 /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
797 /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
798 /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
799 /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
800 /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
801 /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
802 /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
803 /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
807 /***********************************************************************
808 Allocate talloc context for container object
809 **********************************************************************/
811 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
816 ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
821 /***********************************************************************
822 release all allocated memory and zero out structure
823 **********************************************************************/
825 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
831 talloc_destroy(ctr->ctx);
838 /***********************************************************************
839 **********************************************************************/
841 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
849 /***********************************************************************
850 **********************************************************************/
852 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
854 if ( !ctr || !ctr->msg_groups )
857 if ( idx >= ctr->num_groups )
860 return &ctr->msg_groups[idx];
864 /***********************************************************************
865 How many groups of change messages do we have ?
866 **********************************************************************/
868 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
873 return ctr->num_groups;
876 /***********************************************************************
877 Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
878 **********************************************************************/
880 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
882 SPOOLSS_NOTIFY_MSG_GROUP *groups = NULL;
883 SPOOLSS_NOTIFY_MSG_GROUP *msg_grp = NULL;
884 SPOOLSS_NOTIFY_MSG *msg_list = NULL;
890 /* loop over all groups looking for a matching printer name */
892 for ( i=0; i<ctr->num_groups; i++ ) {
893 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
897 /* add a new group? */
899 if ( i == ctr->num_groups ) {
902 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
903 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
906 ctr->msg_groups = groups;
908 /* clear the new entry and set the printer name */
910 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
911 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
914 /* add the change messages; 'i' is the correct index now regardless */
916 msg_grp = &ctr->msg_groups[i];
920 if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
921 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
924 msg_grp->msgs = msg_list;
926 new_slot = msg_grp->num_msgs-1;
927 memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
929 /* need to allocate own copy of data */
932 msg_grp->msgs[new_slot].notify.data = (char *)
933 TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
935 return ctr->num_groups;
938 /***********************************************************************
939 Send a change notication message on all handles which have a call
941 **********************************************************************/
943 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
946 TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
947 SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
948 SPOOLSS_NOTIFY_MSG *messages;
949 int sending_msg_count;
952 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
956 messages = msg_group->msgs;
959 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
963 DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
965 /* loop over all printers */
967 for (p = printers_list; p; p = p->next) {
968 struct spoolss_Notify *notifies;
973 /* Is there notification on this handle? */
975 if ( !p->notify.client_connected )
978 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
980 /* For this printer? Print servers always receive
983 if ( ( p->printer_type == SPLHND_PRINTER ) &&
984 ( !strequal(msg_group->printername, p->sharename) ) )
987 DEBUG(10,("Our printer\n"));
989 /* allocate the max entries possible */
991 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
996 /* build the array of change notifications */
998 sending_msg_count = 0;
1000 for ( i=0; i<msg_group->num_msgs; i++ ) {
1001 SPOOLSS_NOTIFY_MSG *msg = &messages[i];
1003 /* Are we monitoring this event? */
1005 if (!is_monitoring_event(p, msg->type, msg->field))
1008 sending_msg_count++;
1011 DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1012 msg->type, msg->field, p->sharename));
1015 * if the is a printer notification handle and not a job notification
1016 * type, then set the id to 0. Other wise just use what was specified
1019 * When registering change notification on a print server handle
1020 * we always need to send back the id (snum) matching the printer
1021 * for which the change took place. For change notify registered
1022 * on a printer handle, this does not matter and the id should be 0.
1027 if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1033 /* Convert unix jobid to smb jobid */
1035 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1036 id = sysjob_to_jobid(msg->id);
1039 DEBUG(3, ("no such unix jobid %d\n", msg->id));
1044 construct_info_data( ¬ifies[count], msg->type, msg->field, id );
1047 case PRINTER_NOTIFY_TYPE:
1048 if ( printer_notify_table[msg->field].fn )
1049 printer_notify_table[msg->field].fn(msg, ¬ifies[count], mem_ctx);
1052 case JOB_NOTIFY_TYPE:
1053 if ( job_notify_table[msg->field].fn )
1054 job_notify_table[msg->field].fn(msg, ¬ifies[count], mem_ctx);
1058 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1065 if ( sending_msg_count ) {
1068 union spoolss_ReplyPrinterInfo info;
1069 struct spoolss_NotifyInfo info0;
1070 uint32_t reply_result;
1072 info0.version = 0x2;
1073 info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1074 info0.count = count;
1075 info0.notifies = notifies;
1077 info.info0 = &info0;
1079 status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1080 &p->notify.client_hnd,
1081 p->notify.change, /* color */
1084 0, /* reply_type, must be 0 */
1087 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1088 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1089 notify_cli_pipe->srv_name_slash,
1092 switch (reply_result) {
1095 case PRINTER_NOTIFY_INFO_DISCARDED:
1096 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1097 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1106 DEBUG(8,("send_notify2_changes: Exit...\n"));
1110 /***********************************************************************
1111 **********************************************************************/
1113 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1116 uint32_t tv_sec, tv_usec;
1119 /* Unpack message */
1121 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1124 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1126 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1129 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1130 &msg->notify.value[0], &msg->notify.value[1]);
1132 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1133 &msg->len, &msg->notify.data);
1135 DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1136 msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1138 tv->tv_sec = tv_sec;
1139 tv->tv_usec = tv_usec;
1142 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1143 msg->notify.value[1]));
1145 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1150 /********************************************************************
1151 Receive a notify2 message list
1152 ********************************************************************/
1154 static void receive_notify2_message_list(struct messaging_context *msg,
1157 struct server_id server_id,
1160 size_t msg_count, i;
1161 char *buf = (char *)data->data;
1164 SPOOLSS_NOTIFY_MSG notify;
1165 SPOOLSS_NOTIFY_MSG_CTR messages;
1168 if (data->length < 4) {
1169 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1173 msg_count = IVAL(buf, 0);
1176 DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1178 if (msg_count == 0) {
1179 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1183 /* initialize the container */
1185 ZERO_STRUCT( messages );
1186 notify_msg_ctr_init( &messages );
1189 * build message groups for each printer identified
1190 * in a change_notify msg. Remember that a PCN message
1191 * includes the handle returned for the srv_spoolss_replyopenprinter()
1192 * call. Therefore messages are grouped according to printer handle.
1195 for ( i=0; i<msg_count; i++ ) {
1196 struct timeval msg_tv;
1198 if (msg_ptr + 4 - buf > data->length) {
1199 DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1203 msg_len = IVAL(msg_ptr,0);
1206 if (msg_ptr + msg_len - buf > data->length) {
1207 DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1211 /* unpack messages */
1213 ZERO_STRUCT( notify );
1214 notify2_unpack_msg( ¬ify, &msg_tv, msg_ptr, msg_len );
1217 /* add to correct list in container */
1219 notify_msg_ctr_addmsg( &messages, ¬ify );
1221 /* free memory that might have been allocated by notify2_unpack_msg() */
1223 if ( notify.len != 0 )
1224 SAFE_FREE( notify.notify.data );
1227 /* process each group of messages */
1229 num_groups = notify_msg_ctr_numgroups( &messages );
1230 for ( i=0; i<num_groups; i++ )
1231 send_notify2_changes( &messages, i );
1236 DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1237 (uint32_t)msg_count ));
1239 notify_msg_ctr_destroy( &messages );
1244 /********************************************************************
1245 Send a message to ourself about new driver being installed
1246 so we can upgrade the information for each printer bound to this
1248 ********************************************************************/
1250 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1252 int len = strlen(drivername);
1257 DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1260 messaging_send_buf(smbd_messaging_context(), procid_self(),
1261 MSG_PRINTER_DRVUPGRADE,
1262 (uint8_t *)drivername, len+1);
1267 /**********************************************************************
1268 callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1269 over all printers, upgrading ones as necessary
1270 **********************************************************************/
1272 void do_drv_upgrade_printer(struct messaging_context *msg,
1275 struct server_id server_id,
1280 int n_services = lp_numservices();
1283 len = MIN(data->length,sizeof(drivername)-1);
1284 strncpy(drivername, (const char *)data->data, len);
1286 DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1288 /* Iterate the printer list */
1290 for (snum=0; snum<n_services; snum++)
1292 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1295 NT_PRINTER_INFO_LEVEL *printer = NULL;
1297 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1298 if (!W_ERROR_IS_OK(result))
1301 if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1303 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1305 /* all we care about currently is the change_id */
1307 result = mod_a_printer(printer, 2);
1308 if (!W_ERROR_IS_OK(result)) {
1309 DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1310 win_errstr(result)));
1314 free_a_printer(&printer, 2);
1321 /********************************************************************
1322 Update the cache for all printq's with a registered client
1324 ********************************************************************/
1326 void update_monitored_printq_cache( void )
1328 Printer_entry *printer = printers_list;
1331 /* loop through all printers and update the cache where
1332 client_connected == true */
1335 if ( (printer->printer_type == SPLHND_PRINTER)
1336 && printer->notify.client_connected )
1338 snum = print_queue_snum(printer->sharename);
1339 print_queue_status( snum, NULL, NULL );
1342 printer = printer->next;
1347 /********************************************************************
1348 Send a message to ourself about new driver being installed
1349 so we can upgrade the information for each printer bound to this
1351 ********************************************************************/
1353 static bool srv_spoolss_reset_printerdata(char* drivername)
1355 int len = strlen(drivername);
1360 DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1363 messaging_send_buf(smbd_messaging_context(), procid_self(),
1364 MSG_PRINTERDATA_INIT_RESET,
1365 (uint8_t *)drivername, len+1);
1370 /**********************************************************************
1371 callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1372 over all printers, resetting printer data as neessary
1373 **********************************************************************/
1375 void reset_all_printerdata(struct messaging_context *msg,
1378 struct server_id server_id,
1383 int n_services = lp_numservices();
1386 len = MIN( data->length, sizeof(drivername)-1 );
1387 strncpy( drivername, (const char *)data->data, len );
1389 DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1391 /* Iterate the printer list */
1393 for ( snum=0; snum<n_services; snum++ )
1395 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1398 NT_PRINTER_INFO_LEVEL *printer = NULL;
1400 result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1401 if ( !W_ERROR_IS_OK(result) )
1405 * if the printer is bound to the driver,
1406 * then reset to the new driver initdata
1409 if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1411 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1413 if ( !set_driver_init(printer, 2) ) {
1414 DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1415 printer->info_2->printername, printer->info_2->drivername));
1418 result = mod_a_printer( printer, 2 );
1419 if ( !W_ERROR_IS_OK(result) ) {
1420 DEBUG(3,("reset_all_printerdata: mod_a_printer() failed! (%s)\n",
1421 get_dos_error_msg(result)));
1425 free_a_printer( &printer, 2 );
1434 /****************************************************************
1435 _spoolss_OpenPrinter
1436 ****************************************************************/
1438 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1439 struct spoolss_OpenPrinter *r)
1441 struct spoolss_OpenPrinterEx e;
1444 ZERO_STRUCT(e.in.userlevel);
1446 e.in.printername = r->in.printername;
1447 e.in.datatype = r->in.datatype;
1448 e.in.devmode_ctr = r->in.devmode_ctr;
1449 e.in.access_mask = r->in.access_mask;
1452 e.out.handle = r->out.handle;
1454 werr = _spoolss_OpenPrinterEx(p, &e);
1456 if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1457 /* OpenPrinterEx returns this for a bad
1458 * printer name. We must return WERR_INVALID_PRINTER_NAME
1461 werr = WERR_INVALID_PRINTER_NAME;
1467 /********************************************************************
1468 ********************************************************************/
1470 bool convert_devicemode(const char *printername,
1471 const struct spoolss_DeviceMode *devmode,
1472 NT_DEVICEMODE **pp_nt_devmode)
1474 NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1477 * Ensure nt_devmode is a valid pointer
1478 * as we will be overwriting it.
1481 if (nt_devmode == NULL) {
1482 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1483 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1487 fstrcpy(nt_devmode->devicename, devmode->devicename);
1488 fstrcpy(nt_devmode->formname, devmode->formname);
1490 nt_devmode->devicename[31] = '\0';
1491 nt_devmode->formname[31] = '\0';
1493 nt_devmode->specversion = devmode->specversion;
1494 nt_devmode->driverversion = devmode->driverversion;
1495 nt_devmode->size = devmode->size;
1496 nt_devmode->fields = devmode->fields;
1497 nt_devmode->orientation = devmode->orientation;
1498 nt_devmode->papersize = devmode->papersize;
1499 nt_devmode->paperlength = devmode->paperlength;
1500 nt_devmode->paperwidth = devmode->paperwidth;
1501 nt_devmode->scale = devmode->scale;
1502 nt_devmode->copies = devmode->copies;
1503 nt_devmode->defaultsource = devmode->defaultsource;
1504 nt_devmode->printquality = devmode->printquality;
1505 nt_devmode->color = devmode->color;
1506 nt_devmode->duplex = devmode->duplex;
1507 nt_devmode->yresolution = devmode->yresolution;
1508 nt_devmode->ttoption = devmode->ttoption;
1509 nt_devmode->collate = devmode->collate;
1511 nt_devmode->logpixels = devmode->logpixels;
1512 nt_devmode->bitsperpel = devmode->bitsperpel;
1513 nt_devmode->pelswidth = devmode->pelswidth;
1514 nt_devmode->pelsheight = devmode->pelsheight;
1515 nt_devmode->displayflags = devmode->displayflags;
1516 nt_devmode->displayfrequency = devmode->displayfrequency;
1517 nt_devmode->icmmethod = devmode->icmmethod;
1518 nt_devmode->icmintent = devmode->icmintent;
1519 nt_devmode->mediatype = devmode->mediatype;
1520 nt_devmode->dithertype = devmode->dithertype;
1521 nt_devmode->reserved1 = devmode->reserved1;
1522 nt_devmode->reserved2 = devmode->reserved2;
1523 nt_devmode->panningwidth = devmode->panningwidth;
1524 nt_devmode->panningheight = devmode->panningheight;
1527 * Only change private and driverextra if the incoming devmode
1528 * has a new one. JRA.
1531 if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1532 SAFE_FREE(nt_devmode->nt_dev_private);
1533 nt_devmode->driverextra = devmode->__driverextra_length;
1534 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1536 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1539 *pp_nt_devmode = nt_devmode;
1544 /****************************************************************
1545 _spoolss_OpenPrinterEx
1546 ****************************************************************/
1548 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1549 struct spoolss_OpenPrinterEx *r)
1552 Printer_entry *Printer=NULL;
1554 if (!r->in.printername) {
1555 return WERR_INVALID_PARAM;
1558 /* some sanity check because you can open a printer or a print server */
1559 /* aka: \\server\printer or \\server */
1561 DEBUGADD(3,("checking name: %s\n", r->in.printername));
1563 if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1564 ZERO_STRUCTP(r->out.handle);
1565 return WERR_INVALID_PARAM;
1568 Printer = find_printer_index_by_hnd(p, r->out.handle);
1570 DEBUG(0,("_spoolss_OpenPrinterEx: logic error. Can't find printer "
1571 "handle we created for printer %s\n", r->in.printername));
1572 close_printer_handle(p, r->out.handle);
1573 ZERO_STRUCTP(r->out.handle);
1574 return WERR_INVALID_PARAM;
1578 * First case: the user is opening the print server:
1580 * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1581 * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1583 * Then both Win2k and WinNT clients try an OpenPrinterEx with
1584 * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1585 * or if the user is listed in the smb.conf printer admin parameter.
1587 * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1588 * client view printer folder, but does not show the MSAPW.
1590 * Note: this test needs code to check access rights here too. Jeremy
1591 * could you look at this?
1593 * Second case: the user is opening a printer:
1594 * NT doesn't let us connect to a printer if the connecting user
1595 * doesn't have print permission.
1597 * Third case: user is opening a Port Monitor
1598 * access checks same as opening a handle to the print server.
1601 switch (Printer->printer_type )
1604 case SPLHND_PORTMON_TCP:
1605 case SPLHND_PORTMON_LOCAL:
1606 /* Printserver handles use global struct... */
1610 /* Map standard access rights to object specific access rights */
1612 se_map_standard(&r->in.access_mask,
1613 &printserver_std_mapping);
1615 /* Deny any object specific bits that don't apply to print
1616 servers (i.e printer and job specific bits) */
1618 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1620 if (r->in.access_mask &
1621 ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1622 DEBUG(3, ("access DENIED for non-printserver bits\n"));
1623 close_printer_handle(p, r->out.handle);
1624 ZERO_STRUCTP(r->out.handle);
1625 return WERR_ACCESS_DENIED;
1628 /* Allow admin access */
1630 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1632 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1634 if (!lp_ms_add_printer_wizard()) {
1635 close_printer_handle(p, r->out.handle);
1636 ZERO_STRUCTP(r->out.handle);
1637 return WERR_ACCESS_DENIED;
1640 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1641 and not a printer admin, then fail */
1643 if ((p->server_info->utok.uid != sec_initial_uid()) &&
1644 !user_has_privileges(p->server_info->ptok,
1646 !token_contains_name_in_list(
1647 uidtoname(p->server_info->utok.uid),
1649 p->server_info->ptok,
1650 lp_printer_admin(snum))) {
1651 close_printer_handle(p, r->out.handle);
1652 ZERO_STRUCTP(r->out.handle);
1653 return WERR_ACCESS_DENIED;
1656 r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1660 r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1663 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1664 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1666 /* We fall through to return WERR_OK */
1669 case SPLHND_PRINTER:
1670 /* NT doesn't let us connect to a printer if the connecting user
1671 doesn't have print permission. */
1673 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1674 close_printer_handle(p, r->out.handle);
1675 ZERO_STRUCTP(r->out.handle);
1679 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1680 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1683 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1685 /* map an empty access mask to the minimum access mask */
1686 if (r->in.access_mask == 0x0)
1687 r->in.access_mask = PRINTER_ACCESS_USE;
1690 * If we are not serving the printer driver for this printer,
1691 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1692 * will keep NT clients happy --jerry
1695 if (lp_use_client_driver(snum)
1696 && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1698 r->in.access_mask = PRINTER_ACCESS_USE;
1701 /* check smb.conf parameters and the the sec_desc */
1703 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1704 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1705 ZERO_STRUCTP(r->out.handle);
1706 return WERR_ACCESS_DENIED;
1709 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1710 p->server_info->ptok, snum) ||
1711 !print_access_check(p->server_info, snum,
1712 r->in.access_mask)) {
1713 DEBUG(3, ("access DENIED for printer open\n"));
1714 close_printer_handle(p, r->out.handle);
1715 ZERO_STRUCTP(r->out.handle);
1716 return WERR_ACCESS_DENIED;
1719 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1720 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1721 close_printer_handle(p, r->out.handle);
1722 ZERO_STRUCTP(r->out.handle);
1723 return WERR_ACCESS_DENIED;
1726 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1727 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1729 r->in.access_mask = PRINTER_ACCESS_USE;
1731 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1732 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1737 /* sanity check to prevent programmer error */
1738 ZERO_STRUCTP(r->out.handle);
1742 Printer->access_granted = r->in.access_mask;
1745 * If the client sent a devmode in the OpenPrinter() call, then
1746 * save it here in case we get a job submission on this handle
1749 if ((Printer->printer_type != SPLHND_SERVER) &&
1750 r->in.devmode_ctr.devmode) {
1751 convert_devicemode(Printer->sharename,
1752 r->in.devmode_ctr.devmode,
1753 &Printer->nt_devmode);
1756 #if 0 /* JERRY -- I'm doubtful this is really effective */
1757 /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1758 optimization in Windows 2000 clients --jerry */
1760 if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1761 && (RA_WIN2K == get_remote_arch()) )
1763 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1764 sys_usleep( 500000 );
1771 /****************************************************************************
1772 ****************************************************************************/
1774 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1775 NT_PRINTER_INFO_LEVEL_2 *d)
1777 DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1783 d->attributes = r->attributes;
1784 d->priority = r->priority;
1785 d->default_priority = r->defaultpriority;
1786 d->starttime = r->starttime;
1787 d->untiltime = r->untiltime;
1788 d->status = r->status;
1789 d->cjobs = r->cjobs;
1791 fstrcpy(d->servername, r->servername);
1792 fstrcpy(d->printername, r->printername);
1793 fstrcpy(d->sharename, r->sharename);
1794 fstrcpy(d->portname, r->portname);
1795 fstrcpy(d->drivername, r->drivername);
1796 slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1797 fstrcpy(d->location, r->location);
1798 fstrcpy(d->sepfile, r->sepfile);
1799 fstrcpy(d->printprocessor, r->printprocessor);
1800 fstrcpy(d->datatype, r->datatype);
1801 fstrcpy(d->parameters, r->parameters);
1806 /****************************************************************************
1807 ****************************************************************************/
1809 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1810 NT_PRINTER_INFO_LEVEL *printer)
1814 switch (info_ctr->level) {
1816 /* allocate memory if needed. Messy because
1817 convert_printer_info is used to update an existing
1818 printer or build a new one */
1820 if (!printer->info_2) {
1821 printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1822 if (!printer->info_2) {
1823 DEBUG(0,("convert_printer_info: "
1824 "talloc() failed!\n"));
1829 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1831 printer->info_2->setuptime = time(NULL);
1838 /****************************************************************
1839 _spoolss_ClosePrinter
1840 ****************************************************************/
1842 WERROR _spoolss_ClosePrinter(pipes_struct *p,
1843 struct spoolss_ClosePrinter *r)
1845 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1847 if (Printer && Printer->document_started) {
1848 struct spoolss_EndDocPrinter e;
1850 e.in.handle = r->in.handle;
1852 _spoolss_EndDocPrinter(p, &e);
1855 if (!close_printer_handle(p, r->in.handle))
1858 /* clear the returned printer handle. Observed behavior
1859 from Win2k server. Don't think this really matters.
1860 Previous code just copied the value of the closed
1863 ZERO_STRUCTP(r->out.handle);
1868 /****************************************************************
1869 _spoolss_DeletePrinter
1870 ****************************************************************/
1872 WERROR _spoolss_DeletePrinter(pipes_struct *p,
1873 struct spoolss_DeletePrinter *r)
1875 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1878 if (Printer && Printer->document_started) {
1879 struct spoolss_EndDocPrinter e;
1881 e.in.handle = r->in.handle;
1883 _spoolss_EndDocPrinter(p, &e);
1886 result = delete_printer_handle(p, r->in.handle);
1888 update_c_setprinter(false);
1893 /*******************************************************************
1894 * static function to lookup the version id corresponding to an
1895 * long architecture string
1896 ******************************************************************/
1898 static const struct print_architecture_table_node archi_table[]= {
1900 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
1901 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
1902 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
1903 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
1904 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
1905 {"Windows IA64", SPL_ARCH_IA64, 3 },
1906 {"Windows x64", SPL_ARCH_X64, 3 },
1910 static int get_version_id(const char *arch)
1914 for (i=0; archi_table[i].long_archi != NULL; i++)
1916 if (strcmp(arch, archi_table[i].long_archi) == 0)
1917 return (archi_table[i].version);
1923 /****************************************************************
1924 _spoolss_DeletePrinterDriver
1925 ****************************************************************/
1927 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
1928 struct spoolss_DeletePrinterDriver *r)
1931 struct spoolss_DriverInfo8 *info = NULL;
1932 struct spoolss_DriverInfo8 *info_win2k = NULL;
1935 WERROR status_win2k = WERR_ACCESS_DENIED;
1936 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1938 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1939 and not a printer admin, then fail */
1941 if ( (p->server_info->utok.uid != sec_initial_uid())
1942 && !user_has_privileges(p->server_info->ptok, &se_printop )
1943 && !token_contains_name_in_list(
1944 uidtoname(p->server_info->utok.uid), NULL,
1945 NULL, p->server_info->ptok,
1946 lp_printer_admin(-1)) )
1948 return WERR_ACCESS_DENIED;
1951 /* check that we have a valid driver name first */
1953 if ((version = get_version_id(r->in.architecture)) == -1)
1954 return WERR_INVALID_ENVIRONMENT;
1956 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
1960 /* try for Win2k driver if "Windows NT x86" */
1962 if ( version == 2 ) {
1964 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
1969 status = WERR_UNKNOWN_PRINTER_DRIVER;
1973 /* otherwise it was a failure */
1975 status = WERR_UNKNOWN_PRINTER_DRIVER;
1981 if (printer_driver_in_use(info)) {
1982 status = WERR_PRINTER_DRIVER_IN_USE;
1988 if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
1991 r->in.architecture, 3)))
1993 /* if we get to here, we now have 2 driver info structures to remove */
1994 /* remove the Win2k driver first*/
1996 status_win2k = delete_printer_driver(
1997 p, info_win2k, 3, false);
1998 free_a_printer_driver(info_win2k);
2000 /* this should not have failed---if it did, report to client */
2001 if ( !W_ERROR_IS_OK(status_win2k) )
2003 status = status_win2k;
2009 status = delete_printer_driver(p, info, version, false);
2011 /* if at least one of the deletes succeeded return OK */
2013 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2017 free_a_printer_driver(info);
2022 /****************************************************************
2023 _spoolss_DeletePrinterDriverEx
2024 ****************************************************************/
2026 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2027 struct spoolss_DeletePrinterDriverEx *r)
2029 struct spoolss_DriverInfo8 *info = NULL;
2030 struct spoolss_DriverInfo8 *info_win2k = NULL;
2034 WERROR status_win2k = WERR_ACCESS_DENIED;
2035 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2037 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2038 and not a printer admin, then fail */
2040 if ( (p->server_info->utok.uid != sec_initial_uid())
2041 && !user_has_privileges(p->server_info->ptok, &se_printop )
2042 && !token_contains_name_in_list(
2043 uidtoname(p->server_info->utok.uid), NULL, NULL,
2044 p->server_info->ptok, lp_printer_admin(-1)) )
2046 return WERR_ACCESS_DENIED;
2049 /* check that we have a valid driver name first */
2050 if ((version = get_version_id(r->in.architecture)) == -1) {
2051 /* this is what NT returns */
2052 return WERR_INVALID_ENVIRONMENT;
2055 if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2056 version = r->in.version;
2058 status = get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
2059 r->in.architecture, version);
2061 if ( !W_ERROR_IS_OK(status) )
2064 * if the client asked for a specific version,
2065 * or this is something other than Windows NT x86,
2069 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2072 /* try for Win2k driver if "Windows NT x86" */
2075 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
2078 status = WERR_UNKNOWN_PRINTER_DRIVER;
2083 if (printer_driver_in_use(info)) {
2084 status = WERR_PRINTER_DRIVER_IN_USE;
2089 * we have a couple of cases to consider.
2090 * (1) Are any files in use? If so and DPD_DELTE_ALL_FILE is set,
2091 * then the delete should fail if **any** files overlap with
2093 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2094 * non-overlapping files
2095 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2096 * is set, the do not delete any files
2097 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2100 delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2102 /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2104 if (delete_files && printer_driver_files_in_use(info, info) & (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
2105 /* no idea of the correct error here */
2106 status = WERR_ACCESS_DENIED;
2111 /* also check for W32X86/3 if necessary; maybe we already have? */
2113 if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
2114 if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info_win2k,
2116 r->in.architecture, 3)))
2119 if (delete_files && printer_driver_files_in_use(info, info_win2k) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2120 /* no idea of the correct error here */
2121 free_a_printer_driver(info_win2k);
2122 status = WERR_ACCESS_DENIED;
2126 /* if we get to here, we now have 2 driver info structures to remove */
2127 /* remove the Win2k driver first*/
2129 status_win2k = delete_printer_driver(
2130 p, info_win2k, 3, delete_files);
2131 free_a_printer_driver(info_win2k);
2133 /* this should not have failed---if it did, report to client */
2135 if ( !W_ERROR_IS_OK(status_win2k) )
2140 status = delete_printer_driver(p, info, version, delete_files);
2142 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2145 free_a_printer_driver(info);
2151 /****************************************************************************
2152 Internal routine for removing printerdata
2153 ***************************************************************************/
2155 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2157 return delete_printer_data( printer->info_2, key, value );
2160 /****************************************************************************
2161 Internal routine for storing printerdata
2162 ***************************************************************************/
2164 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2165 const char *key, const char *value,
2166 uint32_t type, uint8_t *data, int real_len)
2168 /* the registry objects enforce uniqueness based on value name */
2170 return add_printer_data( printer->info_2, key, value, type, data, real_len );
2173 /********************************************************************
2174 GetPrinterData on a printer server Handle.
2175 ********************************************************************/
2177 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2179 enum winreg_Type *type,
2180 union spoolss_PrinterData *data)
2182 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2184 if (!StrCaseCmp(value, "W3SvcInstalled")) {
2190 if (!StrCaseCmp(value, "BeepEnabled")) {
2196 if (!StrCaseCmp(value, "EventLog")) {
2198 /* formally was 0x1b */
2203 if (!StrCaseCmp(value, "NetPopup")) {
2209 if (!StrCaseCmp(value, "MajorVersion")) {
2212 /* Windows NT 4.0 seems to not allow uploading of drivers
2213 to a server that reports 0x3 as the MajorVersion.
2214 need to investigate more how Win2k gets around this .
2217 if (RA_WINNT == get_remote_arch()) {
2226 if (!StrCaseCmp(value, "MinorVersion")) {
2233 * uint32_t size = 0x114
2234 * uint32_t major = 5
2235 * uint32_t minor = [0|1]
2236 * uint32_t build = [2195|2600]
2237 * extra unicode string = e.g. "Service Pack 3"
2239 if (!StrCaseCmp(value, "OSVersion")) {
2241 enum ndr_err_code ndr_err;
2242 struct spoolss_OSVersion os;
2244 os.major = 5; /* Windows 2000 == 5.0 */
2246 os.build = 2195; /* build */
2247 os.extra_string = ""; /* leave extra string empty */
2249 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2250 (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2251 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2252 return WERR_GENERAL_FAILURE;
2256 data->binary = blob;
2262 if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2265 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2266 W_ERROR_HAVE_NO_MEMORY(data->string);
2271 if (!StrCaseCmp(value, "Architecture")) {
2273 data->string = talloc_strdup(mem_ctx,
2274 lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", SPOOLSS_ARCHITECTURE_NT_X86));
2275 W_ERROR_HAVE_NO_MEMORY(data->string);
2280 if (!StrCaseCmp(value, "DsPresent")) {
2283 /* only show the publish check box if we are a
2284 member of a AD domain */
2286 if (lp_security() == SEC_ADS) {
2294 if (!StrCaseCmp(value, "DNSMachineName")) {
2295 const char *hostname = get_mydnsfullname();
2298 return WERR_BADFILE;
2302 data->string = talloc_strdup(mem_ctx, hostname);
2303 W_ERROR_HAVE_NO_MEMORY(data->string);
2310 return WERR_INVALID_PARAM;
2313 /****************************************************************
2314 _spoolss_GetPrinterData
2315 ****************************************************************/
2317 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2318 struct spoolss_GetPrinterData *r)
2320 struct spoolss_GetPrinterDataEx r2;
2322 r2.in.handle = r->in.handle;
2323 r2.in.key_name = "PrinterDriverData";
2324 r2.in.value_name = r->in.value_name;
2325 r2.in.offered = r->in.offered;
2326 r2.out.type = r->out.type;
2327 r2.out.data = r->out.data;
2328 r2.out.needed = r->out.needed;
2330 return _spoolss_GetPrinterDataEx(p, &r2);
2333 /*********************************************************
2334 Connect to the client machine.
2335 **********************************************************/
2337 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2338 struct sockaddr_storage *client_ss, const char *remote_machine)
2341 struct cli_state *the_cli;
2342 struct sockaddr_storage rm_addr;
2343 char addr[INET6_ADDRSTRLEN];
2345 if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2346 DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
2348 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2349 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2352 print_sockaddr(addr, sizeof(addr), &rm_addr);
2354 rm_addr = *client_ss;
2355 print_sockaddr(addr, sizeof(addr), &rm_addr);
2356 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2360 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2361 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
2366 /* setup the connection */
2367 ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2368 &rm_addr, 0, "IPC$", "IPC",
2372 0, lp_client_signing(), NULL );
2374 if ( !NT_STATUS_IS_OK( ret ) ) {
2375 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2380 if ( the_cli->protocol != PROTOCOL_NT1 ) {
2381 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2382 cli_shutdown(the_cli);
2387 * Ok - we have an anonymous connection to the IPC$ share.
2388 * Now start the NT Domain stuff :-).
2391 ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2392 if (!NT_STATUS_IS_OK(ret)) {
2393 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2394 remote_machine, nt_errstr(ret)));
2395 cli_shutdown(the_cli);
2402 /***************************************************************************
2403 Connect to the client.
2404 ****************************************************************************/
2406 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2407 uint32_t localprinter, uint32_t type,
2408 struct policy_handle *handle,
2409 struct sockaddr_storage *client_ss)
2415 * If it's the first connection, contact the client
2416 * and connect to the IPC$ share anonymously
2418 if (smb_connections==0) {
2419 fstring unix_printer;
2421 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2423 if ( !spoolss_connect_to_client( ¬ify_cli_pipe, client_ss, unix_printer ))
2426 messaging_register(smbd_messaging_context(), NULL,
2427 MSG_PRINTER_NOTIFY2,
2428 receive_notify2_message_list);
2429 /* Tell the connections db we're now interested in printer
2430 * notify messages. */
2431 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2435 * Tell the specific printing tdb we want messages for this printer
2436 * by registering our PID.
2439 if (!print_notify_register_pid(snum))
2440 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2444 status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2452 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2453 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2454 win_errstr(result)));
2456 return (W_ERROR_IS_OK(result));
2459 /****************************************************************
2460 ****************************************************************/
2462 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2463 const struct spoolss_NotifyOption *r)
2465 struct spoolss_NotifyOption *option;
2472 option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2479 if (!option->count) {
2483 option->types = talloc_zero_array(option,
2484 struct spoolss_NotifyOptionType, option->count);
2485 if (!option->types) {
2486 talloc_free(option);
2490 for (i=0; i < option->count; i++) {
2491 option->types[i] = r->types[i];
2493 if (option->types[i].count) {
2494 option->types[i].fields = talloc_zero_array(option,
2495 union spoolss_Field, option->types[i].count);
2496 if (!option->types[i].fields) {
2497 talloc_free(option);
2500 for (k=0; k<option->types[i].count; k++) {
2501 option->types[i].fields[k] =
2502 r->types[i].fields[k];
2510 /****************************************************************
2511 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2513 * before replying OK: status=0 a rpc call is made to the workstation
2514 * asking ReplyOpenPrinter
2516 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2517 * called from api_spoolss_rffpcnex
2518 ****************************************************************/
2520 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2521 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2524 struct spoolss_NotifyOption *option = r->in.notify_options;
2525 struct sockaddr_storage client_ss;
2527 /* store the notify value in the printer struct */
2529 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2532 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2533 "Invalid handle (%s:%u:%u).\n",
2534 OUR_HANDLE(r->in.handle)));
2538 Printer->notify.flags = r->in.flags;
2539 Printer->notify.options = r->in.options;
2540 Printer->notify.printerlocal = r->in.printer_local;
2542 TALLOC_FREE(Printer->notify.option);
2543 Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2545 fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2547 /* Connect to the client machine and send a ReplyOpenPrinter */
2549 if ( Printer->printer_type == SPLHND_SERVER)
2551 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2552 !get_printer_snum(p, r->in.handle, &snum, NULL) )
2555 DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2556 "client_address is %s\n", p->client_address));
2558 if (!interpret_string_addr(&client_ss, p->client_address,
2560 return WERR_SERVER_UNAVAILABLE;
2563 if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2564 Printer->notify.printerlocal, 1,
2565 &Printer->notify.client_hnd, &client_ss))
2566 return WERR_SERVER_UNAVAILABLE;
2568 Printer->notify.client_connected = true;
2573 /*******************************************************************
2574 * fill a notify_info_data with the servername
2575 ********************************************************************/
2577 void spoolss_notify_server_name(int snum,
2578 struct spoolss_Notify *data,
2579 print_queue_struct *queue,
2580 NT_PRINTER_INFO_LEVEL *printer,
2581 TALLOC_CTX *mem_ctx)
2583 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2586 /*******************************************************************
2587 * fill a notify_info_data with the printername (not including the servername).
2588 ********************************************************************/
2590 void spoolss_notify_printer_name(int snum,
2591 struct spoolss_Notify *data,
2592 print_queue_struct *queue,
2593 NT_PRINTER_INFO_LEVEL *printer,
2594 TALLOC_CTX *mem_ctx)
2596 /* the notify name should not contain the \\server\ part */
2597 char *p = strrchr(printer->info_2->printername, '\\');
2600 p = printer->info_2->printername;
2605 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2608 /*******************************************************************
2609 * fill a notify_info_data with the servicename
2610 ********************************************************************/
2612 void spoolss_notify_share_name(int snum,
2613 struct spoolss_Notify *data,
2614 print_queue_struct *queue,
2615 NT_PRINTER_INFO_LEVEL *printer,
2616 TALLOC_CTX *mem_ctx)
2618 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2621 /*******************************************************************
2622 * fill a notify_info_data with the port name
2623 ********************************************************************/
2625 void spoolss_notify_port_name(int snum,
2626 struct spoolss_Notify *data,
2627 print_queue_struct *queue,
2628 NT_PRINTER_INFO_LEVEL *printer,
2629 TALLOC_CTX *mem_ctx)
2631 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2634 /*******************************************************************
2635 * fill a notify_info_data with the printername
2636 * but it doesn't exist, have to see what to do
2637 ********************************************************************/
2639 void spoolss_notify_driver_name(int snum,
2640 struct spoolss_Notify *data,
2641 print_queue_struct *queue,
2642 NT_PRINTER_INFO_LEVEL *printer,
2643 TALLOC_CTX *mem_ctx)
2645 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2648 /*******************************************************************
2649 * fill a notify_info_data with the comment
2650 ********************************************************************/
2652 void spoolss_notify_comment(int snum,
2653 struct spoolss_Notify *data,
2654 print_queue_struct *queue,
2655 NT_PRINTER_INFO_LEVEL *printer,
2656 TALLOC_CTX *mem_ctx)
2660 if (*printer->info_2->comment == '\0') {
2661 p = lp_comment(snum);
2663 p = printer->info_2->comment;
2666 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2669 /*******************************************************************
2670 * fill a notify_info_data with the comment
2671 * location = "Room 1, floor 2, building 3"
2672 ********************************************************************/
2674 void spoolss_notify_location(int snum,
2675 struct spoolss_Notify *data,
2676 print_queue_struct *queue,
2677 NT_PRINTER_INFO_LEVEL *printer,
2678 TALLOC_CTX *mem_ctx)
2680 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2683 /*******************************************************************
2684 * fill a notify_info_data with the device mode
2685 * jfm:xxxx don't to it for know but that's a real problem !!!
2686 ********************************************************************/
2688 static void spoolss_notify_devmode(int snum,
2689 struct spoolss_Notify *data,
2690 print_queue_struct *queue,
2691 NT_PRINTER_INFO_LEVEL *printer,
2692 TALLOC_CTX *mem_ctx)
2694 /* for a dummy implementation we have to zero the fields */
2695 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2698 /*******************************************************************
2699 * fill a notify_info_data with the separator file name
2700 ********************************************************************/
2702 void spoolss_notify_sepfile(int snum,
2703 struct spoolss_Notify *data,
2704 print_queue_struct *queue,
2705 NT_PRINTER_INFO_LEVEL *printer,
2706 TALLOC_CTX *mem_ctx)
2708 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2711 /*******************************************************************
2712 * fill a notify_info_data with the print processor
2713 * jfm:xxxx return always winprint to indicate we don't do anything to it
2714 ********************************************************************/
2716 void spoolss_notify_print_processor(int snum,
2717 struct spoolss_Notify *data,
2718 print_queue_struct *queue,
2719 NT_PRINTER_INFO_LEVEL *printer,
2720 TALLOC_CTX *mem_ctx)
2722 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2725 /*******************************************************************
2726 * fill a notify_info_data with the print processor options
2727 * jfm:xxxx send an empty string
2728 ********************************************************************/
2730 void spoolss_notify_parameters(int snum,
2731 struct spoolss_Notify *data,
2732 print_queue_struct *queue,
2733 NT_PRINTER_INFO_LEVEL *printer,
2734 TALLOC_CTX *mem_ctx)
2736 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2739 /*******************************************************************
2740 * fill a notify_info_data with the data type
2741 * jfm:xxxx always send RAW as data type
2742 ********************************************************************/
2744 void spoolss_notify_datatype(int snum,
2745 struct spoolss_Notify *data,
2746 print_queue_struct *queue,
2747 NT_PRINTER_INFO_LEVEL *printer,
2748 TALLOC_CTX *mem_ctx)
2750 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
2753 /*******************************************************************
2754 * fill a notify_info_data with the security descriptor
2755 * jfm:xxxx send an null pointer to say no security desc
2756 * have to implement security before !
2757 ********************************************************************/
2759 static void spoolss_notify_security_desc(int snum,
2760 struct spoolss_Notify *data,
2761 print_queue_struct *queue,
2762 NT_PRINTER_INFO_LEVEL *printer,
2763 TALLOC_CTX *mem_ctx)
2765 SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
2766 printer->info_2->secdesc_buf->sd_size,
2767 printer->info_2->secdesc_buf->sd);
2770 /*******************************************************************
2771 * fill a notify_info_data with the attributes
2772 * jfm:xxxx a samba printer is always shared
2773 ********************************************************************/
2775 void spoolss_notify_attributes(int snum,
2776 struct spoolss_Notify *data,
2777 print_queue_struct *queue,
2778 NT_PRINTER_INFO_LEVEL *printer,
2779 TALLOC_CTX *mem_ctx)
2781 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
2784 /*******************************************************************
2785 * fill a notify_info_data with the priority
2786 ********************************************************************/
2788 static void spoolss_notify_priority(int snum,
2789 struct spoolss_Notify *data,
2790 print_queue_struct *queue,
2791 NT_PRINTER_INFO_LEVEL *printer,
2792 TALLOC_CTX *mem_ctx)
2794 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
2797 /*******************************************************************
2798 * fill a notify_info_data with the default priority
2799 ********************************************************************/
2801 static void spoolss_notify_default_priority(int snum,
2802 struct spoolss_Notify *data,
2803 print_queue_struct *queue,
2804 NT_PRINTER_INFO_LEVEL *printer,
2805 TALLOC_CTX *mem_ctx)
2807 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
2810 /*******************************************************************
2811 * fill a notify_info_data with the start time
2812 ********************************************************************/
2814 static void spoolss_notify_start_time(int snum,
2815 struct spoolss_Notify *data,
2816 print_queue_struct *queue,
2817 NT_PRINTER_INFO_LEVEL *printer,
2818 TALLOC_CTX *mem_ctx)
2820 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
2823 /*******************************************************************
2824 * fill a notify_info_data with the until time
2825 ********************************************************************/
2827 static void spoolss_notify_until_time(int snum,
2828 struct spoolss_Notify *data,
2829 print_queue_struct *queue,
2830 NT_PRINTER_INFO_LEVEL *printer,
2831 TALLOC_CTX *mem_ctx)
2833 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
2836 /*******************************************************************
2837 * fill a notify_info_data with the status
2838 ********************************************************************/
2840 static void spoolss_notify_status(int snum,
2841 struct spoolss_Notify *data,
2842 print_queue_struct *queue,
2843 NT_PRINTER_INFO_LEVEL *printer,
2844 TALLOC_CTX *mem_ctx)
2846 print_status_struct status;
2848 print_queue_length(snum, &status);
2849 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
2852 /*******************************************************************
2853 * fill a notify_info_data with the number of jobs queued
2854 ********************************************************************/
2856 void spoolss_notify_cjobs(int snum,
2857 struct spoolss_Notify *data,
2858 print_queue_struct *queue,
2859 NT_PRINTER_INFO_LEVEL *printer,
2860 TALLOC_CTX *mem_ctx)
2862 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
2865 /*******************************************************************
2866 * fill a notify_info_data with the average ppm
2867 ********************************************************************/
2869 static void spoolss_notify_average_ppm(int snum,
2870 struct spoolss_Notify *data,
2871 print_queue_struct *queue,
2872 NT_PRINTER_INFO_LEVEL *printer,
2873 TALLOC_CTX *mem_ctx)
2875 /* always respond 8 pages per minutes */
2876 /* a little hard ! */
2877 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
2880 /*******************************************************************
2881 * fill a notify_info_data with username
2882 ********************************************************************/
2884 static void spoolss_notify_username(int snum,
2885 struct spoolss_Notify *data,
2886 print_queue_struct *queue,
2887 NT_PRINTER_INFO_LEVEL *printer,
2888 TALLOC_CTX *mem_ctx)
2890 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
2893 /*******************************************************************
2894 * fill a notify_info_data with job status
2895 ********************************************************************/
2897 static void spoolss_notify_job_status(int snum,
2898 struct spoolss_Notify *data,
2899 print_queue_struct *queue,
2900 NT_PRINTER_INFO_LEVEL *printer,
2901 TALLOC_CTX *mem_ctx)
2903 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
2906 /*******************************************************************
2907 * fill a notify_info_data with job name
2908 ********************************************************************/
2910 static void spoolss_notify_job_name(int snum,
2911 struct spoolss_Notify *data,
2912 print_queue_struct *queue,
2913 NT_PRINTER_INFO_LEVEL *printer,
2914 TALLOC_CTX *mem_ctx)
2916 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
2919 /*******************************************************************
2920 * fill a notify_info_data with job status
2921 ********************************************************************/
2923 static void spoolss_notify_job_status_string(int snum,
2924 struct spoolss_Notify *data,
2925 print_queue_struct *queue,
2926 NT_PRINTER_INFO_LEVEL *printer,
2927 TALLOC_CTX *mem_ctx)
2930 * Now we're returning job status codes we just return a "" here. JRA.
2935 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
2938 switch (queue->status) {
2943 p = ""; /* NT provides the paused string */
2952 #endif /* NO LONGER NEEDED. */
2954 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2957 /*******************************************************************
2958 * fill a notify_info_data with job time
2959 ********************************************************************/
2961 static void spoolss_notify_job_time(int snum,
2962 struct spoolss_Notify *data,
2963 print_queue_struct *queue,
2964 NT_PRINTER_INFO_LEVEL *printer,
2965 TALLOC_CTX *mem_ctx)
2967 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
2970 /*******************************************************************
2971 * fill a notify_info_data with job size
2972 ********************************************************************/
2974 static void spoolss_notify_job_size(int snum,
2975 struct spoolss_Notify *data,
2976 print_queue_struct *queue,
2977 NT_PRINTER_INFO_LEVEL *printer,
2978 TALLOC_CTX *mem_ctx)
2980 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
2983 /*******************************************************************
2984 * fill a notify_info_data with page info
2985 ********************************************************************/
2986 static void spoolss_notify_total_pages(int snum,
2987 struct spoolss_Notify *data,
2988 print_queue_struct *queue,
2989 NT_PRINTER_INFO_LEVEL *printer,
2990 TALLOC_CTX *mem_ctx)
2992 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
2995 /*******************************************************************
2996 * fill a notify_info_data with pages printed info.
2997 ********************************************************************/
2998 static void spoolss_notify_pages_printed(int snum,
2999 struct spoolss_Notify *data,
3000 print_queue_struct *queue,
3001 NT_PRINTER_INFO_LEVEL *printer,
3002 TALLOC_CTX *mem_ctx)
3004 /* Add code when back-end tracks this */
3005 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3008 /*******************************************************************
3009 Fill a notify_info_data with job position.
3010 ********************************************************************/
3012 static void spoolss_notify_job_position(int snum,
3013 struct spoolss_Notify *data,
3014 print_queue_struct *queue,
3015 NT_PRINTER_INFO_LEVEL *printer,
3016 TALLOC_CTX *mem_ctx)
3018 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3021 /*******************************************************************
3022 Fill a notify_info_data with submitted time.
3023 ********************************************************************/
3025 static void spoolss_notify_submitted_time(int snum,
3026 struct spoolss_Notify *data,
3027 print_queue_struct *queue,
3028 NT_PRINTER_INFO_LEVEL *printer,
3029 TALLOC_CTX *mem_ctx)
3031 data->data.string.string = NULL;
3032 data->data.string.size = 0;
3034 init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3035 &data->data.string.string,
3036 &data->data.string.size);
3040 struct s_notify_info_data_table
3042 enum spoolss_NotifyType type;
3045 enum spoolss_NotifyTable variable_type;
3046 void (*fn) (int snum, struct spoolss_Notify *data,
3047 print_queue_struct *queue,
3048 NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3051 /* A table describing the various print notification constants and
3052 whether the notification data is a pointer to a variable sized
3053 buffer, a one value uint32_t or a two value uint32_t. */
3055 static const struct s_notify_info_data_table notify_info_data_table[] =
3057 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3058 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3059 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_share_name },
3060 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3061 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3062 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING, spoolss_notify_comment },
3063 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING, spoolss_notify_location },
3064 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3065 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING, spoolss_notify_sepfile },
3066 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3067 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3068 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3069 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, spoolss_notify_security_desc },
3070 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD, spoolss_notify_attributes },
3071 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3072 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_default_priority },
3073 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3074 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3075 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_status },
3076 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, NULL },
3077 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD, spoolss_notify_cjobs },
3078 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD, spoolss_notify_average_ppm },
3079 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, NULL },
3080 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3081 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, NULL },
3082 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3083 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINTER_NAME, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3084 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_MACHINE_NAME, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3085 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PORT_NAME, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3086 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3087 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_NOTIFY_NAME, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3088 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DATATYPE, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3089 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINT_PROCESSOR, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3090 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PARAMETERS, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3091 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DRIVER_NAME, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3092 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DEVMODE, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3093 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_job_status },
3094 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS_STRING, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, spoolss_notify_job_status_string },
3095 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, NULL },
3096 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING, spoolss_notify_job_name },
3097 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRIORITY, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3098 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_POSITION, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD, spoolss_notify_job_position },
3099 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME, spoolss_notify_submitted_time },
3100 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_START_TIME, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3101 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_UNTIL_TIME, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3102 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TIME, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_job_time },
3103 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_PAGES, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, spoolss_notify_total_pages },
3104 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PAGES_PRINTED, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, spoolss_notify_pages_printed },
3105 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_BYTES, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, spoolss_notify_job_size },
3108 /*******************************************************************
3109 Return the variable_type of info_data structure.
3110 ********************************************************************/
3112 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3117 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3118 if ( (notify_info_data_table[i].type == type) &&
3119 (notify_info_data_table[i].field == field) ) {
3120 return notify_info_data_table[i].variable_type;
3124 DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3129 /****************************************************************************
3130 ****************************************************************************/
3132 static bool search_notify(enum spoolss_NotifyType type,
3138 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3139 if (notify_info_data_table[i].type == type &&
3140 notify_info_data_table[i].field == field &&
3141 notify_info_data_table[i].fn != NULL) {
3150 /****************************************************************************
3151 ****************************************************************************/
3153 void construct_info_data(struct spoolss_Notify *info_data,
3154 enum spoolss_NotifyType type,
3158 info_data->type = type;
3159 info_data->field.field = field;
3160 info_data->variable_type = variable_type_of_notify_info_data(type, field);
3161 info_data->job_id = id;
3164 /*******************************************************************
3166 * fill a notify_info struct with info asked
3168 ********************************************************************/
3170 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3171 struct spoolss_NotifyInfo *info,
3173 const struct spoolss_NotifyOptionType *option_type,
3175 TALLOC_CTX *mem_ctx)
3178 enum spoolss_NotifyType type;
3181 struct spoolss_Notify *current_data;
3182 NT_PRINTER_INFO_LEVEL *printer = NULL;
3183 print_queue_struct *queue=NULL;
3185 type = option_type->type;
3187 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3188 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3189 option_type->count, lp_servicename(snum)));
3191 if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3194 for(field_num=0; field_num < option_type->count; field_num++) {
3195 field = option_type->fields[field_num].field;
3197 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3199 if (!search_notify(type, field, &j) )
3202 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3203 struct spoolss_Notify,
3205 if (info->notifies == NULL) {
3206 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3207 free_a_printer(&printer, 2);
3211 current_data = &info->notifies[info->count];
3213 construct_info_data(current_data, type, field, id);
3215 DEBUG(10,("construct_notify_printer_info: calling [%s] snum=%d printername=[%s])\n",
3216 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3218 notify_info_data_table[j].fn(snum, current_data, queue,
3224 free_a_printer(&printer, 2);
3228 /*******************************************************************
3230 * fill a notify_info struct with info asked
3232 ********************************************************************/
3234 static bool construct_notify_jobs_info(print_queue_struct *queue,
3235 struct spoolss_NotifyInfo *info,
3236 NT_PRINTER_INFO_LEVEL *printer,
3238 const struct spoolss_NotifyOptionType *option_type,
3240 TALLOC_CTX *mem_ctx)
3243 enum spoolss_NotifyType type;
3245 struct spoolss_Notify *current_data;
3247 DEBUG(4,("construct_notify_jobs_info\n"));
3249 type = option_type->type;
3251 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3252 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3253 option_type->count));
3255 for(field_num=0; field_num<option_type->count; field_num++) {
3256 field = option_type->fields[field_num].field;
3258 if (!search_notify(type, field, &j) )
3261 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3262 struct spoolss_Notify,
3264 if (info->notifies == NULL) {
3265 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3269 current_data=&(info->notifies[info->count]);
3271 construct_info_data(current_data, type, field, id);
3272 notify_info_data_table[j].fn(snum, current_data, queue,
3281 * JFM: The enumeration is not that simple, it's even non obvious.
3283 * let's take an example: I want to monitor the PRINTER SERVER for
3284 * the printer's name and the number of jobs currently queued.
3285 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3286 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3288 * I have 3 printers on the back of my server.
3290 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3293 * 1 printer 1 name 1
3294 * 2 printer 1 cjob 1
3295 * 3 printer 2 name 2
3296 * 4 printer 2 cjob 2
3297 * 5 printer 3 name 3
3298 * 6 printer 3 name 3
3300 * that's the print server case, the printer case is even worse.
3303 /*******************************************************************
3305 * enumerate all printers on the printserver
3306 * fill a notify_info struct with info asked
3308 ********************************************************************/
3310 static WERROR printserver_notify_info(pipes_struct *p,
3311 struct policy_handle *hnd,
3312 struct spoolss_NotifyInfo *info,
3313 TALLOC_CTX *mem_ctx)
3316 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3317 int n_services=lp_numservices();
3319 struct spoolss_NotifyOption *option;
3320 struct spoolss_NotifyOptionType option_type;
3322 DEBUG(4,("printserver_notify_info\n"));
3327 option = Printer->notify.option;
3330 info->notifies = NULL;
3333 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3334 sending a ffpcn() request first */
3339 for (i=0; i<option->count; i++) {
3340 option_type = option->types[i];
3342 if (option_type.type != PRINTER_NOTIFY_TYPE)
3345 for (snum=0; snum<n_services; snum++)
3347 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3348 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3354 * Debugging information, don't delete.
3357 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3358 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3359 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3361 for (i=0; i<info->count; i++) {
3362 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3363 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3364 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3371 /*******************************************************************
3373 * fill a notify_info struct with info asked
3375 ********************************************************************/
3377 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3378 struct spoolss_NotifyInfo *info,
3379 TALLOC_CTX *mem_ctx)
3382 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3385 struct spoolss_NotifyOption *option;
3386 struct spoolss_NotifyOptionType option_type;
3388 print_queue_struct *queue=NULL;
3389 print_status_struct status;
3391 DEBUG(4,("printer_notify_info\n"));
3396 option = Printer->notify.option;
3400 info->notifies = NULL;
3403 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3404 sending a ffpcn() request first */
3409 get_printer_snum(p, hnd, &snum, NULL);
3411 for (i=0; i<option->count; i++) {
3412 option_type = option->types[i];
3414 switch (option_type.type) {
3415 case PRINTER_NOTIFY_TYPE:
3416 if(construct_notify_printer_info(Printer, info, snum,
3422 case JOB_NOTIFY_TYPE: {
3423 NT_PRINTER_INFO_LEVEL *printer = NULL;
3425 count = print_queue_status(snum, &queue, &status);
3427 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3430 for (j=0; j<count; j++) {
3431 construct_notify_jobs_info(&queue[j], info,
3438 free_a_printer(&printer, 2);
3448 * Debugging information, don't delete.
3451 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3452 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3453 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3455 for (i=0; i<info->count; i++) {
3456 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3457 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3458 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3464 /****************************************************************
3465 _spoolss_RouterRefreshPrinterChangeNotify
3466 ****************************************************************/
3468 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3469 struct spoolss_RouterRefreshPrinterChangeNotify *r)
3471 struct spoolss_NotifyInfo *info;
3473 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3474 WERROR result = WERR_BADFID;
3476 /* we always have a spoolss_NotifyInfo struct */
3477 info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3479 result = WERR_NOMEM;
3483 *r->out.info = info;
3486 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3487 "Invalid handle (%s:%u:%u).\n",
3488 OUR_HANDLE(r->in.handle)));
3492 DEBUG(4,("Printer type %x\n",Printer->printer_type));
3495 * We are now using the change value, and
3496 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3497 * I don't have a global notification system, I'm sending back all the
3498 * informations even when _NOTHING_ has changed.
3501 /* We need to keep track of the change value to send back in
3502 RRPCN replies otherwise our updates are ignored. */
3504 Printer->notify.fnpcn = true;
3506 if (Printer->notify.client_connected) {
3507 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3508 "Saving change value in request [%x]\n",
3510 Printer->notify.change = r->in.change_low;
3513 /* just ignore the spoolss_NotifyOption */
3515 switch (Printer->printer_type) {
3517 result = printserver_notify_info(p, r->in.handle,
3521 case SPLHND_PRINTER:
3522 result = printer_notify_info(p, r->in.handle,
3527 Printer->notify.fnpcn = false;
3533 /********************************************************************
3534 * construct_printer_info_0
3535 * fill a printer_info_0 struct
3536 ********************************************************************/
3538 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3539 const NT_PRINTER_INFO_LEVEL *ntprinter,
3540 struct spoolss_PrinterInfo0 *r,
3544 counter_printer_0 *session_counter;
3546 print_status_struct status;
3548 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3549 W_ERROR_HAVE_NO_MEMORY(r->printername);
3551 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3552 W_ERROR_HAVE_NO_MEMORY(r->servername);
3554 count = print_queue_length(snum, &status);
3556 /* check if we already have a counter for this printer */
3557 for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3558 if (session_counter->snum == snum)
3562 /* it's the first time, add it to the list */
3563 if (session_counter == NULL) {
3564 session_counter = SMB_MALLOC_P(counter_printer_0);
3565 W_ERROR_HAVE_NO_MEMORY(session_counter);
3566 ZERO_STRUCTP(session_counter);
3567 session_counter->snum = snum;
3568 session_counter->counter = 0;
3569 DLIST_ADD(counter_list, session_counter);
3573 session_counter->counter++;
3579 setuptime = (time_t)ntprinter->info_2->setuptime;
3581 init_systemtime(&r->time, gmtime(&setuptime));
3584 * the global_counter should be stored in a TDB as it's common to all the clients
3585 * and should be zeroed on samba startup
3587 r->global_counter = session_counter->counter;
3589 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3590 r->version = 0x0005; /* NT 5 */
3591 r->free_build = 0x0893; /* build 2195 */
3593 r->max_spooling = 0;
3594 r->session_counter = session_counter->counter;
3595 r->num_error_out_of_paper = 0x0;
3596 r->num_error_not_ready = 0x0; /* number of print failure */
3598 r->number_of_processors = 0x1;
3599 r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3600 r->high_part_total_bytes = 0x0;
3601 r->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3602 r->last_error = WERR_OK;
3603 r->status = nt_printq_status(status.status);
3604 r->enumerate_network_printers = 0x0;
3605 r->c_setprinter = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3606 r->processor_architecture = 0x0;
3607 r->processor_level = 0x6; /* 6 ???*/
3615 /****************************************************************************
3616 Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure. Both pointers
3617 should be valid upon entry
3618 ****************************************************************************/
3620 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3621 struct spoolss_DeviceMode *r,
3622 const NT_DEVICEMODE *ntdevmode)
3624 if (!r || !ntdevmode) {
3625 return WERR_INVALID_PARAM;
3628 r->devicename = talloc_strdup(mem_ctx, ntdevmode->devicename);
3629 W_ERROR_HAVE_NO_MEMORY(r->devicename);
3631 r->specversion = ntdevmode->specversion;
3632 r->driverversion = ntdevmode->driverversion;
3633 r->size = ntdevmode->size;
3634 r->__driverextra_length = ntdevmode->driverextra;
3635 r->fields = ntdevmode->fields;
3637 r->orientation = ntdevmode->orientation;
3638 r->papersize = ntdevmode->papersize;
3639 r->paperlength = ntdevmode->paperlength;
3640 r->paperwidth = ntdevmode->paperwidth;
3641 r->scale = ntdevmode->scale;
3642 r->copies = ntdevmode->copies;
3643 r->defaultsource = ntdevmode->defaultsource;
3644 r->printquality = ntdevmode->printquality;
3645 r->color = ntdevmode->color;
3646 r->duplex = ntdevmode->duplex;
3647 r->yresolution = ntdevmode->yresolution;
3648 r->ttoption = ntdevmode->ttoption;
3649 r->collate = ntdevmode->collate;
3651 r->formname = talloc_strdup(mem_ctx, ntdevmode->formname);
3652 W_ERROR_HAVE_NO_MEMORY(r->formname);
3654 /* all 0 below are values that have not been set in the old parsing/copy
3655 * function, maybe they should... - gd */
3661 r->displayflags = 0;
3662 r->displayfrequency = 0;
3663 r->icmmethod = ntdevmode->icmmethod;
3664 r->icmintent = ntdevmode->icmintent;
3665 r->mediatype = ntdevmode->mediatype;
3666 r->dithertype = ntdevmode->dithertype;
3669 r->panningwidth = 0;
3670 r->panningheight = 0;
3672 if (ntdevmode->nt_dev_private != NULL) {
3673 r->driverextra_data = data_blob_talloc(mem_ctx,
3674 ntdevmode->nt_dev_private,
3675 ntdevmode->driverextra);
3676 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3683 /****************************************************************************
3684 Create a spoolss_DeviceMode struct. Returns talloced memory.
3685 ****************************************************************************/
3687 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3688 const char *servicename)
3691 NT_PRINTER_INFO_LEVEL *printer = NULL;
3692 struct spoolss_DeviceMode *devmode = NULL;
3694 DEBUG(7,("construct_dev_mode\n"));
3696 DEBUGADD(8,("getting printer characteristics\n"));
3698 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3701 if (!printer->info_2->devmode) {
3702 DEBUG(5, ("BONG! There was no device mode!\n"));
3706 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3708 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3712 DEBUGADD(8,("loading DEVICEMODE\n"));
3714 result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3715 if (!W_ERROR_IS_OK(result)) {
3716 TALLOC_FREE(devmode);
3720 free_a_printer(&printer,2);
3725 /********************************************************************
3726 * construct_printer_info1
3727 * fill a spoolss_PrinterInfo1 struct
3728 ********************************************************************/
3730 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3731 const NT_PRINTER_INFO_LEVEL *ntprinter,
3733 struct spoolss_PrinterInfo1 *r,
3738 r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
3739 ntprinter->info_2->printername,
3740 ntprinter->info_2->drivername,
3741 ntprinter->info_2->location);
3742 W_ERROR_HAVE_NO_MEMORY(r->description);
3744 if (*ntprinter->info_2->comment == '\0') {
3745 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
3747 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
3749 W_ERROR_HAVE_NO_MEMORY(r->comment);
3751 r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3752 W_ERROR_HAVE_NO_MEMORY(r->name);
3757 /********************************************************************
3758 * construct_printer_info2
3759 * fill a spoolss_PrinterInfo2 struct
3760 ********************************************************************/
3762 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3763 const NT_PRINTER_INFO_LEVEL *ntprinter,
3764 struct spoolss_PrinterInfo2 *r,
3769 print_status_struct status;
3771 count = print_queue_length(snum, &status);
3773 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3774 W_ERROR_HAVE_NO_MEMORY(r->servername);
3775 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3776 W_ERROR_HAVE_NO_MEMORY(r->printername);
3777 r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
3778 W_ERROR_HAVE_NO_MEMORY(r->sharename);
3779 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
3780 W_ERROR_HAVE_NO_MEMORY(r->portname);
3781 r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
3782 W_ERROR_HAVE_NO_MEMORY(r->drivername);
3784 if (*ntprinter->info_2->comment == '\0') {
3785 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
3787 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
3789 W_ERROR_HAVE_NO_MEMORY(r->comment);
3791 r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
3792 W_ERROR_HAVE_NO_MEMORY(r->location);
3793 r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
3794 W_ERROR_HAVE_NO_MEMORY(r->sepfile);
3795 r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
3796 W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
3797 r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
3798 W_ERROR_HAVE_NO_MEMORY(r->datatype);
3799 r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
3800 W_ERROR_HAVE_NO_MEMORY(r->parameters);
3802 r->attributes = ntprinter->info_2->attributes;
3804 r->priority = ntprinter->info_2->priority;
3805 r->defaultpriority = ntprinter->info_2->default_priority;
3806 r->starttime = ntprinter->info_2->starttime;
3807 r->untiltime = ntprinter->info_2->untiltime;
3808 r->status = nt_printq_status(status.status);
3810 r->averageppm = ntprinter->info_2->averageppm;
3812 r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
3814 DEBUG(8,("Returning NULL Devicemode!\n"));
3819 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3820 /* don't use talloc_steal() here unless you do a deep steal of all
3821 the SEC_DESC members */
3823 r->secdesc = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
3829 /********************************************************************
3830 * construct_printer_info3
3831 * fill a spoolss_PrinterInfo3 struct
3832 ********************************************************************/
3834 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3835 const NT_PRINTER_INFO_LEVEL *ntprinter,
3836 struct spoolss_PrinterInfo3 *r,
3839 /* These are the components of the SD we are returning. */
3841 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3842 /* don't use talloc_steal() here unless you do a deep steal of all
3843 the SEC_DESC members */
3845 r->secdesc = dup_sec_desc(mem_ctx,
3846 ntprinter->info_2->secdesc_buf->sd);
3847 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3853 /********************************************************************
3854 * construct_printer_info4
3855 * fill a spoolss_PrinterInfo4 struct
3856 ********************************************************************/
3858 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
3859 const NT_PRINTER_INFO_LEVEL *ntprinter,
3860 struct spoolss_PrinterInfo4 *r,
3863 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3864 W_ERROR_HAVE_NO_MEMORY(r->printername);
3865 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3866 W_ERROR_HAVE_NO_MEMORY(r->servername);
3868 r->attributes = ntprinter->info_2->attributes;
3873 /********************************************************************
3874 * construct_printer_info5
3875 * fill a spoolss_PrinterInfo5 struct
3876 ********************************************************************/
3878 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
3879 const NT_PRINTER_INFO_LEVEL *ntprinter,
3880 struct spoolss_PrinterInfo5 *r,
3883 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3884 W_ERROR_HAVE_NO_MEMORY(r->printername);
3885 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
3886 W_ERROR_HAVE_NO_MEMORY(r->portname);
3888 r->attributes = ntprinter->info_2->attributes;
3890 /* these two are not used by NT+ according to MSDN */
3892 r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
3893 r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
3898 /********************************************************************
3899 * construct_printer_info_6
3900 * fill a spoolss_PrinterInfo6 struct
3901 ********************************************************************/
3903 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
3904 const NT_PRINTER_INFO_LEVEL *ntprinter,
3905 struct spoolss_PrinterInfo6 *r,
3909 print_status_struct status;
3911 count = print_queue_length(snum, &status);
3913 r->status = nt_printq_status(status.status);
3918 /********************************************************************
3919 * construct_printer_info7
3920 * fill a spoolss_PrinterInfo7 struct
3921 ********************************************************************/
3923 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
3924 Printer_entry *print_hnd,
3925 struct spoolss_PrinterInfo7 *r,
3930 if (is_printer_published(print_hnd, snum, &guid)) {
3931 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
3932 r->action = DSPRINT_PUBLISH;
3934 r->guid = talloc_strdup(mem_ctx, "");
3935 r->action = DSPRINT_UNPUBLISH;
3937 W_ERROR_HAVE_NO_MEMORY(r->guid);
3942 /********************************************************************
3943 * construct_printer_info8
3944 * fill a spoolss_PrinterInfo8 struct
3945 ********************************************************************/
3947 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
3948 const NT_PRINTER_INFO_LEVEL *ntprinter,
3949 struct spoolss_DeviceModeInfo *r,
3952 struct spoolss_DeviceMode *devmode;
3955 if (!ntprinter->info_2->devmode) {
3960 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3961 W_ERROR_HAVE_NO_MEMORY(devmode);
3963 result = convert_nt_devicemode(mem_ctx, devmode, ntprinter->info_2->devmode);
3964 if (!W_ERROR_IS_OK(result)) {
3965 TALLOC_FREE(devmode);
3969 r->devmode = devmode;
3975 /********************************************************************
3976 ********************************************************************/
3978 static bool snum_is_shared_printer(int snum)
3980 return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
3983 /********************************************************************
3984 Spoolss_enumprinters.
3985 ********************************************************************/
3987 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
3990 union spoolss_PrinterInfo **info_p,
3994 int n_services = lp_numservices();
3995 union spoolss_PrinterInfo *info = NULL;
3997 WERROR result = WERR_OK;
4002 for (snum = 0; snum < n_services; snum++) {
4004 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4006 if (!snum_is_shared_printer(snum)) {
4010 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4011 lp_servicename(snum), snum));
4013 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4014 union spoolss_PrinterInfo,
4017 result = WERR_NOMEM;
4021 result = get_a_printer(NULL, &ntprinter, 2,
4022 lp_const_servicename(snum));
4023 if (!W_ERROR_IS_OK(result)) {
4029 result = construct_printer_info0(info, ntprinter,
4030 &info[count].info0, snum);
4033 result = construct_printer_info1(info, ntprinter, flags,
4034 &info[count].info1, snum);
4037 result = construct_printer_info2(info, ntprinter,
4038 &info[count].info2, snum);
4041 result = construct_printer_info4(info, ntprinter,
4042 &info[count].info4, snum);
4045 result = construct_printer_info5(info, ntprinter,
4046 &info[count].info5, snum);
4050 result = WERR_UNKNOWN_LEVEL;
4051 free_a_printer(&ntprinter, 2);
4055 free_a_printer(&ntprinter, 2);
4056 if (!W_ERROR_IS_OK(result)) {
4067 if (!W_ERROR_IS_OK(result)) {
4077 /********************************************************************
4078 * handle enumeration of printers at level 0
4079 ********************************************************************/
4081 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4083 const char *servername,
4084 union spoolss_PrinterInfo **info,
4087 DEBUG(4,("enum_all_printers_info_0\n"));
4089 return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4093 /********************************************************************
4094 ********************************************************************/
4096 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4098 union spoolss_PrinterInfo **info,
4101 DEBUG(4,("enum_all_printers_info_1\n"));
4103 return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4106 /********************************************************************
4107 enum_all_printers_info_1_local.
4108 *********************************************************************/
4110 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4111 union spoolss_PrinterInfo **info,
4114 DEBUG(4,("enum_all_printers_info_1_local\n"));
4116 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4119 /********************************************************************
4120 enum_all_printers_info_1_name.
4121 *********************************************************************/
4123 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4125 union spoolss_PrinterInfo **info,
4128 const char *s = name;
4130 DEBUG(4,("enum_all_printers_info_1_name\n"));
4132 if ((name[0] == '\\') && (name[1] == '\\')) {
4136 if (!is_myname_or_ipaddr(s)) {
4137 return WERR_INVALID_NAME;
4140 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4143 /********************************************************************
4144 enum_all_printers_info_1_network.
4145 *********************************************************************/
4147 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4149 union spoolss_PrinterInfo **info,
4152 const char *s = name;
4154 DEBUG(4,("enum_all_printers_info_1_network\n"));
4156 /* If we respond to a enum_printers level 1 on our name with flags
4157 set to PRINTER_ENUM_REMOTE with a list of printers then these
4158 printers incorrectly appear in the APW browse list.
4159 Specifically the printers for the server appear at the workgroup
4160 level where all the other servers in the domain are
4161 listed. Windows responds to this call with a
4162 WERR_CAN_NOT_COMPLETE so we should do the same. */
4164 if (name[0] == '\\' && name[1] == '\\') {
4168 if (is_myname_or_ipaddr(s)) {
4169 return WERR_CAN_NOT_COMPLETE;
4172 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4175 /********************************************************************
4176 * api_spoolss_enumprinters
4178 * called from api_spoolss_enumprinters (see this to understand)
4179 ********************************************************************/
4181 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4182 union spoolss_PrinterInfo **info,
4185 DEBUG(4,("enum_all_printers_info_2\n"));
4187 return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4190 /********************************************************************
4191 * handle enumeration of printers at level 1
4192 ********************************************************************/
4194 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4197 union spoolss_PrinterInfo **info,
4200 /* Not all the flags are equals */
4202 if (flags & PRINTER_ENUM_LOCAL) {
4203 return enum_all_printers_info_1_local(mem_ctx, info, count);
4206 if (flags & PRINTER_ENUM_NAME) {
4207 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4210 if (flags & PRINTER_ENUM_NETWORK) {
4211 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4214 return WERR_OK; /* NT4sp5 does that */
4217 /********************************************************************
4218 * handle enumeration of printers at level 2
4219 ********************************************************************/
4221 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4223 const char *servername,
4224 union spoolss_PrinterInfo **info,
4227 if (flags & PRINTER_ENUM_LOCAL) {
4228 return enum_all_printers_info_2(mem_ctx, info, count);
4231 if (flags & PRINTER_ENUM_NAME) {
4232 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4233 return WERR_INVALID_NAME;
4236 return enum_all_printers_info_2(mem_ctx, info, count);
4239 if (flags & PRINTER_ENUM_REMOTE) {
4240 return WERR_UNKNOWN_LEVEL;
4246 /********************************************************************
4247 * handle enumeration of printers at level 4
4248 ********************************************************************/
4250 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4252 const char *servername,
4253 union spoolss_PrinterInfo **info,
4256 DEBUG(4,("enum_all_printers_info_4\n"));
4258 return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4262 /********************************************************************
4263 * handle enumeration of printers at level 5
4264 ********************************************************************/
4266 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4268 const char *servername,
4269 union spoolss_PrinterInfo **info,
4272 DEBUG(4,("enum_all_printers_info_5\n"));
4274 return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4277 /****************************************************************
4278 _spoolss_EnumPrinters
4279 ****************************************************************/
4281 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4282 struct spoolss_EnumPrinters *r)
4284 const char *name = NULL;
4287 /* that's an [in out] buffer */
4289 if (!r->in.buffer && (r->in.offered != 0)) {
4290 return WERR_INVALID_PARAM;
4293 DEBUG(4,("_spoolss_EnumPrinters\n"));
4297 *r->out.info = NULL;
4301 * flags==PRINTER_ENUM_NAME
4302 * if name=="" then enumerates all printers
4303 * if name!="" then enumerate the printer
4304 * flags==PRINTER_ENUM_REMOTE
4305 * name is NULL, enumerate printers
4306 * Level 2: name!="" enumerates printers, name can't be NULL
4307 * Level 3: doesn't exist
4308 * Level 4: does a local registry lookup
4309 * Level 5: same as Level 2
4313 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4314 W_ERROR_HAVE_NO_MEMORY(name);
4317 switch (r->in.level) {
4319 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4320 r->out.info, r->out.count);
4323 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4324 r->out.info, r->out.count);
4327 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4328 r->out.info, r->out.count);
4331 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4332 r->out.info, r->out.count);
4335 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4336 r->out.info, r->out.count);
4339 return WERR_UNKNOWN_LEVEL;
4342 if (!W_ERROR_IS_OK(result)) {
4346 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4347 spoolss_EnumPrinters, NULL,
4348 *r->out.info, r->in.level,
4350 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4351 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4353 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4356 /****************************************************************
4358 ****************************************************************/
4360 WERROR _spoolss_GetPrinter(pipes_struct *p,
4361 struct spoolss_GetPrinter *r)
4363 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4364 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4365 WERROR result = WERR_OK;
4369 /* that's an [in out] buffer */
4371 if (!r->in.buffer && (r->in.offered != 0)) {
4372 return WERR_INVALID_PARAM;
4377 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4381 result = get_a_printer(Printer, &ntprinter, 2,
4382 lp_const_servicename(snum));
4383 if (!W_ERROR_IS_OK(result)) {
4387 switch (r->in.level) {
4389 result = construct_printer_info0(p->mem_ctx, ntprinter,
4390 &r->out.info->info0, snum);
4393 result = construct_printer_info1(p->mem_ctx, ntprinter,
4395 &r->out.info->info1, snum);
4398 result = construct_printer_info2(p->mem_ctx, ntprinter,
4399 &r->out.info->info2, snum);
4402 result = construct_printer_info3(p->mem_ctx, ntprinter,
4403 &r->out.info->info3, snum);
4406 result = construct_printer_info4(p->mem_ctx, ntprinter,
4407 &r->out.info->info4, snum);
4410 result = construct_printer_info5(p->mem_ctx, ntprinter,
4411 &r->out.info->info5, snum);
4414 result = construct_printer_info6(p->mem_ctx, ntprinter,
4415 &r->out.info->info6, snum);
4418 result = construct_printer_info7(p->mem_ctx, Printer,
4419 &r->out.info->info7, snum);
4422 result = construct_printer_info8(p->mem_ctx, ntprinter,
4423 &r->out.info->info8, snum);
4426 result = WERR_UNKNOWN_LEVEL;
4430 free_a_printer(&ntprinter, 2);
4432 if (!W_ERROR_IS_OK(result)) {
4433 TALLOC_FREE(r->out.info);
4437 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4438 r->out.info, r->in.level);
4439 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4441 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4444 /********************************************************************
4445 ********************************************************************/
4447 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4448 const char **string_array,
4449 const char *cservername)
4451 int i, num_strings = 0;
4452 const char **array = NULL;
4454 if (!string_array) {
4458 for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4460 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4461 cservername, string_array[i]);
4468 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4475 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4476 &array, &num_strings);
4482 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4484 if (in && strlen(in)) { \
4485 out = talloc_strdup(mem_ctx, in); \
4486 W_ERROR_HAVE_NO_MEMORY(out); \
4492 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, in, out) \
4494 if (in && strlen(in)) { \
4495 out = talloc_asprintf(mem_ctx, "\\\\%s%s", server, in); \
4497 out = talloc_strdup(mem_ctx, ""); \
4499 W_ERROR_HAVE_NO_MEMORY(out); \
4502 /********************************************************************
4503 * fill a spoolss_DriverInfo1 struct
4504 ********************************************************************/
4506 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4507 struct spoolss_DriverInfo1 *r,
4508 const struct spoolss_DriverInfo8 *driver,
4509 const char *servername)
4511 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4512 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4517 /********************************************************************
4518 * fill a spoolss_DriverInfo2 struct
4519 ********************************************************************/
4521 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4522 struct spoolss_DriverInfo2 *r,
4523 const struct spoolss_DriverInfo8 *driver,
4524 const char *servername)
4527 const char *cservername = canon_servername(servername);
4529 r->version = driver->version;
4531 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4532 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4533 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4534 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4536 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4537 driver->driver_path,
4540 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4544 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4545 driver->config_file,
4551 /********************************************************************
4552 * fill a spoolss_DriverInfo3 struct
4553 ********************************************************************/
4555 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4556 struct spoolss_DriverInfo3 *r,
4557 const struct spoolss_DriverInfo8 *driver,
4558 const char *servername)
4560 const char *cservername = canon_servername(servername);
4562 r->version = driver->version;
4564 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4565 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4566 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4567 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4569 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4570 driver->driver_path,
4573 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4577 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4578 driver->config_file,
4581 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4585 FILL_DRIVER_STRING(mem_ctx,
4586 driver->monitor_name,
4589 FILL_DRIVER_STRING(mem_ctx,
4590 driver->default_datatype,
4591 r->default_datatype);
4593 r->dependent_files = string_array_from_driver_info(mem_ctx,
4594 driver->dependent_files,
4599 /********************************************************************
4600 * fill a spoolss_DriverInfo4 struct
4601 ********************************************************************/
4603 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4604 struct spoolss_DriverInfo4 *r,
4605 const struct spoolss_DriverInfo8 *driver,
4606 const char *servername)
4608 const char *cservername = canon_servername(servername);
4610 r->version = driver->version;
4612 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4613 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4614 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4615 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4617 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4618 driver->driver_path,
4621 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4625 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4626 driver->config_file,
4629 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4633 r->dependent_files = string_array_from_driver_info(mem_ctx,
4634 driver->dependent_files,
4637 FILL_DRIVER_STRING(mem_ctx,
4638 driver->monitor_name,
4641 FILL_DRIVER_STRING(mem_ctx,
4642 driver->default_datatype,
4643 r->default_datatype);
4645 r->previous_names = string_array_from_driver_info(mem_ctx,
4646 driver->previous_names,
4652 /********************************************************************
4653 * fill a spoolss_DriverInfo5 struct
4654 ********************************************************************/
4656 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4657 struct spoolss_DriverInfo5 *r,
4658 const struct spoolss_DriverInfo8 *driver,
4659 const char *servername)
4661 const char *cservername = canon_servername(servername);
4663 r->version = driver->version;
4665 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4666 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4667 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4668 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4670 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4671 driver->driver_path,
4674 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4678 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4679 driver->config_file,
4682 r->driver_attributes = 0;
4683 r->config_version = 0;
4684 r->driver_version = 0;
4688 /********************************************************************
4689 * fill a spoolss_DriverInfo6 struct
4690 ********************************************************************/
4692 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4693 struct spoolss_DriverInfo6 *r,
4694 const struct spoolss_DriverInfo8 *driver,
4695 const char *servername)
4697 const char *cservername = canon_servername(servername);
4699 r->version = driver->version;
4701 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4702 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4703 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4704 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4706 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4707 driver->driver_path,
4710 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4714 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4715 driver->config_file,
4718 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4722 FILL_DRIVER_STRING(mem_ctx,
4723 driver->monitor_name,
4726 FILL_DRIVER_STRING(mem_ctx,
4727 driver->default_datatype,
4728 r->default_datatype);
4730 r->dependent_files = string_array_from_driver_info(mem_ctx,
4731 driver->dependent_files,
4733 r->previous_names = string_array_from_driver_info(mem_ctx,
4734 driver->previous_names,
4737 r->driver_date = driver->driver_date;
4738 r->driver_version = driver->driver_version;
4740 FILL_DRIVER_STRING(mem_ctx,
4741 driver->manufacturer_name,
4742 r->manufacturer_name);
4743 FILL_DRIVER_STRING(mem_ctx,
4744 driver->manufacturer_url,
4745 r->manufacturer_url);
4746 FILL_DRIVER_STRING(mem_ctx,
4747 driver->hardware_id,
4749 FILL_DRIVER_STRING(mem_ctx,
4756 /********************************************************************
4757 * fill a spoolss_DriverInfo8 struct
4758 ********************************************************************/
4760 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
4761 struct spoolss_DriverInfo8 *r,
4762 const struct spoolss_DriverInfo8 *driver,
4763 const char *servername)
4765 const char *cservername = canon_servername(servername);
4767 r->version = driver->version;
4769 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4770 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4771 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4772 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4774 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4775 driver->driver_path,
4778 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4782 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4783 driver->config_file,
4786 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4790 FILL_DRIVER_STRING(mem_ctx,
4791 driver->monitor_name,
4794 FILL_DRIVER_STRING(mem_ctx,
4795 driver->default_datatype,
4796 r->default_datatype);
4798 r->dependent_files = string_array_from_driver_info(mem_ctx,
4799 driver->dependent_files,
4801 r->previous_names = string_array_from_driver_info(mem_ctx,
4802 driver->previous_names,
4805 r->driver_date = driver->driver_date;
4806 r->driver_version = driver->driver_version;
4808 FILL_DRIVER_STRING(mem_ctx,
4809 driver->manufacturer_name,
4810 r->manufacturer_name);
4811 FILL_DRIVER_STRING(mem_ctx,
4812 driver->manufacturer_url,
4813 r->manufacturer_url);
4814 FILL_DRIVER_STRING(mem_ctx,
4815 driver->hardware_id,
4817 FILL_DRIVER_STRING(mem_ctx,
4821 FILL_DRIVER_STRING(mem_ctx,
4822 driver->print_processor,
4823 r->print_processor);
4824 FILL_DRIVER_STRING(mem_ctx,
4825 driver->vendor_setup,
4828 r->color_profiles = string_array_from_driver_info(mem_ctx,
4829 driver->color_profiles,
4832 FILL_DRIVER_STRING(mem_ctx,
4836 r->printer_driver_attributes = driver->printer_driver_attributes;
4838 r->core_driver_dependencies = string_array_from_driver_info(mem_ctx,
4839 driver->core_driver_dependencies,
4842 r->min_inbox_driver_ver_date = driver->min_inbox_driver_ver_date;
4843 r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
4848 #if 0 /* disabled until marshalling issues are resolved - gd */
4849 /********************************************************************
4850 ********************************************************************/
4852 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
4853 struct spoolss_DriverFileInfo *r,
4854 const char *cservername,
4855 const char *file_name,
4856 enum spoolss_DriverFileType file_type,
4857 uint32_t file_version)
4859 r->file_name = talloc_asprintf(mem_ctx, "\\\\%s%s",
4860 cservername, file_name);
4861 W_ERROR_HAVE_NO_MEMORY(r->file_name);
4862 r->file_type = file_type;
4863 r->file_version = file_version;
4868 /********************************************************************
4869 ********************************************************************/
4871 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
4872 const struct spoolss_DriverInfo8 *driver,
4873 const char *cservername,
4874 struct spoolss_DriverFileInfo **info_p,
4877 struct spoolss_DriverFileInfo *info = NULL;
4885 if (strlen(driver->driver_path)) {
4886 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4887 struct spoolss_DriverFileInfo,
4889 W_ERROR_HAVE_NO_MEMORY(info);
4890 result = fill_spoolss_DriverFileInfo(info,
4893 driver->driver_path,
4894 SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
4896 W_ERROR_NOT_OK_RETURN(result);
4900 if (strlen(driver->config_file)) {
4901 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4902 struct spoolss_DriverFileInfo,
4904 W_ERROR_HAVE_NO_MEMORY(info);
4905 result = fill_spoolss_DriverFileInfo(info,
4908 driver->config_file,
4909 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
4911 W_ERROR_NOT_OK_RETURN(result);
4915 if (strlen(driver->data_file)) {
4916 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4917 struct spoolss_DriverFileInfo,
4919 W_ERROR_HAVE_NO_MEMORY(info);
4920 result = fill_spoolss_DriverFileInfo(info,
4924 SPOOLSS_DRIVER_FILE_TYPE_DATA,
4926 W_ERROR_NOT_OK_RETURN(result);
4930 if (strlen(driver->help_file)) {
4931 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4932 struct spoolss_DriverFileInfo,
4934 W_ERROR_HAVE_NO_MEMORY(info);
4935 result = fill_spoolss_DriverFileInfo(info,
4939 SPOOLSS_DRIVER_FILE_TYPE_HELP,
4941 W_ERROR_NOT_OK_RETURN(result);
4945 for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
4946 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4947 struct spoolss_DriverFileInfo,
4949 W_ERROR_HAVE_NO_MEMORY(info);
4950 result = fill_spoolss_DriverFileInfo(info,
4953 driver->dependent_files[i],
4954 SPOOLSS_DRIVER_FILE_TYPE_OTHER,
4956 W_ERROR_NOT_OK_RETURN(result);
4966 /********************************************************************
4967 * fill a spoolss_DriverInfo101 struct
4968 ********************************************************************/
4970 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
4971 struct spoolss_DriverInfo101 *r,
4972 const struct spoolss_DriverInfo8 *driver,
4973 const char *servername)
4975 const char *cservername = canon_servername(servername);
4978 r->version = driver->version;
4980 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4981 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4982 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4983 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4985 result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
4989 if (!W_ERROR_IS_OK(result)) {
4993 FILL_DRIVER_STRING(mem_ctx,
4994 driver->monitor_name,
4997 FILL_DRIVER_STRING(mem_ctx,
4998 driver->default_datatype,
4999 r->default_datatype);
5001 r->previous_names = string_array_from_driver_info(mem_ctx,
5002 driver->previous_names,
5004 r->driver_date = driver->driver_date;
5005 r->driver_version = driver->driver_version;
5007 FILL_DRIVER_STRING(mem_ctx,
5008 driver->manufacturer_name,
5009 r->manufacturer_name);
5010 FILL_DRIVER_STRING(mem_ctx,
5011 driver->manufacturer_url,
5012 r->manufacturer_url);
5013 FILL_DRIVER_STRING(mem_ctx,
5014 driver->hardware_id,
5016 FILL_DRIVER_STRING(mem_ctx,
5023 /********************************************************************
5024 ********************************************************************/
5026 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
5028 union spoolss_DriverInfo *r,
5030 const char *servername,
5031 const char *architecture,
5034 NT_PRINTER_INFO_LEVEL *printer = NULL;
5035 struct spoolss_DriverInfo8 *driver;
5038 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5040 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5041 win_errstr(result)));
5043 if (!W_ERROR_IS_OK(result)) {
5044 return WERR_INVALID_PRINTER_NAME;
5047 result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
5048 architecture, version);
5050 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5051 win_errstr(result)));
5053 if (!W_ERROR_IS_OK(result)) {
5055 * Is this a W2k client ?
5059 free_a_printer(&printer, 2);
5060 return WERR_UNKNOWN_PRINTER_DRIVER;
5063 /* Yes - try again with a WinNT driver. */
5065 result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
5066 architecture, version);
5067 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5068 win_errstr(result)));
5069 if (!W_ERROR_IS_OK(result)) {
5070 free_a_printer(&printer, 2);
5071 return WERR_UNKNOWN_PRINTER_DRIVER;
5077 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5080 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5083 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5086 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5089 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5092 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5095 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5097 #if 0 /* disabled until marshalling issues are resolved - gd */
5099 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5103 result = WERR_UNKNOWN_LEVEL;
5107 free_a_printer(&printer, 2);
5108 free_a_printer_driver(driver);
5113 /****************************************************************
5114 _spoolss_GetPrinterDriver2
5115 ****************************************************************/
5117 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5118 struct spoolss_GetPrinterDriver2 *r)
5120 Printer_entry *printer;
5123 const char *servername;
5126 /* that's an [in out] buffer */
5128 if (!r->in.buffer && (r->in.offered != 0)) {
5129 return WERR_INVALID_PARAM;
5132 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5134 if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5135 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5136 return WERR_INVALID_PRINTER_NAME;
5140 *r->out.server_major_version = 0;
5141 *r->out.server_minor_version = 0;
5143 servername = get_server_name(printer);
5145 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5149 result = construct_printer_driver_info_level(p->mem_ctx, r->in.level,
5153 r->in.client_major_version);
5154 if (!W_ERROR_IS_OK(result)) {
5155 TALLOC_FREE(r->out.info);
5159 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5160 r->out.info, r->in.level);
5161 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5163 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5167 /****************************************************************
5168 _spoolss_StartPagePrinter
5169 ****************************************************************/
5171 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5172 struct spoolss_StartPagePrinter *r)
5174 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5177 DEBUG(3,("_spoolss_StartPagePrinter: "
5178 "Error in startpageprinter printer handle\n"));
5182 Printer->page_started = true;
5186 /****************************************************************
5187 _spoolss_EndPagePrinter
5188 ****************************************************************/
5190 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5191 struct spoolss_EndPagePrinter *r)
5195 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5198 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5199 OUR_HANDLE(r->in.handle)));
5203 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5206 Printer->page_started = false;
5207 print_job_endpage(snum, Printer->jobid);
5212 /****************************************************************
5213 _spoolss_StartDocPrinter
5214 ****************************************************************/
5216 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5217 struct spoolss_StartDocPrinter *r)
5219 struct spoolss_DocumentInfo1 *info_1;
5221 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5224 DEBUG(2,("_spoolss_StartDocPrinter: "
5225 "Invalid handle (%s:%u:%u)\n",
5226 OUR_HANDLE(r->in.handle)));
5230 if (r->in.level != 1) {
5231 return WERR_UNKNOWN_LEVEL;
5234 info_1 = r->in.info.info1;
5237 * a nice thing with NT is it doesn't listen to what you tell it.
5238 * when asked to send _only_ RAW datas, it tries to send datas
5241 * So I add checks like in NT Server ...
5244 if (info_1->datatype) {
5245 if (strcmp(info_1->datatype, "RAW") != 0) {
5247 return WERR_INVALID_DATATYPE;
5251 /* get the share number of the printer */
5252 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5256 Printer->jobid = print_job_start(p->server_info, snum,
5257 info_1->document_name,
5258 Printer->nt_devmode);
5260 /* An error occured in print_job_start() so return an appropriate
5263 if (Printer->jobid == -1) {
5264 return map_werror_from_unix(errno);
5267 Printer->document_started = true;
5268 *r->out.job_id = Printer->jobid;
5273 /****************************************************************
5274 _spoolss_EndDocPrinter
5275 ****************************************************************/
5277 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5278 struct spoolss_EndDocPrinter *r)
5280 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5284 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5285 OUR_HANDLE(r->in.handle)));
5289 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5293 Printer->document_started = false;
5294 print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
5295 /* error codes unhandled so far ... */
5300 /****************************************************************
5301 _spoolss_WritePrinter
5302 ****************************************************************/
5304 WERROR _spoolss_WritePrinter(pipes_struct *p,
5305 struct spoolss_WritePrinter *r)
5307 uint32_t buffer_written;
5309 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5312 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5313 OUR_HANDLE(r->in.handle)));
5314 *r->out.num_written = r->in._data_size;
5318 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5321 buffer_written = (uint32_t)print_job_write(snum, Printer->jobid,
5322 (const char *)r->in.data.data,
5324 (size_t)r->in._data_size);
5325 if (buffer_written == (uint32_t)-1) {
5326 *r->out.num_written = 0;
5327 if (errno == ENOSPC)
5328 return WERR_NO_SPOOL_SPACE;
5330 return WERR_ACCESS_DENIED;
5333 *r->out.num_written = r->in._data_size;
5338 /********************************************************************
5339 * api_spoolss_getprinter
5340 * called from the spoolss dispatcher
5342 ********************************************************************/
5344 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5348 WERROR errcode = WERR_BADFUNC;
5349 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5352 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5353 OUR_HANDLE(handle)));
5357 if (!get_printer_snum(p, handle, &snum, NULL))
5361 case SPOOLSS_PRINTER_CONTROL_PAUSE:
5362 errcode = print_queue_pause(p->server_info, snum);
5364 case SPOOLSS_PRINTER_CONTROL_RESUME:
5365 case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5366 errcode = print_queue_resume(p->server_info, snum);
5368 case SPOOLSS_PRINTER_CONTROL_PURGE:
5369 errcode = print_queue_purge(p->server_info, snum);
5372 return WERR_UNKNOWN_LEVEL;
5379 /****************************************************************
5380 _spoolss_AbortPrinter
5381 * From MSDN: "Deletes printer's spool file if printer is configured
5383 ****************************************************************/
5385 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5386 struct spoolss_AbortPrinter *r)
5388 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5390 WERROR errcode = WERR_OK;
5393 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5394 OUR_HANDLE(r->in.handle)));
5398 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5401 print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5406 /********************************************************************
5407 * called by spoolss_api_setprinter
5408 * when updating a printer description
5409 ********************************************************************/
5411 static WERROR update_printer_sec(struct policy_handle *handle,
5412 pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5414 SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5418 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5420 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5421 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5422 OUR_HANDLE(handle)));
5424 result = WERR_BADFID;
5429 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5430 result = WERR_INVALID_PARAM;
5434 /* Check the user has permissions to change the security
5435 descriptor. By experimentation with two NT machines, the user
5436 requires Full Access to the printer to change security
5439 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5440 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5441 result = WERR_ACCESS_DENIED;
5445 /* NT seems to like setting the security descriptor even though
5446 nothing may have actually changed. */
5448 if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5449 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5450 result = WERR_BADFID;
5454 if (DEBUGLEVEL >= 10) {
5458 the_acl = old_secdesc_ctr->sd->dacl;
5459 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5460 PRINTERNAME(snum), the_acl->num_aces));
5462 for (i = 0; i < the_acl->num_aces; i++) {
5463 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5464 &the_acl->aces[i].trustee),
5465 the_acl->aces[i].access_mask));
5468 the_acl = secdesc_ctr->sd->dacl;
5471 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5472 PRINTERNAME(snum), the_acl->num_aces));
5474 for (i = 0; i < the_acl->num_aces; i++) {
5475 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5476 &the_acl->aces[i].trustee),
5477 the_acl->aces[i].access_mask));
5480 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5484 new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5485 if (!new_secdesc_ctr) {
5486 result = WERR_NOMEM;
5490 if (security_descriptor_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5495 result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5502 /********************************************************************
5503 Canonicalize printer info from a client
5505 ATTN: It does not matter what we set the servername to hear
5506 since we do the necessary work in get_a_printer() to set it to
5507 the correct value based on what the client sent in the
5508 _spoolss_open_printer_ex().
5509 ********************************************************************/
5511 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5513 fstring printername;
5516 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5517 "portname=%s drivername=%s comment=%s location=%s\n",
5518 info->servername, info->printername, info->sharename,
5519 info->portname, info->drivername, info->comment, info->location));
5521 /* we force some elements to "correct" values */
5522 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5523 fstrcpy(info->sharename, lp_servicename(snum));
5525 /* check to see if we allow printername != sharename */
5527 if ( lp_force_printername(snum) ) {
5528 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5529 global_myname(), info->sharename );
5532 /* make sure printername is in \\server\printername format */
5534 fstrcpy( printername, info->printername );
5536 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5537 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5541 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5542 global_myname(), p );
5545 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5546 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5553 /****************************************************************************
5554 ****************************************************************************/
5556 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5558 char *cmd = lp_addport_cmd();
5559 char *command = NULL;
5561 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5562 bool is_print_op = false;
5565 return WERR_ACCESS_DENIED;
5568 command = talloc_asprintf(ctx,
5569 "%s \"%s\" \"%s\"", cmd, portname, uri );
5575 is_print_op = user_has_privileges( token, &se_printop );
5577 DEBUG(10,("Running [%s]\n", command));
5579 /********* BEGIN SePrintOperatorPrivilege **********/
5584 ret = smbrun(command, NULL);
5589 /********* END SePrintOperatorPrivilege **********/
5591 DEBUGADD(10,("returned [%d]\n", ret));
5593 TALLOC_FREE(command);
5596 return WERR_ACCESS_DENIED;
5602 /****************************************************************************
5603 ****************************************************************************/
5605 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5607 char *cmd = lp_addprinter_cmd();
5609 char *command = NULL;
5613 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5614 bool is_print_op = false;
5615 char *remote_machine = talloc_strdup(ctx, "%m");
5617 if (!remote_machine) {
5620 remote_machine = talloc_sub_basic(ctx,
5621 current_user_info.smb_name,
5622 current_user_info.domain,
5624 if (!remote_machine) {
5628 command = talloc_asprintf(ctx,
5629 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5630 cmd, printer->info_2->printername, printer->info_2->sharename,
5631 printer->info_2->portname, printer->info_2->drivername,
5632 printer->info_2->location, printer->info_2->comment, remote_machine);
5638 is_print_op = user_has_privileges( token, &se_printop );
5640 DEBUG(10,("Running [%s]\n", command));
5642 /********* BEGIN SePrintOperatorPrivilege **********/
5647 if ( (ret = smbrun(command, &fd)) == 0 ) {
5648 /* Tell everyone we updated smb.conf. */
5649 message_send_all(smbd_messaging_context(),
5650 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
5656 /********* END SePrintOperatorPrivilege **********/
5658 DEBUGADD(10,("returned [%d]\n", ret));
5660 TALLOC_FREE(command);
5661 TALLOC_FREE(remote_machine);
5669 /* reload our services immediately */
5671 reload_services(false);
5675 /* Get lines and convert them back to dos-codepage */
5676 qlines = fd_lines_load(fd, &numlines, 0, NULL);
5677 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5680 /* Set the portname to what the script says the portname should be. */
5681 /* but don't require anything to be return from the script exit a good error code */
5684 /* Set the portname to what the script says the portname should be. */
5685 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
5686 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
5689 TALLOC_FREE(qlines);
5694 /********************************************************************
5695 * Called by spoolss_api_setprinter
5696 * when updating a printer description.
5697 ********************************************************************/
5699 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
5700 struct spoolss_SetPrinterInfoCtr *info_ctr,
5701 struct spoolss_DeviceMode *devmode)
5704 NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
5705 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5710 DEBUG(8,("update_printer\n"));
5715 result = WERR_BADFID;
5719 if (!get_printer_snum(p, handle, &snum, NULL)) {
5720 result = WERR_BADFID;
5724 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
5725 (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
5726 result = WERR_BADFID;
5730 DEBUGADD(8,("Converting info_2 struct\n"));
5733 * convert_printer_info converts the incoming
5734 * info from the client and overwrites the info
5735 * just read from the tdb in the pointer 'printer'.
5738 if (!convert_printer_info(info_ctr, printer)) {
5739 result = WERR_NOMEM;
5744 /* we have a valid devmode
5745 convert it and link it*/
5747 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5748 if (!convert_devicemode(printer->info_2->printername, devmode,
5749 &printer->info_2->devmode)) {
5750 result = WERR_NOMEM;
5755 /* Do sanity check on the requested changes for Samba */
5757 if (!check_printer_ok(printer->info_2, snum)) {
5758 result = WERR_INVALID_PARAM;
5762 /* FIXME!!! If the driver has changed we really should verify that
5763 it is installed before doing much else --jerry */
5765 /* Check calling user has permission to update printer description */
5767 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
5768 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5769 result = WERR_ACCESS_DENIED;
5773 /* Call addprinter hook */
5774 /* Check changes to see if this is really needed */
5776 if ( *lp_addprinter_cmd()
5777 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
5778 || !strequal(printer->info_2->comment, old_printer->info_2->comment)
5779 || !strequal(printer->info_2->portname, old_printer->info_2->portname)
5780 || !strequal(printer->info_2->location, old_printer->info_2->location)) )
5782 /* add_printer_hook() will call reload_services() */
5784 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
5786 result = WERR_ACCESS_DENIED;
5792 * When a *new* driver is bound to a printer, the drivername is used to
5793 * lookup previously saved driver initialization info, which is then
5794 * bound to the printer, simulating what happens in the Windows arch.
5796 if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
5798 if (!set_driver_init(printer, 2))
5800 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
5801 printer->info_2->drivername));
5804 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
5805 printer->info_2->drivername));
5807 notify_printer_driver(snum, printer->info_2->drivername);
5811 * flag which changes actually occured. This is a small subset of
5812 * all the possible changes. We also have to update things in the
5816 if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
5817 push_reg_sz(talloc_tos(), &buffer, printer->info_2->comment);
5818 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
5819 REG_SZ, buffer.data, buffer.length);
5821 notify_printer_comment(snum, printer->info_2->comment);
5824 if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
5825 push_reg_sz(talloc_tos(), &buffer, printer->info_2->sharename);
5826 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
5827 REG_SZ, buffer.data, buffer.length);
5829 notify_printer_sharename(snum, printer->info_2->sharename);
5832 if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
5835 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
5838 pname = printer->info_2->printername;
5841 push_reg_sz(talloc_tos(), &buffer, pname);
5842 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
5843 REG_SZ, buffer.data, buffer.length);
5845 notify_printer_printername( snum, pname );
5848 if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
5849 push_reg_sz(talloc_tos(), &buffer, printer->info_2->portname);
5850 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
5851 REG_SZ, buffer.data, buffer.length);
5853 notify_printer_port(snum, printer->info_2->portname);
5856 if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
5857 push_reg_sz(talloc_tos(), &buffer, printer->info_2->location);
5858 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
5859 REG_SZ, buffer.data, buffer.length);
5861 notify_printer_location(snum, printer->info_2->location);
5864 /* here we need to update some more DsSpooler keys */
5865 /* uNCName, serverName, shortServerName */
5867 push_reg_sz(talloc_tos(), &buffer, global_myname());
5868 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
5869 REG_SZ, buffer.data, buffer.length);
5870 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
5871 REG_SZ, buffer.data, buffer.length);
5873 slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
5874 global_myname(), printer->info_2->sharename );
5875 push_reg_sz(talloc_tos(), &buffer, asc_buffer);
5876 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
5877 REG_SZ, buffer.data, buffer.length);
5879 /* Update printer info */
5880 result = mod_a_printer(printer, 2);
5883 free_a_printer(&printer, 2);
5884 free_a_printer(&old_printer, 2);
5890 /****************************************************************************
5891 ****************************************************************************/
5892 static WERROR publish_or_unpublish_printer(pipes_struct *p,
5893 struct policy_handle *handle,
5894 struct spoolss_SetPrinterInfo7 *info7)
5898 Printer_entry *Printer;
5900 if ( lp_security() != SEC_ADS ) {
5901 return WERR_UNKNOWN_LEVEL;
5904 Printer = find_printer_index_by_hnd(p, handle);
5906 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
5911 if (!get_printer_snum(p, handle, &snum, NULL))
5914 nt_printer_publish(Printer, snum, info7->action);
5918 return WERR_UNKNOWN_LEVEL;
5922 /********************************************************************
5923 ********************************************************************/
5925 static WERROR update_printer_devmode(pipes_struct *p, struct policy_handle *handle,
5926 struct spoolss_DeviceMode *devmode)
5929 NT_PRINTER_INFO_LEVEL *printer = NULL;
5930 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5933 DEBUG(8,("update_printer_devmode\n"));
5938 result = WERR_BADFID;
5942 if (!get_printer_snum(p, handle, &snum, NULL)) {
5943 result = WERR_BADFID;
5947 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum)))) {
5948 result = WERR_BADFID;
5953 /* we have a valid devmode
5954 convert it and link it*/
5956 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5957 if (!convert_devicemode(printer->info_2->printername, devmode,
5958 &printer->info_2->devmode)) {
5959 result = WERR_NOMEM;
5964 /* Check calling user has permission to update printer description */
5966 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
5967 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5968 result = WERR_ACCESS_DENIED;
5973 /* Update printer info */
5974 result = mod_a_printer(printer, 2);
5977 free_a_printer(&printer, 2);
5983 /****************************************************************
5985 ****************************************************************/
5987 WERROR _spoolss_SetPrinter(pipes_struct *p,
5988 struct spoolss_SetPrinter *r)
5992 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5995 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
5996 OUR_HANDLE(r->in.handle)));
6000 /* check the level */
6001 switch (r->in.info_ctr->level) {
6003 return control_printer(r->in.handle, r->in.command, p);
6005 result = update_printer(p, r->in.handle,
6007 r->in.devmode_ctr->devmode);
6008 if (!W_ERROR_IS_OK(result))
6010 if (r->in.secdesc_ctr->sd)
6011 result = update_printer_sec(r->in.handle, p,
6015 return update_printer_sec(r->in.handle, p,
6018 return publish_or_unpublish_printer(p, r->in.handle,
6019 r->in.info_ctr->info.info7);
6021 return update_printer_devmode(p, r->in.handle,
6022 r->in.devmode_ctr->devmode);
6024 return WERR_UNKNOWN_LEVEL;
6028 /****************************************************************
6029 _spoolss_FindClosePrinterNotify
6030 ****************************************************************/
6032 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
6033 struct spoolss_FindClosePrinterNotify *r)
6035 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6038 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6039 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6043 if (Printer->notify.client_connected == true) {
6046 if ( Printer->printer_type == SPLHND_SERVER)
6048 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6049 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6052 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6055 Printer->notify.flags=0;
6056 Printer->notify.options=0;
6057 Printer->notify.localmachine[0]='\0';
6058 Printer->notify.printerlocal=0;
6059 TALLOC_FREE(Printer->notify.option);
6060 Printer->notify.client_connected = false;
6065 /****************************************************************
6067 ****************************************************************/
6069 WERROR _spoolss_AddJob(pipes_struct *p,
6070 struct spoolss_AddJob *r)
6072 if (!r->in.buffer && (r->in.offered != 0)) {
6073 return WERR_INVALID_PARAM;
6076 /* this is what a NT server returns for AddJob. AddJob must fail on
6077 * non-local printers */
6079 if (r->in.level != 1) {
6080 return WERR_UNKNOWN_LEVEL;
6083 return WERR_INVALID_PARAM;
6086 /****************************************************************************
6088 ****************************************************************************/
6090 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6091 struct spoolss_JobInfo1 *r,
6092 const print_queue_struct *queue,
6093 int position, int snum,
6094 const NT_PRINTER_INFO_LEVEL *ntprinter)
6098 t = gmtime(&queue->time);
6100 r->job_id = queue->job;
6102 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6103 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6104 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6105 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6106 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6107 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6108 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6109 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6110 r->data_type = talloc_strdup(mem_ctx, "RAW");
6111 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6112 r->text_status = talloc_strdup(mem_ctx, "");
6113 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6115 r->status = nt_printj_status(queue->status);
6116 r->priority = queue->priority;
6117 r->position = position;
6118 r->total_pages = queue->page_count;
6119 r->pages_printed = 0; /* ??? */
6121 init_systemtime(&r->submitted, t);
6126 /****************************************************************************
6128 ****************************************************************************/
6130 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6131 struct spoolss_JobInfo2 *r,
6132 const print_queue_struct *queue,
6133 int position, int snum,
6134 const NT_PRINTER_INFO_LEVEL *ntprinter,
6135 struct spoolss_DeviceMode *devmode)
6139 t = gmtime(&queue->time);
6141 r->job_id = queue->job;
6143 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6144 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6145 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6146 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6147 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6148 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6149 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6150 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6151 r->notify_name = talloc_strdup(mem_ctx, queue->fs_user);
6152 W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6153 r->data_type = talloc_strdup(mem_ctx, "RAW");
6154 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6155 r->print_processor = talloc_strdup(mem_ctx, "winprint");
6156 W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6157 r->parameters = talloc_strdup(mem_ctx, "");
6158 W_ERROR_HAVE_NO_MEMORY(r->parameters);
6159 r->driver_name = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6160 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6162 r->devmode = devmode;
6164 r->text_status = talloc_strdup(mem_ctx, "");
6165 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6169 r->status = nt_printj_status(queue->status);
6170 r->priority = queue->priority;
6171 r->position = position;
6174 r->total_pages = queue->page_count;
6175 r->size = queue->size;
6176 init_systemtime(&r->submitted, t);
6178 r->pages_printed = 0; /* ??? */
6183 /****************************************************************************
6185 ****************************************************************************/
6187 static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
6188 struct spoolss_JobInfo3 *r,
6189 const print_queue_struct *queue,
6190 const print_queue_struct *next_queue,
6191 int position, int snum,
6192 const NT_PRINTER_INFO_LEVEL *ntprinter)
6194 r->job_id = queue->job;
6197 r->next_job_id = next_queue->job;
6204 /****************************************************************************
6205 Enumjobs at level 1.
6206 ****************************************************************************/
6208 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6209 const print_queue_struct *queue,
6210 uint32_t num_queues, int snum,
6211 const NT_PRINTER_INFO_LEVEL *ntprinter,
6212 union spoolss_JobInfo **info_p,
6215 union spoolss_JobInfo *info;
6217 WERROR result = WERR_OK;
6219 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6220 W_ERROR_HAVE_NO_MEMORY(info);
6222 *count = num_queues;
6224 for (i=0; i<*count; i++) {
6225 result = fill_job_info1(info,
6231 if (!W_ERROR_IS_OK(result)) {
6237 if (!W_ERROR_IS_OK(result)) {
6248 /****************************************************************************
6249 Enumjobs at level 2.
6250 ****************************************************************************/
6252 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6253 const print_queue_struct *queue,
6254 uint32_t num_queues, int snum,
6255 const NT_PRINTER_INFO_LEVEL *ntprinter,
6256 union spoolss_JobInfo **info_p,
6259 union spoolss_JobInfo *info;
6261 WERROR result = WERR_OK;
6263 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6264 W_ERROR_HAVE_NO_MEMORY(info);
6266 *count = num_queues;
6268 for (i=0; i<*count; i++) {
6270 struct spoolss_DeviceMode *devmode;
6272 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6274 result = WERR_NOMEM;
6278 result = fill_job_info2(info,
6285 if (!W_ERROR_IS_OK(result)) {
6291 if (!W_ERROR_IS_OK(result)) {
6302 /****************************************************************************
6303 Enumjobs at level 3.
6304 ****************************************************************************/
6306 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
6307 const print_queue_struct *queue,
6308 uint32_t num_queues, int snum,
6309 const NT_PRINTER_INFO_LEVEL *ntprinter,
6310 union spoolss_JobInfo **info_p,
6313 union spoolss_JobInfo *info;
6315 WERROR result = WERR_OK;
6317 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6318 W_ERROR_HAVE_NO_MEMORY(info);
6320 *count = num_queues;
6322 for (i=0; i<*count; i++) {
6323 const print_queue_struct *next_queue = NULL;
6326 next_queue = &queue[i+1];
6329 result = fill_job_info3(info,
6336 if (!W_ERROR_IS_OK(result)) {
6342 if (!W_ERROR_IS_OK(result)) {
6353 /****************************************************************
6355 ****************************************************************/
6357 WERROR _spoolss_EnumJobs(pipes_struct *p,
6358 struct spoolss_EnumJobs *r)
6361 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6363 print_status_struct prt_status;
6364 print_queue_struct *queue = NULL;
6367 /* that's an [in out] buffer */
6369 if (!r->in.buffer && (r->in.offered != 0)) {
6370 return WERR_INVALID_PARAM;
6373 DEBUG(4,("_spoolss_EnumJobs\n"));
6377 *r->out.info = NULL;
6379 /* lookup the printer snum and tdb entry */
6381 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6385 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6386 if (!W_ERROR_IS_OK(result)) {
6390 count = print_queue_status(snum, &queue, &prt_status);
6391 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6392 count, prt_status.status, prt_status.message));
6396 free_a_printer(&ntprinter, 2);
6400 switch (r->in.level) {
6402 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6403 ntprinter, r->out.info, r->out.count);
6406 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6407 ntprinter, r->out.info, r->out.count);
6410 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
6411 ntprinter, r->out.info, r->out.count);
6414 result = WERR_UNKNOWN_LEVEL;
6419 free_a_printer(&ntprinter, 2);
6421 if (!W_ERROR_IS_OK(result)) {
6425 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6426 spoolss_EnumJobs, NULL,
6427 *r->out.info, r->in.level,
6429 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6430 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6432 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6435 /****************************************************************
6436 _spoolss_ScheduleJob
6437 ****************************************************************/
6439 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6440 struct spoolss_ScheduleJob *r)
6445 /****************************************************************
6447 ****************************************************************/
6449 WERROR _spoolss_SetJob(pipes_struct *p,
6450 struct spoolss_SetJob *r)
6453 WERROR errcode = WERR_BADFUNC;
6455 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6459 if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6460 return WERR_INVALID_PRINTER_NAME;
6463 switch (r->in.command) {
6464 case SPOOLSS_JOB_CONTROL_CANCEL:
6465 case SPOOLSS_JOB_CONTROL_DELETE:
6466 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6470 case SPOOLSS_JOB_CONTROL_PAUSE:
6471 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6475 case SPOOLSS_JOB_CONTROL_RESTART:
6476 case SPOOLSS_JOB_CONTROL_RESUME:
6477 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6482 return WERR_UNKNOWN_LEVEL;
6488 /****************************************************************************
6489 Enumerates all printer drivers by level and architecture.
6490 ****************************************************************************/
6492 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
6493 const char *servername,
6494 const char *architecture,
6496 union spoolss_DriverInfo **info_p,
6502 fstring *list = NULL;
6503 struct spoolss_DriverInfo8 *driver;
6504 union spoolss_DriverInfo *info = NULL;
6506 WERROR result = WERR_OK;
6511 for (version=0; version<DRIVER_MAX_VERSION; version++) {
6513 ndrivers = get_ntdrivers(&list, architecture, version);
6514 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6515 ndrivers, architecture, version));
6517 if (ndrivers == -1) {
6518 result = WERR_NOMEM;
6522 if (ndrivers != 0) {
6523 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6524 union spoolss_DriverInfo,
6527 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
6528 "failed to enlarge driver info buffer!\n"));
6529 result = WERR_NOMEM;
6534 for (i=0; i<ndrivers; i++) {
6535 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6536 ZERO_STRUCT(driver);
6537 result = get_a_printer_driver(mem_ctx, &driver, list[i],
6538 architecture, version);
6539 if (!W_ERROR_IS_OK(result)) {
6545 result = fill_printer_driver_info1(info, &info[count+i].info1,
6546 driver, servername);
6549 result = fill_printer_driver_info2(info, &info[count+i].info2,
6550 driver, servername);
6553 result = fill_printer_driver_info3(info, &info[count+i].info3,
6554 driver, servername);
6557 result = fill_printer_driver_info4(info, &info[count+i].info4,
6558 driver, servername);
6561 result = fill_printer_driver_info5(info, &info[count+i].info5,
6562 driver, servername);
6565 result = fill_printer_driver_info6(info, &info[count+i].info6,
6566 driver, servername);
6569 result = fill_printer_driver_info8(info, &info[count+i].info8,
6570 driver, servername);
6573 result = WERR_UNKNOWN_LEVEL;
6577 free_a_printer_driver(driver);
6579 if (!W_ERROR_IS_OK(result)) {
6591 if (!W_ERROR_IS_OK(result)) {
6602 /****************************************************************************
6603 Enumerates all printer drivers by level.
6604 ****************************************************************************/
6606 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6607 const char *servername,
6608 const char *architecture,
6610 union spoolss_DriverInfo **info_p,
6614 WERROR result = WERR_OK;
6616 if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
6618 for (a=0; archi_table[a].long_archi != NULL; a++) {
6620 union spoolss_DriverInfo *info = NULL;
6623 result = enumprinterdrivers_level_by_architecture(mem_ctx,
6625 archi_table[a].long_archi,
6629 if (!W_ERROR_IS_OK(result)) {
6633 for (i=0; i < count; i++) {
6634 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
6635 info[i], info_p, count_p);
6642 return enumprinterdrivers_level_by_architecture(mem_ctx,
6650 /****************************************************************
6651 _spoolss_EnumPrinterDrivers
6652 ****************************************************************/
6654 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6655 struct spoolss_EnumPrinterDrivers *r)
6657 const char *cservername;
6660 /* that's an [in out] buffer */
6662 if (!r->in.buffer && (r->in.offered != 0)) {
6663 return WERR_INVALID_PARAM;
6666 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6670 *r->out.info = NULL;
6672 cservername = canon_servername(r->in.server);
6674 if (!is_myname_or_ipaddr(cservername)) {
6675 return WERR_UNKNOWN_PRINTER_DRIVER;
6678 result = enumprinterdrivers_level(p->mem_ctx, cservername,
6683 if (!W_ERROR_IS_OK(result)) {
6687 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6688 spoolss_EnumPrinterDrivers, NULL,
6689 *r->out.info, r->in.level,
6691 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6692 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6694 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6697 /****************************************************************************
6698 ****************************************************************************/
6700 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
6701 struct spoolss_FormInfo1 *r,
6702 const nt_forms_struct *form)
6704 r->form_name = talloc_strdup(mem_ctx, form->name);
6705 W_ERROR_HAVE_NO_MEMORY(r->form_name);
6707 r->flags = form->flag;
6708 r->size.width = form->width;
6709 r->size.height = form->length;
6710 r->area.left = form->left;
6711 r->area.top = form->top;
6712 r->area.right = form->right;
6713 r->area.bottom = form->bottom;
6718 /****************************************************************
6719 spoolss_enumforms_level1
6720 ****************************************************************/
6722 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
6723 const nt_forms_struct *builtin_forms,
6724 uint32_t num_builtin_forms,
6725 const nt_forms_struct *user_forms,
6726 uint32_t num_user_forms,
6727 union spoolss_FormInfo **info_p,
6730 union spoolss_FormInfo *info;
6731 WERROR result = WERR_OK;
6734 *count = num_builtin_forms + num_user_forms;
6736 info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
6737 W_ERROR_HAVE_NO_MEMORY(info);
6739 /* construct the list of form structures */
6740 for (i=0; i<num_builtin_forms; i++) {
6741 DEBUGADD(6,("Filling builtin form number [%d]\n",i));
6742 result = fill_form_info_1(info, &info[i].info1,
6744 if (!W_ERROR_IS_OK(result)) {
6749 for (i=0; i<num_user_forms; i++) {
6750 DEBUGADD(6,("Filling user form number [%d]\n",i));
6751 result = fill_form_info_1(info, &info[i+num_builtin_forms].info1,
6753 if (!W_ERROR_IS_OK(result)) {
6759 if (!W_ERROR_IS_OK(result)) {
6770 /****************************************************************
6772 ****************************************************************/
6774 WERROR _spoolss_EnumForms(pipes_struct *p,
6775 struct spoolss_EnumForms *r)
6778 nt_forms_struct *user_forms = NULL;
6779 nt_forms_struct *builtin_forms = NULL;
6780 uint32_t num_user_forms;
6781 uint32_t num_builtin_forms;
6785 *r->out.info = NULL;
6787 /* that's an [in out] buffer */
6789 if (!r->in.buffer && (r->in.offered != 0) ) {
6790 return WERR_INVALID_PARAM;
6793 DEBUG(4,("_spoolss_EnumForms\n"));
6794 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6795 DEBUGADD(5,("Info level [%d]\n", r->in.level));
6797 num_builtin_forms = get_builtin_ntforms(&builtin_forms);
6798 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
6799 num_user_forms = get_ntforms(&user_forms);
6800 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
6802 if (num_user_forms + num_builtin_forms == 0) {
6803 SAFE_FREE(builtin_forms);
6804 SAFE_FREE(user_forms);
6805 return WERR_NO_MORE_ITEMS;
6808 switch (r->in.level) {
6810 result = spoolss_enumforms_level1(p->mem_ctx,
6819 result = WERR_UNKNOWN_LEVEL;
6823 SAFE_FREE(user_forms);
6824 SAFE_FREE(builtin_forms);
6826 if (!W_ERROR_IS_OK(result)) {
6830 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6831 spoolss_EnumForms, NULL,
6832 *r->out.info, r->in.level,
6834 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6835 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6837 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6840 /****************************************************************
6841 ****************************************************************/
6843 static WERROR find_form_byname(const char *name,
6844 nt_forms_struct *form)
6846 nt_forms_struct *list = NULL;
6847 int num_forms = 0, i = 0;
6849 if (get_a_builtin_ntform_by_string(name, form)) {
6853 num_forms = get_ntforms(&list);
6854 DEBUGADD(5,("Number of forms [%d]\n", num_forms));
6856 if (num_forms == 0) {
6860 /* Check if the requested name is in the list of form structures */
6861 for (i = 0; i < num_forms; i++) {
6863 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
6865 if (strequal(name, list[i].name)) {
6866 DEBUGADD(6,("Found form %s number [%d]\n", name, i));
6878 /****************************************************************
6880 ****************************************************************/
6882 WERROR _spoolss_GetForm(pipes_struct *p,
6883 struct spoolss_GetForm *r)
6886 nt_forms_struct form;
6888 /* that's an [in out] buffer */
6890 if (!r->in.buffer && (r->in.offered != 0)) {
6891 return WERR_INVALID_PARAM;
6894 DEBUG(4,("_spoolss_GetForm\n"));
6895 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6896 DEBUGADD(5,("Info level [%d]\n", r->in.level));
6898 result = find_form_byname(r->in.form_name, &form);
6899 if (!W_ERROR_IS_OK(result)) {
6900 TALLOC_FREE(r->out.info);
6904 switch (r->in.level) {
6906 result = fill_form_info_1(p->mem_ctx,
6907 &r->out.info->info1,
6912 result = WERR_UNKNOWN_LEVEL;
6916 if (!W_ERROR_IS_OK(result)) {
6917 TALLOC_FREE(r->out.info);
6921 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
6922 r->out.info, r->in.level);
6923 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
6925 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6928 /****************************************************************************
6929 ****************************************************************************/
6931 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
6932 struct spoolss_PortInfo1 *r,
6935 r->port_name = talloc_strdup(mem_ctx, name);
6936 W_ERROR_HAVE_NO_MEMORY(r->port_name);
6941 /****************************************************************************
6942 TODO: This probably needs distinguish between TCP/IP and Local ports
6944 ****************************************************************************/
6946 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
6947 struct spoolss_PortInfo2 *r,
6950 r->port_name = talloc_strdup(mem_ctx, name);
6951 W_ERROR_HAVE_NO_MEMORY(r->port_name);
6953 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
6954 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
6956 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
6957 W_ERROR_HAVE_NO_MEMORY(r->description);
6959 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
6966 /****************************************************************************
6967 wrapper around the enumer ports command
6968 ****************************************************************************/
6970 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
6972 char *cmd = lp_enumports_cmd();
6973 char **qlines = NULL;
6974 char *command = NULL;
6982 /* if no hook then just fill in the default port */
6985 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
6988 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
6989 TALLOC_FREE(qlines);
6996 /* we have a valid enumport command */
6998 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7003 DEBUG(10,("Running [%s]\n", command));
7004 ret = smbrun(command, &fd);
7005 DEBUG(10,("Returned [%d]\n", ret));
7006 TALLOC_FREE(command);
7011 return WERR_ACCESS_DENIED;
7015 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7016 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7026 /****************************************************************************
7028 ****************************************************************************/
7030 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7031 union spoolss_PortInfo **info_p,
7034 union spoolss_PortInfo *info = NULL;
7036 WERROR result = WERR_OK;
7037 char **qlines = NULL;
7040 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7041 if (!W_ERROR_IS_OK(result)) {
7046 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7048 DEBUG(10,("Returning WERR_NOMEM\n"));
7049 result = WERR_NOMEM;
7053 for (i=0; i<numlines; i++) {
7054 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7055 result = fill_port_1(info, &info[i].info1, qlines[i]);
7056 if (!W_ERROR_IS_OK(result)) {
7061 TALLOC_FREE(qlines);
7064 if (!W_ERROR_IS_OK(result)) {
7066 TALLOC_FREE(qlines);
7078 /****************************************************************************
7080 ****************************************************************************/
7082 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7083 union spoolss_PortInfo **info_p,
7086 union spoolss_PortInfo *info = NULL;
7088 WERROR result = WERR_OK;
7089 char **qlines = NULL;
7092 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7093 if (!W_ERROR_IS_OK(result)) {
7098 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7100 DEBUG(10,("Returning WERR_NOMEM\n"));
7101 result = WERR_NOMEM;
7105 for (i=0; i<numlines; i++) {
7106 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7107 result = fill_port_2(info, &info[i].info2, qlines[i]);
7108 if (!W_ERROR_IS_OK(result)) {
7113 TALLOC_FREE(qlines);
7116 if (!W_ERROR_IS_OK(result)) {
7118 TALLOC_FREE(qlines);
7130 /****************************************************************
7132 ****************************************************************/
7134 WERROR _spoolss_EnumPorts(pipes_struct *p,
7135 struct spoolss_EnumPorts *r)
7139 /* that's an [in out] buffer */
7141 if (!r->in.buffer && (r->in.offered != 0)) {
7142 return WERR_INVALID_PARAM;
7145 DEBUG(4,("_spoolss_EnumPorts\n"));
7149 *r->out.info = NULL;
7151 switch (r->in.level) {
7153 result = enumports_level_1(p->mem_ctx, r->out.info,
7157 result = enumports_level_2(p->mem_ctx, r->out.info,
7161 return WERR_UNKNOWN_LEVEL;
7164 if (!W_ERROR_IS_OK(result)) {
7168 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7169 spoolss_EnumPorts, NULL,
7170 *r->out.info, r->in.level,
7172 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7173 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7175 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7178 /****************************************************************************
7179 ****************************************************************************/
7181 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7183 struct spoolss_SetPrinterInfoCtr *info_ctr,
7184 struct spoolss_DeviceMode *devmode,
7185 struct security_descriptor *sec_desc,
7186 struct spoolss_UserLevelCtr *user_ctr,
7187 struct policy_handle *handle)
7189 NT_PRINTER_INFO_LEVEL *printer = NULL;
7192 WERROR err = WERR_OK;
7194 if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7195 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7199 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7200 if (!convert_printer_info(info_ctr, printer)) {
7201 free_a_printer(&printer, 2);
7205 /* samba does not have a concept of local, non-shared printers yet, so
7206 * make sure we always setup sharename - gd */
7207 if ((printer->info_2->sharename[0] == '\0') && (printer->info_2->printername != '\0')) {
7208 DEBUG(5, ("spoolss_addprinterex_level_2: "
7209 "no sharename has been set, setting printername %s as sharename\n",
7210 printer->info_2->printername));
7211 fstrcpy(printer->info_2->sharename, printer->info_2->printername);
7214 /* check to see if the printer already exists */
7216 if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7217 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7218 printer->info_2->sharename));
7219 free_a_printer(&printer, 2);
7220 return WERR_PRINTER_ALREADY_EXISTS;
7223 if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
7224 if ((snum = print_queue_snum(printer->info_2->printername)) != -1) {
7225 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7226 printer->info_2->printername));
7227 free_a_printer(&printer, 2);
7228 return WERR_PRINTER_ALREADY_EXISTS;
7232 /* validate printer info struct */
7233 if (!info_ctr->info.info2->printername ||
7234 strlen(info_ctr->info.info2->printername) == 0) {
7235 free_a_printer(&printer,2);
7236 return WERR_INVALID_PRINTER_NAME;
7238 if (!info_ctr->info.info2->portname ||
7239 strlen(info_ctr->info.info2->portname) == 0) {
7240 free_a_printer(&printer,2);
7241 return WERR_UNKNOWN_PORT;
7243 if (!info_ctr->info.info2->drivername ||
7244 strlen(info_ctr->info.info2->drivername) == 0) {
7245 free_a_printer(&printer,2);
7246 return WERR_UNKNOWN_PRINTER_DRIVER;
7248 if (!info_ctr->info.info2->printprocessor ||
7249 strlen(info_ctr->info.info2->printprocessor) == 0) {
7250 free_a_printer(&printer,2);
7251 return WERR_UNKNOWN_PRINTPROCESSOR;
7254 /* FIXME!!! smbd should check to see if the driver is installed before
7255 trying to add a printer like this --jerry */
7257 if (*lp_addprinter_cmd() ) {
7258 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7260 free_a_printer(&printer,2);
7261 return WERR_ACCESS_DENIED;
7264 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7265 "smb.conf parameter \"addprinter command\" is defined. This"
7266 "parameter must exist for this call to succeed\n",
7267 printer->info_2->sharename ));
7270 /* use our primary netbios name since get_a_printer() will convert
7271 it to what the client expects on a case by case basis */
7273 slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7274 printer->info_2->sharename);
7277 if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7278 free_a_printer(&printer,2);
7279 return WERR_ACCESS_DENIED;
7282 /* you must be a printer admin to add a new printer */
7283 if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
7284 free_a_printer(&printer,2);
7285 return WERR_ACCESS_DENIED;
7289 * Do sanity check on the requested changes for Samba.
7292 if (!check_printer_ok(printer->info_2, snum)) {
7293 free_a_printer(&printer,2);
7294 return WERR_INVALID_PARAM;
7298 * When a printer is created, the drivername bound to the printer is used
7299 * to lookup previously saved driver initialization info, which is then
7300 * bound to the new printer, simulating what happens in the Windows arch.
7305 set_driver_init(printer, 2);
7309 /* A valid devmode was included, convert and link it
7311 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7313 if (!convert_devicemode(printer->info_2->printername, devmode,
7314 &printer->info_2->devmode)) {
7319 /* write the ASCII on disk */
7320 err = mod_a_printer(printer, 2);
7321 if (!W_ERROR_IS_OK(err)) {
7322 free_a_printer(&printer,2);
7326 if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7327 /* Handle open failed - remove addition. */
7328 del_a_printer(printer->info_2->sharename);
7329 free_a_printer(&printer,2);
7330 ZERO_STRUCTP(handle);
7331 return WERR_ACCESS_DENIED;
7334 update_c_setprinter(false);
7335 free_a_printer(&printer,2);
7340 /****************************************************************
7341 _spoolss_AddPrinterEx
7342 ****************************************************************/
7344 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7345 struct spoolss_AddPrinterEx *r)
7347 switch (r->in.info_ctr->level) {
7349 /* we don't handle yet */
7350 /* but I know what to do ... */
7351 return WERR_UNKNOWN_LEVEL;
7353 return spoolss_addprinterex_level_2(p, r->in.server,
7355 r->in.devmode_ctr->devmode,
7356 r->in.secdesc_ctr->sd,
7357 r->in.userlevel_ctr,
7360 return WERR_UNKNOWN_LEVEL;
7364 /****************************************************************
7366 ****************************************************************/
7368 WERROR _spoolss_AddPrinter(pipes_struct *p,
7369 struct spoolss_AddPrinter *r)
7371 struct spoolss_AddPrinterEx a;
7372 struct spoolss_UserLevelCtr userlevel_ctr;
7374 ZERO_STRUCT(userlevel_ctr);
7376 userlevel_ctr.level = 1;
7378 a.in.server = r->in.server;
7379 a.in.info_ctr = r->in.info_ctr;
7380 a.in.devmode_ctr = r->in.devmode_ctr;
7381 a.in.secdesc_ctr = r->in.secdesc_ctr;
7382 a.in.userlevel_ctr = &userlevel_ctr;
7383 a.out.handle = r->out.handle;
7385 return _spoolss_AddPrinterEx(p, &a);
7388 /****************************************************************
7389 _spoolss_AddPrinterDriver
7390 ****************************************************************/
7392 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7393 struct spoolss_AddPrinterDriver *r)
7395 WERROR err = WERR_OK;
7396 char *driver_name = NULL;
7400 switch (p->hdr_req.opnum) {
7401 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7402 fn = "_spoolss_AddPrinterDriver";
7404 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7405 fn = "_spoolss_AddPrinterDriverEx";
7408 return WERR_INVALID_PARAM;
7413 if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
7414 /* Clever hack from Martin Zielinski <mz@seh.de>
7415 * to allow downgrade from level 8 (Vista).
7417 DEBUG(0,("%s: level %d not yet implemented\n", fn,
7418 r->in.info_ctr->level));
7419 return WERR_UNKNOWN_LEVEL;
7422 DEBUG(5,("Cleaning driver's information\n"));
7423 err = clean_up_driver_struct(p, r->in.info_ctr);
7424 if (!W_ERROR_IS_OK(err))
7427 DEBUG(5,("Moving driver to final destination\n"));
7428 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, r->in.info_ctr,
7433 if (add_a_printer_driver(p->mem_ctx, r->in.info_ctr, &driver_name, &version)!=0) {
7434 err = WERR_ACCESS_DENIED;
7439 * I think this is where he DrvUpgradePrinter() hook would be
7440 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7441 * server. Right now, we just need to send ourselves a message
7442 * to update each printer bound to this driver. --jerry
7445 if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7446 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7451 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7452 * decide if the driver init data should be deleted. The rules are:
7453 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7454 * 2) delete init data only if there is no 2k/Xp driver
7455 * 3) always delete init data
7456 * The generalized rule is always use init data from the highest order driver.
7457 * It is necessary to follow the driver install by an initialization step to
7458 * finish off this process.
7463 * 9x printer driver - never delete init data
7466 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7471 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7472 * there is no 2k/Xp driver init data for this driver name.
7476 struct spoolss_DriverInfo8 *driver1;
7478 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &driver1, driver_name, "Windows NT x86", 3))) {
7480 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7482 if (!del_driver_init(driver_name))
7483 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7487 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7489 free_a_printer_driver(driver1);
7490 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7497 * 2k or Xp printer driver - always delete init data
7500 if (!del_driver_init(driver_name))
7501 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7506 DEBUG(0,("%s: invalid level=%d\n", fn,
7507 r->in.info_ctr->level));
7516 /****************************************************************
7517 _spoolss_AddPrinterDriverEx
7518 ****************************************************************/
7520 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7521 struct spoolss_AddPrinterDriverEx *r)
7523 struct spoolss_AddPrinterDriver a;
7526 * we only support the semantics of AddPrinterDriver()
7527 * i.e. only copy files that are newer than existing ones
7530 if (r->in.flags != APD_COPY_NEW_FILES) {
7531 return WERR_ACCESS_DENIED;
7534 a.in.servername = r->in.servername;
7535 a.in.info_ctr = r->in.info_ctr;
7537 return _spoolss_AddPrinterDriver(p, &a);
7540 /****************************************************************************
7541 ****************************************************************************/
7543 struct _spoolss_paths {
7549 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7551 static const struct _spoolss_paths spoolss_paths[]= {
7552 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
7553 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
7556 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7557 const char *servername,
7558 const char *environment,
7562 const char *pservername = NULL;
7563 const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7564 const char *short_archi;
7568 /* environment may be empty */
7569 if (environment && strlen(environment)) {
7570 long_archi = environment;
7573 /* servername may be empty */
7574 if (servername && strlen(servername)) {
7575 pservername = canon_servername(servername);
7577 if (!is_myname_or_ipaddr(pservername)) {
7578 return WERR_INVALID_PARAM;
7582 if (!(short_archi = get_short_archi(long_archi))) {
7583 return WERR_INVALID_ENVIRONMENT;
7586 switch (component) {
7587 case SPOOLSS_PRTPROCS_PATH:
7588 case SPOOLSS_DRIVER_PATH:
7590 *path = talloc_asprintf(mem_ctx,
7593 spoolss_paths[component].share,
7596 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7597 SPOOLSS_DEFAULT_SERVER_PATH,
7598 spoolss_paths[component].dir,
7603 return WERR_INVALID_PARAM;
7613 /****************************************************************************
7614 ****************************************************************************/
7616 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7617 const char *servername,
7618 const char *environment,
7619 struct spoolss_DriverDirectoryInfo1 *r)
7624 werr = compose_spoolss_server_path(mem_ctx,
7627 SPOOLSS_DRIVER_PATH,
7629 if (!W_ERROR_IS_OK(werr)) {
7633 DEBUG(4,("printer driver directory: [%s]\n", path));
7635 r->directory_name = path;
7640 /****************************************************************
7641 _spoolss_GetPrinterDriverDirectory
7642 ****************************************************************/
7644 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7645 struct spoolss_GetPrinterDriverDirectory *r)
7649 /* that's an [in out] buffer */
7651 if (!r->in.buffer && (r->in.offered != 0)) {
7652 return WERR_INVALID_PARAM;
7655 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7660 /* r->in.level is ignored */
7662 werror = getprinterdriverdir_level_1(p->mem_ctx,
7665 &r->out.info->info1);
7666 if (!W_ERROR_IS_OK(werror)) {
7667 TALLOC_FREE(r->out.info);
7671 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
7672 r->out.info, r->in.level);
7673 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7675 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7678 /****************************************************************
7679 _spoolss_EnumPrinterData
7680 ****************************************************************/
7682 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
7683 struct spoolss_EnumPrinterData *r)
7685 NT_PRINTER_INFO_LEVEL *printer = NULL;
7686 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7689 struct regval_blob *val = NULL;
7690 NT_PRINTER_DATA *p_data;
7691 int i, key_index, num_values;
7694 *r->out.value_needed = 0;
7695 *r->out.type = REG_NONE;
7696 *r->out.data_needed = 0;
7698 DEBUG(5,("_spoolss_EnumPrinterData\n"));
7701 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
7702 OUR_HANDLE(r->in.handle)));
7706 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7710 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7711 if (!W_ERROR_IS_OK(result)) {
7715 p_data = printer->info_2->data;
7716 key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
7721 * The NT machine wants to know the biggest size of value and data
7723 * cf: MSDN EnumPrinterData remark section
7726 if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
7728 uint32_t biggest_valuesize = 0;
7729 uint32_t biggest_datasize = 0;
7731 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7733 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
7735 for ( i=0; i<num_values; i++ )
7737 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
7739 name_length = strlen(val->valuename);
7740 if ( strlen(val->valuename) > biggest_valuesize )
7741 biggest_valuesize = name_length;
7743 if ( val->size > biggest_datasize )
7744 biggest_datasize = val->size;
7746 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
7750 /* the value is an UNICODE string but real_value_size is the length
7751 in bytes including the trailing 0 */
7753 *r->out.value_needed = 2 * (1 + biggest_valuesize);
7754 *r->out.data_needed = biggest_datasize;
7756 DEBUG(6,("final values: [%d], [%d]\n",
7757 *r->out.value_needed, *r->out.data_needed));
7763 * the value len is wrong in NT sp3
7764 * that's the number of bytes not the number of unicode chars
7767 if (key_index != -1) {
7768 val = regval_ctr_specific_value(p_data->keys[key_index].values,
7774 /* out_value should default to "" or else NT4 has
7775 problems unmarshalling the response */
7777 if (r->in.value_offered) {
7778 *r->out.value_needed = 1;
7779 r->out.value_name = talloc_strdup(r, "");
7780 if (!r->out.value_name) {
7781 result = WERR_NOMEM;
7785 r->out.value_name = NULL;
7786 *r->out.value_needed = 0;
7789 /* the data is counted in bytes */
7791 *r->out.data_needed = r->in.data_offered;
7793 result = WERR_NO_MORE_ITEMS;
7797 * - counted in bytes in the request
7798 * - counted in UNICODE chars in the max reply
7799 * - counted in bytes in the real size
7801 * take a pause *before* coding not *during* coding
7805 if (r->in.value_offered) {
7806 r->out.value_name = talloc_strdup(r, regval_name(val));
7807 if (!r->out.value_name) {
7808 result = WERR_NOMEM;
7811 *r->out.value_needed = strlen_m(regval_name(val));
7813 r->out.value_name = NULL;
7814 *r->out.value_needed = 0;
7819 *r->out.type = regval_type(val);
7821 /* data - counted in bytes */
7824 * See the section "Dynamically Typed Query Parameters"
7828 if (r->out.data && regval_data_p(val) &&
7829 regval_size(val) && r->in.data_offered) {
7830 memcpy(r->out.data, regval_data_p(val),
7831 MIN(regval_size(val),r->in.data_offered));
7834 *r->out.data_needed = regval_size(val);
7838 free_a_printer(&printer, 2);
7842 /****************************************************************
7843 _spoolss_SetPrinterData
7844 ****************************************************************/
7846 WERROR _spoolss_SetPrinterData(pipes_struct *p,
7847 struct spoolss_SetPrinterData *r)
7849 struct spoolss_SetPrinterDataEx r2;
7851 r2.in.handle = r->in.handle;
7852 r2.in.key_name = "PrinterDriverData";
7853 r2.in.value_name = r->in.value_name;
7854 r2.in.type = r->in.type;
7855 r2.in.data = r->in.data;
7856 r2.in._offered = r->in._offered;
7858 return _spoolss_SetPrinterDataEx(p, &r2);
7861 /****************************************************************
7862 _spoolss_ResetPrinter
7863 ****************************************************************/
7865 WERROR _spoolss_ResetPrinter(pipes_struct *p,
7866 struct spoolss_ResetPrinter *r)
7868 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7871 DEBUG(5,("_spoolss_ResetPrinter\n"));
7874 * All we do is to check to see if the handle and queue is valid.
7875 * This call really doesn't mean anything to us because we only
7876 * support RAW printing. --jerry
7880 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
7881 OUR_HANDLE(r->in.handle)));
7885 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7889 /* blindly return success */
7893 /****************************************************************
7894 _spoolss_DeletePrinterData
7895 ****************************************************************/
7897 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
7898 struct spoolss_DeletePrinterData *r)
7900 struct spoolss_DeletePrinterDataEx r2;
7902 r2.in.handle = r->in.handle;
7903 r2.in.key_name = "PrinterDriverData";
7904 r2.in.value_name = r->in.value_name;
7906 return _spoolss_DeletePrinterDataEx(p, &r2);
7909 /****************************************************************
7911 ****************************************************************/
7913 WERROR _spoolss_AddForm(pipes_struct *p,
7914 struct spoolss_AddForm *r)
7916 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
7917 nt_forms_struct tmpForm;
7919 WERROR status = WERR_OK;
7920 NT_PRINTER_INFO_LEVEL *printer = NULL;
7921 SE_PRIV se_printop = SE_PRINT_OPERATOR;
7924 nt_forms_struct *list=NULL;
7925 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7927 DEBUG(5,("_spoolss_AddForm\n"));
7930 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
7931 OUR_HANDLE(r->in.handle)));
7936 /* forms can be added on printer of on the print server handle */
7938 if ( Printer->printer_type == SPLHND_PRINTER )
7940 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7943 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7944 if (!W_ERROR_IS_OK(status))
7948 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
7949 and not a printer admin, then fail */
7951 if ((p->server_info->utok.uid != sec_initial_uid()) &&
7952 !user_has_privileges(p->server_info->ptok, &se_printop) &&
7953 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7955 p->server_info->ptok,
7956 lp_printer_admin(snum))) {
7957 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
7958 return WERR_ACCESS_DENIED;
7961 /* can't add if builtin */
7963 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
7964 status = WERR_FILE_EXISTS;
7968 count = get_ntforms(&list);
7970 if(!add_a_form(&list, form, &count)) {
7971 status = WERR_NOMEM;
7976 write_ntforms(&list, count);
7980 * ChangeID must always be set if this is a printer
7983 if ( Printer->printer_type == SPLHND_PRINTER )
7984 status = mod_a_printer(printer, 2);
7988 free_a_printer(&printer, 2);
7994 /****************************************************************
7996 ****************************************************************/
7998 WERROR _spoolss_DeleteForm(pipes_struct *p,
7999 struct spoolss_DeleteForm *r)
8001 const char *form_name = r->in.form_name;
8002 nt_forms_struct tmpForm;
8004 nt_forms_struct *list=NULL;
8005 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8007 WERROR status = WERR_OK;
8008 NT_PRINTER_INFO_LEVEL *printer = NULL;
8009 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8012 DEBUG(5,("_spoolss_DeleteForm\n"));
8015 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8016 OUR_HANDLE(r->in.handle)));
8020 /* forms can be deleted on printer of on the print server handle */
8022 if ( Printer->printer_type == SPLHND_PRINTER )
8024 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8027 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8028 if (!W_ERROR_IS_OK(status))
8032 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8033 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8034 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8036 p->server_info->ptok,
8037 lp_printer_admin(snum))) {
8038 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8039 return WERR_ACCESS_DENIED;
8043 /* can't delete if builtin */
8045 if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8046 status = WERR_INVALID_PARAM;
8050 count = get_ntforms(&list);
8053 ret = delete_a_form(&list, form_name, &count, &status);
8060 * ChangeID must always be set if this is a printer
8063 if ( Printer->printer_type == SPLHND_PRINTER )
8064 status = mod_a_printer(printer, 2);
8068 free_a_printer(&printer, 2);
8074 /****************************************************************
8076 ****************************************************************/
8078 WERROR _spoolss_SetForm(pipes_struct *p,
8079 struct spoolss_SetForm *r)
8081 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8082 nt_forms_struct tmpForm;
8084 WERROR status = WERR_OK;
8085 NT_PRINTER_INFO_LEVEL *printer = NULL;
8086 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8089 nt_forms_struct *list=NULL;
8090 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8092 DEBUG(5,("_spoolss_SetForm\n"));
8095 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8096 OUR_HANDLE(r->in.handle)));
8100 /* forms can be modified on printer of on the print server handle */
8102 if ( Printer->printer_type == SPLHND_PRINTER )
8104 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8107 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8108 if (!W_ERROR_IS_OK(status))
8112 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8113 and not a printer admin, then fail */
8115 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8116 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8117 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8119 p->server_info->ptok,
8120 lp_printer_admin(snum))) {
8121 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8122 return WERR_ACCESS_DENIED;
8125 /* can't set if builtin */
8126 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8127 status = WERR_INVALID_PARAM;
8131 count = get_ntforms(&list);
8132 update_a_form(&list, form, count);
8134 write_ntforms(&list, count);
8138 * ChangeID must always be set if this is a printer
8141 if ( Printer->printer_type == SPLHND_PRINTER )
8142 status = mod_a_printer(printer, 2);
8147 free_a_printer(&printer, 2);
8153 /****************************************************************************
8154 fill_print_processor1
8155 ****************************************************************************/
8157 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8158 struct spoolss_PrintProcessorInfo1 *r,
8159 const char *print_processor_name)
8161 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8162 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8167 /****************************************************************************
8168 enumprintprocessors level 1.
8169 ****************************************************************************/
8171 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8172 union spoolss_PrintProcessorInfo **info_p,
8175 union spoolss_PrintProcessorInfo *info;
8178 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8179 W_ERROR_HAVE_NO_MEMORY(info);
8183 result = fill_print_processor1(info, &info[0].info1, "winprint");
8184 if (!W_ERROR_IS_OK(result)) {
8189 if (!W_ERROR_IS_OK(result)) {
8200 /****************************************************************
8201 _spoolss_EnumPrintProcessors
8202 ****************************************************************/
8204 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8205 struct spoolss_EnumPrintProcessors *r)
8209 /* that's an [in out] buffer */
8211 if (!r->in.buffer && (r->in.offered != 0)) {
8212 return WERR_INVALID_PARAM;
8215 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8218 * Enumerate the print processors ...
8220 * Just reply with "winprint", to keep NT happy
8221 * and I can use my nice printer checker.
8226 *r->out.info = NULL;
8228 switch (r->in.level) {
8230 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8234 return WERR_UNKNOWN_LEVEL;
8237 if (!W_ERROR_IS_OK(result)) {
8241 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8242 spoolss_EnumPrintProcessors, NULL,
8243 *r->out.info, r->in.level,
8245 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8246 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8248 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8251 /****************************************************************************
8252 fill_printprocdatatype1
8253 ****************************************************************************/
8255 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8256 struct spoolss_PrintProcDataTypesInfo1 *r,
8257 const char *name_array)
8259 r->name_array = talloc_strdup(mem_ctx, name_array);
8260 W_ERROR_HAVE_NO_MEMORY(r->name_array);
8265 /****************************************************************************
8266 enumprintprocdatatypes level 1.
8267 ****************************************************************************/
8269 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8270 union spoolss_PrintProcDataTypesInfo **info_p,
8274 union spoolss_PrintProcDataTypesInfo *info;
8276 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8277 W_ERROR_HAVE_NO_MEMORY(info);
8281 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8282 if (!W_ERROR_IS_OK(result)) {
8287 if (!W_ERROR_IS_OK(result)) {
8298 /****************************************************************
8299 _spoolss_EnumPrintProcDataTypes
8300 ****************************************************************/
8302 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8303 struct spoolss_EnumPrintProcDataTypes *r)
8307 /* that's an [in out] buffer */
8309 if (!r->in.buffer && (r->in.offered != 0)) {
8310 return WERR_INVALID_PARAM;
8313 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8317 *r->out.info = NULL;
8319 switch (r->in.level) {
8321 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8325 return WERR_UNKNOWN_LEVEL;
8328 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8329 spoolss_EnumPrintProcDataTypes, NULL,
8330 *r->out.info, r->in.level,
8332 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8333 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8335 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8338 /****************************************************************************
8340 ****************************************************************************/
8342 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8343 struct spoolss_MonitorInfo1 *r,
8344 const char *monitor_name)
8346 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8347 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8352 /****************************************************************************
8354 ****************************************************************************/
8356 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8357 struct spoolss_MonitorInfo2 *r,
8358 const char *monitor_name,
8359 const char *environment,
8360 const char *dll_name)
8362 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8363 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8364 r->environment = talloc_strdup(mem_ctx, environment);
8365 W_ERROR_HAVE_NO_MEMORY(r->environment);
8366 r->dll_name = talloc_strdup(mem_ctx, dll_name);
8367 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8372 /****************************************************************************
8373 enumprintmonitors level 1.
8374 ****************************************************************************/
8376 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8377 union spoolss_MonitorInfo **info_p,
8380 union spoolss_MonitorInfo *info;
8381 WERROR result = WERR_OK;
8383 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8384 W_ERROR_HAVE_NO_MEMORY(info);
8388 result = fill_monitor_1(info, &info[0].info1,
8390 if (!W_ERROR_IS_OK(result)) {
8394 result = fill_monitor_1(info, &info[1].info1,
8396 if (!W_ERROR_IS_OK(result)) {
8401 if (!W_ERROR_IS_OK(result)) {
8412 /****************************************************************************
8413 enumprintmonitors level 2.
8414 ****************************************************************************/
8416 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8417 union spoolss_MonitorInfo **info_p,
8420 union spoolss_MonitorInfo *info;
8421 WERROR result = WERR_OK;
8423 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8424 W_ERROR_HAVE_NO_MEMORY(info);
8428 result = fill_monitor_2(info, &info[0].info2,
8430 "Windows NT X86", /* FIXME */
8432 if (!W_ERROR_IS_OK(result)) {
8436 result = fill_monitor_2(info, &info[1].info2,
8438 "Windows NT X86", /* FIXME */
8440 if (!W_ERROR_IS_OK(result)) {
8445 if (!W_ERROR_IS_OK(result)) {
8456 /****************************************************************
8457 _spoolss_EnumMonitors
8458 ****************************************************************/
8460 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8461 struct spoolss_EnumMonitors *r)
8465 /* that's an [in out] buffer */
8467 if (!r->in.buffer && (r->in.offered != 0)) {
8468 return WERR_INVALID_PARAM;
8471 DEBUG(5,("_spoolss_EnumMonitors\n"));
8474 * Enumerate the print monitors ...
8476 * Just reply with "Local Port", to keep NT happy
8477 * and I can use my nice printer checker.
8482 *r->out.info = NULL;
8484 switch (r->in.level) {
8486 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8490 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8494 return WERR_UNKNOWN_LEVEL;
8497 if (!W_ERROR_IS_OK(result)) {
8501 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8502 spoolss_EnumMonitors, NULL,
8503 *r->out.info, r->in.level,
8505 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8506 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8508 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8511 /****************************************************************************
8512 ****************************************************************************/
8514 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8515 const print_queue_struct *queue,
8516 int count, int snum,
8517 const NT_PRINTER_INFO_LEVEL *ntprinter,
8519 struct spoolss_JobInfo1 *r)
8524 for (i=0; i<count && found == false; i++) {
8525 if (queue[i].job == (int)jobid) {
8530 if (found == false) {
8531 /* NT treats not found as bad param... yet another bad choice */
8532 return WERR_INVALID_PARAM;
8535 return fill_job_info1(mem_ctx,
8543 /****************************************************************************
8544 ****************************************************************************/
8546 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8547 const print_queue_struct *queue,
8548 int count, int snum,
8549 const NT_PRINTER_INFO_LEVEL *ntprinter,
8551 struct spoolss_JobInfo2 *r)
8555 struct spoolss_DeviceMode *devmode;
8556 NT_DEVICEMODE *nt_devmode;
8559 for (i=0; i<count && found == false; i++) {
8560 if (queue[i].job == (int)jobid) {
8565 if (found == false) {
8566 /* NT treats not found as bad param... yet another bad
8568 return WERR_INVALID_PARAM;
8572 * if the print job does not have a DEVMODE associated with it,
8573 * just use the one for the printer. A NULL devicemode is not
8574 * a failure condition
8577 nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8579 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
8580 W_ERROR_HAVE_NO_MEMORY(devmode);
8581 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
8582 if (!W_ERROR_IS_OK(result)) {
8586 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
8587 W_ERROR_HAVE_NO_MEMORY(devmode);
8590 return fill_job_info2(mem_ctx,
8599 /****************************************************************
8601 ****************************************************************/
8603 WERROR _spoolss_GetJob(pipes_struct *p,
8604 struct spoolss_GetJob *r)
8606 WERROR result = WERR_OK;
8607 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
8610 print_queue_struct *queue = NULL;
8611 print_status_struct prt_status;
8613 /* that's an [in out] buffer */
8615 if (!r->in.buffer && (r->in.offered != 0)) {
8616 return WERR_INVALID_PARAM;
8619 DEBUG(5,("_spoolss_GetJob\n"));
8623 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8627 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
8628 if (!W_ERROR_IS_OK(result)) {
8632 count = print_queue_status(snum, &queue, &prt_status);
8634 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8635 count, prt_status.status, prt_status.message));
8637 switch (r->in.level) {
8639 result = getjob_level_1(p->mem_ctx,
8640 queue, count, snum, ntprinter,
8641 r->in.job_id, &r->out.info->info1);
8644 result = getjob_level_2(p->mem_ctx,
8645 queue, count, snum, ntprinter,
8646 r->in.job_id, &r->out.info->info2);
8649 result = WERR_UNKNOWN_LEVEL;
8654 free_a_printer(&ntprinter, 2);
8656 if (!W_ERROR_IS_OK(result)) {
8657 TALLOC_FREE(r->out.info);
8661 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
8662 r->out.info, r->in.level);
8663 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8665 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8668 /****************************************************************
8669 _spoolss_GetPrinterDataEx
8670 ****************************************************************/
8672 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
8673 struct spoolss_GetPrinterDataEx *r)
8676 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8677 struct regval_blob *val = NULL;
8678 NT_PRINTER_INFO_LEVEL *printer = NULL;
8680 WERROR result = WERR_OK;
8683 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8685 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8686 r->in.key_name, r->in.value_name));
8688 /* in case of problem, return some default values */
8691 *r->out.type = REG_NONE;
8694 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8695 OUR_HANDLE(r->in.handle)));
8696 result = WERR_BADFID;
8700 /* Is the handle to a printer or to the server? */
8702 if (Printer->printer_type == SPLHND_SERVER) {
8704 result = getprinterdata_printer_server(p->mem_ctx,
8711 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8712 result = WERR_BADFID;
8716 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8717 if (!W_ERROR_IS_OK(result)) {
8721 /* check to see if the keyname is valid */
8722 if (!strlen(r->in.key_name)) {
8723 result = WERR_INVALID_PARAM;
8727 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
8729 if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
8730 strequal(r->in.value_name, "ChangeId")) {
8731 *r->out.type = REG_DWORD;
8733 r->out.data->value = printer->info_2->changeid;
8738 if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
8739 DEBUG(4,("_spoolss_GetPrinterDataEx: "
8740 "Invalid keyname [%s]\n", r->in.key_name ));
8741 result = WERR_BADFILE;
8745 val = get_printer_data(printer->info_2,
8746 r->in.key_name, r->in.value_name);
8748 result = WERR_BADFILE;
8752 *r->out.needed = regval_size(val);
8753 *r->out.type = regval_type(val);
8755 blob = data_blob_const(regval_data_p(val), regval_size(val));
8757 result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
8763 free_a_printer(&printer, 2);
8766 if (!W_ERROR_IS_OK(result)) {
8770 *r->out.needed = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
8771 *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
8772 r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
8774 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
8777 /****************************************************************
8778 _spoolss_SetPrinterDataEx
8779 ****************************************************************/
8781 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
8782 struct spoolss_SetPrinterDataEx *r)
8784 NT_PRINTER_INFO_LEVEL *printer = NULL;
8786 WERROR result = WERR_OK;
8787 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8791 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
8793 /* From MSDN documentation of SetPrinterDataEx: pass request to
8794 SetPrinterData if key is "PrinterDriverData" */
8797 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8798 OUR_HANDLE(r->in.handle)));
8802 if (Printer->printer_type == SPLHND_SERVER) {
8803 DEBUG(10,("_spoolss_SetPrinterDataEx: "
8804 "Not implemented for server handles yet\n"));
8805 return WERR_INVALID_PARAM;
8808 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8813 * Access check : NT returns "access denied" if you make a
8814 * SetPrinterData call without the necessary privildge.
8815 * we were originally returning OK if nothing changed
8816 * which made Win2k issue **a lot** of SetPrinterData
8817 * when connecting to a printer --jerry
8820 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8821 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
8822 "change denied by handle access permissions\n"));
8823 return WERR_ACCESS_DENIED;
8826 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8827 if (!W_ERROR_IS_OK(result)) {
8831 /* check for OID in valuename */
8833 oid_string = strchr(r->in.value_name, ',');
8839 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8840 r->in.type, &r->in.data);
8841 if (!W_ERROR_IS_OK(result)) {
8846 * When client side code sets a magic printer data key, detect it and save
8847 * the current printer data and the magic key's data (its the DEVMODE) for
8848 * future printer/driver initializations.
8850 if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8851 /* Set devmode and printer initialization info */
8852 result = save_driver_init(printer, 2, blob.data, blob.length);
8854 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8859 /* save the registry data */
8861 result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
8862 r->in.type, blob.data, blob.length);
8864 if (W_ERROR_IS_OK(result)) {
8865 /* save the OID if one was specified */
8867 char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
8868 r->in.key_name, SPOOL_OID_KEY);
8870 result = WERR_NOMEM;
8875 * I'm not checking the status here on purpose. Don't know
8876 * if this is right, but I'm returning the status from the
8877 * previous set_printer_dataex() call. I have no idea if
8878 * this is right. --jerry
8881 set_printer_dataex(printer, str, r->in.value_name,
8882 REG_SZ, (uint8_t *)oid_string,
8883 strlen(oid_string)+1);
8886 result = mod_a_printer(printer, 2);
8890 free_a_printer(&printer, 2);
8895 /****************************************************************
8896 _spoolss_DeletePrinterDataEx
8897 ****************************************************************/
8899 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
8900 struct spoolss_DeletePrinterDataEx *r)
8902 NT_PRINTER_INFO_LEVEL *printer = NULL;
8904 WERROR status = WERR_OK;
8905 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8907 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
8910 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
8911 "Invalid handle (%s:%u:%u).\n",
8912 OUR_HANDLE(r->in.handle)));
8916 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8919 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8920 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
8921 "printer properties change denied by handle\n"));
8922 return WERR_ACCESS_DENIED;
8925 if (!r->in.value_name || !r->in.key_name) {
8929 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8930 if (!W_ERROR_IS_OK(status))
8933 status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
8935 if ( W_ERROR_IS_OK(status) )
8936 mod_a_printer( printer, 2 );
8938 free_a_printer(&printer, 2);
8943 /****************************************************************
8944 _spoolss_EnumPrinterKey
8945 ****************************************************************/
8947 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
8948 struct spoolss_EnumPrinterKey *r)
8950 fstring *keynames = NULL;
8952 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8953 NT_PRINTER_DATA *data;
8954 NT_PRINTER_INFO_LEVEL *printer = NULL;
8956 WERROR result = WERR_BADFILE;
8958 const char **array = NULL;
8961 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
8964 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
8965 OUR_HANDLE(r->in.handle)));
8969 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8973 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8974 if (!W_ERROR_IS_OK(result)) {
8978 /* get the list of subkey names */
8980 data = printer->info_2->data;
8982 num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
8983 if (num_keys == -1) {
8984 result = WERR_BADFILE;
8988 array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 2);
8990 result = WERR_NOMEM;
8995 array[0] = talloc_strdup(array, "");
8997 result = WERR_NOMEM;
9002 for (i=0; i < num_keys; i++) {
9004 DEBUG(10,("_spoolss_EnumPrinterKey: adding keyname: %s\n",
9007 array[i] = talloc_strdup(array, keynames[i]);
9009 result = WERR_NOMEM;
9014 if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
9015 result = WERR_NOMEM;
9019 *r->out._ndr_size = r->in.offered / 2;
9020 *r->out.needed = blob.length;
9022 if (r->in.offered < *r->out.needed) {
9023 result = WERR_MORE_DATA;
9026 r->out.key_buffer->string_array = array;
9030 if (!W_ERROR_IS_OK(result)) {
9032 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
9037 free_a_printer(&printer, 2);
9038 SAFE_FREE(keynames);
9043 /****************************************************************
9044 _spoolss_DeletePrinterKey
9045 ****************************************************************/
9047 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9048 struct spoolss_DeletePrinterKey *r)
9050 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9051 NT_PRINTER_INFO_LEVEL *printer = NULL;
9055 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9058 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9059 OUR_HANDLE(r->in.handle)));
9063 /* if keyname == NULL, return error */
9065 if ( !r->in.key_name )
9066 return WERR_INVALID_PARAM;
9068 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9071 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9072 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9073 "printer properties change denied by handle\n"));
9074 return WERR_ACCESS_DENIED;
9077 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9078 if (!W_ERROR_IS_OK(status))
9081 /* delete the key and all subneys */
9083 status = delete_all_printer_data( printer->info_2, r->in.key_name );
9085 if ( W_ERROR_IS_OK(status) )
9086 status = mod_a_printer(printer, 2);
9088 free_a_printer( &printer, 2 );
9093 /****************************************************************
9094 ****************************************************************/
9096 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9097 struct regval_blob *v,
9098 struct spoolss_PrinterEnumValues *r)
9102 r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
9103 W_ERROR_HAVE_NO_MEMORY(r->data);
9105 r->value_name = talloc_strdup(mem_ctx, regval_name(v));
9106 W_ERROR_HAVE_NO_MEMORY(r->value_name);
9108 r->type = regval_type(v);
9109 r->data_length = regval_size(v);
9111 if (r->data_length) {
9112 DATA_BLOB blob = data_blob_const(regval_data_p(v),
9114 result = pull_spoolss_PrinterData(mem_ctx, &blob,
9117 if (!W_ERROR_IS_OK(result)) {
9125 /****************************************************************
9126 _spoolss_EnumPrinterDataEx
9127 ****************************************************************/
9129 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9130 struct spoolss_EnumPrinterDataEx *r)
9133 NT_PRINTER_INFO_LEVEL *printer = NULL;
9134 struct spoolss_PrinterEnumValues *info = NULL;
9135 NT_PRINTER_DATA *p_data;
9136 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9142 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9146 *r->out.info = NULL;
9149 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9150 OUR_HANDLE(r->in.handle)));
9155 * first check for a keyname of NULL or "". Win2k seems to send
9156 * this a lot and we should send back WERR_INVALID_PARAM
9157 * no need to spend time looking up the printer in this case.
9161 if (!strlen(r->in.key_name)) {
9162 result = WERR_INVALID_PARAM;
9166 /* get the printer off of disk */
9168 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9172 ZERO_STRUCT(printer);
9173 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9174 if (!W_ERROR_IS_OK(result)) {
9178 /* now look for a match on the key name */
9180 p_data = printer->info_2->data;
9182 key_index = lookup_printerkey(p_data, r->in.key_name);
9183 if (key_index == -1) {
9184 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9186 result = WERR_INVALID_PARAM;
9190 /* allocate the memory for the array of pointers -- if necessary */
9192 count = regval_ctr_numvals(p_data->keys[key_index].values);
9194 result = WERR_OK; /* ??? */
9198 info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9199 struct spoolss_PrinterEnumValues,
9202 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9203 result = WERR_NOMEM;
9208 * loop through all params and build the array to pass
9209 * back to the client
9212 for (i=0; i < count; i++) {
9214 struct regval_blob *val;
9216 /* lookup the registry value */
9218 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9220 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9224 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9225 if (!W_ERROR_IS_OK(result)) {
9230 #if 0 /* FIXME - gd */
9231 /* housekeeping information in the reply */
9233 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9234 * the hand marshalled container size is a multiple
9235 * of 4 bytes for RPC alignment.
9239 needed += 4-(needed % 4);
9242 *r->out.count = count;
9243 *r->out.info = info;
9248 free_a_printer(&printer, 2);
9251 if (!W_ERROR_IS_OK(result)) {
9255 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9256 spoolss_EnumPrinterDataEx, NULL,
9259 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9260 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9262 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9265 /****************************************************************************
9266 ****************************************************************************/
9268 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9269 const char *servername,
9270 const char *environment,
9271 struct spoolss_PrintProcessorDirectoryInfo1 *r)
9276 werr = compose_spoolss_server_path(mem_ctx,
9279 SPOOLSS_PRTPROCS_PATH,
9281 if (!W_ERROR_IS_OK(werr)) {
9285 DEBUG(4,("print processor directory: [%s]\n", path));
9287 r->directory_name = path;
9292 /****************************************************************
9293 _spoolss_GetPrintProcessorDirectory
9294 ****************************************************************/
9296 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9297 struct spoolss_GetPrintProcessorDirectory *r)
9301 /* that's an [in out] buffer */
9303 if (!r->in.buffer && (r->in.offered != 0)) {
9304 return WERR_INVALID_PARAM;
9307 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9312 /* r->in.level is ignored */
9314 /* We always should reply with a local print processor directory so that
9315 * users are not forced to have a [prnproc$] share on the Samba spoolss
9316 * server - Guenther */
9318 result = getprintprocessordirectory_level_1(p->mem_ctx,
9319 NULL, /* r->in.server */
9321 &r->out.info->info1);
9322 if (!W_ERROR_IS_OK(result)) {
9323 TALLOC_FREE(r->out.info);
9327 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9328 r->out.info, r->in.level);
9329 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9331 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9334 /*******************************************************************
9335 ********************************************************************/
9337 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9338 const char *dllname)
9340 enum ndr_err_code ndr_err;
9341 struct spoolss_MonitorUi ui;
9343 ui.dll_name = dllname;
9345 ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9346 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9347 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9348 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9350 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9353 /*******************************************************************
9354 Streams the monitor UI DLL name in UNICODE
9355 *******************************************************************/
9357 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9358 NT_USER_TOKEN *token, DATA_BLOB *in,
9359 DATA_BLOB *out, uint32_t *needed)
9361 const char *dllname = "tcpmonui.dll";
9363 *needed = (strlen(dllname)+1) * 2;
9365 if (out->length < *needed) {
9366 return WERR_INSUFFICIENT_BUFFER;
9369 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9376 /*******************************************************************
9377 ********************************************************************/
9379 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9380 struct spoolss_PortData1 *port1,
9381 const DATA_BLOB *buf)
9383 enum ndr_err_code ndr_err;
9384 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9385 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9386 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9387 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9389 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9392 /*******************************************************************
9393 ********************************************************************/
9395 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9396 struct spoolss_PortData2 *port2,
9397 const DATA_BLOB *buf)
9399 enum ndr_err_code ndr_err;
9400 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9401 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9402 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9403 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9405 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9408 /*******************************************************************
9409 Create a new TCP/IP port
9410 *******************************************************************/
9412 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9413 NT_USER_TOKEN *token, DATA_BLOB *in,
9414 DATA_BLOB *out, uint32_t *needed)
9416 struct spoolss_PortData1 port1;
9417 struct spoolss_PortData2 port2;
9418 char *device_uri = NULL;
9421 const char *portname;
9422 const char *hostaddress;
9424 uint32_t port_number;
9427 /* peek for spoolss_PortData version */
9429 if (!in || (in->length < (128 + 4))) {
9430 return WERR_GENERAL_FAILURE;
9433 version = IVAL(in->data, 128);
9439 if (!pull_port_data_1(mem_ctx, &port1, in)) {
9443 portname = port1.portname;
9444 hostaddress = port1.hostaddress;
9445 queue = port1.queue;
9446 protocol = port1.protocol;
9447 port_number = port1.port_number;
9453 if (!pull_port_data_2(mem_ctx, &port2, in)) {
9457 portname = port2.portname;
9458 hostaddress = port2.hostaddress;
9459 queue = port2.queue;
9460 protocol = port2.protocol;
9461 port_number = port2.port_number;
9465 DEBUG(1,("xcvtcp_addport: "
9466 "unknown version of port_data: %d\n", version));
9467 return WERR_UNKNOWN_PORT;
9470 /* create the device URI and call the add_port_hook() */
9473 case PROTOCOL_RAWTCP_TYPE:
9474 device_uri = talloc_asprintf(mem_ctx,
9475 "socket://%s:%d/", hostaddress,
9479 case PROTOCOL_LPR_TYPE:
9480 device_uri = talloc_asprintf(mem_ctx,
9481 "lpr://%s/%s", hostaddress, queue );
9485 return WERR_UNKNOWN_PORT;
9492 return add_port_hook(mem_ctx, token, portname, device_uri);
9495 /*******************************************************************
9496 *******************************************************************/
9498 struct xcv_api_table xcvtcp_cmds[] = {
9499 { "MonitorUI", xcvtcp_monitorui },
9500 { "AddPort", xcvtcp_addport},
9504 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9505 NT_USER_TOKEN *token, const char *command,
9512 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9514 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9515 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9516 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9519 return WERR_BADFUNC;
9522 /*******************************************************************
9523 *******************************************************************/
9524 #if 0 /* don't support management using the "Local Port" monitor */
9526 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9527 NT_USER_TOKEN *token, DATA_BLOB *in,
9528 DATA_BLOB *out, uint32_t *needed)
9530 const char *dllname = "localui.dll";
9532 *needed = (strlen(dllname)+1) * 2;
9534 if (out->length < *needed) {
9535 return WERR_INSUFFICIENT_BUFFER;
9538 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9545 /*******************************************************************
9546 *******************************************************************/
9548 struct xcv_api_table xcvlocal_cmds[] = {
9549 { "MonitorUI", xcvlocal_monitorui },
9553 struct xcv_api_table xcvlocal_cmds[] = {
9560 /*******************************************************************
9561 *******************************************************************/
9563 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9564 NT_USER_TOKEN *token, const char *command,
9565 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9570 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9572 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9573 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9574 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9576 return WERR_BADFUNC;
9579 /****************************************************************
9581 ****************************************************************/
9583 WERROR _spoolss_XcvData(pipes_struct *p,
9584 struct spoolss_XcvData *r)
9586 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9587 DATA_BLOB out_data = data_blob_null;
9591 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9592 OUR_HANDLE(r->in.handle)));
9596 /* Has to be a handle to the TCP/IP port monitor */
9598 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9599 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9603 /* requires administrative access to the server */
9605 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9606 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9607 return WERR_ACCESS_DENIED;
9610 /* Allocate the outgoing buffer */
9612 if (r->in.out_data_size) {
9613 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9614 if (out_data.data == NULL) {
9619 switch ( Printer->printer_type ) {
9620 case SPLHND_PORTMON_TCP:
9621 werror = process_xcvtcp_command(p->mem_ctx,
9622 p->server_info->ptok,
9623 r->in.function_name,
9624 &r->in.in_data, &out_data,
9627 case SPLHND_PORTMON_LOCAL:
9628 werror = process_xcvlocal_command(p->mem_ctx,
9629 p->server_info->ptok,
9630 r->in.function_name,
9631 &r->in.in_data, &out_data,
9635 werror = WERR_INVALID_PRINT_MONITOR;
9638 if (!W_ERROR_IS_OK(werror)) {
9642 *r->out.status_code = 0;
9644 if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
9645 memcpy(r->out.out_data, out_data.data,
9646 MIN(r->in.out_data_size, out_data.length));
9652 /****************************************************************
9653 _spoolss_AddPrintProcessor
9654 ****************************************************************/
9656 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
9657 struct spoolss_AddPrintProcessor *r)
9659 /* for now, just indicate success and ignore the add. We'll
9660 automatically set the winprint processor for printer
9661 entries later. Used to debug the LexMark Optra S 1855 PCL
9667 /****************************************************************
9669 ****************************************************************/
9671 WERROR _spoolss_AddPort(pipes_struct *p,
9672 struct spoolss_AddPort *r)
9674 /* do what w2k3 does */
9676 return WERR_NOT_SUPPORTED;
9679 /****************************************************************
9680 _spoolss_GetPrinterDriver
9681 ****************************************************************/
9683 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
9684 struct spoolss_GetPrinterDriver *r)
9686 p->rng_fault_state = true;
9687 return WERR_NOT_SUPPORTED;
9690 /****************************************************************
9691 _spoolss_ReadPrinter
9692 ****************************************************************/
9694 WERROR _spoolss_ReadPrinter(pipes_struct *p,
9695 struct spoolss_ReadPrinter *r)
9697 p->rng_fault_state = true;
9698 return WERR_NOT_SUPPORTED;
9701 /****************************************************************
9702 _spoolss_WaitForPrinterChange
9703 ****************************************************************/
9705 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
9706 struct spoolss_WaitForPrinterChange *r)
9708 p->rng_fault_state = true;
9709 return WERR_NOT_SUPPORTED;
9712 /****************************************************************
9713 _spoolss_ConfigurePort
9714 ****************************************************************/
9716 WERROR _spoolss_ConfigurePort(pipes_struct *p,
9717 struct spoolss_ConfigurePort *r)
9719 p->rng_fault_state = true;
9720 return WERR_NOT_SUPPORTED;
9723 /****************************************************************
9725 ****************************************************************/
9727 WERROR _spoolss_DeletePort(pipes_struct *p,
9728 struct spoolss_DeletePort *r)
9730 p->rng_fault_state = true;
9731 return WERR_NOT_SUPPORTED;
9734 /****************************************************************
9735 _spoolss_CreatePrinterIC
9736 ****************************************************************/
9738 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
9739 struct spoolss_CreatePrinterIC *r)
9741 p->rng_fault_state = true;
9742 return WERR_NOT_SUPPORTED;
9745 /****************************************************************
9746 _spoolss_PlayGDIScriptOnPrinterIC
9747 ****************************************************************/
9749 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
9750 struct spoolss_PlayGDIScriptOnPrinterIC *r)
9752 p->rng_fault_state = true;
9753 return WERR_NOT_SUPPORTED;
9756 /****************************************************************
9757 _spoolss_DeletePrinterIC
9758 ****************************************************************/
9760 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
9761 struct spoolss_DeletePrinterIC *r)
9763 p->rng_fault_state = true;
9764 return WERR_NOT_SUPPORTED;
9767 /****************************************************************
9768 _spoolss_AddPrinterConnection
9769 ****************************************************************/
9771 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
9772 struct spoolss_AddPrinterConnection *r)
9774 p->rng_fault_state = true;
9775 return WERR_NOT_SUPPORTED;
9778 /****************************************************************
9779 _spoolss_DeletePrinterConnection
9780 ****************************************************************/
9782 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
9783 struct spoolss_DeletePrinterConnection *r)
9785 p->rng_fault_state = true;
9786 return WERR_NOT_SUPPORTED;
9789 /****************************************************************
9790 _spoolss_PrinterMessageBox
9791 ****************************************************************/
9793 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
9794 struct spoolss_PrinterMessageBox *r)
9796 p->rng_fault_state = true;
9797 return WERR_NOT_SUPPORTED;
9800 /****************************************************************
9802 ****************************************************************/
9804 WERROR _spoolss_AddMonitor(pipes_struct *p,
9805 struct spoolss_AddMonitor *r)
9807 p->rng_fault_state = true;
9808 return WERR_NOT_SUPPORTED;
9811 /****************************************************************
9812 _spoolss_DeleteMonitor
9813 ****************************************************************/
9815 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
9816 struct spoolss_DeleteMonitor *r)
9818 p->rng_fault_state = true;
9819 return WERR_NOT_SUPPORTED;
9822 /****************************************************************
9823 _spoolss_DeletePrintProcessor
9824 ****************************************************************/
9826 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
9827 struct spoolss_DeletePrintProcessor *r)
9829 p->rng_fault_state = true;
9830 return WERR_NOT_SUPPORTED;
9833 /****************************************************************
9834 _spoolss_AddPrintProvidor
9835 ****************************************************************/
9837 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
9838 struct spoolss_AddPrintProvidor *r)
9840 p->rng_fault_state = true;
9841 return WERR_NOT_SUPPORTED;
9844 /****************************************************************
9845 _spoolss_DeletePrintProvidor
9846 ****************************************************************/
9848 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
9849 struct spoolss_DeletePrintProvidor *r)
9851 p->rng_fault_state = true;
9852 return WERR_NOT_SUPPORTED;
9855 /****************************************************************
9856 _spoolss_FindFirstPrinterChangeNotification
9857 ****************************************************************/
9859 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
9860 struct spoolss_FindFirstPrinterChangeNotification *r)
9862 p->rng_fault_state = true;
9863 return WERR_NOT_SUPPORTED;
9866 /****************************************************************
9867 _spoolss_FindNextPrinterChangeNotification
9868 ****************************************************************/
9870 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
9871 struct spoolss_FindNextPrinterChangeNotification *r)
9873 p->rng_fault_state = true;
9874 return WERR_NOT_SUPPORTED;
9877 /****************************************************************
9878 _spoolss_RouterFindFirstPrinterChangeNotificationOld
9879 ****************************************************************/
9881 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
9882 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
9884 p->rng_fault_state = true;
9885 return WERR_NOT_SUPPORTED;
9888 /****************************************************************
9889 _spoolss_ReplyOpenPrinter
9890 ****************************************************************/
9892 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
9893 struct spoolss_ReplyOpenPrinter *r)
9895 p->rng_fault_state = true;
9896 return WERR_NOT_SUPPORTED;
9899 /****************************************************************
9900 _spoolss_RouterReplyPrinter
9901 ****************************************************************/
9903 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
9904 struct spoolss_RouterReplyPrinter *r)
9906 p->rng_fault_state = true;
9907 return WERR_NOT_SUPPORTED;
9910 /****************************************************************
9911 _spoolss_ReplyClosePrinter
9912 ****************************************************************/
9914 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
9915 struct spoolss_ReplyClosePrinter *r)
9917 p->rng_fault_state = true;
9918 return WERR_NOT_SUPPORTED;
9921 /****************************************************************
9923 ****************************************************************/
9925 WERROR _spoolss_AddPortEx(pipes_struct *p,
9926 struct spoolss_AddPortEx *r)
9928 p->rng_fault_state = true;
9929 return WERR_NOT_SUPPORTED;
9932 /****************************************************************
9933 _spoolss_RouterFindFirstPrinterChangeNotification
9934 ****************************************************************/
9936 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
9937 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
9939 p->rng_fault_state = true;
9940 return WERR_NOT_SUPPORTED;
9943 /****************************************************************
9944 _spoolss_SpoolerInit
9945 ****************************************************************/
9947 WERROR _spoolss_SpoolerInit(pipes_struct *p,
9948 struct spoolss_SpoolerInit *r)
9950 p->rng_fault_state = true;
9951 return WERR_NOT_SUPPORTED;
9954 /****************************************************************
9955 _spoolss_ResetPrinterEx
9956 ****************************************************************/
9958 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
9959 struct spoolss_ResetPrinterEx *r)
9961 p->rng_fault_state = true;
9962 return WERR_NOT_SUPPORTED;
9965 /****************************************************************
9966 _spoolss_RouterReplyPrinterEx
9967 ****************************************************************/
9969 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
9970 struct spoolss_RouterReplyPrinterEx *r)
9972 p->rng_fault_state = true;
9973 return WERR_NOT_SUPPORTED;
9976 /****************************************************************
9978 ****************************************************************/
9980 WERROR _spoolss_44(pipes_struct *p,
9981 struct spoolss_44 *r)
9983 p->rng_fault_state = true;
9984 return WERR_NOT_SUPPORTED;
9987 /****************************************************************
9989 ****************************************************************/
9991 WERROR _spoolss_47(pipes_struct *p,
9992 struct spoolss_47 *r)
9994 p->rng_fault_state = true;
9995 return WERR_NOT_SUPPORTED;
9998 /****************************************************************
10000 ****************************************************************/
10002 WERROR _spoolss_4a(pipes_struct *p,
10003 struct spoolss_4a *r)
10005 p->rng_fault_state = true;
10006 return WERR_NOT_SUPPORTED;
10009 /****************************************************************
10011 ****************************************************************/
10013 WERROR _spoolss_4b(pipes_struct *p,
10014 struct spoolss_4b *r)
10016 p->rng_fault_state = true;
10017 return WERR_NOT_SUPPORTED;
10020 /****************************************************************
10022 ****************************************************************/
10024 WERROR _spoolss_4c(pipes_struct *p,
10025 struct spoolss_4c *r)
10027 p->rng_fault_state = true;
10028 return WERR_NOT_SUPPORTED;
10031 /****************************************************************
10033 ****************************************************************/
10035 WERROR _spoolss_53(pipes_struct *p,
10036 struct spoolss_53 *r)
10038 p->rng_fault_state = true;
10039 return WERR_NOT_SUPPORTED;
10042 /****************************************************************
10044 ****************************************************************/
10046 WERROR _spoolss_55(pipes_struct *p,
10047 struct spoolss_55 *r)
10049 p->rng_fault_state = true;
10050 return WERR_NOT_SUPPORTED;
10053 /****************************************************************
10055 ****************************************************************/
10057 WERROR _spoolss_56(pipes_struct *p,
10058 struct spoolss_56 *r)
10060 p->rng_fault_state = true;
10061 return WERR_NOT_SUPPORTED;
10064 /****************************************************************
10066 ****************************************************************/
10068 WERROR _spoolss_57(pipes_struct *p,
10069 struct spoolss_57 *r)
10071 p->rng_fault_state = true;
10072 return WERR_NOT_SUPPORTED;
10075 /****************************************************************
10077 ****************************************************************/
10079 WERROR _spoolss_5a(pipes_struct *p,
10080 struct spoolss_5a *r)
10082 p->rng_fault_state = true;
10083 return WERR_NOT_SUPPORTED;
10086 /****************************************************************
10088 ****************************************************************/
10090 WERROR _spoolss_5b(pipes_struct *p,
10091 struct spoolss_5b *r)
10093 p->rng_fault_state = true;
10094 return WERR_NOT_SUPPORTED;
10097 /****************************************************************
10099 ****************************************************************/
10101 WERROR _spoolss_5c(pipes_struct *p,
10102 struct spoolss_5c *r)
10104 p->rng_fault_state = true;
10105 return WERR_NOT_SUPPORTED;
10108 /****************************************************************
10110 ****************************************************************/
10112 WERROR _spoolss_5d(pipes_struct *p,
10113 struct spoolss_5d *r)
10115 p->rng_fault_state = true;
10116 return WERR_NOT_SUPPORTED;
10119 /****************************************************************
10121 ****************************************************************/
10123 WERROR _spoolss_5e(pipes_struct *p,
10124 struct spoolss_5e *r)
10126 p->rng_fault_state = true;
10127 return WERR_NOT_SUPPORTED;
10130 /****************************************************************
10132 ****************************************************************/
10134 WERROR _spoolss_5f(pipes_struct *p,
10135 struct spoolss_5f *r)
10137 p->rng_fault_state = true;
10138 return WERR_NOT_SUPPORTED;
10141 /****************************************************************
10143 ****************************************************************/
10145 WERROR _spoolss_60(pipes_struct *p,
10146 struct spoolss_60 *r)
10148 p->rng_fault_state = true;
10149 return WERR_NOT_SUPPORTED;
10152 /****************************************************************
10154 ****************************************************************/
10156 WERROR _spoolss_61(pipes_struct *p,
10157 struct spoolss_61 *r)
10159 p->rng_fault_state = true;
10160 return WERR_NOT_SUPPORTED;
10163 /****************************************************************
10165 ****************************************************************/
10167 WERROR _spoolss_62(pipes_struct *p,
10168 struct spoolss_62 *r)
10170 p->rng_fault_state = true;
10171 return WERR_NOT_SUPPORTED;
10174 /****************************************************************
10176 ****************************************************************/
10178 WERROR _spoolss_63(pipes_struct *p,
10179 struct spoolss_63 *r)
10181 p->rng_fault_state = true;
10182 return WERR_NOT_SUPPORTED;
10185 /****************************************************************
10187 ****************************************************************/
10189 WERROR _spoolss_64(pipes_struct *p,
10190 struct spoolss_64 *r)
10192 p->rng_fault_state = true;
10193 return WERR_NOT_SUPPORTED;
10196 /****************************************************************
10198 ****************************************************************/
10200 WERROR _spoolss_65(pipes_struct *p,
10201 struct spoolss_65 *r)
10203 p->rng_fault_state = true;
10204 return WERR_NOT_SUPPORTED;
10207 /****************************************************************
10208 _spoolss_GetCorePrinterDrivers
10209 ****************************************************************/
10211 WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p,
10212 struct spoolss_GetCorePrinterDrivers *r)
10214 p->rng_fault_state = true;
10215 return WERR_NOT_SUPPORTED;
10218 /****************************************************************
10220 ****************************************************************/
10222 WERROR _spoolss_67(pipes_struct *p,
10223 struct spoolss_67 *r)
10225 p->rng_fault_state = true;
10226 return WERR_NOT_SUPPORTED;
10229 /****************************************************************
10230 _spoolss_GetPrinterDriverPackagePath
10231 ****************************************************************/
10233 WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p,
10234 struct spoolss_GetPrinterDriverPackagePath *r)
10236 p->rng_fault_state = true;
10237 return WERR_NOT_SUPPORTED;
10240 /****************************************************************
10242 ****************************************************************/
10244 WERROR _spoolss_69(pipes_struct *p,
10245 struct spoolss_69 *r)
10247 p->rng_fault_state = true;
10248 return WERR_NOT_SUPPORTED;
10251 /****************************************************************
10253 ****************************************************************/
10255 WERROR _spoolss_6a(pipes_struct *p,
10256 struct spoolss_6a *r)
10258 p->rng_fault_state = true;
10259 return WERR_NOT_SUPPORTED;
10262 /****************************************************************
10264 ****************************************************************/
10266 WERROR _spoolss_6b(pipes_struct *p,
10267 struct spoolss_6b *r)
10269 p->rng_fault_state = true;
10270 return WERR_NOT_SUPPORTED;
10273 /****************************************************************
10275 ****************************************************************/
10277 WERROR _spoolss_6c(pipes_struct *p,
10278 struct spoolss_6c *r)
10280 p->rng_fault_state = true;
10281 return WERR_NOT_SUPPORTED;
10284 /****************************************************************
10286 ****************************************************************/
10288 WERROR _spoolss_6d(pipes_struct *p,
10289 struct spoolss_6d *r)
10291 p->rng_fault_state = true;
10292 return WERR_NOT_SUPPORTED;