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 SSVAL(&r
->version
, 0, 0x0005); /* NT 5 */
3591 SSVAL(&r
->version
, 2, 0x0893); /* build 2195 */
3592 r
->free_build
= SPOOLSS_RELEASE_BUILD
;
3594 r
->max_spooling
= 0;
3595 r
->session_counter
= session_counter
->counter
;
3596 r
->num_error_out_of_paper
= 0x0;
3597 r
->num_error_not_ready
= 0x0; /* number of print failure */
3599 r
->number_of_processors
= 0x1;
3600 r
->processor_type
= PROCESSOR_INTEL_PENTIUM
; /* 586 Pentium ? */
3601 r
->high_part_total_bytes
= 0x0;
3602 r
->change_id
= ntprinter
->info_2
->changeid
; /* ChangeID in milliseconds*/
3603 r
->last_error
= WERR_OK
;
3604 r
->status
= nt_printq_status(status
.status
);
3605 r
->enumerate_network_printers
= 0x0;
3606 r
->c_setprinter
= get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3607 r
->processor_architecture
= 0x0;
3608 r
->processor_level
= 0x6; /* 6 ???*/
3616 /****************************************************************************
3617 Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure. Both pointers
3618 should be valid upon entry
3619 ****************************************************************************/
3621 static WERROR
convert_nt_devicemode(TALLOC_CTX
*mem_ctx
,
3622 struct spoolss_DeviceMode
*r
,
3623 const NT_DEVICEMODE
*ntdevmode
)
3625 if (!r
|| !ntdevmode
) {
3626 return WERR_INVALID_PARAM
;
3629 r
->devicename
= talloc_strdup(mem_ctx
, ntdevmode
->devicename
);
3630 W_ERROR_HAVE_NO_MEMORY(r
->devicename
);
3632 r
->specversion
= ntdevmode
->specversion
;
3633 r
->driverversion
= ntdevmode
->driverversion
;
3634 r
->size
= ntdevmode
->size
;
3635 r
->__driverextra_length
= ntdevmode
->driverextra
;
3636 r
->fields
= ntdevmode
->fields
;
3638 r
->orientation
= ntdevmode
->orientation
;
3639 r
->papersize
= ntdevmode
->papersize
;
3640 r
->paperlength
= ntdevmode
->paperlength
;
3641 r
->paperwidth
= ntdevmode
->paperwidth
;
3642 r
->scale
= ntdevmode
->scale
;
3643 r
->copies
= ntdevmode
->copies
;
3644 r
->defaultsource
= ntdevmode
->defaultsource
;
3645 r
->printquality
= ntdevmode
->printquality
;
3646 r
->color
= ntdevmode
->color
;
3647 r
->duplex
= ntdevmode
->duplex
;
3648 r
->yresolution
= ntdevmode
->yresolution
;
3649 r
->ttoption
= ntdevmode
->ttoption
;
3650 r
->collate
= ntdevmode
->collate
;
3652 r
->formname
= talloc_strdup(mem_ctx
, ntdevmode
->formname
);
3653 W_ERROR_HAVE_NO_MEMORY(r
->formname
);
3655 r
->logpixels
= ntdevmode
->logpixels
;
3656 r
->bitsperpel
= ntdevmode
->bitsperpel
;
3657 r
->pelswidth
= ntdevmode
->pelswidth
;
3658 r
->pelsheight
= ntdevmode
->pelsheight
;
3659 r
->displayflags
= ntdevmode
->displayflags
;
3660 r
->displayfrequency
= ntdevmode
->displayfrequency
;
3661 r
->icmmethod
= ntdevmode
->icmmethod
;
3662 r
->icmintent
= ntdevmode
->icmintent
;
3663 r
->mediatype
= ntdevmode
->mediatype
;
3664 r
->dithertype
= ntdevmode
->dithertype
;
3665 r
->reserved1
= ntdevmode
->reserved1
;
3666 r
->reserved2
= ntdevmode
->reserved2
;
3667 r
->panningwidth
= ntdevmode
->panningwidth
;
3668 r
->panningheight
= ntdevmode
->panningheight
;
3670 if (ntdevmode
->nt_dev_private
!= NULL
) {
3671 r
->driverextra_data
= data_blob_talloc(mem_ctx
,
3672 ntdevmode
->nt_dev_private
,
3673 ntdevmode
->driverextra
);
3674 W_ERROR_HAVE_NO_MEMORY(r
->driverextra_data
.data
);
3681 /****************************************************************************
3682 Create a spoolss_DeviceMode struct. Returns talloced memory.
3683 ****************************************************************************/
3685 struct spoolss_DeviceMode
*construct_dev_mode(TALLOC_CTX
*mem_ctx
,
3686 const char *servicename
)
3689 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
3690 struct spoolss_DeviceMode
*devmode
= NULL
;
3692 DEBUG(7,("construct_dev_mode\n"));
3694 DEBUGADD(8,("getting printer characteristics\n"));
3696 if (!W_ERROR_IS_OK(get_a_printer(NULL
, &printer
, 2, servicename
)))
3699 if (!printer
->info_2
->devmode
) {
3700 DEBUG(5, ("BONG! There was no device mode!\n"));
3704 devmode
= TALLOC_ZERO_P(mem_ctx
, struct spoolss_DeviceMode
);
3706 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3710 DEBUGADD(8,("loading DEVICEMODE\n"));
3712 result
= convert_nt_devicemode(mem_ctx
, devmode
, printer
->info_2
->devmode
);
3713 if (!W_ERROR_IS_OK(result
)) {
3714 TALLOC_FREE(devmode
);
3718 free_a_printer(&printer
,2);
3723 /********************************************************************
3724 * construct_printer_info1
3725 * fill a spoolss_PrinterInfo1 struct
3726 ********************************************************************/
3728 static WERROR
construct_printer_info1(TALLOC_CTX
*mem_ctx
,
3729 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3731 struct spoolss_PrinterInfo1
*r
,
3736 r
->description
= talloc_asprintf(mem_ctx
, "%s,%s,%s",
3737 ntprinter
->info_2
->printername
,
3738 ntprinter
->info_2
->drivername
,
3739 ntprinter
->info_2
->location
);
3740 W_ERROR_HAVE_NO_MEMORY(r
->description
);
3742 if (*ntprinter
->info_2
->comment
== '\0') {
3743 r
->comment
= talloc_strdup(mem_ctx
, lp_comment(snum
));
3745 r
->comment
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->comment
); /* saved comment */
3747 W_ERROR_HAVE_NO_MEMORY(r
->comment
);
3749 r
->name
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printername
);
3750 W_ERROR_HAVE_NO_MEMORY(r
->name
);
3755 /********************************************************************
3756 * construct_printer_info2
3757 * fill a spoolss_PrinterInfo2 struct
3758 ********************************************************************/
3760 static WERROR
construct_printer_info2(TALLOC_CTX
*mem_ctx
,
3761 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3762 struct spoolss_PrinterInfo2
*r
,
3767 print_status_struct status
;
3769 count
= print_queue_length(snum
, &status
);
3771 r
->servername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->servername
);
3772 W_ERROR_HAVE_NO_MEMORY(r
->servername
);
3773 r
->printername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printername
);
3774 W_ERROR_HAVE_NO_MEMORY(r
->printername
);
3775 r
->sharename
= talloc_strdup(mem_ctx
, lp_servicename(snum
));
3776 W_ERROR_HAVE_NO_MEMORY(r
->sharename
);
3777 r
->portname
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->portname
);
3778 W_ERROR_HAVE_NO_MEMORY(r
->portname
);
3779 r
->drivername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->drivername
);
3780 W_ERROR_HAVE_NO_MEMORY(r
->drivername
);
3782 if (*ntprinter
->info_2
->comment
== '\0') {
3783 r
->comment
= talloc_strdup(mem_ctx
, lp_comment(snum
));
3785 r
->comment
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->comment
);
3787 W_ERROR_HAVE_NO_MEMORY(r
->comment
);
3789 r
->location
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->location
);
3790 W_ERROR_HAVE_NO_MEMORY(r
->location
);
3791 r
->sepfile
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->sepfile
);
3792 W_ERROR_HAVE_NO_MEMORY(r
->sepfile
);
3793 r
->printprocessor
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printprocessor
);
3794 W_ERROR_HAVE_NO_MEMORY(r
->printprocessor
);
3795 r
->datatype
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->datatype
);
3796 W_ERROR_HAVE_NO_MEMORY(r
->datatype
);
3797 r
->parameters
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->parameters
);
3798 W_ERROR_HAVE_NO_MEMORY(r
->parameters
);
3800 r
->attributes
= ntprinter
->info_2
->attributes
;
3802 r
->priority
= ntprinter
->info_2
->priority
;
3803 r
->defaultpriority
= ntprinter
->info_2
->default_priority
;
3804 r
->starttime
= ntprinter
->info_2
->starttime
;
3805 r
->untiltime
= ntprinter
->info_2
->untiltime
;
3806 r
->status
= nt_printq_status(status
.status
);
3808 r
->averageppm
= ntprinter
->info_2
->averageppm
;
3810 r
->devmode
= construct_dev_mode(mem_ctx
, lp_const_servicename(snum
));
3812 DEBUG(8,("Returning NULL Devicemode!\n"));
3817 if (ntprinter
->info_2
->secdesc_buf
&& ntprinter
->info_2
->secdesc_buf
->sd_size
!= 0) {
3818 /* don't use talloc_steal() here unless you do a deep steal of all
3819 the SEC_DESC members */
3821 r
->secdesc
= dup_sec_desc(mem_ctx
, ntprinter
->info_2
->secdesc_buf
->sd
);
3827 /********************************************************************
3828 * construct_printer_info3
3829 * fill a spoolss_PrinterInfo3 struct
3830 ********************************************************************/
3832 static WERROR
construct_printer_info3(TALLOC_CTX
*mem_ctx
,
3833 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3834 struct spoolss_PrinterInfo3
*r
,
3837 /* These are the components of the SD we are returning. */
3839 if (ntprinter
->info_2
->secdesc_buf
&& ntprinter
->info_2
->secdesc_buf
->sd_size
!= 0) {
3840 /* don't use talloc_steal() here unless you do a deep steal of all
3841 the SEC_DESC members */
3843 r
->secdesc
= dup_sec_desc(mem_ctx
,
3844 ntprinter
->info_2
->secdesc_buf
->sd
);
3845 W_ERROR_HAVE_NO_MEMORY(r
->secdesc
);
3851 /********************************************************************
3852 * construct_printer_info4
3853 * fill a spoolss_PrinterInfo4 struct
3854 ********************************************************************/
3856 static WERROR
construct_printer_info4(TALLOC_CTX
*mem_ctx
,
3857 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3858 struct spoolss_PrinterInfo4
*r
,
3861 r
->printername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printername
);
3862 W_ERROR_HAVE_NO_MEMORY(r
->printername
);
3863 r
->servername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->servername
);
3864 W_ERROR_HAVE_NO_MEMORY(r
->servername
);
3866 r
->attributes
= ntprinter
->info_2
->attributes
;
3871 /********************************************************************
3872 * construct_printer_info5
3873 * fill a spoolss_PrinterInfo5 struct
3874 ********************************************************************/
3876 static WERROR
construct_printer_info5(TALLOC_CTX
*mem_ctx
,
3877 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3878 struct spoolss_PrinterInfo5
*r
,
3881 r
->printername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printername
);
3882 W_ERROR_HAVE_NO_MEMORY(r
->printername
);
3883 r
->portname
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->portname
);
3884 W_ERROR_HAVE_NO_MEMORY(r
->portname
);
3886 r
->attributes
= ntprinter
->info_2
->attributes
;
3888 /* these two are not used by NT+ according to MSDN */
3890 r
->device_not_selected_timeout
= 0x0; /* have seen 0x3a98 */
3891 r
->transmission_retry_timeout
= 0x0; /* have seen 0xafc8 */
3896 /********************************************************************
3897 * construct_printer_info_6
3898 * fill a spoolss_PrinterInfo6 struct
3899 ********************************************************************/
3901 static WERROR
construct_printer_info6(TALLOC_CTX
*mem_ctx
,
3902 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3903 struct spoolss_PrinterInfo6
*r
,
3907 print_status_struct status
;
3909 count
= print_queue_length(snum
, &status
);
3911 r
->status
= nt_printq_status(status
.status
);
3916 /********************************************************************
3917 * construct_printer_info7
3918 * fill a spoolss_PrinterInfo7 struct
3919 ********************************************************************/
3921 static WERROR
construct_printer_info7(TALLOC_CTX
*mem_ctx
,
3922 Printer_entry
*print_hnd
,
3923 struct spoolss_PrinterInfo7
*r
,
3928 if (is_printer_published(print_hnd
, snum
, &guid
)) {
3929 r
->guid
= talloc_strdup_upper(mem_ctx
, GUID_string2(mem_ctx
, &guid
));
3930 r
->action
= DSPRINT_PUBLISH
;
3932 r
->guid
= talloc_strdup(mem_ctx
, "");
3933 r
->action
= DSPRINT_UNPUBLISH
;
3935 W_ERROR_HAVE_NO_MEMORY(r
->guid
);
3940 /********************************************************************
3941 * construct_printer_info8
3942 * fill a spoolss_PrinterInfo8 struct
3943 ********************************************************************/
3945 static WERROR
construct_printer_info8(TALLOC_CTX
*mem_ctx
,
3946 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3947 struct spoolss_DeviceModeInfo
*r
,
3950 r
->devmode
= construct_dev_mode(mem_ctx
, lp_const_servicename(snum
));
3952 DEBUG(8,("Returning NULL Devicemode!\n"));
3959 /********************************************************************
3960 ********************************************************************/
3962 static bool snum_is_shared_printer(int snum
)
3964 return (lp_browseable(snum
) && lp_snum_ok(snum
) && lp_print_ok(snum
));
3967 /********************************************************************
3968 Spoolss_enumprinters.
3969 ********************************************************************/
3971 static WERROR
enum_all_printers_info_level(TALLOC_CTX
*mem_ctx
,
3974 union spoolss_PrinterInfo
**info_p
,
3978 int n_services
= lp_numservices();
3979 union spoolss_PrinterInfo
*info
= NULL
;
3981 WERROR result
= WERR_OK
;
3986 for (snum
= 0; snum
< n_services
; snum
++) {
3988 NT_PRINTER_INFO_LEVEL
*ntprinter
= NULL
;
3990 if (!snum_is_shared_printer(snum
)) {
3994 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
3995 lp_servicename(snum
), snum
));
3997 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
3998 union spoolss_PrinterInfo
,
4001 result
= WERR_NOMEM
;
4005 result
= get_a_printer(NULL
, &ntprinter
, 2,
4006 lp_const_servicename(snum
));
4007 if (!W_ERROR_IS_OK(result
)) {
4013 result
= construct_printer_info0(info
, ntprinter
,
4014 &info
[count
].info0
, snum
);
4017 result
= construct_printer_info1(info
, ntprinter
, flags
,
4018 &info
[count
].info1
, snum
);
4021 result
= construct_printer_info2(info
, ntprinter
,
4022 &info
[count
].info2
, snum
);
4025 result
= construct_printer_info4(info
, ntprinter
,
4026 &info
[count
].info4
, snum
);
4029 result
= construct_printer_info5(info
, ntprinter
,
4030 &info
[count
].info5
, snum
);
4034 result
= WERR_UNKNOWN_LEVEL
;
4035 free_a_printer(&ntprinter
, 2);
4039 free_a_printer(&ntprinter
, 2);
4040 if (!W_ERROR_IS_OK(result
)) {
4051 if (!W_ERROR_IS_OK(result
)) {
4061 /********************************************************************
4062 * handle enumeration of printers at level 0
4063 ********************************************************************/
4065 static WERROR
enumprinters_level0(TALLOC_CTX
*mem_ctx
,
4067 const char *servername
,
4068 union spoolss_PrinterInfo
**info
,
4071 DEBUG(4,("enum_all_printers_info_0\n"));
4073 return enum_all_printers_info_level(mem_ctx
, 0, flags
, info
, count
);
4077 /********************************************************************
4078 ********************************************************************/
4080 static WERROR
enum_all_printers_info_1(TALLOC_CTX
*mem_ctx
,
4082 union spoolss_PrinterInfo
**info
,
4085 DEBUG(4,("enum_all_printers_info_1\n"));
4087 return enum_all_printers_info_level(mem_ctx
, 1, flags
, info
, count
);
4090 /********************************************************************
4091 enum_all_printers_info_1_local.
4092 *********************************************************************/
4094 static WERROR
enum_all_printers_info_1_local(TALLOC_CTX
*mem_ctx
,
4095 union spoolss_PrinterInfo
**info
,
4098 DEBUG(4,("enum_all_printers_info_1_local\n"));
4100 return enum_all_printers_info_1(mem_ctx
, PRINTER_ENUM_ICON8
, info
, count
);
4103 /********************************************************************
4104 enum_all_printers_info_1_name.
4105 *********************************************************************/
4107 static WERROR
enum_all_printers_info_1_name(TALLOC_CTX
*mem_ctx
,
4109 union spoolss_PrinterInfo
**info
,
4112 const char *s
= name
;
4114 DEBUG(4,("enum_all_printers_info_1_name\n"));
4116 if ((name
[0] == '\\') && (name
[1] == '\\')) {
4120 if (!is_myname_or_ipaddr(s
)) {
4121 return WERR_INVALID_NAME
;
4124 return enum_all_printers_info_1(mem_ctx
, PRINTER_ENUM_ICON8
, info
, count
);
4127 /********************************************************************
4128 enum_all_printers_info_1_network.
4129 *********************************************************************/
4131 static WERROR
enum_all_printers_info_1_network(TALLOC_CTX
*mem_ctx
,
4133 union spoolss_PrinterInfo
**info
,
4136 const char *s
= name
;
4138 DEBUG(4,("enum_all_printers_info_1_network\n"));
4140 /* If we respond to a enum_printers level 1 on our name with flags
4141 set to PRINTER_ENUM_REMOTE with a list of printers then these
4142 printers incorrectly appear in the APW browse list.
4143 Specifically the printers for the server appear at the workgroup
4144 level where all the other servers in the domain are
4145 listed. Windows responds to this call with a
4146 WERR_CAN_NOT_COMPLETE so we should do the same. */
4148 if (name
[0] == '\\' && name
[1] == '\\') {
4152 if (is_myname_or_ipaddr(s
)) {
4153 return WERR_CAN_NOT_COMPLETE
;
4156 return enum_all_printers_info_1(mem_ctx
, PRINTER_ENUM_NAME
, info
, count
);
4159 /********************************************************************
4160 * api_spoolss_enumprinters
4162 * called from api_spoolss_enumprinters (see this to understand)
4163 ********************************************************************/
4165 static WERROR
enum_all_printers_info_2(TALLOC_CTX
*mem_ctx
,
4166 union spoolss_PrinterInfo
**info
,
4169 DEBUG(4,("enum_all_printers_info_2\n"));
4171 return enum_all_printers_info_level(mem_ctx
, 2, 0, info
, count
);
4174 /********************************************************************
4175 * handle enumeration of printers at level 1
4176 ********************************************************************/
4178 static WERROR
enumprinters_level1(TALLOC_CTX
*mem_ctx
,
4181 union spoolss_PrinterInfo
**info
,
4184 /* Not all the flags are equals */
4186 if (flags
& PRINTER_ENUM_LOCAL
) {
4187 return enum_all_printers_info_1_local(mem_ctx
, info
, count
);
4190 if (flags
& PRINTER_ENUM_NAME
) {
4191 return enum_all_printers_info_1_name(mem_ctx
, name
, info
, count
);
4194 if (flags
& PRINTER_ENUM_NETWORK
) {
4195 return enum_all_printers_info_1_network(mem_ctx
, name
, info
, count
);
4198 return WERR_OK
; /* NT4sp5 does that */
4201 /********************************************************************
4202 * handle enumeration of printers at level 2
4203 ********************************************************************/
4205 static WERROR
enumprinters_level2(TALLOC_CTX
*mem_ctx
,
4207 const char *servername
,
4208 union spoolss_PrinterInfo
**info
,
4211 if (flags
& PRINTER_ENUM_LOCAL
) {
4212 return enum_all_printers_info_2(mem_ctx
, info
, count
);
4215 if (flags
& PRINTER_ENUM_NAME
) {
4216 if (!is_myname_or_ipaddr(canon_servername(servername
))) {
4217 return WERR_INVALID_NAME
;
4220 return enum_all_printers_info_2(mem_ctx
, info
, count
);
4223 if (flags
& PRINTER_ENUM_REMOTE
) {
4224 return WERR_UNKNOWN_LEVEL
;
4230 /********************************************************************
4231 * handle enumeration of printers at level 4
4232 ********************************************************************/
4234 static WERROR
enumprinters_level4(TALLOC_CTX
*mem_ctx
,
4236 const char *servername
,
4237 union spoolss_PrinterInfo
**info
,
4240 DEBUG(4,("enum_all_printers_info_4\n"));
4242 return enum_all_printers_info_level(mem_ctx
, 4, flags
, info
, count
);
4246 /********************************************************************
4247 * handle enumeration of printers at level 5
4248 ********************************************************************/
4250 static WERROR
enumprinters_level5(TALLOC_CTX
*mem_ctx
,
4252 const char *servername
,
4253 union spoolss_PrinterInfo
**info
,
4256 DEBUG(4,("enum_all_printers_info_5\n"));
4258 return enum_all_printers_info_level(mem_ctx
, 5, flags
, info
, count
);
4261 /****************************************************************
4262 _spoolss_EnumPrinters
4263 ****************************************************************/
4265 WERROR
_spoolss_EnumPrinters(pipes_struct
*p
,
4266 struct spoolss_EnumPrinters
*r
)
4268 const char *name
= NULL
;
4271 /* that's an [in out] buffer */
4273 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
4274 return WERR_INVALID_PARAM
;
4277 DEBUG(4,("_spoolss_EnumPrinters\n"));
4281 *r
->out
.info
= NULL
;
4285 * flags==PRINTER_ENUM_NAME
4286 * if name=="" then enumerates all printers
4287 * if name!="" then enumerate the printer
4288 * flags==PRINTER_ENUM_REMOTE
4289 * name is NULL, enumerate printers
4290 * Level 2: name!="" enumerates printers, name can't be NULL
4291 * Level 3: doesn't exist
4292 * Level 4: does a local registry lookup
4293 * Level 5: same as Level 2
4297 name
= talloc_strdup_upper(p
->mem_ctx
, r
->in
.server
);
4298 W_ERROR_HAVE_NO_MEMORY(name
);
4301 switch (r
->in
.level
) {
4303 result
= enumprinters_level0(p
->mem_ctx
, r
->in
.flags
, name
,
4304 r
->out
.info
, r
->out
.count
);
4307 result
= enumprinters_level1(p
->mem_ctx
, r
->in
.flags
, name
,
4308 r
->out
.info
, r
->out
.count
);
4311 result
= enumprinters_level2(p
->mem_ctx
, r
->in
.flags
, name
,
4312 r
->out
.info
, r
->out
.count
);
4315 result
= enumprinters_level4(p
->mem_ctx
, r
->in
.flags
, name
,
4316 r
->out
.info
, r
->out
.count
);
4319 result
= enumprinters_level5(p
->mem_ctx
, r
->in
.flags
, name
,
4320 r
->out
.info
, r
->out
.count
);
4323 return WERR_UNKNOWN_LEVEL
;
4326 if (!W_ERROR_IS_OK(result
)) {
4330 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
4331 spoolss_EnumPrinters
, NULL
,
4332 *r
->out
.info
, r
->in
.level
,
4334 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
4335 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
4337 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
4340 /****************************************************************
4342 ****************************************************************/
4344 WERROR
_spoolss_GetPrinter(pipes_struct
*p
,
4345 struct spoolss_GetPrinter
*r
)
4347 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
4348 NT_PRINTER_INFO_LEVEL
*ntprinter
= NULL
;
4349 WERROR result
= WERR_OK
;
4353 /* that's an [in out] buffer */
4355 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
4356 return WERR_INVALID_PARAM
;
4361 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
4365 result
= get_a_printer(Printer
, &ntprinter
, 2,
4366 lp_const_servicename(snum
));
4367 if (!W_ERROR_IS_OK(result
)) {
4371 switch (r
->in
.level
) {
4373 result
= construct_printer_info0(p
->mem_ctx
, ntprinter
,
4374 &r
->out
.info
->info0
, snum
);
4377 result
= construct_printer_info1(p
->mem_ctx
, ntprinter
,
4379 &r
->out
.info
->info1
, snum
);
4382 result
= construct_printer_info2(p
->mem_ctx
, ntprinter
,
4383 &r
->out
.info
->info2
, snum
);
4386 result
= construct_printer_info3(p
->mem_ctx
, ntprinter
,
4387 &r
->out
.info
->info3
, snum
);
4390 result
= construct_printer_info4(p
->mem_ctx
, ntprinter
,
4391 &r
->out
.info
->info4
, snum
);
4394 result
= construct_printer_info5(p
->mem_ctx
, ntprinter
,
4395 &r
->out
.info
->info5
, snum
);
4398 result
= construct_printer_info6(p
->mem_ctx
, ntprinter
,
4399 &r
->out
.info
->info6
, snum
);
4402 result
= construct_printer_info7(p
->mem_ctx
, Printer
,
4403 &r
->out
.info
->info7
, snum
);
4406 result
= construct_printer_info8(p
->mem_ctx
, ntprinter
,
4407 &r
->out
.info
->info8
, snum
);
4410 result
= WERR_UNKNOWN_LEVEL
;
4414 free_a_printer(&ntprinter
, 2);
4416 if (!W_ERROR_IS_OK(result
)) {
4417 TALLOC_FREE(r
->out
.info
);
4421 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo
, NULL
,
4422 r
->out
.info
, r
->in
.level
);
4423 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
4425 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
4428 /********************************************************************
4429 ********************************************************************/
4431 static const char **string_array_from_driver_info(TALLOC_CTX
*mem_ctx
,
4432 const char **string_array
,
4433 const char *cservername
)
4435 int i
, num_strings
= 0;
4436 const char **array
= NULL
;
4438 if (!string_array
) {
4442 for (i
=0; string_array
[i
] && string_array
[i
][0] != '\0'; i
++) {
4444 const char *str
= talloc_asprintf(mem_ctx
, "\\\\%s%s",
4445 cservername
, string_array
[i
]);
4452 if (!add_string_to_array(mem_ctx
, str
, &array
, &num_strings
)) {
4459 ADD_TO_ARRAY(mem_ctx
, const char *, NULL
,
4460 &array
, &num_strings
);
4466 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4468 if (in && strlen(in)) { \
4469 out = talloc_strdup(mem_ctx, in); \
4470 W_ERROR_HAVE_NO_MEMORY(out); \
4476 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, in, out) \
4478 if (in && strlen(in)) { \
4479 out = talloc_asprintf(mem_ctx, "\\\\%s%s", server, in); \
4481 out = talloc_strdup(mem_ctx, ""); \
4483 W_ERROR_HAVE_NO_MEMORY(out); \
4486 /********************************************************************
4487 * fill a spoolss_DriverInfo1 struct
4488 ********************************************************************/
4490 static WERROR
fill_printer_driver_info1(TALLOC_CTX
*mem_ctx
,
4491 struct spoolss_DriverInfo1
*r
,
4492 const struct spoolss_DriverInfo8
*driver
,
4493 const char *servername
)
4495 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4496 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4501 /********************************************************************
4502 * fill a spoolss_DriverInfo2 struct
4503 ********************************************************************/
4505 static WERROR
fill_printer_driver_info2(TALLOC_CTX
*mem_ctx
,
4506 struct spoolss_DriverInfo2
*r
,
4507 const struct spoolss_DriverInfo8
*driver
,
4508 const char *servername
)
4511 const char *cservername
= canon_servername(servername
);
4513 r
->version
= driver
->version
;
4515 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4516 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4517 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4518 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4520 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4521 driver
->driver_path
,
4524 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4528 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4529 driver
->config_file
,
4535 /********************************************************************
4536 * fill a spoolss_DriverInfo3 struct
4537 ********************************************************************/
4539 static WERROR
fill_printer_driver_info3(TALLOC_CTX
*mem_ctx
,
4540 struct spoolss_DriverInfo3
*r
,
4541 const struct spoolss_DriverInfo8
*driver
,
4542 const char *servername
)
4544 const char *cservername
= canon_servername(servername
);
4546 r
->version
= driver
->version
;
4548 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4549 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4550 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4551 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4553 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4554 driver
->driver_path
,
4557 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4561 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4562 driver
->config_file
,
4565 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4569 FILL_DRIVER_STRING(mem_ctx
,
4570 driver
->monitor_name
,
4573 FILL_DRIVER_STRING(mem_ctx
,
4574 driver
->default_datatype
,
4575 r
->default_datatype
);
4577 r
->dependent_files
= string_array_from_driver_info(mem_ctx
,
4578 driver
->dependent_files
,
4583 /********************************************************************
4584 * fill a spoolss_DriverInfo4 struct
4585 ********************************************************************/
4587 static WERROR
fill_printer_driver_info4(TALLOC_CTX
*mem_ctx
,
4588 struct spoolss_DriverInfo4
*r
,
4589 const struct spoolss_DriverInfo8
*driver
,
4590 const char *servername
)
4592 const char *cservername
= canon_servername(servername
);
4594 r
->version
= driver
->version
;
4596 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4597 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4598 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4599 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4601 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4602 driver
->driver_path
,
4605 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4609 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4610 driver
->config_file
,
4613 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4617 r
->dependent_files
= string_array_from_driver_info(mem_ctx
,
4618 driver
->dependent_files
,
4621 FILL_DRIVER_STRING(mem_ctx
,
4622 driver
->monitor_name
,
4625 FILL_DRIVER_STRING(mem_ctx
,
4626 driver
->default_datatype
,
4627 r
->default_datatype
);
4629 r
->previous_names
= string_array_from_driver_info(mem_ctx
,
4630 driver
->previous_names
,
4636 /********************************************************************
4637 * fill a spoolss_DriverInfo5 struct
4638 ********************************************************************/
4640 static WERROR
fill_printer_driver_info5(TALLOC_CTX
*mem_ctx
,
4641 struct spoolss_DriverInfo5
*r
,
4642 const struct spoolss_DriverInfo8
*driver
,
4643 const char *servername
)
4645 const char *cservername
= canon_servername(servername
);
4647 r
->version
= driver
->version
;
4649 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4650 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4651 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4652 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4654 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4655 driver
->driver_path
,
4658 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4662 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4663 driver
->config_file
,
4666 r
->driver_attributes
= 0;
4667 r
->config_version
= 0;
4668 r
->driver_version
= 0;
4672 /********************************************************************
4673 * fill a spoolss_DriverInfo6 struct
4674 ********************************************************************/
4676 static WERROR
fill_printer_driver_info6(TALLOC_CTX
*mem_ctx
,
4677 struct spoolss_DriverInfo6
*r
,
4678 const struct spoolss_DriverInfo8
*driver
,
4679 const char *servername
)
4681 const char *cservername
= canon_servername(servername
);
4683 r
->version
= driver
->version
;
4685 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4686 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4687 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4688 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4690 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4691 driver
->driver_path
,
4694 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4698 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4699 driver
->config_file
,
4702 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4706 FILL_DRIVER_STRING(mem_ctx
,
4707 driver
->monitor_name
,
4710 FILL_DRIVER_STRING(mem_ctx
,
4711 driver
->default_datatype
,
4712 r
->default_datatype
);
4714 r
->dependent_files
= string_array_from_driver_info(mem_ctx
,
4715 driver
->dependent_files
,
4717 r
->previous_names
= string_array_from_driver_info(mem_ctx
,
4718 driver
->previous_names
,
4721 r
->driver_date
= driver
->driver_date
;
4722 r
->driver_version
= driver
->driver_version
;
4724 FILL_DRIVER_STRING(mem_ctx
,
4725 driver
->manufacturer_name
,
4726 r
->manufacturer_name
);
4727 FILL_DRIVER_STRING(mem_ctx
,
4728 driver
->manufacturer_url
,
4729 r
->manufacturer_url
);
4730 FILL_DRIVER_STRING(mem_ctx
,
4731 driver
->hardware_id
,
4733 FILL_DRIVER_STRING(mem_ctx
,
4740 /********************************************************************
4741 * fill a spoolss_DriverInfo8 struct
4742 ********************************************************************/
4744 static WERROR
fill_printer_driver_info8(TALLOC_CTX
*mem_ctx
,
4745 struct spoolss_DriverInfo8
*r
,
4746 const struct spoolss_DriverInfo8
*driver
,
4747 const char *servername
)
4749 const char *cservername
= canon_servername(servername
);
4751 r
->version
= driver
->version
;
4753 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4754 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4755 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4756 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4758 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4759 driver
->driver_path
,
4762 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4766 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4767 driver
->config_file
,
4770 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4774 FILL_DRIVER_STRING(mem_ctx
,
4775 driver
->monitor_name
,
4778 FILL_DRIVER_STRING(mem_ctx
,
4779 driver
->default_datatype
,
4780 r
->default_datatype
);
4782 r
->dependent_files
= string_array_from_driver_info(mem_ctx
,
4783 driver
->dependent_files
,
4785 r
->previous_names
= string_array_from_driver_info(mem_ctx
,
4786 driver
->previous_names
,
4789 r
->driver_date
= driver
->driver_date
;
4790 r
->driver_version
= driver
->driver_version
;
4792 FILL_DRIVER_STRING(mem_ctx
,
4793 driver
->manufacturer_name
,
4794 r
->manufacturer_name
);
4795 FILL_DRIVER_STRING(mem_ctx
,
4796 driver
->manufacturer_url
,
4797 r
->manufacturer_url
);
4798 FILL_DRIVER_STRING(mem_ctx
,
4799 driver
->hardware_id
,
4801 FILL_DRIVER_STRING(mem_ctx
,
4805 FILL_DRIVER_STRING(mem_ctx
,
4806 driver
->print_processor
,
4807 r
->print_processor
);
4808 FILL_DRIVER_STRING(mem_ctx
,
4809 driver
->vendor_setup
,
4812 r
->color_profiles
= string_array_from_driver_info(mem_ctx
,
4813 driver
->color_profiles
,
4816 FILL_DRIVER_STRING(mem_ctx
,
4820 r
->printer_driver_attributes
= driver
->printer_driver_attributes
;
4822 r
->core_driver_dependencies
= string_array_from_driver_info(mem_ctx
,
4823 driver
->core_driver_dependencies
,
4826 r
->min_inbox_driver_ver_date
= driver
->min_inbox_driver_ver_date
;
4827 r
->min_inbox_driver_ver_version
= driver
->min_inbox_driver_ver_version
;
4832 #if 0 /* disabled until marshalling issues are resolved - gd */
4833 /********************************************************************
4834 ********************************************************************/
4836 static WERROR
fill_spoolss_DriverFileInfo(TALLOC_CTX
*mem_ctx
,
4837 struct spoolss_DriverFileInfo
*r
,
4838 const char *cservername
,
4839 const char *file_name
,
4840 enum spoolss_DriverFileType file_type
,
4841 uint32_t file_version
)
4843 r
->file_name
= talloc_asprintf(mem_ctx
, "\\\\%s%s",
4844 cservername
, file_name
);
4845 W_ERROR_HAVE_NO_MEMORY(r
->file_name
);
4846 r
->file_type
= file_type
;
4847 r
->file_version
= file_version
;
4852 /********************************************************************
4853 ********************************************************************/
4855 static WERROR
spoolss_DriverFileInfo_from_driver(TALLOC_CTX
*mem_ctx
,
4856 const struct spoolss_DriverInfo8
*driver
,
4857 const char *cservername
,
4858 struct spoolss_DriverFileInfo
**info_p
,
4861 struct spoolss_DriverFileInfo
*info
= NULL
;
4869 if (strlen(driver
->driver_path
)) {
4870 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4871 struct spoolss_DriverFileInfo
,
4873 W_ERROR_HAVE_NO_MEMORY(info
);
4874 result
= fill_spoolss_DriverFileInfo(info
,
4877 driver
->driver_path
,
4878 SPOOLSS_DRIVER_FILE_TYPE_RENDERING
,
4880 W_ERROR_NOT_OK_RETURN(result
);
4884 if (strlen(driver
->config_file
)) {
4885 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4886 struct spoolss_DriverFileInfo
,
4888 W_ERROR_HAVE_NO_MEMORY(info
);
4889 result
= fill_spoolss_DriverFileInfo(info
,
4892 driver
->config_file
,
4893 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION
,
4895 W_ERROR_NOT_OK_RETURN(result
);
4899 if (strlen(driver
->data_file
)) {
4900 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4901 struct spoolss_DriverFileInfo
,
4903 W_ERROR_HAVE_NO_MEMORY(info
);
4904 result
= fill_spoolss_DriverFileInfo(info
,
4908 SPOOLSS_DRIVER_FILE_TYPE_DATA
,
4910 W_ERROR_NOT_OK_RETURN(result
);
4914 if (strlen(driver
->help_file
)) {
4915 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4916 struct spoolss_DriverFileInfo
,
4918 W_ERROR_HAVE_NO_MEMORY(info
);
4919 result
= fill_spoolss_DriverFileInfo(info
,
4923 SPOOLSS_DRIVER_FILE_TYPE_HELP
,
4925 W_ERROR_NOT_OK_RETURN(result
);
4929 for (i
=0; driver
->dependent_files
[i
] && driver
->dependent_files
[i
][0] != '\0'; i
++) {
4930 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4931 struct spoolss_DriverFileInfo
,
4933 W_ERROR_HAVE_NO_MEMORY(info
);
4934 result
= fill_spoolss_DriverFileInfo(info
,
4937 driver
->dependent_files
[i
],
4938 SPOOLSS_DRIVER_FILE_TYPE_OTHER
,
4940 W_ERROR_NOT_OK_RETURN(result
);
4950 /********************************************************************
4951 * fill a spoolss_DriverInfo101 struct
4952 ********************************************************************/
4954 static WERROR
fill_printer_driver_info101(TALLOC_CTX
*mem_ctx
,
4955 struct spoolss_DriverInfo101
*r
,
4956 const struct spoolss_DriverInfo8
*driver
,
4957 const char *servername
)
4959 const char *cservername
= canon_servername(servername
);
4962 r
->version
= driver
->version
;
4964 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4965 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4966 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4967 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4969 result
= spoolss_DriverFileInfo_from_driver(mem_ctx
, driver
,
4973 if (!W_ERROR_IS_OK(result
)) {
4977 FILL_DRIVER_STRING(mem_ctx
,
4978 driver
->monitor_name
,
4981 FILL_DRIVER_STRING(mem_ctx
,
4982 driver
->default_datatype
,
4983 r
->default_datatype
);
4985 r
->previous_names
= string_array_from_driver_info(mem_ctx
,
4986 driver
->previous_names
,
4988 r
->driver_date
= driver
->driver_date
;
4989 r
->driver_version
= driver
->driver_version
;
4991 FILL_DRIVER_STRING(mem_ctx
,
4992 driver
->manufacturer_name
,
4993 r
->manufacturer_name
);
4994 FILL_DRIVER_STRING(mem_ctx
,
4995 driver
->manufacturer_url
,
4996 r
->manufacturer_url
);
4997 FILL_DRIVER_STRING(mem_ctx
,
4998 driver
->hardware_id
,
5000 FILL_DRIVER_STRING(mem_ctx
,
5007 /********************************************************************
5008 ********************************************************************/
5010 static WERROR
construct_printer_driver_info_level(TALLOC_CTX
*mem_ctx
,
5012 union spoolss_DriverInfo
*r
,
5014 const char *servername
,
5015 const char *architecture
,
5018 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
5019 struct spoolss_DriverInfo8
*driver
;
5022 result
= get_a_printer(NULL
, &printer
, 2, lp_const_servicename(snum
));
5024 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5025 win_errstr(result
)));
5027 if (!W_ERROR_IS_OK(result
)) {
5028 return WERR_INVALID_PRINTER_NAME
;
5031 result
= get_a_printer_driver(mem_ctx
, &driver
, printer
->info_2
->drivername
,
5032 architecture
, version
);
5034 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5035 win_errstr(result
)));
5037 if (!W_ERROR_IS_OK(result
)) {
5039 * Is this a W2k client ?
5043 free_a_printer(&printer
, 2);
5044 return WERR_UNKNOWN_PRINTER_DRIVER
;
5047 /* Yes - try again with a WinNT driver. */
5049 result
= get_a_printer_driver(mem_ctx
, &driver
, printer
->info_2
->drivername
,
5050 architecture
, version
);
5051 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5052 win_errstr(result
)));
5053 if (!W_ERROR_IS_OK(result
)) {
5054 free_a_printer(&printer
, 2);
5055 return WERR_UNKNOWN_PRINTER_DRIVER
;
5061 result
= fill_printer_driver_info1(mem_ctx
, &r
->info1
, driver
, servername
);
5064 result
= fill_printer_driver_info2(mem_ctx
, &r
->info2
, driver
, servername
);
5067 result
= fill_printer_driver_info3(mem_ctx
, &r
->info3
, driver
, servername
);
5070 result
= fill_printer_driver_info4(mem_ctx
, &r
->info4
, driver
, servername
);
5073 result
= fill_printer_driver_info5(mem_ctx
, &r
->info5
, driver
, servername
);
5076 result
= fill_printer_driver_info6(mem_ctx
, &r
->info6
, driver
, servername
);
5079 result
= fill_printer_driver_info8(mem_ctx
, &r
->info8
, driver
, servername
);
5081 #if 0 /* disabled until marshalling issues are resolved - gd */
5083 result
= fill_printer_driver_info101(mem_ctx
, &r
->info101
, driver
, servername
);
5087 result
= WERR_UNKNOWN_LEVEL
;
5091 free_a_printer(&printer
, 2);
5092 free_a_printer_driver(driver
);
5097 /****************************************************************
5098 _spoolss_GetPrinterDriver2
5099 ****************************************************************/
5101 WERROR
_spoolss_GetPrinterDriver2(pipes_struct
*p
,
5102 struct spoolss_GetPrinterDriver2
*r
)
5104 Printer_entry
*printer
;
5107 const char *servername
;
5110 /* that's an [in out] buffer */
5112 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
5113 return WERR_INVALID_PARAM
;
5116 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5118 if (!(printer
= find_printer_index_by_hnd(p
, r
->in
.handle
))) {
5119 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5120 return WERR_INVALID_PRINTER_NAME
;
5124 *r
->out
.server_major_version
= 0;
5125 *r
->out
.server_minor_version
= 0;
5127 servername
= get_server_name(printer
);
5129 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
5133 result
= construct_printer_driver_info_level(p
->mem_ctx
, r
->in
.level
,
5137 r
->in
.client_major_version
);
5138 if (!W_ERROR_IS_OK(result
)) {
5139 TALLOC_FREE(r
->out
.info
);
5143 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_DriverInfo
, NULL
,
5144 r
->out
.info
, r
->in
.level
);
5145 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
5147 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
5151 /****************************************************************
5152 _spoolss_StartPagePrinter
5153 ****************************************************************/
5155 WERROR
_spoolss_StartPagePrinter(pipes_struct
*p
,
5156 struct spoolss_StartPagePrinter
*r
)
5158 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5161 DEBUG(3,("_spoolss_StartPagePrinter: "
5162 "Error in startpageprinter printer handle\n"));
5166 Printer
->page_started
= true;
5170 /****************************************************************
5171 _spoolss_EndPagePrinter
5172 ****************************************************************/
5174 WERROR
_spoolss_EndPagePrinter(pipes_struct
*p
,
5175 struct spoolss_EndPagePrinter
*r
)
5179 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5182 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5183 OUR_HANDLE(r
->in
.handle
)));
5187 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
5190 Printer
->page_started
= false;
5191 print_job_endpage(snum
, Printer
->jobid
);
5196 /****************************************************************
5197 _spoolss_StartDocPrinter
5198 ****************************************************************/
5200 WERROR
_spoolss_StartDocPrinter(pipes_struct
*p
,
5201 struct spoolss_StartDocPrinter
*r
)
5203 struct spoolss_DocumentInfo1
*info_1
;
5205 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5208 DEBUG(2,("_spoolss_StartDocPrinter: "
5209 "Invalid handle (%s:%u:%u)\n",
5210 OUR_HANDLE(r
->in
.handle
)));
5214 if (r
->in
.level
!= 1) {
5215 return WERR_UNKNOWN_LEVEL
;
5218 info_1
= r
->in
.info
.info1
;
5221 * a nice thing with NT is it doesn't listen to what you tell it.
5222 * when asked to send _only_ RAW datas, it tries to send datas
5225 * So I add checks like in NT Server ...
5228 if (info_1
->datatype
) {
5229 if (strcmp(info_1
->datatype
, "RAW") != 0) {
5231 return WERR_INVALID_DATATYPE
;
5235 /* get the share number of the printer */
5236 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
5240 Printer
->jobid
= print_job_start(p
->server_info
, snum
,
5241 info_1
->document_name
,
5242 Printer
->nt_devmode
);
5244 /* An error occured in print_job_start() so return an appropriate
5247 if (Printer
->jobid
== -1) {
5248 return map_werror_from_unix(errno
);
5251 Printer
->document_started
= true;
5252 *r
->out
.job_id
= Printer
->jobid
;
5257 /****************************************************************
5258 _spoolss_EndDocPrinter
5259 ****************************************************************/
5261 WERROR
_spoolss_EndDocPrinter(pipes_struct
*p
,
5262 struct spoolss_EndDocPrinter
*r
)
5264 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5268 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5269 OUR_HANDLE(r
->in
.handle
)));
5273 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
5277 Printer
->document_started
= false;
5278 print_job_end(snum
, Printer
->jobid
, NORMAL_CLOSE
);
5279 /* error codes unhandled so far ... */
5284 /****************************************************************
5285 _spoolss_WritePrinter
5286 ****************************************************************/
5288 WERROR
_spoolss_WritePrinter(pipes_struct
*p
,
5289 struct spoolss_WritePrinter
*r
)
5291 ssize_t buffer_written
;
5293 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5296 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5297 OUR_HANDLE(r
->in
.handle
)));
5298 *r
->out
.num_written
= r
->in
._data_size
;
5302 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
5305 buffer_written
= print_job_write(snum
, Printer
->jobid
,
5306 (const char *)r
->in
.data
.data
,
5308 (size_t)r
->in
._data_size
);
5309 if (buffer_written
== (ssize_t
)-1) {
5310 *r
->out
.num_written
= 0;
5311 if (errno
== ENOSPC
)
5312 return WERR_NO_SPOOL_SPACE
;
5314 return WERR_ACCESS_DENIED
;
5317 *r
->out
.num_written
= r
->in
._data_size
;
5322 /********************************************************************
5323 * api_spoolss_getprinter
5324 * called from the spoolss dispatcher
5326 ********************************************************************/
5328 static WERROR
control_printer(struct policy_handle
*handle
, uint32_t command
,
5332 WERROR errcode
= WERR_BADFUNC
;
5333 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, handle
);
5336 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5337 OUR_HANDLE(handle
)));
5341 if (!get_printer_snum(p
, handle
, &snum
, NULL
))
5345 case SPOOLSS_PRINTER_CONTROL_PAUSE
:
5346 errcode
= print_queue_pause(p
->server_info
, snum
);
5348 case SPOOLSS_PRINTER_CONTROL_RESUME
:
5349 case SPOOLSS_PRINTER_CONTROL_UNPAUSE
:
5350 errcode
= print_queue_resume(p
->server_info
, snum
);
5352 case SPOOLSS_PRINTER_CONTROL_PURGE
:
5353 errcode
= print_queue_purge(p
->server_info
, snum
);
5356 return WERR_UNKNOWN_LEVEL
;
5363 /****************************************************************
5364 _spoolss_AbortPrinter
5365 * From MSDN: "Deletes printer's spool file if printer is configured
5367 ****************************************************************/
5369 WERROR
_spoolss_AbortPrinter(pipes_struct
*p
,
5370 struct spoolss_AbortPrinter
*r
)
5372 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5374 WERROR errcode
= WERR_OK
;
5377 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5378 OUR_HANDLE(r
->in
.handle
)));
5382 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
5385 print_job_delete(p
->server_info
, snum
, Printer
->jobid
, &errcode
);
5390 /********************************************************************
5391 * called by spoolss_api_setprinter
5392 * when updating a printer description
5393 ********************************************************************/
5395 static WERROR
update_printer_sec(struct policy_handle
*handle
,
5396 pipes_struct
*p
, SEC_DESC_BUF
*secdesc_ctr
)
5398 SEC_DESC_BUF
*new_secdesc_ctr
= NULL
, *old_secdesc_ctr
= NULL
;
5402 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, handle
);
5404 if (!Printer
|| !get_printer_snum(p
, handle
, &snum
, NULL
)) {
5405 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5406 OUR_HANDLE(handle
)));
5408 result
= WERR_BADFID
;
5413 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5414 result
= WERR_INVALID_PARAM
;
5418 /* Check the user has permissions to change the security
5419 descriptor. By experimentation with two NT machines, the user
5420 requires Full Access to the printer to change security
5423 if ( Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
5424 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5425 result
= WERR_ACCESS_DENIED
;
5429 /* NT seems to like setting the security descriptor even though
5430 nothing may have actually changed. */
5432 if ( !nt_printing_getsec(p
->mem_ctx
, Printer
->sharename
, &old_secdesc_ctr
)) {
5433 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5434 result
= WERR_BADFID
;
5438 if (DEBUGLEVEL
>= 10) {
5442 the_acl
= old_secdesc_ctr
->sd
->dacl
;
5443 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5444 PRINTERNAME(snum
), the_acl
->num_aces
));
5446 for (i
= 0; i
< the_acl
->num_aces
; i
++) {
5447 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5448 &the_acl
->aces
[i
].trustee
),
5449 the_acl
->aces
[i
].access_mask
));
5452 the_acl
= secdesc_ctr
->sd
->dacl
;
5455 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5456 PRINTERNAME(snum
), the_acl
->num_aces
));
5458 for (i
= 0; i
< the_acl
->num_aces
; i
++) {
5459 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5460 &the_acl
->aces
[i
].trustee
),
5461 the_acl
->aces
[i
].access_mask
));
5464 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5468 new_secdesc_ctr
= sec_desc_merge(p
->mem_ctx
, secdesc_ctr
, old_secdesc_ctr
);
5469 if (!new_secdesc_ctr
) {
5470 result
= WERR_NOMEM
;
5474 if (security_descriptor_equal(new_secdesc_ctr
->sd
, old_secdesc_ctr
->sd
)) {
5479 result
= nt_printing_setsec(Printer
->sharename
, new_secdesc_ctr
);
5486 /********************************************************************
5487 Canonicalize printer info from a client
5489 ATTN: It does not matter what we set the servername to hear
5490 since we do the necessary work in get_a_printer() to set it to
5491 the correct value based on what the client sent in the
5492 _spoolss_open_printer_ex().
5493 ********************************************************************/
5495 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2
*info
, int snum
)
5497 fstring printername
;
5500 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5501 "portname=%s drivername=%s comment=%s location=%s\n",
5502 info
->servername
, info
->printername
, info
->sharename
,
5503 info
->portname
, info
->drivername
, info
->comment
, info
->location
));
5505 /* we force some elements to "correct" values */
5506 slprintf(info
->servername
, sizeof(info
->servername
)-1, "\\\\%s", global_myname());
5507 fstrcpy(info
->sharename
, lp_servicename(snum
));
5509 /* check to see if we allow printername != sharename */
5511 if ( lp_force_printername(snum
) ) {
5512 slprintf(info
->printername
, sizeof(info
->printername
)-1, "\\\\%s\\%s",
5513 global_myname(), info
->sharename
);
5516 /* make sure printername is in \\server\printername format */
5518 fstrcpy( printername
, info
->printername
);
5520 if ( printername
[0] == '\\' && printername
[1] == '\\' ) {
5521 if ( (p
= strchr_m( &printername
[2], '\\' )) != NULL
)
5525 slprintf(info
->printername
, sizeof(info
->printername
)-1, "\\\\%s\\%s",
5526 global_myname(), p
);
5529 info
->attributes
|= PRINTER_ATTRIBUTE_SAMBA
;
5530 info
->attributes
&= ~PRINTER_ATTRIBUTE_NOT_SAMBA
;
5537 /****************************************************************************
5538 ****************************************************************************/
5540 static WERROR
add_port_hook(TALLOC_CTX
*ctx
, NT_USER_TOKEN
*token
, const char *portname
, const char *uri
)
5542 char *cmd
= lp_addport_cmd();
5543 char *command
= NULL
;
5545 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
5546 bool is_print_op
= false;
5549 return WERR_ACCESS_DENIED
;
5552 command
= talloc_asprintf(ctx
,
5553 "%s \"%s\" \"%s\"", cmd
, portname
, uri
);
5559 is_print_op
= user_has_privileges( token
, &se_printop
);
5561 DEBUG(10,("Running [%s]\n", command
));
5563 /********* BEGIN SePrintOperatorPrivilege **********/
5568 ret
= smbrun(command
, NULL
);
5573 /********* END SePrintOperatorPrivilege **********/
5575 DEBUGADD(10,("returned [%d]\n", ret
));
5577 TALLOC_FREE(command
);
5580 return WERR_ACCESS_DENIED
;
5586 /****************************************************************************
5587 ****************************************************************************/
5589 bool add_printer_hook(TALLOC_CTX
*ctx
, NT_USER_TOKEN
*token
, NT_PRINTER_INFO_LEVEL
*printer
)
5591 char *cmd
= lp_addprinter_cmd();
5593 char *command
= NULL
;
5597 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
5598 bool is_print_op
= false;
5599 char *remote_machine
= talloc_strdup(ctx
, "%m");
5601 if (!remote_machine
) {
5604 remote_machine
= talloc_sub_basic(ctx
,
5605 current_user_info
.smb_name
,
5606 current_user_info
.domain
,
5608 if (!remote_machine
) {
5612 command
= talloc_asprintf(ctx
,
5613 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5614 cmd
, printer
->info_2
->printername
, printer
->info_2
->sharename
,
5615 printer
->info_2
->portname
, printer
->info_2
->drivername
,
5616 printer
->info_2
->location
, printer
->info_2
->comment
, remote_machine
);
5622 is_print_op
= user_has_privileges( token
, &se_printop
);
5624 DEBUG(10,("Running [%s]\n", command
));
5626 /********* BEGIN SePrintOperatorPrivilege **********/
5631 if ( (ret
= smbrun(command
, &fd
)) == 0 ) {
5632 /* Tell everyone we updated smb.conf. */
5633 message_send_all(smbd_messaging_context(),
5634 MSG_SMB_CONF_UPDATED
, NULL
, 0, NULL
);
5640 /********* END SePrintOperatorPrivilege **********/
5642 DEBUGADD(10,("returned [%d]\n", ret
));
5644 TALLOC_FREE(command
);
5645 TALLOC_FREE(remote_machine
);
5653 /* reload our services immediately */
5655 reload_services(false);
5659 /* Get lines and convert them back to dos-codepage */
5660 qlines
= fd_lines_load(fd
, &numlines
, 0, NULL
);
5661 DEBUGADD(10,("Lines returned = [%d]\n", numlines
));
5664 /* Set the portname to what the script says the portname should be. */
5665 /* but don't require anything to be return from the script exit a good error code */
5668 /* Set the portname to what the script says the portname should be. */
5669 strncpy(printer
->info_2
->portname
, qlines
[0], sizeof(printer
->info_2
->portname
));
5670 DEBUGADD(6,("Line[0] = [%s]\n", qlines
[0]));
5673 TALLOC_FREE(qlines
);
5678 /********************************************************************
5679 * Called by spoolss_api_setprinter
5680 * when updating a printer description.
5681 ********************************************************************/
5683 static WERROR
update_printer(pipes_struct
*p
, struct policy_handle
*handle
,
5684 struct spoolss_SetPrinterInfoCtr
*info_ctr
,
5685 struct spoolss_DeviceMode
*devmode
)
5688 NT_PRINTER_INFO_LEVEL
*printer
= NULL
, *old_printer
= NULL
;
5689 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, handle
);
5694 DEBUG(8,("update_printer\n"));
5699 result
= WERR_BADFID
;
5703 if (!get_printer_snum(p
, handle
, &snum
, NULL
)) {
5704 result
= WERR_BADFID
;
5708 if (!W_ERROR_IS_OK(get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
))) ||
5709 (!W_ERROR_IS_OK(get_a_printer(Printer
, &old_printer
, 2, lp_const_servicename(snum
))))) {
5710 result
= WERR_BADFID
;
5714 DEBUGADD(8,("Converting info_2 struct\n"));
5717 * convert_printer_info converts the incoming
5718 * info from the client and overwrites the info
5719 * just read from the tdb in the pointer 'printer'.
5722 if (!convert_printer_info(info_ctr
, printer
)) {
5723 result
= WERR_NOMEM
;
5728 /* we have a valid devmode
5729 convert it and link it*/
5731 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5732 if (!convert_devicemode(printer
->info_2
->printername
, devmode
,
5733 &printer
->info_2
->devmode
)) {
5734 result
= WERR_NOMEM
;
5739 /* Do sanity check on the requested changes for Samba */
5741 if (!check_printer_ok(printer
->info_2
, snum
)) {
5742 result
= WERR_INVALID_PARAM
;
5746 /* FIXME!!! If the driver has changed we really should verify that
5747 it is installed before doing much else --jerry */
5749 /* Check calling user has permission to update printer description */
5751 if (Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
5752 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5753 result
= WERR_ACCESS_DENIED
;
5757 /* Call addprinter hook */
5758 /* Check changes to see if this is really needed */
5760 if ( *lp_addprinter_cmd()
5761 && (!strequal(printer
->info_2
->drivername
, old_printer
->info_2
->drivername
)
5762 || !strequal(printer
->info_2
->comment
, old_printer
->info_2
->comment
)
5763 || !strequal(printer
->info_2
->portname
, old_printer
->info_2
->portname
)
5764 || !strequal(printer
->info_2
->location
, old_printer
->info_2
->location
)) )
5766 /* add_printer_hook() will call reload_services() */
5768 if ( !add_printer_hook(p
->mem_ctx
, p
->server_info
->ptok
,
5770 result
= WERR_ACCESS_DENIED
;
5776 * When a *new* driver is bound to a printer, the drivername is used to
5777 * lookup previously saved driver initialization info, which is then
5778 * bound to the printer, simulating what happens in the Windows arch.
5780 if (!strequal(printer
->info_2
->drivername
, old_printer
->info_2
->drivername
))
5782 if (!set_driver_init(printer
, 2))
5784 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
5785 printer
->info_2
->drivername
));
5788 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
5789 printer
->info_2
->drivername
));
5791 notify_printer_driver(snum
, printer
->info_2
->drivername
);
5795 * flag which changes actually occured. This is a small subset of
5796 * all the possible changes. We also have to update things in the
5800 if (!strequal(printer
->info_2
->comment
, old_printer
->info_2
->comment
)) {
5801 push_reg_sz(talloc_tos(), &buffer
, printer
->info_2
->comment
);
5802 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "description",
5803 REG_SZ
, buffer
.data
, buffer
.length
);
5805 notify_printer_comment(snum
, printer
->info_2
->comment
);
5808 if (!strequal(printer
->info_2
->sharename
, old_printer
->info_2
->sharename
)) {
5809 push_reg_sz(talloc_tos(), &buffer
, printer
->info_2
->sharename
);
5810 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "shareName",
5811 REG_SZ
, buffer
.data
, buffer
.length
);
5813 notify_printer_sharename(snum
, printer
->info_2
->sharename
);
5816 if (!strequal(printer
->info_2
->printername
, old_printer
->info_2
->printername
)) {
5819 if ( (pname
= strchr_m( printer
->info_2
->printername
+2, '\\' )) != NULL
)
5822 pname
= printer
->info_2
->printername
;
5825 push_reg_sz(talloc_tos(), &buffer
, pname
);
5826 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "printerName",
5827 REG_SZ
, buffer
.data
, buffer
.length
);
5829 notify_printer_printername( snum
, pname
);
5832 if (!strequal(printer
->info_2
->portname
, old_printer
->info_2
->portname
)) {
5833 push_reg_sz(talloc_tos(), &buffer
, printer
->info_2
->portname
);
5834 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "portName",
5835 REG_SZ
, buffer
.data
, buffer
.length
);
5837 notify_printer_port(snum
, printer
->info_2
->portname
);
5840 if (!strequal(printer
->info_2
->location
, old_printer
->info_2
->location
)) {
5841 push_reg_sz(talloc_tos(), &buffer
, printer
->info_2
->location
);
5842 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "location",
5843 REG_SZ
, buffer
.data
, buffer
.length
);
5845 notify_printer_location(snum
, printer
->info_2
->location
);
5848 /* here we need to update some more DsSpooler keys */
5849 /* uNCName, serverName, shortServerName */
5851 push_reg_sz(talloc_tos(), &buffer
, global_myname());
5852 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "serverName",
5853 REG_SZ
, buffer
.data
, buffer
.length
);
5854 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "shortServerName",
5855 REG_SZ
, buffer
.data
, buffer
.length
);
5857 slprintf( asc_buffer
, sizeof(asc_buffer
)-1, "\\\\%s\\%s",
5858 global_myname(), printer
->info_2
->sharename
);
5859 push_reg_sz(talloc_tos(), &buffer
, asc_buffer
);
5860 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "uNCName",
5861 REG_SZ
, buffer
.data
, buffer
.length
);
5863 /* Update printer info */
5864 result
= mod_a_printer(printer
, 2);
5867 free_a_printer(&printer
, 2);
5868 free_a_printer(&old_printer
, 2);
5874 /****************************************************************************
5875 ****************************************************************************/
5876 static WERROR
publish_or_unpublish_printer(pipes_struct
*p
,
5877 struct policy_handle
*handle
,
5878 struct spoolss_SetPrinterInfo7
*info7
)
5882 Printer_entry
*Printer
;
5884 if ( lp_security() != SEC_ADS
) {
5885 return WERR_UNKNOWN_LEVEL
;
5888 Printer
= find_printer_index_by_hnd(p
, handle
);
5890 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7
->action
));
5895 if (!get_printer_snum(p
, handle
, &snum
, NULL
))
5898 nt_printer_publish(Printer
, snum
, info7
->action
);
5902 return WERR_UNKNOWN_LEVEL
;
5906 /********************************************************************
5907 ********************************************************************/
5909 static WERROR
update_printer_devmode(pipes_struct
*p
, struct policy_handle
*handle
,
5910 struct spoolss_DeviceMode
*devmode
)
5913 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
5914 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, handle
);
5917 DEBUG(8,("update_printer_devmode\n"));
5922 result
= WERR_BADFID
;
5926 if (!get_printer_snum(p
, handle
, &snum
, NULL
)) {
5927 result
= WERR_BADFID
;
5931 if (!W_ERROR_IS_OK(get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
)))) {
5932 result
= WERR_BADFID
;
5937 /* we have a valid devmode
5938 convert it and link it*/
5940 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5941 if (!convert_devicemode(printer
->info_2
->printername
, devmode
,
5942 &printer
->info_2
->devmode
)) {
5943 result
= WERR_NOMEM
;
5948 /* Check calling user has permission to update printer description */
5950 if (Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
5951 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5952 result
= WERR_ACCESS_DENIED
;
5957 /* Update printer info */
5958 result
= mod_a_printer(printer
, 2);
5961 free_a_printer(&printer
, 2);
5967 /****************************************************************
5969 ****************************************************************/
5971 WERROR
_spoolss_SetPrinter(pipes_struct
*p
,
5972 struct spoolss_SetPrinter
*r
)
5976 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5979 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
5980 OUR_HANDLE(r
->in
.handle
)));
5984 /* check the level */
5985 switch (r
->in
.info_ctr
->level
) {
5987 return control_printer(r
->in
.handle
, r
->in
.command
, p
);
5989 result
= update_printer(p
, r
->in
.handle
,
5991 r
->in
.devmode_ctr
->devmode
);
5992 if (!W_ERROR_IS_OK(result
))
5994 if (r
->in
.secdesc_ctr
->sd
)
5995 result
= update_printer_sec(r
->in
.handle
, p
,
5999 return update_printer_sec(r
->in
.handle
, p
,
6002 return publish_or_unpublish_printer(p
, r
->in
.handle
,
6003 r
->in
.info_ctr
->info
.info7
);
6005 return update_printer_devmode(p
, r
->in
.handle
,
6006 r
->in
.devmode_ctr
->devmode
);
6008 return WERR_UNKNOWN_LEVEL
;
6012 /****************************************************************
6013 _spoolss_FindClosePrinterNotify
6014 ****************************************************************/
6016 WERROR
_spoolss_FindClosePrinterNotify(pipes_struct
*p
,
6017 struct spoolss_FindClosePrinterNotify
*r
)
6019 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
6022 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6023 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r
->in
.handle
)));
6027 if (Printer
->notify
.client_connected
== true) {
6030 if ( Printer
->printer_type
== SPLHND_SERVER
)
6032 else if ( (Printer
->printer_type
== SPLHND_PRINTER
) &&
6033 !get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
) )
6036 srv_spoolss_replycloseprinter(snum
, &Printer
->notify
.client_hnd
);
6039 Printer
->notify
.flags
=0;
6040 Printer
->notify
.options
=0;
6041 Printer
->notify
.localmachine
[0]='\0';
6042 Printer
->notify
.printerlocal
=0;
6043 TALLOC_FREE(Printer
->notify
.option
);
6044 Printer
->notify
.client_connected
= false;
6049 /****************************************************************
6051 ****************************************************************/
6053 WERROR
_spoolss_AddJob(pipes_struct
*p
,
6054 struct spoolss_AddJob
*r
)
6056 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
6057 return WERR_INVALID_PARAM
;
6060 /* this is what a NT server returns for AddJob. AddJob must fail on
6061 * non-local printers */
6063 if (r
->in
.level
!= 1) {
6064 return WERR_UNKNOWN_LEVEL
;
6067 return WERR_INVALID_PARAM
;
6070 /****************************************************************************
6072 ****************************************************************************/
6074 static WERROR
fill_job_info1(TALLOC_CTX
*mem_ctx
,
6075 struct spoolss_JobInfo1
*r
,
6076 const print_queue_struct
*queue
,
6077 int position
, int snum
,
6078 const NT_PRINTER_INFO_LEVEL
*ntprinter
)
6082 t
= gmtime(&queue
->time
);
6084 r
->job_id
= queue
->job
;
6086 r
->printer_name
= talloc_strdup(mem_ctx
, lp_servicename(snum
));
6087 W_ERROR_HAVE_NO_MEMORY(r
->printer_name
);
6088 r
->server_name
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->servername
);
6089 W_ERROR_HAVE_NO_MEMORY(r
->server_name
);
6090 r
->user_name
= talloc_strdup(mem_ctx
, queue
->fs_user
);
6091 W_ERROR_HAVE_NO_MEMORY(r
->user_name
);
6092 r
->document_name
= talloc_strdup(mem_ctx
, queue
->fs_file
);
6093 W_ERROR_HAVE_NO_MEMORY(r
->document_name
);
6094 r
->data_type
= talloc_strdup(mem_ctx
, "RAW");
6095 W_ERROR_HAVE_NO_MEMORY(r
->data_type
);
6096 r
->text_status
= talloc_strdup(mem_ctx
, "");
6097 W_ERROR_HAVE_NO_MEMORY(r
->text_status
);
6099 r
->status
= nt_printj_status(queue
->status
);
6100 r
->priority
= queue
->priority
;
6101 r
->position
= position
;
6102 r
->total_pages
= queue
->page_count
;
6103 r
->pages_printed
= 0; /* ??? */
6105 init_systemtime(&r
->submitted
, t
);
6110 /****************************************************************************
6112 ****************************************************************************/
6114 static WERROR
fill_job_info2(TALLOC_CTX
*mem_ctx
,
6115 struct spoolss_JobInfo2
*r
,
6116 const print_queue_struct
*queue
,
6117 int position
, int snum
,
6118 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
6119 struct spoolss_DeviceMode
*devmode
)
6123 t
= gmtime(&queue
->time
);
6125 r
->job_id
= queue
->job
;
6127 r
->printer_name
= talloc_strdup(mem_ctx
, lp_servicename(snum
));
6128 W_ERROR_HAVE_NO_MEMORY(r
->printer_name
);
6129 r
->server_name
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->servername
);
6130 W_ERROR_HAVE_NO_MEMORY(r
->server_name
);
6131 r
->user_name
= talloc_strdup(mem_ctx
, queue
->fs_user
);
6132 W_ERROR_HAVE_NO_MEMORY(r
->user_name
);
6133 r
->document_name
= talloc_strdup(mem_ctx
, queue
->fs_file
);
6134 W_ERROR_HAVE_NO_MEMORY(r
->document_name
);
6135 r
->notify_name
= talloc_strdup(mem_ctx
, queue
->fs_user
);
6136 W_ERROR_HAVE_NO_MEMORY(r
->notify_name
);
6137 r
->data_type
= talloc_strdup(mem_ctx
, "RAW");
6138 W_ERROR_HAVE_NO_MEMORY(r
->data_type
);
6139 r
->print_processor
= talloc_strdup(mem_ctx
, "winprint");
6140 W_ERROR_HAVE_NO_MEMORY(r
->print_processor
);
6141 r
->parameters
= talloc_strdup(mem_ctx
, "");
6142 W_ERROR_HAVE_NO_MEMORY(r
->parameters
);
6143 r
->driver_name
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->drivername
);
6144 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
6146 r
->devmode
= devmode
;
6148 r
->text_status
= talloc_strdup(mem_ctx
, "");
6149 W_ERROR_HAVE_NO_MEMORY(r
->text_status
);
6153 r
->status
= nt_printj_status(queue
->status
);
6154 r
->priority
= queue
->priority
;
6155 r
->position
= position
;
6158 r
->total_pages
= queue
->page_count
;
6159 r
->size
= queue
->size
;
6160 init_systemtime(&r
->submitted
, t
);
6162 r
->pages_printed
= 0; /* ??? */
6167 /****************************************************************************
6169 ****************************************************************************/
6171 static WERROR
fill_job_info3(TALLOC_CTX
*mem_ctx
,
6172 struct spoolss_JobInfo3
*r
,
6173 const print_queue_struct
*queue
,
6174 const print_queue_struct
*next_queue
,
6175 int position
, int snum
,
6176 const NT_PRINTER_INFO_LEVEL
*ntprinter
)
6178 r
->job_id
= queue
->job
;
6181 r
->next_job_id
= next_queue
->job
;
6188 /****************************************************************************
6189 Enumjobs at level 1.
6190 ****************************************************************************/
6192 static WERROR
enumjobs_level1(TALLOC_CTX
*mem_ctx
,
6193 const print_queue_struct
*queue
,
6194 uint32_t num_queues
, int snum
,
6195 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
6196 union spoolss_JobInfo
**info_p
,
6199 union spoolss_JobInfo
*info
;
6201 WERROR result
= WERR_OK
;
6203 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_JobInfo
, num_queues
);
6204 W_ERROR_HAVE_NO_MEMORY(info
);
6206 *count
= num_queues
;
6208 for (i
=0; i
<*count
; i
++) {
6209 result
= fill_job_info1(info
,
6215 if (!W_ERROR_IS_OK(result
)) {
6221 if (!W_ERROR_IS_OK(result
)) {
6232 /****************************************************************************
6233 Enumjobs at level 2.
6234 ****************************************************************************/
6236 static WERROR
enumjobs_level2(TALLOC_CTX
*mem_ctx
,
6237 const print_queue_struct
*queue
,
6238 uint32_t num_queues
, int snum
,
6239 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
6240 union spoolss_JobInfo
**info_p
,
6243 union spoolss_JobInfo
*info
;
6245 WERROR result
= WERR_OK
;
6247 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_JobInfo
, num_queues
);
6248 W_ERROR_HAVE_NO_MEMORY(info
);
6250 *count
= num_queues
;
6252 for (i
=0; i
<*count
; i
++) {
6254 struct spoolss_DeviceMode
*devmode
;
6256 devmode
= construct_dev_mode(info
, lp_const_servicename(snum
));
6258 result
= WERR_NOMEM
;
6262 result
= fill_job_info2(info
,
6269 if (!W_ERROR_IS_OK(result
)) {
6275 if (!W_ERROR_IS_OK(result
)) {
6286 /****************************************************************************
6287 Enumjobs at level 3.
6288 ****************************************************************************/
6290 static WERROR
enumjobs_level3(TALLOC_CTX
*mem_ctx
,
6291 const print_queue_struct
*queue
,
6292 uint32_t num_queues
, int snum
,
6293 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
6294 union spoolss_JobInfo
**info_p
,
6297 union spoolss_JobInfo
*info
;
6299 WERROR result
= WERR_OK
;
6301 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_JobInfo
, num_queues
);
6302 W_ERROR_HAVE_NO_MEMORY(info
);
6304 *count
= num_queues
;
6306 for (i
=0; i
<*count
; i
++) {
6307 const print_queue_struct
*next_queue
= NULL
;
6310 next_queue
= &queue
[i
+1];
6313 result
= fill_job_info3(info
,
6320 if (!W_ERROR_IS_OK(result
)) {
6326 if (!W_ERROR_IS_OK(result
)) {
6337 /****************************************************************
6339 ****************************************************************/
6341 WERROR
_spoolss_EnumJobs(pipes_struct
*p
,
6342 struct spoolss_EnumJobs
*r
)
6345 NT_PRINTER_INFO_LEVEL
*ntprinter
= NULL
;
6347 print_status_struct prt_status
;
6348 print_queue_struct
*queue
= NULL
;
6351 /* that's an [in out] buffer */
6353 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
6354 return WERR_INVALID_PARAM
;
6357 DEBUG(4,("_spoolss_EnumJobs\n"));
6361 *r
->out
.info
= NULL
;
6363 /* lookup the printer snum and tdb entry */
6365 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
6369 result
= get_a_printer(NULL
, &ntprinter
, 2, lp_servicename(snum
));
6370 if (!W_ERROR_IS_OK(result
)) {
6374 count
= print_queue_status(snum
, &queue
, &prt_status
);
6375 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6376 count
, prt_status
.status
, prt_status
.message
));
6380 free_a_printer(&ntprinter
, 2);
6384 switch (r
->in
.level
) {
6386 result
= enumjobs_level1(p
->mem_ctx
, queue
, count
, snum
,
6387 ntprinter
, r
->out
.info
, r
->out
.count
);
6390 result
= enumjobs_level2(p
->mem_ctx
, queue
, count
, snum
,
6391 ntprinter
, r
->out
.info
, r
->out
.count
);
6394 result
= enumjobs_level3(p
->mem_ctx
, queue
, count
, snum
,
6395 ntprinter
, r
->out
.info
, r
->out
.count
);
6398 result
= WERR_UNKNOWN_LEVEL
;
6403 free_a_printer(&ntprinter
, 2);
6405 if (!W_ERROR_IS_OK(result
)) {
6409 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
6410 spoolss_EnumJobs
, NULL
,
6411 *r
->out
.info
, r
->in
.level
,
6413 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
6414 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
6416 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
6419 /****************************************************************
6420 _spoolss_ScheduleJob
6421 ****************************************************************/
6423 WERROR
_spoolss_ScheduleJob(pipes_struct
*p
,
6424 struct spoolss_ScheduleJob
*r
)
6429 /****************************************************************
6431 ****************************************************************/
6433 WERROR
_spoolss_SetJob(pipes_struct
*p
,
6434 struct spoolss_SetJob
*r
)
6437 WERROR errcode
= WERR_BADFUNC
;
6439 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
6443 if (!print_job_exists(lp_const_servicename(snum
), r
->in
.job_id
)) {
6444 return WERR_INVALID_PRINTER_NAME
;
6447 switch (r
->in
.command
) {
6448 case SPOOLSS_JOB_CONTROL_CANCEL
:
6449 case SPOOLSS_JOB_CONTROL_DELETE
:
6450 if (print_job_delete(p
->server_info
, snum
, r
->in
.job_id
, &errcode
)) {
6454 case SPOOLSS_JOB_CONTROL_PAUSE
:
6455 if (print_job_pause(p
->server_info
, snum
, r
->in
.job_id
, &errcode
)) {
6459 case SPOOLSS_JOB_CONTROL_RESTART
:
6460 case SPOOLSS_JOB_CONTROL_RESUME
:
6461 if (print_job_resume(p
->server_info
, snum
, r
->in
.job_id
, &errcode
)) {
6466 return WERR_UNKNOWN_LEVEL
;
6472 /****************************************************************************
6473 Enumerates all printer drivers by level and architecture.
6474 ****************************************************************************/
6476 static WERROR
enumprinterdrivers_level_by_architecture(TALLOC_CTX
*mem_ctx
,
6477 const char *servername
,
6478 const char *architecture
,
6480 union spoolss_DriverInfo
**info_p
,
6486 fstring
*list
= NULL
;
6487 struct spoolss_DriverInfo8
*driver
;
6488 union spoolss_DriverInfo
*info
= NULL
;
6490 WERROR result
= WERR_OK
;
6495 for (version
=0; version
<DRIVER_MAX_VERSION
; version
++) {
6497 ndrivers
= get_ntdrivers(&list
, architecture
, version
);
6498 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6499 ndrivers
, architecture
, version
));
6501 if (ndrivers
== -1) {
6502 result
= WERR_NOMEM
;
6506 if (ndrivers
!= 0) {
6507 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
6508 union spoolss_DriverInfo
,
6511 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
6512 "failed to enlarge driver info buffer!\n"));
6513 result
= WERR_NOMEM
;
6518 for (i
=0; i
<ndrivers
; i
++) {
6519 DEBUGADD(5,("\tdriver: [%s]\n", list
[i
]));
6520 ZERO_STRUCT(driver
);
6521 result
= get_a_printer_driver(mem_ctx
, &driver
, list
[i
],
6522 architecture
, version
);
6523 if (!W_ERROR_IS_OK(result
)) {
6529 result
= fill_printer_driver_info1(info
, &info
[count
+i
].info1
,
6530 driver
, servername
);
6533 result
= fill_printer_driver_info2(info
, &info
[count
+i
].info2
,
6534 driver
, servername
);
6537 result
= fill_printer_driver_info3(info
, &info
[count
+i
].info3
,
6538 driver
, servername
);
6541 result
= fill_printer_driver_info4(info
, &info
[count
+i
].info4
,
6542 driver
, servername
);
6545 result
= fill_printer_driver_info5(info
, &info
[count
+i
].info5
,
6546 driver
, servername
);
6549 result
= fill_printer_driver_info6(info
, &info
[count
+i
].info6
,
6550 driver
, servername
);
6553 result
= fill_printer_driver_info8(info
, &info
[count
+i
].info8
,
6554 driver
, servername
);
6557 result
= WERR_UNKNOWN_LEVEL
;
6561 free_a_printer_driver(driver
);
6563 if (!W_ERROR_IS_OK(result
)) {
6575 if (!W_ERROR_IS_OK(result
)) {
6586 /****************************************************************************
6587 Enumerates all printer drivers by level.
6588 ****************************************************************************/
6590 static WERROR
enumprinterdrivers_level(TALLOC_CTX
*mem_ctx
,
6591 const char *servername
,
6592 const char *architecture
,
6594 union spoolss_DriverInfo
**info_p
,
6598 WERROR result
= WERR_OK
;
6600 if (strequal(architecture
, SPOOLSS_ARCHITECTURE_ALL
)) {
6602 for (a
=0; archi_table
[a
].long_archi
!= NULL
; a
++) {
6604 union spoolss_DriverInfo
*info
= NULL
;
6607 result
= enumprinterdrivers_level_by_architecture(mem_ctx
,
6609 archi_table
[a
].long_archi
,
6613 if (!W_ERROR_IS_OK(result
)) {
6617 for (i
=0; i
< count
; i
++) {
6618 ADD_TO_ARRAY(mem_ctx
, union spoolss_DriverInfo
,
6619 info
[i
], info_p
, count_p
);
6626 return enumprinterdrivers_level_by_architecture(mem_ctx
,
6634 /****************************************************************
6635 _spoolss_EnumPrinterDrivers
6636 ****************************************************************/
6638 WERROR
_spoolss_EnumPrinterDrivers(pipes_struct
*p
,
6639 struct spoolss_EnumPrinterDrivers
*r
)
6641 const char *cservername
;
6644 /* that's an [in out] buffer */
6646 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
6647 return WERR_INVALID_PARAM
;
6650 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6654 *r
->out
.info
= NULL
;
6656 cservername
= canon_servername(r
->in
.server
);
6658 if (!is_myname_or_ipaddr(cservername
)) {
6659 return WERR_UNKNOWN_PRINTER_DRIVER
;
6662 result
= enumprinterdrivers_level(p
->mem_ctx
, cservername
,
6667 if (!W_ERROR_IS_OK(result
)) {
6671 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
6672 spoolss_EnumPrinterDrivers
, NULL
,
6673 *r
->out
.info
, r
->in
.level
,
6675 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
6676 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
6678 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
6681 /****************************************************************************
6682 ****************************************************************************/
6684 static WERROR
fill_form_info_1(TALLOC_CTX
*mem_ctx
,
6685 struct spoolss_FormInfo1
*r
,
6686 const nt_forms_struct
*form
)
6688 r
->form_name
= talloc_strdup(mem_ctx
, form
->name
);
6689 W_ERROR_HAVE_NO_MEMORY(r
->form_name
);
6691 r
->flags
= form
->flag
;
6692 r
->size
.width
= form
->width
;
6693 r
->size
.height
= form
->length
;
6694 r
->area
.left
= form
->left
;
6695 r
->area
.top
= form
->top
;
6696 r
->area
.right
= form
->right
;
6697 r
->area
.bottom
= form
->bottom
;
6702 /****************************************************************
6703 spoolss_enumforms_level1
6704 ****************************************************************/
6706 static WERROR
spoolss_enumforms_level1(TALLOC_CTX
*mem_ctx
,
6707 const nt_forms_struct
*builtin_forms
,
6708 uint32_t num_builtin_forms
,
6709 const nt_forms_struct
*user_forms
,
6710 uint32_t num_user_forms
,
6711 union spoolss_FormInfo
**info_p
,
6714 union spoolss_FormInfo
*info
;
6715 WERROR result
= WERR_OK
;
6718 *count
= num_builtin_forms
+ num_user_forms
;
6720 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_FormInfo
, *count
);
6721 W_ERROR_HAVE_NO_MEMORY(info
);
6723 /* construct the list of form structures */
6724 for (i
=0; i
<num_builtin_forms
; i
++) {
6725 DEBUGADD(6,("Filling builtin form number [%d]\n",i
));
6726 result
= fill_form_info_1(info
, &info
[i
].info1
,
6728 if (!W_ERROR_IS_OK(result
)) {
6733 for (i
=0; i
<num_user_forms
; i
++) {
6734 DEBUGADD(6,("Filling user form number [%d]\n",i
));
6735 result
= fill_form_info_1(info
, &info
[i
+num_builtin_forms
].info1
,
6737 if (!W_ERROR_IS_OK(result
)) {
6743 if (!W_ERROR_IS_OK(result
)) {
6754 /****************************************************************
6756 ****************************************************************/
6758 WERROR
_spoolss_EnumForms(pipes_struct
*p
,
6759 struct spoolss_EnumForms
*r
)
6762 nt_forms_struct
*user_forms
= NULL
;
6763 nt_forms_struct
*builtin_forms
= NULL
;
6764 uint32_t num_user_forms
;
6765 uint32_t num_builtin_forms
;
6769 *r
->out
.info
= NULL
;
6771 /* that's an [in out] buffer */
6773 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0) ) {
6774 return WERR_INVALID_PARAM
;
6777 DEBUG(4,("_spoolss_EnumForms\n"));
6778 DEBUGADD(5,("Offered buffer size [%d]\n", r
->in
.offered
));
6779 DEBUGADD(5,("Info level [%d]\n", r
->in
.level
));
6781 num_builtin_forms
= get_builtin_ntforms(&builtin_forms
);
6782 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms
));
6783 num_user_forms
= get_ntforms(&user_forms
);
6784 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms
));
6786 if (num_user_forms
+ num_builtin_forms
== 0) {
6787 SAFE_FREE(builtin_forms
);
6788 SAFE_FREE(user_forms
);
6789 return WERR_NO_MORE_ITEMS
;
6792 switch (r
->in
.level
) {
6794 result
= spoolss_enumforms_level1(p
->mem_ctx
,
6803 result
= WERR_UNKNOWN_LEVEL
;
6807 SAFE_FREE(user_forms
);
6808 SAFE_FREE(builtin_forms
);
6810 if (!W_ERROR_IS_OK(result
)) {
6814 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
6815 spoolss_EnumForms
, NULL
,
6816 *r
->out
.info
, r
->in
.level
,
6818 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
6819 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
6821 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
6824 /****************************************************************
6825 ****************************************************************/
6827 static WERROR
find_form_byname(const char *name
,
6828 nt_forms_struct
*form
)
6830 nt_forms_struct
*list
= NULL
;
6831 int num_forms
= 0, i
= 0;
6833 if (get_a_builtin_ntform_by_string(name
, form
)) {
6837 num_forms
= get_ntforms(&list
);
6838 DEBUGADD(5,("Number of forms [%d]\n", num_forms
));
6840 if (num_forms
== 0) {
6844 /* Check if the requested name is in the list of form structures */
6845 for (i
= 0; i
< num_forms
; i
++) {
6847 DEBUG(4,("checking form %s (want %s)\n", list
[i
].name
, name
));
6849 if (strequal(name
, list
[i
].name
)) {
6850 DEBUGADD(6,("Found form %s number [%d]\n", name
, i
));
6862 /****************************************************************
6864 ****************************************************************/
6866 WERROR
_spoolss_GetForm(pipes_struct
*p
,
6867 struct spoolss_GetForm
*r
)
6870 nt_forms_struct form
;
6872 /* that's an [in out] buffer */
6874 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
6875 return WERR_INVALID_PARAM
;
6878 DEBUG(4,("_spoolss_GetForm\n"));
6879 DEBUGADD(5,("Offered buffer size [%d]\n", r
->in
.offered
));
6880 DEBUGADD(5,("Info level [%d]\n", r
->in
.level
));
6882 result
= find_form_byname(r
->in
.form_name
, &form
);
6883 if (!W_ERROR_IS_OK(result
)) {
6884 TALLOC_FREE(r
->out
.info
);
6888 switch (r
->in
.level
) {
6890 result
= fill_form_info_1(p
->mem_ctx
,
6891 &r
->out
.info
->info1
,
6896 result
= WERR_UNKNOWN_LEVEL
;
6900 if (!W_ERROR_IS_OK(result
)) {
6901 TALLOC_FREE(r
->out
.info
);
6905 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_FormInfo
, NULL
,
6906 r
->out
.info
, r
->in
.level
);
6907 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
6909 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
6912 /****************************************************************************
6913 ****************************************************************************/
6915 static WERROR
fill_port_1(TALLOC_CTX
*mem_ctx
,
6916 struct spoolss_PortInfo1
*r
,
6919 r
->port_name
= talloc_strdup(mem_ctx
, name
);
6920 W_ERROR_HAVE_NO_MEMORY(r
->port_name
);
6925 /****************************************************************************
6926 TODO: This probably needs distinguish between TCP/IP and Local ports
6928 ****************************************************************************/
6930 static WERROR
fill_port_2(TALLOC_CTX
*mem_ctx
,
6931 struct spoolss_PortInfo2
*r
,
6934 r
->port_name
= talloc_strdup(mem_ctx
, name
);
6935 W_ERROR_HAVE_NO_MEMORY(r
->port_name
);
6937 r
->monitor_name
= talloc_strdup(mem_ctx
, "Local Monitor");
6938 W_ERROR_HAVE_NO_MEMORY(r
->monitor_name
);
6940 r
->description
= talloc_strdup(mem_ctx
, SPL_LOCAL_PORT
);
6941 W_ERROR_HAVE_NO_MEMORY(r
->description
);
6943 r
->port_type
= SPOOLSS_PORT_TYPE_WRITE
;
6950 /****************************************************************************
6951 wrapper around the enumer ports command
6952 ****************************************************************************/
6954 static WERROR
enumports_hook(TALLOC_CTX
*ctx
, int *count
, char ***lines
)
6956 char *cmd
= lp_enumports_cmd();
6957 char **qlines
= NULL
;
6958 char *command
= NULL
;
6966 /* if no hook then just fill in the default port */
6969 if (!(qlines
= TALLOC_ARRAY( NULL
, char*, 2 ))) {
6972 if (!(qlines
[0] = talloc_strdup(qlines
, SAMBA_PRINTER_PORT_NAME
))) {
6973 TALLOC_FREE(qlines
);
6980 /* we have a valid enumport command */
6982 command
= talloc_asprintf(ctx
, "%s \"%d\"", cmd
, 1);
6987 DEBUG(10,("Running [%s]\n", command
));
6988 ret
= smbrun(command
, &fd
);
6989 DEBUG(10,("Returned [%d]\n", ret
));
6990 TALLOC_FREE(command
);
6995 return WERR_ACCESS_DENIED
;
6999 qlines
= fd_lines_load(fd
, &numlines
, 0, NULL
);
7000 DEBUGADD(10,("Lines returned = [%d]\n", numlines
));
7010 /****************************************************************************
7012 ****************************************************************************/
7014 static WERROR
enumports_level_1(TALLOC_CTX
*mem_ctx
,
7015 union spoolss_PortInfo
**info_p
,
7018 union spoolss_PortInfo
*info
= NULL
;
7020 WERROR result
= WERR_OK
;
7021 char **qlines
= NULL
;
7024 result
= enumports_hook(talloc_tos(), &numlines
, &qlines
);
7025 if (!W_ERROR_IS_OK(result
)) {
7030 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_PortInfo
, numlines
);
7032 DEBUG(10,("Returning WERR_NOMEM\n"));
7033 result
= WERR_NOMEM
;
7037 for (i
=0; i
<numlines
; i
++) {
7038 DEBUG(6,("Filling port number [%d] with port [%s]\n", i
, qlines
[i
]));
7039 result
= fill_port_1(info
, &info
[i
].info1
, qlines
[i
]);
7040 if (!W_ERROR_IS_OK(result
)) {
7045 TALLOC_FREE(qlines
);
7048 if (!W_ERROR_IS_OK(result
)) {
7050 TALLOC_FREE(qlines
);
7062 /****************************************************************************
7064 ****************************************************************************/
7066 static WERROR
enumports_level_2(TALLOC_CTX
*mem_ctx
,
7067 union spoolss_PortInfo
**info_p
,
7070 union spoolss_PortInfo
*info
= NULL
;
7072 WERROR result
= WERR_OK
;
7073 char **qlines
= NULL
;
7076 result
= enumports_hook(talloc_tos(), &numlines
, &qlines
);
7077 if (!W_ERROR_IS_OK(result
)) {
7082 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_PortInfo
, numlines
);
7084 DEBUG(10,("Returning WERR_NOMEM\n"));
7085 result
= WERR_NOMEM
;
7089 for (i
=0; i
<numlines
; i
++) {
7090 DEBUG(6,("Filling port number [%d] with port [%s]\n", i
, qlines
[i
]));
7091 result
= fill_port_2(info
, &info
[i
].info2
, qlines
[i
]);
7092 if (!W_ERROR_IS_OK(result
)) {
7097 TALLOC_FREE(qlines
);
7100 if (!W_ERROR_IS_OK(result
)) {
7102 TALLOC_FREE(qlines
);
7114 /****************************************************************
7116 ****************************************************************/
7118 WERROR
_spoolss_EnumPorts(pipes_struct
*p
,
7119 struct spoolss_EnumPorts
*r
)
7123 /* that's an [in out] buffer */
7125 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
7126 return WERR_INVALID_PARAM
;
7129 DEBUG(4,("_spoolss_EnumPorts\n"));
7133 *r
->out
.info
= NULL
;
7135 switch (r
->in
.level
) {
7137 result
= enumports_level_1(p
->mem_ctx
, r
->out
.info
,
7141 result
= enumports_level_2(p
->mem_ctx
, r
->out
.info
,
7145 return WERR_UNKNOWN_LEVEL
;
7148 if (!W_ERROR_IS_OK(result
)) {
7152 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
7153 spoolss_EnumPorts
, NULL
,
7154 *r
->out
.info
, r
->in
.level
,
7156 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
7157 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
7159 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
7162 /****************************************************************************
7163 ****************************************************************************/
7165 static WERROR
spoolss_addprinterex_level_2(pipes_struct
*p
,
7167 struct spoolss_SetPrinterInfoCtr
*info_ctr
,
7168 struct spoolss_DeviceMode
*devmode
,
7169 struct security_descriptor
*sec_desc
,
7170 struct spoolss_UserLevelCtr
*user_ctr
,
7171 struct policy_handle
*handle
)
7173 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
7176 WERROR err
= WERR_OK
;
7178 if ( !(printer
= TALLOC_ZERO_P(NULL
, NT_PRINTER_INFO_LEVEL
)) ) {
7179 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7183 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7184 if (!convert_printer_info(info_ctr
, printer
)) {
7185 free_a_printer(&printer
, 2);
7189 /* samba does not have a concept of local, non-shared printers yet, so
7190 * make sure we always setup sharename - gd */
7191 if ((printer
->info_2
->sharename
[0] == '\0') && (printer
->info_2
->printername
!= '\0')) {
7192 DEBUG(5, ("spoolss_addprinterex_level_2: "
7193 "no sharename has been set, setting printername %s as sharename\n",
7194 printer
->info_2
->printername
));
7195 fstrcpy(printer
->info_2
->sharename
, printer
->info_2
->printername
);
7198 /* check to see if the printer already exists */
7200 if ((snum
= print_queue_snum(printer
->info_2
->sharename
)) != -1) {
7201 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7202 printer
->info_2
->sharename
));
7203 free_a_printer(&printer
, 2);
7204 return WERR_PRINTER_ALREADY_EXISTS
;
7207 if (!lp_force_printername(GLOBAL_SECTION_SNUM
)) {
7208 if ((snum
= print_queue_snum(printer
->info_2
->printername
)) != -1) {
7209 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7210 printer
->info_2
->printername
));
7211 free_a_printer(&printer
, 2);
7212 return WERR_PRINTER_ALREADY_EXISTS
;
7216 /* validate printer info struct */
7217 if (!info_ctr
->info
.info2
->printername
||
7218 strlen(info_ctr
->info
.info2
->printername
) == 0) {
7219 free_a_printer(&printer
,2);
7220 return WERR_INVALID_PRINTER_NAME
;
7222 if (!info_ctr
->info
.info2
->portname
||
7223 strlen(info_ctr
->info
.info2
->portname
) == 0) {
7224 free_a_printer(&printer
,2);
7225 return WERR_UNKNOWN_PORT
;
7227 if (!info_ctr
->info
.info2
->drivername
||
7228 strlen(info_ctr
->info
.info2
->drivername
) == 0) {
7229 free_a_printer(&printer
,2);
7230 return WERR_UNKNOWN_PRINTER_DRIVER
;
7232 if (!info_ctr
->info
.info2
->printprocessor
||
7233 strlen(info_ctr
->info
.info2
->printprocessor
) == 0) {
7234 free_a_printer(&printer
,2);
7235 return WERR_UNKNOWN_PRINTPROCESSOR
;
7238 /* FIXME!!! smbd should check to see if the driver is installed before
7239 trying to add a printer like this --jerry */
7241 if (*lp_addprinter_cmd() ) {
7242 if ( !add_printer_hook(p
->mem_ctx
, p
->server_info
->ptok
,
7244 free_a_printer(&printer
,2);
7245 return WERR_ACCESS_DENIED
;
7248 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7249 "smb.conf parameter \"addprinter command\" is defined. This"
7250 "parameter must exist for this call to succeed\n",
7251 printer
->info_2
->sharename
));
7254 /* use our primary netbios name since get_a_printer() will convert
7255 it to what the client expects on a case by case basis */
7257 slprintf(name
, sizeof(name
)-1, "\\\\%s\\%s", global_myname(),
7258 printer
->info_2
->sharename
);
7261 if ((snum
= print_queue_snum(printer
->info_2
->sharename
)) == -1) {
7262 free_a_printer(&printer
,2);
7263 return WERR_ACCESS_DENIED
;
7266 /* you must be a printer admin to add a new printer */
7267 if (!print_access_check(p
->server_info
, snum
, PRINTER_ACCESS_ADMINISTER
)) {
7268 free_a_printer(&printer
,2);
7269 return WERR_ACCESS_DENIED
;
7273 * Do sanity check on the requested changes for Samba.
7276 if (!check_printer_ok(printer
->info_2
, snum
)) {
7277 free_a_printer(&printer
,2);
7278 return WERR_INVALID_PARAM
;
7282 * When a printer is created, the drivername bound to the printer is used
7283 * to lookup previously saved driver initialization info, which is then
7284 * bound to the new printer, simulating what happens in the Windows arch.
7289 set_driver_init(printer
, 2);
7293 /* A valid devmode was included, convert and link it
7295 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7297 if (!convert_devicemode(printer
->info_2
->printername
, devmode
,
7298 &printer
->info_2
->devmode
)) {
7303 /* write the ASCII on disk */
7304 err
= mod_a_printer(printer
, 2);
7305 if (!W_ERROR_IS_OK(err
)) {
7306 free_a_printer(&printer
,2);
7310 if (!open_printer_hnd(p
, handle
, name
, PRINTER_ACCESS_ADMINISTER
)) {
7311 /* Handle open failed - remove addition. */
7312 del_a_printer(printer
->info_2
->sharename
);
7313 free_a_printer(&printer
,2);
7314 ZERO_STRUCTP(handle
);
7315 return WERR_ACCESS_DENIED
;
7318 update_c_setprinter(false);
7319 free_a_printer(&printer
,2);
7324 /****************************************************************
7325 _spoolss_AddPrinterEx
7326 ****************************************************************/
7328 WERROR
_spoolss_AddPrinterEx(pipes_struct
*p
,
7329 struct spoolss_AddPrinterEx
*r
)
7331 switch (r
->in
.info_ctr
->level
) {
7333 /* we don't handle yet */
7334 /* but I know what to do ... */
7335 return WERR_UNKNOWN_LEVEL
;
7337 return spoolss_addprinterex_level_2(p
, r
->in
.server
,
7339 r
->in
.devmode_ctr
->devmode
,
7340 r
->in
.secdesc_ctr
->sd
,
7341 r
->in
.userlevel_ctr
,
7344 return WERR_UNKNOWN_LEVEL
;
7348 /****************************************************************
7350 ****************************************************************/
7352 WERROR
_spoolss_AddPrinter(pipes_struct
*p
,
7353 struct spoolss_AddPrinter
*r
)
7355 struct spoolss_AddPrinterEx a
;
7356 struct spoolss_UserLevelCtr userlevel_ctr
;
7358 ZERO_STRUCT(userlevel_ctr
);
7360 userlevel_ctr
.level
= 1;
7362 a
.in
.server
= r
->in
.server
;
7363 a
.in
.info_ctr
= r
->in
.info_ctr
;
7364 a
.in
.devmode_ctr
= r
->in
.devmode_ctr
;
7365 a
.in
.secdesc_ctr
= r
->in
.secdesc_ctr
;
7366 a
.in
.userlevel_ctr
= &userlevel_ctr
;
7367 a
.out
.handle
= r
->out
.handle
;
7369 return _spoolss_AddPrinterEx(p
, &a
);
7372 /****************************************************************
7373 _spoolss_AddPrinterDriver
7374 ****************************************************************/
7376 WERROR
_spoolss_AddPrinterDriver(pipes_struct
*p
,
7377 struct spoolss_AddPrinterDriver
*r
)
7379 WERROR err
= WERR_OK
;
7380 char *driver_name
= NULL
;
7384 switch (p
->hdr_req
.opnum
) {
7385 case NDR_SPOOLSS_ADDPRINTERDRIVER
:
7386 fn
= "_spoolss_AddPrinterDriver";
7388 case NDR_SPOOLSS_ADDPRINTERDRIVEREX
:
7389 fn
= "_spoolss_AddPrinterDriverEx";
7392 return WERR_INVALID_PARAM
;
7397 if (r
->in
.info_ctr
->level
!= 3 && r
->in
.info_ctr
->level
!= 6) {
7398 /* Clever hack from Martin Zielinski <mz@seh.de>
7399 * to allow downgrade from level 8 (Vista).
7401 DEBUG(0,("%s: level %d not yet implemented\n", fn
,
7402 r
->in
.info_ctr
->level
));
7403 return WERR_UNKNOWN_LEVEL
;
7406 DEBUG(5,("Cleaning driver's information\n"));
7407 err
= clean_up_driver_struct(p
, r
->in
.info_ctr
);
7408 if (!W_ERROR_IS_OK(err
))
7411 DEBUG(5,("Moving driver to final destination\n"));
7412 if( !W_ERROR_IS_OK(err
= move_driver_to_download_area(p
, r
->in
.info_ctr
,
7417 if (add_a_printer_driver(p
->mem_ctx
, r
->in
.info_ctr
, &driver_name
, &version
)!=0) {
7418 err
= WERR_ACCESS_DENIED
;
7423 * I think this is where he DrvUpgradePrinter() hook would be
7424 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7425 * server. Right now, we just need to send ourselves a message
7426 * to update each printer bound to this driver. --jerry
7429 if (!srv_spoolss_drv_upgrade_printer(driver_name
)) {
7430 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7435 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7436 * decide if the driver init data should be deleted. The rules are:
7437 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7438 * 2) delete init data only if there is no 2k/Xp driver
7439 * 3) always delete init data
7440 * The generalized rule is always use init data from the highest order driver.
7441 * It is necessary to follow the driver install by an initialization step to
7442 * finish off this process.
7447 * 9x printer driver - never delete init data
7450 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7455 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7456 * there is no 2k/Xp driver init data for this driver name.
7460 struct spoolss_DriverInfo8
*driver1
;
7462 if (!W_ERROR_IS_OK(get_a_printer_driver(p
->mem_ctx
, &driver1
, driver_name
, "Windows NT x86", 3))) {
7464 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7466 if (!del_driver_init(driver_name
))
7467 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7471 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7473 free_a_printer_driver(driver1
);
7474 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7481 * 2k or Xp printer driver - always delete init data
7484 if (!del_driver_init(driver_name
))
7485 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7490 DEBUG(0,("%s: invalid level=%d\n", fn
,
7491 r
->in
.info_ctr
->level
));
7500 /****************************************************************
7501 _spoolss_AddPrinterDriverEx
7502 ****************************************************************/
7504 WERROR
_spoolss_AddPrinterDriverEx(pipes_struct
*p
,
7505 struct spoolss_AddPrinterDriverEx
*r
)
7507 struct spoolss_AddPrinterDriver a
;
7510 * we only support the semantics of AddPrinterDriver()
7511 * i.e. only copy files that are newer than existing ones
7514 if (r
->in
.flags
!= APD_COPY_NEW_FILES
) {
7515 return WERR_ACCESS_DENIED
;
7518 a
.in
.servername
= r
->in
.servername
;
7519 a
.in
.info_ctr
= r
->in
.info_ctr
;
7521 return _spoolss_AddPrinterDriver(p
, &a
);
7524 /****************************************************************************
7525 ****************************************************************************/
7527 struct _spoolss_paths
{
7533 enum { SPOOLSS_DRIVER_PATH
, SPOOLSS_PRTPROCS_PATH
};
7535 static const struct _spoolss_paths spoolss_paths
[]= {
7536 { SPOOLSS_DRIVER_PATH
, "print$", "DRIVERS" },
7537 { SPOOLSS_PRTPROCS_PATH
, "prnproc$", "PRTPROCS" }
7540 static WERROR
compose_spoolss_server_path(TALLOC_CTX
*mem_ctx
,
7541 const char *servername
,
7542 const char *environment
,
7546 const char *pservername
= NULL
;
7547 const char *long_archi
= SPOOLSS_ARCHITECTURE_NT_X86
;
7548 const char *short_archi
;
7552 /* environment may be empty */
7553 if (environment
&& strlen(environment
)) {
7554 long_archi
= environment
;
7557 /* servername may be empty */
7558 if (servername
&& strlen(servername
)) {
7559 pservername
= canon_servername(servername
);
7561 if (!is_myname_or_ipaddr(pservername
)) {
7562 return WERR_INVALID_PARAM
;
7566 if (!(short_archi
= get_short_archi(long_archi
))) {
7567 return WERR_INVALID_ENVIRONMENT
;
7570 switch (component
) {
7571 case SPOOLSS_PRTPROCS_PATH
:
7572 case SPOOLSS_DRIVER_PATH
:
7574 *path
= talloc_asprintf(mem_ctx
,
7577 spoolss_paths
[component
].share
,
7580 *path
= talloc_asprintf(mem_ctx
, "%s\\%s\\%s",
7581 SPOOLSS_DEFAULT_SERVER_PATH
,
7582 spoolss_paths
[component
].dir
,
7587 return WERR_INVALID_PARAM
;
7597 /****************************************************************************
7598 ****************************************************************************/
7600 static WERROR
getprinterdriverdir_level_1(TALLOC_CTX
*mem_ctx
,
7601 const char *servername
,
7602 const char *environment
,
7603 struct spoolss_DriverDirectoryInfo1
*r
)
7608 werr
= compose_spoolss_server_path(mem_ctx
,
7611 SPOOLSS_DRIVER_PATH
,
7613 if (!W_ERROR_IS_OK(werr
)) {
7617 DEBUG(4,("printer driver directory: [%s]\n", path
));
7619 r
->directory_name
= path
;
7624 /****************************************************************
7625 _spoolss_GetPrinterDriverDirectory
7626 ****************************************************************/
7628 WERROR
_spoolss_GetPrinterDriverDirectory(pipes_struct
*p
,
7629 struct spoolss_GetPrinterDriverDirectory
*r
)
7633 /* that's an [in out] buffer */
7635 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
7636 return WERR_INVALID_PARAM
;
7639 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7644 /* r->in.level is ignored */
7646 werror
= getprinterdriverdir_level_1(p
->mem_ctx
,
7649 &r
->out
.info
->info1
);
7650 if (!W_ERROR_IS_OK(werror
)) {
7651 TALLOC_FREE(r
->out
.info
);
7655 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo
, NULL
,
7656 r
->out
.info
, r
->in
.level
);
7657 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
7659 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
7662 /****************************************************************
7663 _spoolss_EnumPrinterData
7664 ****************************************************************/
7666 WERROR
_spoolss_EnumPrinterData(pipes_struct
*p
,
7667 struct spoolss_EnumPrinterData
*r
)
7670 struct spoolss_EnumPrinterDataEx r2
;
7672 struct spoolss_PrinterEnumValues
*info
, *val
= NULL
;
7675 r2
.in
.handle
= r
->in
.handle
;
7676 r2
.in
.key_name
= "PrinterDriverData";
7678 r2
.out
.count
= &count
;
7679 r2
.out
.info
= &info
;
7680 r2
.out
.needed
= &needed
;
7682 result
= _spoolss_EnumPrinterDataEx(p
, &r2
);
7683 if (W_ERROR_EQUAL(result
, WERR_MORE_DATA
)) {
7684 r2
.in
.offered
= needed
;
7685 result
= _spoolss_EnumPrinterDataEx(p
, &r2
);
7687 if (!W_ERROR_IS_OK(result
)) {
7692 * The NT machine wants to know the biggest size of value and data
7694 * cf: MSDN EnumPrinterData remark section
7697 if (!r
->in
.value_offered
&& !r
->in
.data_offered
) {
7698 uint32_t biggest_valuesize
= 0;
7699 uint32_t biggest_datasize
= 0;
7702 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7704 for (i
=0; i
<count
; i
++) {
7706 name_length
= strlen(info
[i
].value_name
);
7707 if (strlen(info
[i
].value_name
) > biggest_valuesize
) {
7708 biggest_valuesize
= name_length
;
7711 if (info
[i
].data_length
> biggest_datasize
) {
7712 biggest_datasize
= info
[i
].data_length
;
7715 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize
,
7719 /* the value is an UNICODE string but real_value_size is the length
7720 in bytes including the trailing 0 */
7722 *r
->out
.value_needed
= 2 * (1 + biggest_valuesize
);
7723 *r
->out
.data_needed
= biggest_datasize
;
7725 DEBUG(6,("final values: [%d], [%d]\n",
7726 *r
->out
.value_needed
, *r
->out
.data_needed
));
7731 if (r
->in
.enum_index
< count
) {
7732 val
= &info
[r
->in
.enum_index
];
7736 /* out_value should default to "" or else NT4 has
7737 problems unmarshalling the response */
7739 if (r
->in
.value_offered
) {
7740 *r
->out
.value_needed
= 1;
7741 r
->out
.value_name
= talloc_strdup(r
, "");
7742 if (!r
->out
.value_name
) {
7746 r
->out
.value_name
= NULL
;
7747 *r
->out
.value_needed
= 0;
7750 /* the data is counted in bytes */
7752 *r
->out
.data_needed
= r
->in
.data_offered
;
7754 result
= WERR_NO_MORE_ITEMS
;
7758 * - counted in bytes in the request
7759 * - counted in UNICODE chars in the max reply
7760 * - counted in bytes in the real size
7762 * take a pause *before* coding not *during* coding
7766 if (r
->in
.value_offered
) {
7767 r
->out
.value_name
= talloc_strdup(r
, val
->value_name
);
7768 if (!r
->out
.value_name
) {
7771 *r
->out
.value_needed
= val
->value_name_len
;
7773 r
->out
.value_name
= NULL
;
7774 *r
->out
.value_needed
= 0;
7779 *r
->out
.type
= val
->type
;
7781 /* data - counted in bytes */
7784 * See the section "Dynamically Typed Query Parameters"
7788 if (r
->out
.data
&& val
->data
&& val
->data
->data
&&
7789 val
->data_length
&& r
->in
.data_offered
) {
7790 memcpy(r
->out
.data
, val
->data
->data
,
7791 MIN(val
->data_length
,r
->in
.data_offered
));
7794 *r
->out
.data_needed
= val
->data_length
;
7802 /****************************************************************
7803 _spoolss_SetPrinterData
7804 ****************************************************************/
7806 WERROR
_spoolss_SetPrinterData(pipes_struct
*p
,
7807 struct spoolss_SetPrinterData
*r
)
7809 struct spoolss_SetPrinterDataEx r2
;
7811 r2
.in
.handle
= r
->in
.handle
;
7812 r2
.in
.key_name
= "PrinterDriverData";
7813 r2
.in
.value_name
= r
->in
.value_name
;
7814 r2
.in
.type
= r
->in
.type
;
7815 r2
.in
.data
= r
->in
.data
;
7816 r2
.in
.offered
= r
->in
.offered
;
7818 return _spoolss_SetPrinterDataEx(p
, &r2
);
7821 /****************************************************************
7822 _spoolss_ResetPrinter
7823 ****************************************************************/
7825 WERROR
_spoolss_ResetPrinter(pipes_struct
*p
,
7826 struct spoolss_ResetPrinter
*r
)
7828 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
7831 DEBUG(5,("_spoolss_ResetPrinter\n"));
7834 * All we do is to check to see if the handle and queue is valid.
7835 * This call really doesn't mean anything to us because we only
7836 * support RAW printing. --jerry
7840 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
7841 OUR_HANDLE(r
->in
.handle
)));
7845 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
7849 /* blindly return success */
7853 /****************************************************************
7854 _spoolss_DeletePrinterData
7855 ****************************************************************/
7857 WERROR
_spoolss_DeletePrinterData(pipes_struct
*p
,
7858 struct spoolss_DeletePrinterData
*r
)
7860 struct spoolss_DeletePrinterDataEx r2
;
7862 r2
.in
.handle
= r
->in
.handle
;
7863 r2
.in
.key_name
= "PrinterDriverData";
7864 r2
.in
.value_name
= r
->in
.value_name
;
7866 return _spoolss_DeletePrinterDataEx(p
, &r2
);
7869 /****************************************************************
7871 ****************************************************************/
7873 WERROR
_spoolss_AddForm(pipes_struct
*p
,
7874 struct spoolss_AddForm
*r
)
7876 struct spoolss_AddFormInfo1
*form
= r
->in
.info
.info1
;
7877 nt_forms_struct tmpForm
;
7879 WERROR status
= WERR_OK
;
7880 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
7881 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
7884 nt_forms_struct
*list
=NULL
;
7885 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
7887 DEBUG(5,("_spoolss_AddForm\n"));
7890 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
7891 OUR_HANDLE(r
->in
.handle
)));
7896 /* forms can be added on printer of on the print server handle */
7898 if ( Printer
->printer_type
== SPLHND_PRINTER
)
7900 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
7903 status
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
7904 if (!W_ERROR_IS_OK(status
))
7908 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
7909 and not a printer admin, then fail */
7911 if ((p
->server_info
->utok
.uid
!= sec_initial_uid()) &&
7912 !user_has_privileges(p
->server_info
->ptok
, &se_printop
) &&
7913 !token_contains_name_in_list(uidtoname(p
->server_info
->utok
.uid
),
7915 p
->server_info
->ptok
,
7916 lp_printer_admin(snum
))) {
7917 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
7918 return WERR_ACCESS_DENIED
;
7921 /* can't add if builtin */
7923 if (get_a_builtin_ntform_by_string(form
->form_name
, &tmpForm
)) {
7924 status
= WERR_FILE_EXISTS
;
7928 count
= get_ntforms(&list
);
7930 if(!add_a_form(&list
, form
, &count
)) {
7931 status
= WERR_NOMEM
;
7936 write_ntforms(&list
, count
);
7940 * ChangeID must always be set if this is a printer
7943 if ( Printer
->printer_type
== SPLHND_PRINTER
)
7944 status
= mod_a_printer(printer
, 2);
7948 free_a_printer(&printer
, 2);
7954 /****************************************************************
7956 ****************************************************************/
7958 WERROR
_spoolss_DeleteForm(pipes_struct
*p
,
7959 struct spoolss_DeleteForm
*r
)
7961 const char *form_name
= r
->in
.form_name
;
7962 nt_forms_struct tmpForm
;
7964 nt_forms_struct
*list
=NULL
;
7965 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
7967 WERROR status
= WERR_OK
;
7968 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
7969 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
7972 DEBUG(5,("_spoolss_DeleteForm\n"));
7975 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
7976 OUR_HANDLE(r
->in
.handle
)));
7980 /* forms can be deleted on printer of on the print server handle */
7982 if ( Printer
->printer_type
== SPLHND_PRINTER
)
7984 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
7987 status
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
7988 if (!W_ERROR_IS_OK(status
))
7992 if ((p
->server_info
->utok
.uid
!= sec_initial_uid()) &&
7993 !user_has_privileges(p
->server_info
->ptok
, &se_printop
) &&
7994 !token_contains_name_in_list(uidtoname(p
->server_info
->utok
.uid
),
7996 p
->server_info
->ptok
,
7997 lp_printer_admin(snum
))) {
7998 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
7999 return WERR_ACCESS_DENIED
;
8003 /* can't delete if builtin */
8005 if (get_a_builtin_ntform_by_string(form_name
,&tmpForm
)) {
8006 status
= WERR_INVALID_PARAM
;
8010 count
= get_ntforms(&list
);
8013 ret
= delete_a_form(&list
, form_name
, &count
, &status
);
8020 * ChangeID must always be set if this is a printer
8023 if ( Printer
->printer_type
== SPLHND_PRINTER
)
8024 status
= mod_a_printer(printer
, 2);
8028 free_a_printer(&printer
, 2);
8034 /****************************************************************
8036 ****************************************************************/
8038 WERROR
_spoolss_SetForm(pipes_struct
*p
,
8039 struct spoolss_SetForm
*r
)
8041 struct spoolss_AddFormInfo1
*form
= r
->in
.info
.info1
;
8042 nt_forms_struct tmpForm
;
8044 WERROR status
= WERR_OK
;
8045 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
8046 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
8049 nt_forms_struct
*list
=NULL
;
8050 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
8052 DEBUG(5,("_spoolss_SetForm\n"));
8055 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8056 OUR_HANDLE(r
->in
.handle
)));
8060 /* forms can be modified on printer of on the print server handle */
8062 if ( Printer
->printer_type
== SPLHND_PRINTER
)
8064 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
8067 status
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
8068 if (!W_ERROR_IS_OK(status
))
8072 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8073 and not a printer admin, then fail */
8075 if ((p
->server_info
->utok
.uid
!= sec_initial_uid()) &&
8076 !user_has_privileges(p
->server_info
->ptok
, &se_printop
) &&
8077 !token_contains_name_in_list(uidtoname(p
->server_info
->utok
.uid
),
8079 p
->server_info
->ptok
,
8080 lp_printer_admin(snum
))) {
8081 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8082 return WERR_ACCESS_DENIED
;
8085 /* can't set if builtin */
8086 if (get_a_builtin_ntform_by_string(form
->form_name
, &tmpForm
)) {
8087 status
= WERR_INVALID_PARAM
;
8091 count
= get_ntforms(&list
);
8092 update_a_form(&list
, form
, count
);
8094 write_ntforms(&list
, count
);
8098 * ChangeID must always be set if this is a printer
8101 if ( Printer
->printer_type
== SPLHND_PRINTER
)
8102 status
= mod_a_printer(printer
, 2);
8107 free_a_printer(&printer
, 2);
8113 /****************************************************************************
8114 fill_print_processor1
8115 ****************************************************************************/
8117 static WERROR
fill_print_processor1(TALLOC_CTX
*mem_ctx
,
8118 struct spoolss_PrintProcessorInfo1
*r
,
8119 const char *print_processor_name
)
8121 r
->print_processor_name
= talloc_strdup(mem_ctx
, print_processor_name
);
8122 W_ERROR_HAVE_NO_MEMORY(r
->print_processor_name
);
8127 /****************************************************************************
8128 enumprintprocessors level 1.
8129 ****************************************************************************/
8131 static WERROR
enumprintprocessors_level_1(TALLOC_CTX
*mem_ctx
,
8132 union spoolss_PrintProcessorInfo
**info_p
,
8135 union spoolss_PrintProcessorInfo
*info
;
8138 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_PrintProcessorInfo
, 1);
8139 W_ERROR_HAVE_NO_MEMORY(info
);
8143 result
= fill_print_processor1(info
, &info
[0].info1
, "winprint");
8144 if (!W_ERROR_IS_OK(result
)) {
8149 if (!W_ERROR_IS_OK(result
)) {
8160 /****************************************************************
8161 _spoolss_EnumPrintProcessors
8162 ****************************************************************/
8164 WERROR
_spoolss_EnumPrintProcessors(pipes_struct
*p
,
8165 struct spoolss_EnumPrintProcessors
*r
)
8169 /* that's an [in out] buffer */
8171 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
8172 return WERR_INVALID_PARAM
;
8175 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8178 * Enumerate the print processors ...
8180 * Just reply with "winprint", to keep NT happy
8181 * and I can use my nice printer checker.
8186 *r
->out
.info
= NULL
;
8188 switch (r
->in
.level
) {
8190 result
= enumprintprocessors_level_1(p
->mem_ctx
, r
->out
.info
,
8194 return WERR_UNKNOWN_LEVEL
;
8197 if (!W_ERROR_IS_OK(result
)) {
8201 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
8202 spoolss_EnumPrintProcessors
, NULL
,
8203 *r
->out
.info
, r
->in
.level
,
8205 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
8206 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
8208 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
8211 /****************************************************************************
8212 fill_printprocdatatype1
8213 ****************************************************************************/
8215 static WERROR
fill_printprocdatatype1(TALLOC_CTX
*mem_ctx
,
8216 struct spoolss_PrintProcDataTypesInfo1
*r
,
8217 const char *name_array
)
8219 r
->name_array
= talloc_strdup(mem_ctx
, name_array
);
8220 W_ERROR_HAVE_NO_MEMORY(r
->name_array
);
8225 /****************************************************************************
8226 enumprintprocdatatypes level 1.
8227 ****************************************************************************/
8229 static WERROR
enumprintprocdatatypes_level_1(TALLOC_CTX
*mem_ctx
,
8230 union spoolss_PrintProcDataTypesInfo
**info_p
,
8234 union spoolss_PrintProcDataTypesInfo
*info
;
8236 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_PrintProcDataTypesInfo
, 1);
8237 W_ERROR_HAVE_NO_MEMORY(info
);
8241 result
= fill_printprocdatatype1(info
, &info
[0].info1
, "RAW");
8242 if (!W_ERROR_IS_OK(result
)) {
8247 if (!W_ERROR_IS_OK(result
)) {
8258 /****************************************************************
8259 _spoolss_EnumPrintProcDataTypes
8260 ****************************************************************/
8262 WERROR
_spoolss_EnumPrintProcDataTypes(pipes_struct
*p
,
8263 struct spoolss_EnumPrintProcDataTypes
*r
)
8267 /* that's an [in out] buffer */
8269 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
8270 return WERR_INVALID_PARAM
;
8273 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8277 *r
->out
.info
= NULL
;
8279 switch (r
->in
.level
) {
8281 result
= enumprintprocdatatypes_level_1(p
->mem_ctx
, r
->out
.info
,
8285 return WERR_UNKNOWN_LEVEL
;
8288 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
8289 spoolss_EnumPrintProcDataTypes
, NULL
,
8290 *r
->out
.info
, r
->in
.level
,
8292 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
8293 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
8295 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
8298 /****************************************************************************
8300 ****************************************************************************/
8302 static WERROR
fill_monitor_1(TALLOC_CTX
*mem_ctx
,
8303 struct spoolss_MonitorInfo1
*r
,
8304 const char *monitor_name
)
8306 r
->monitor_name
= talloc_strdup(mem_ctx
, monitor_name
);
8307 W_ERROR_HAVE_NO_MEMORY(r
->monitor_name
);
8312 /****************************************************************************
8314 ****************************************************************************/
8316 static WERROR
fill_monitor_2(TALLOC_CTX
*mem_ctx
,
8317 struct spoolss_MonitorInfo2
*r
,
8318 const char *monitor_name
,
8319 const char *environment
,
8320 const char *dll_name
)
8322 r
->monitor_name
= talloc_strdup(mem_ctx
, monitor_name
);
8323 W_ERROR_HAVE_NO_MEMORY(r
->monitor_name
);
8324 r
->environment
= talloc_strdup(mem_ctx
, environment
);
8325 W_ERROR_HAVE_NO_MEMORY(r
->environment
);
8326 r
->dll_name
= talloc_strdup(mem_ctx
, dll_name
);
8327 W_ERROR_HAVE_NO_MEMORY(r
->dll_name
);
8332 /****************************************************************************
8333 enumprintmonitors level 1.
8334 ****************************************************************************/
8336 static WERROR
enumprintmonitors_level_1(TALLOC_CTX
*mem_ctx
,
8337 union spoolss_MonitorInfo
**info_p
,
8340 union spoolss_MonitorInfo
*info
;
8341 WERROR result
= WERR_OK
;
8343 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_MonitorInfo
, 2);
8344 W_ERROR_HAVE_NO_MEMORY(info
);
8348 result
= fill_monitor_1(info
, &info
[0].info1
,
8350 if (!W_ERROR_IS_OK(result
)) {
8354 result
= fill_monitor_1(info
, &info
[1].info1
,
8356 if (!W_ERROR_IS_OK(result
)) {
8361 if (!W_ERROR_IS_OK(result
)) {
8372 /****************************************************************************
8373 enumprintmonitors level 2.
8374 ****************************************************************************/
8376 static WERROR
enumprintmonitors_level_2(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_2(info
, &info
[0].info2
,
8390 "Windows NT X86", /* FIXME */
8392 if (!W_ERROR_IS_OK(result
)) {
8396 result
= fill_monitor_2(info
, &info
[1].info2
,
8398 "Windows NT X86", /* FIXME */
8400 if (!W_ERROR_IS_OK(result
)) {
8405 if (!W_ERROR_IS_OK(result
)) {
8416 /****************************************************************
8417 _spoolss_EnumMonitors
8418 ****************************************************************/
8420 WERROR
_spoolss_EnumMonitors(pipes_struct
*p
,
8421 struct spoolss_EnumMonitors
*r
)
8425 /* that's an [in out] buffer */
8427 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
8428 return WERR_INVALID_PARAM
;
8431 DEBUG(5,("_spoolss_EnumMonitors\n"));
8434 * Enumerate the print monitors ...
8436 * Just reply with "Local Port", to keep NT happy
8437 * and I can use my nice printer checker.
8442 *r
->out
.info
= NULL
;
8444 switch (r
->in
.level
) {
8446 result
= enumprintmonitors_level_1(p
->mem_ctx
, r
->out
.info
,
8450 result
= enumprintmonitors_level_2(p
->mem_ctx
, r
->out
.info
,
8454 return WERR_UNKNOWN_LEVEL
;
8457 if (!W_ERROR_IS_OK(result
)) {
8461 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
8462 spoolss_EnumMonitors
, NULL
,
8463 *r
->out
.info
, r
->in
.level
,
8465 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
8466 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
8468 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
8471 /****************************************************************************
8472 ****************************************************************************/
8474 static WERROR
getjob_level_1(TALLOC_CTX
*mem_ctx
,
8475 const print_queue_struct
*queue
,
8476 int count
, int snum
,
8477 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
8479 struct spoolss_JobInfo1
*r
)
8484 for (i
=0; i
<count
&& found
== false; i
++) {
8485 if (queue
[i
].job
== (int)jobid
) {
8490 if (found
== false) {
8491 /* NT treats not found as bad param... yet another bad choice */
8492 return WERR_INVALID_PARAM
;
8495 return fill_job_info1(mem_ctx
,
8503 /****************************************************************************
8504 ****************************************************************************/
8506 static WERROR
getjob_level_2(TALLOC_CTX
*mem_ctx
,
8507 const print_queue_struct
*queue
,
8508 int count
, int snum
,
8509 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
8511 struct spoolss_JobInfo2
*r
)
8515 struct spoolss_DeviceMode
*devmode
;
8516 NT_DEVICEMODE
*nt_devmode
;
8519 for (i
=0; i
<count
&& found
== false; i
++) {
8520 if (queue
[i
].job
== (int)jobid
) {
8525 if (found
== false) {
8526 /* NT treats not found as bad param... yet another bad
8528 return WERR_INVALID_PARAM
;
8532 * if the print job does not have a DEVMODE associated with it,
8533 * just use the one for the printer. A NULL devicemode is not
8534 * a failure condition
8537 nt_devmode
= print_job_devmode(lp_const_servicename(snum
), jobid
);
8539 devmode
= TALLOC_ZERO_P(mem_ctx
, struct spoolss_DeviceMode
);
8540 W_ERROR_HAVE_NO_MEMORY(devmode
);
8541 result
= convert_nt_devicemode(devmode
, devmode
, nt_devmode
);
8542 if (!W_ERROR_IS_OK(result
)) {
8546 devmode
= construct_dev_mode(mem_ctx
, lp_const_servicename(snum
));
8547 W_ERROR_HAVE_NO_MEMORY(devmode
);
8550 return fill_job_info2(mem_ctx
,
8559 /****************************************************************
8561 ****************************************************************/
8563 WERROR
_spoolss_GetJob(pipes_struct
*p
,
8564 struct spoolss_GetJob
*r
)
8566 WERROR result
= WERR_OK
;
8567 NT_PRINTER_INFO_LEVEL
*ntprinter
= NULL
;
8570 print_queue_struct
*queue
= NULL
;
8571 print_status_struct prt_status
;
8573 /* that's an [in out] buffer */
8575 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
8576 return WERR_INVALID_PARAM
;
8579 DEBUG(5,("_spoolss_GetJob\n"));
8583 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
8587 result
= get_a_printer(NULL
, &ntprinter
, 2, lp_servicename(snum
));
8588 if (!W_ERROR_IS_OK(result
)) {
8592 count
= print_queue_status(snum
, &queue
, &prt_status
);
8594 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8595 count
, prt_status
.status
, prt_status
.message
));
8597 switch (r
->in
.level
) {
8599 result
= getjob_level_1(p
->mem_ctx
,
8600 queue
, count
, snum
, ntprinter
,
8601 r
->in
.job_id
, &r
->out
.info
->info1
);
8604 result
= getjob_level_2(p
->mem_ctx
,
8605 queue
, count
, snum
, ntprinter
,
8606 r
->in
.job_id
, &r
->out
.info
->info2
);
8609 result
= WERR_UNKNOWN_LEVEL
;
8614 free_a_printer(&ntprinter
, 2);
8616 if (!W_ERROR_IS_OK(result
)) {
8617 TALLOC_FREE(r
->out
.info
);
8621 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_JobInfo
, NULL
,
8622 r
->out
.info
, r
->in
.level
);
8623 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
8625 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
8628 /****************************************************************
8629 _spoolss_GetPrinterDataEx
8630 ****************************************************************/
8632 WERROR
_spoolss_GetPrinterDataEx(pipes_struct
*p
,
8633 struct spoolss_GetPrinterDataEx
*r
)
8636 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
8637 struct regval_blob
*val
= NULL
;
8638 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
8640 WERROR result
= WERR_OK
;
8643 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8645 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8646 r
->in
.key_name
, r
->in
.value_name
));
8648 /* in case of problem, return some default values */
8651 *r
->out
.type
= REG_NONE
;
8654 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8655 OUR_HANDLE(r
->in
.handle
)));
8656 result
= WERR_BADFID
;
8660 /* Is the handle to a printer or to the server? */
8662 if (Printer
->printer_type
== SPLHND_SERVER
) {
8664 union spoolss_PrinterData data
;
8666 result
= getprinterdata_printer_server(p
->mem_ctx
,
8670 if (!W_ERROR_IS_OK(result
)) {
8674 result
= push_spoolss_PrinterData(p
->mem_ctx
, &blob
,
8675 *r
->out
.type
, &data
);
8676 if (!W_ERROR_IS_OK(result
)) {
8680 *r
->out
.needed
= blob
.length
;
8682 if (r
->in
.offered
>= *r
->out
.needed
) {
8683 memcpy(r
->out
.data
, blob
.data
, blob
.length
);
8686 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_MORE_DATA
);
8689 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
8690 result
= WERR_BADFID
;
8694 result
= get_a_printer(Printer
, &printer
, 2, lp_servicename(snum
));
8695 if (!W_ERROR_IS_OK(result
)) {
8699 /* check to see if the keyname is valid */
8700 if (!strlen(r
->in
.key_name
)) {
8701 result
= WERR_INVALID_PARAM
;
8705 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
8707 if (strequal(r
->in
.key_name
, SPOOL_PRINTERDATA_KEY
) &&
8708 strequal(r
->in
.value_name
, "ChangeId")) {
8709 *r
->out
.type
= REG_DWORD
;
8711 if (r
->in
.offered
>= *r
->out
.needed
) {
8712 SIVAL(r
->out
.data
, 0, printer
->info_2
->changeid
);
8718 if (lookup_printerkey(printer
->info_2
->data
, r
->in
.key_name
) == -1) {
8719 DEBUG(4,("_spoolss_GetPrinterDataEx: "
8720 "Invalid keyname [%s]\n", r
->in
.key_name
));
8721 result
= WERR_BADFILE
;
8725 val
= get_printer_data(printer
->info_2
,
8726 r
->in
.key_name
, r
->in
.value_name
);
8728 result
= WERR_BADFILE
;
8732 *r
->out
.needed
= regval_size(val
);
8733 *r
->out
.type
= regval_type(val
);
8735 if (r
->in
.offered
>= *r
->out
.needed
) {
8736 memcpy(r
->out
.data
, regval_data_p(val
), regval_size(val
));
8740 free_a_printer(&printer
, 2);
8743 if (!W_ERROR_IS_OK(result
)) {
8747 *r
->out
.type
= SPOOLSS_BUFFER_OK(*r
->out
.type
, REG_NONE
);
8748 r
->out
.data
= SPOOLSS_BUFFER_OK(r
->out
.data
, r
->out
.data
);
8750 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_MORE_DATA
);
8753 /****************************************************************
8754 _spoolss_SetPrinterDataEx
8755 ****************************************************************/
8757 WERROR
_spoolss_SetPrinterDataEx(pipes_struct
*p
,
8758 struct spoolss_SetPrinterDataEx
*r
)
8760 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
8762 WERROR result
= WERR_OK
;
8763 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
8766 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
8768 /* From MSDN documentation of SetPrinterDataEx: pass request to
8769 SetPrinterData if key is "PrinterDriverData" */
8772 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8773 OUR_HANDLE(r
->in
.handle
)));
8777 if (Printer
->printer_type
== SPLHND_SERVER
) {
8778 DEBUG(10,("_spoolss_SetPrinterDataEx: "
8779 "Not implemented for server handles yet\n"));
8780 return WERR_INVALID_PARAM
;
8783 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
8788 * Access check : NT returns "access denied" if you make a
8789 * SetPrinterData call without the necessary privildge.
8790 * we were originally returning OK if nothing changed
8791 * which made Win2k issue **a lot** of SetPrinterData
8792 * when connecting to a printer --jerry
8795 if (Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
8796 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
8797 "change denied by handle access permissions\n"));
8798 return WERR_ACCESS_DENIED
;
8801 result
= get_a_printer(Printer
, &printer
, 2, lp_servicename(snum
));
8802 if (!W_ERROR_IS_OK(result
)) {
8806 /* check for OID in valuename */
8808 oid_string
= strchr(r
->in
.value_name
, ',');
8815 * When client side code sets a magic printer data key, detect it and save
8816 * the current printer data and the magic key's data (its the DEVMODE) for
8817 * future printer/driver initializations.
8819 if ((r
->in
.type
== REG_BINARY
) && strequal(r
->in
.value_name
, PHANTOM_DEVMODE_KEY
)) {
8820 /* Set devmode and printer initialization info */
8821 result
= save_driver_init(printer
, 2, r
->in
.data
, r
->in
.offered
);
8823 srv_spoolss_reset_printerdata(printer
->info_2
->drivername
);
8828 /* save the registry data */
8830 result
= set_printer_dataex(printer
, r
->in
.key_name
, r
->in
.value_name
,
8831 r
->in
.type
, r
->in
.data
, r
->in
.offered
);
8833 if (W_ERROR_IS_OK(result
)) {
8834 /* save the OID if one was specified */
8836 char *str
= talloc_asprintf(p
->mem_ctx
, "%s\\%s",
8837 r
->in
.key_name
, SPOOL_OID_KEY
);
8839 result
= WERR_NOMEM
;
8844 * I'm not checking the status here on purpose. Don't know
8845 * if this is right, but I'm returning the status from the
8846 * previous set_printer_dataex() call. I have no idea if
8847 * this is right. --jerry
8850 set_printer_dataex(printer
, str
, r
->in
.value_name
,
8851 REG_SZ
, (uint8_t *)oid_string
,
8852 strlen(oid_string
)+1);
8855 result
= mod_a_printer(printer
, 2);
8859 free_a_printer(&printer
, 2);
8864 /****************************************************************
8865 _spoolss_DeletePrinterDataEx
8866 ****************************************************************/
8868 WERROR
_spoolss_DeletePrinterDataEx(pipes_struct
*p
,
8869 struct spoolss_DeletePrinterDataEx
*r
)
8871 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
8873 WERROR status
= WERR_OK
;
8874 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
8876 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
8879 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
8880 "Invalid handle (%s:%u:%u).\n",
8881 OUR_HANDLE(r
->in
.handle
)));
8885 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
8888 if (Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
8889 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
8890 "printer properties change denied by handle\n"));
8891 return WERR_ACCESS_DENIED
;
8894 if (!r
->in
.value_name
|| !r
->in
.key_name
) {
8898 status
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
8899 if (!W_ERROR_IS_OK(status
))
8902 status
= delete_printer_dataex( printer
, r
->in
.key_name
, r
->in
.value_name
);
8904 if ( W_ERROR_IS_OK(status
) )
8905 mod_a_printer( printer
, 2 );
8907 free_a_printer(&printer
, 2);
8912 /****************************************************************
8913 _spoolss_EnumPrinterKey
8914 ****************************************************************/
8916 WERROR
_spoolss_EnumPrinterKey(pipes_struct
*p
,
8917 struct spoolss_EnumPrinterKey
*r
)
8919 fstring
*keynames
= NULL
;
8921 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
8922 NT_PRINTER_DATA
*data
;
8923 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
8925 WERROR result
= WERR_BADFILE
;
8927 const char **array
= NULL
;
8930 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
8933 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
8934 OUR_HANDLE(r
->in
.handle
)));
8938 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
8942 result
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
8943 if (!W_ERROR_IS_OK(result
)) {
8947 /* get the list of subkey names */
8949 data
= printer
->info_2
->data
;
8951 num_keys
= get_printer_subkeys(data
, r
->in
.key_name
, &keynames
);
8952 if (num_keys
== -1) {
8953 result
= WERR_BADFILE
;
8957 array
= talloc_zero_array(r
->out
.key_buffer
, const char *, num_keys
+ 2);
8959 result
= WERR_NOMEM
;
8964 array
[0] = talloc_strdup(array
, "");
8966 result
= WERR_NOMEM
;
8971 for (i
=0; i
< num_keys
; i
++) {
8973 DEBUG(10,("_spoolss_EnumPrinterKey: adding keyname: %s\n",
8976 array
[i
] = talloc_strdup(array
, keynames
[i
]);
8978 result
= WERR_NOMEM
;
8983 if (!push_reg_multi_sz(p
->mem_ctx
, &blob
, array
)) {
8984 result
= WERR_NOMEM
;
8988 *r
->out
._ndr_size
= r
->in
.offered
/ 2;
8989 *r
->out
.needed
= blob
.length
;
8991 if (r
->in
.offered
< *r
->out
.needed
) {
8992 result
= WERR_MORE_DATA
;
8995 r
->out
.key_buffer
->string_array
= array
;
8999 if (!W_ERROR_IS_OK(result
)) {
9001 if (!W_ERROR_EQUAL(result
, WERR_MORE_DATA
)) {
9006 free_a_printer(&printer
, 2);
9007 SAFE_FREE(keynames
);
9012 /****************************************************************
9013 _spoolss_DeletePrinterKey
9014 ****************************************************************/
9016 WERROR
_spoolss_DeletePrinterKey(pipes_struct
*p
,
9017 struct spoolss_DeletePrinterKey
*r
)
9019 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
9020 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
9024 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9027 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9028 OUR_HANDLE(r
->in
.handle
)));
9032 /* if keyname == NULL, return error */
9034 if ( !r
->in
.key_name
)
9035 return WERR_INVALID_PARAM
;
9037 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
9040 if (Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
9041 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9042 "printer properties change denied by handle\n"));
9043 return WERR_ACCESS_DENIED
;
9046 status
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
9047 if (!W_ERROR_IS_OK(status
))
9050 /* delete the key and all subneys */
9052 status
= delete_all_printer_data( printer
->info_2
, r
->in
.key_name
);
9054 if ( W_ERROR_IS_OK(status
) )
9055 status
= mod_a_printer(printer
, 2);
9057 free_a_printer( &printer
, 2 );
9062 /****************************************************************
9063 ****************************************************************/
9065 static WERROR
registry_value_to_printer_enum_value(TALLOC_CTX
*mem_ctx
,
9066 struct regval_blob
*v
,
9067 struct spoolss_PrinterEnumValues
*r
)
9069 r
->data
= TALLOC_ZERO_P(mem_ctx
, DATA_BLOB
);
9070 W_ERROR_HAVE_NO_MEMORY(r
->data
);
9072 r
->value_name
= talloc_strdup(mem_ctx
, regval_name(v
));
9073 W_ERROR_HAVE_NO_MEMORY(r
->value_name
);
9075 r
->value_name_len
= strlen_m_term(regval_name(v
)) * 2;
9077 r
->type
= regval_type(v
);
9078 r
->data_length
= regval_size(v
);
9080 if (r
->data_length
) {
9081 *r
->data
= data_blob_talloc(r
->data
, regval_data_p(v
), regval_size(v
));
9087 /****************************************************************
9088 _spoolss_EnumPrinterDataEx
9089 ****************************************************************/
9091 WERROR
_spoolss_EnumPrinterDataEx(pipes_struct
*p
,
9092 struct spoolss_EnumPrinterDataEx
*r
)
9095 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
9096 struct spoolss_PrinterEnumValues
*info
= NULL
;
9097 NT_PRINTER_DATA
*p_data
;
9098 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
9104 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9108 *r
->out
.info
= NULL
;
9111 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9112 OUR_HANDLE(r
->in
.handle
)));
9117 * first check for a keyname of NULL or "". Win2k seems to send
9118 * this a lot and we should send back WERR_INVALID_PARAM
9119 * no need to spend time looking up the printer in this case.
9123 if (!strlen(r
->in
.key_name
)) {
9124 result
= WERR_INVALID_PARAM
;
9128 /* get the printer off of disk */
9130 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
9134 ZERO_STRUCT(printer
);
9135 result
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
9136 if (!W_ERROR_IS_OK(result
)) {
9140 /* now look for a match on the key name */
9142 p_data
= printer
->info_2
->data
;
9144 key_index
= lookup_printerkey(p_data
, r
->in
.key_name
);
9145 if (key_index
== -1) {
9146 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9148 result
= WERR_INVALID_PARAM
;
9152 /* allocate the memory for the array of pointers -- if necessary */
9154 count
= regval_ctr_numvals(p_data
->keys
[key_index
].values
);
9156 result
= WERR_OK
; /* ??? */
9160 info
= TALLOC_ZERO_ARRAY(p
->mem_ctx
,
9161 struct spoolss_PrinterEnumValues
,
9164 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9165 result
= WERR_NOMEM
;
9170 * loop through all params and build the array to pass
9171 * back to the client
9174 for (i
=0; i
< count
; i
++) {
9176 struct regval_blob
*val
;
9178 /* lookup the registry value */
9180 val
= regval_ctr_specific_value(p_data
->keys
[key_index
].values
, i
);
9182 DEBUG(10,("retrieved value number [%d] [%s]\n", i
, regval_name(val
)));
9186 result
= registry_value_to_printer_enum_value(info
, val
, &info
[i
]);
9187 if (!W_ERROR_IS_OK(result
)) {
9192 #if 0 /* FIXME - gd */
9193 /* housekeeping information in the reply */
9195 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9196 * the hand marshalled container size is a multiple
9197 * of 4 bytes for RPC alignment.
9201 needed
+= 4-(needed
% 4);
9204 *r
->out
.count
= count
;
9205 *r
->out
.info
= info
;
9210 free_a_printer(&printer
, 2);
9213 if (!W_ERROR_IS_OK(result
)) {
9217 *r
->out
.needed
= SPOOLSS_BUFFER_ARRAY(p
->mem_ctx
,
9218 spoolss_EnumPrinterDataEx
, NULL
,
9221 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
9222 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, *r
->out
.count
);
9224 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_MORE_DATA
);
9227 /****************************************************************************
9228 ****************************************************************************/
9230 static WERROR
getprintprocessordirectory_level_1(TALLOC_CTX
*mem_ctx
,
9231 const char *servername
,
9232 const char *environment
,
9233 struct spoolss_PrintProcessorDirectoryInfo1
*r
)
9238 werr
= compose_spoolss_server_path(mem_ctx
,
9241 SPOOLSS_PRTPROCS_PATH
,
9243 if (!W_ERROR_IS_OK(werr
)) {
9247 DEBUG(4,("print processor directory: [%s]\n", path
));
9249 r
->directory_name
= path
;
9254 /****************************************************************
9255 _spoolss_GetPrintProcessorDirectory
9256 ****************************************************************/
9258 WERROR
_spoolss_GetPrintProcessorDirectory(pipes_struct
*p
,
9259 struct spoolss_GetPrintProcessorDirectory
*r
)
9263 /* that's an [in out] buffer */
9265 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
9266 return WERR_INVALID_PARAM
;
9269 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9274 /* r->in.level is ignored */
9276 /* We always should reply with a local print processor directory so that
9277 * users are not forced to have a [prnproc$] share on the Samba spoolss
9278 * server - Guenther */
9280 result
= getprintprocessordirectory_level_1(p
->mem_ctx
,
9281 NULL
, /* r->in.server */
9283 &r
->out
.info
->info1
);
9284 if (!W_ERROR_IS_OK(result
)) {
9285 TALLOC_FREE(r
->out
.info
);
9289 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo
, NULL
,
9290 r
->out
.info
, r
->in
.level
);
9291 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
9293 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
9296 /*******************************************************************
9297 ********************************************************************/
9299 static bool push_monitorui_buf(TALLOC_CTX
*mem_ctx
, DATA_BLOB
*buf
,
9300 const char *dllname
)
9302 enum ndr_err_code ndr_err
;
9303 struct spoolss_MonitorUi ui
;
9305 ui
.dll_name
= dllname
;
9307 ndr_err
= ndr_push_struct_blob(buf
, mem_ctx
, NULL
, &ui
,
9308 (ndr_push_flags_fn_t
)ndr_push_spoolss_MonitorUi
);
9309 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err
) && (DEBUGLEVEL
>= 10)) {
9310 NDR_PRINT_DEBUG(spoolss_MonitorUi
, &ui
);
9312 return NDR_ERR_CODE_IS_SUCCESS(ndr_err
);
9315 /*******************************************************************
9316 Streams the monitor UI DLL name in UNICODE
9317 *******************************************************************/
9319 static WERROR
xcvtcp_monitorui(TALLOC_CTX
*mem_ctx
,
9320 NT_USER_TOKEN
*token
, DATA_BLOB
*in
,
9321 DATA_BLOB
*out
, uint32_t *needed
)
9323 const char *dllname
= "tcpmonui.dll";
9325 *needed
= (strlen(dllname
)+1) * 2;
9327 if (out
->length
< *needed
) {
9328 return WERR_INSUFFICIENT_BUFFER
;
9331 if (!push_monitorui_buf(mem_ctx
, out
, dllname
)) {
9338 /*******************************************************************
9339 ********************************************************************/
9341 static bool pull_port_data_1(TALLOC_CTX
*mem_ctx
,
9342 struct spoolss_PortData1
*port1
,
9343 const DATA_BLOB
*buf
)
9345 enum ndr_err_code ndr_err
;
9346 ndr_err
= ndr_pull_struct_blob(buf
, mem_ctx
, NULL
, port1
,
9347 (ndr_pull_flags_fn_t
)ndr_pull_spoolss_PortData1
);
9348 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err
) && (DEBUGLEVEL
>= 10)) {
9349 NDR_PRINT_DEBUG(spoolss_PortData1
, port1
);
9351 return NDR_ERR_CODE_IS_SUCCESS(ndr_err
);
9354 /*******************************************************************
9355 ********************************************************************/
9357 static bool pull_port_data_2(TALLOC_CTX
*mem_ctx
,
9358 struct spoolss_PortData2
*port2
,
9359 const DATA_BLOB
*buf
)
9361 enum ndr_err_code ndr_err
;
9362 ndr_err
= ndr_pull_struct_blob(buf
, mem_ctx
, NULL
, port2
,
9363 (ndr_pull_flags_fn_t
)ndr_pull_spoolss_PortData2
);
9364 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err
) && (DEBUGLEVEL
>= 10)) {
9365 NDR_PRINT_DEBUG(spoolss_PortData2
, port2
);
9367 return NDR_ERR_CODE_IS_SUCCESS(ndr_err
);
9370 /*******************************************************************
9371 Create a new TCP/IP port
9372 *******************************************************************/
9374 static WERROR
xcvtcp_addport(TALLOC_CTX
*mem_ctx
,
9375 NT_USER_TOKEN
*token
, DATA_BLOB
*in
,
9376 DATA_BLOB
*out
, uint32_t *needed
)
9378 struct spoolss_PortData1 port1
;
9379 struct spoolss_PortData2 port2
;
9380 char *device_uri
= NULL
;
9383 const char *portname
;
9384 const char *hostaddress
;
9386 uint32_t port_number
;
9389 /* peek for spoolss_PortData version */
9391 if (!in
|| (in
->length
< (128 + 4))) {
9392 return WERR_GENERAL_FAILURE
;
9395 version
= IVAL(in
->data
, 128);
9401 if (!pull_port_data_1(mem_ctx
, &port1
, in
)) {
9405 portname
= port1
.portname
;
9406 hostaddress
= port1
.hostaddress
;
9407 queue
= port1
.queue
;
9408 protocol
= port1
.protocol
;
9409 port_number
= port1
.port_number
;
9415 if (!pull_port_data_2(mem_ctx
, &port2
, in
)) {
9419 portname
= port2
.portname
;
9420 hostaddress
= port2
.hostaddress
;
9421 queue
= port2
.queue
;
9422 protocol
= port2
.protocol
;
9423 port_number
= port2
.port_number
;
9427 DEBUG(1,("xcvtcp_addport: "
9428 "unknown version of port_data: %d\n", version
));
9429 return WERR_UNKNOWN_PORT
;
9432 /* create the device URI and call the add_port_hook() */
9435 case PROTOCOL_RAWTCP_TYPE
:
9436 device_uri
= talloc_asprintf(mem_ctx
,
9437 "socket://%s:%d/", hostaddress
,
9441 case PROTOCOL_LPR_TYPE
:
9442 device_uri
= talloc_asprintf(mem_ctx
,
9443 "lpr://%s/%s", hostaddress
, queue
);
9447 return WERR_UNKNOWN_PORT
;
9454 return add_port_hook(mem_ctx
, token
, portname
, device_uri
);
9457 /*******************************************************************
9458 *******************************************************************/
9460 struct xcv_api_table xcvtcp_cmds
[] = {
9461 { "MonitorUI", xcvtcp_monitorui
},
9462 { "AddPort", xcvtcp_addport
},
9466 static WERROR
process_xcvtcp_command(TALLOC_CTX
*mem_ctx
,
9467 NT_USER_TOKEN
*token
, const char *command
,
9474 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command
));
9476 for ( i
=0; xcvtcp_cmds
[i
].name
; i
++ ) {
9477 if ( strcmp( command
, xcvtcp_cmds
[i
].name
) == 0 )
9478 return xcvtcp_cmds
[i
].fn(mem_ctx
, token
, inbuf
, outbuf
, needed
);
9481 return WERR_BADFUNC
;
9484 /*******************************************************************
9485 *******************************************************************/
9486 #if 0 /* don't support management using the "Local Port" monitor */
9488 static WERROR
xcvlocal_monitorui(TALLOC_CTX
*mem_ctx
,
9489 NT_USER_TOKEN
*token
, DATA_BLOB
*in
,
9490 DATA_BLOB
*out
, uint32_t *needed
)
9492 const char *dllname
= "localui.dll";
9494 *needed
= (strlen(dllname
)+1) * 2;
9496 if (out
->length
< *needed
) {
9497 return WERR_INSUFFICIENT_BUFFER
;
9500 if (!push_monitorui_buf(mem_ctx
, out
, dllname
)) {
9507 /*******************************************************************
9508 *******************************************************************/
9510 struct xcv_api_table xcvlocal_cmds
[] = {
9511 { "MonitorUI", xcvlocal_monitorui
},
9515 struct xcv_api_table xcvlocal_cmds
[] = {
9522 /*******************************************************************
9523 *******************************************************************/
9525 static WERROR
process_xcvlocal_command(TALLOC_CTX
*mem_ctx
,
9526 NT_USER_TOKEN
*token
, const char *command
,
9527 DATA_BLOB
*inbuf
, DATA_BLOB
*outbuf
,
9532 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command
));
9534 for ( i
=0; xcvlocal_cmds
[i
].name
; i
++ ) {
9535 if ( strcmp( command
, xcvlocal_cmds
[i
].name
) == 0 )
9536 return xcvlocal_cmds
[i
].fn(mem_ctx
, token
, inbuf
, outbuf
, needed
);
9538 return WERR_BADFUNC
;
9541 /****************************************************************
9543 ****************************************************************/
9545 WERROR
_spoolss_XcvData(pipes_struct
*p
,
9546 struct spoolss_XcvData
*r
)
9548 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
9549 DATA_BLOB out_data
= data_blob_null
;
9553 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9554 OUR_HANDLE(r
->in
.handle
)));
9558 /* Has to be a handle to the TCP/IP port monitor */
9560 if ( !(Printer
->printer_type
& (SPLHND_PORTMON_LOCAL
|SPLHND_PORTMON_TCP
)) ) {
9561 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9565 /* requires administrative access to the server */
9567 if ( !(Printer
->access_granted
& SERVER_ACCESS_ADMINISTER
) ) {
9568 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9569 return WERR_ACCESS_DENIED
;
9572 /* Allocate the outgoing buffer */
9574 if (r
->in
.out_data_size
) {
9575 out_data
= data_blob_talloc_zero(p
->mem_ctx
, r
->in
.out_data_size
);
9576 if (out_data
.data
== NULL
) {
9581 switch ( Printer
->printer_type
) {
9582 case SPLHND_PORTMON_TCP
:
9583 werror
= process_xcvtcp_command(p
->mem_ctx
,
9584 p
->server_info
->ptok
,
9585 r
->in
.function_name
,
9586 &r
->in
.in_data
, &out_data
,
9589 case SPLHND_PORTMON_LOCAL
:
9590 werror
= process_xcvlocal_command(p
->mem_ctx
,
9591 p
->server_info
->ptok
,
9592 r
->in
.function_name
,
9593 &r
->in
.in_data
, &out_data
,
9597 werror
= WERR_INVALID_PRINT_MONITOR
;
9600 if (!W_ERROR_IS_OK(werror
)) {
9604 *r
->out
.status_code
= 0;
9606 if (r
->out
.out_data
&& out_data
.data
&& r
->in
.out_data_size
&& out_data
.length
) {
9607 memcpy(r
->out
.out_data
, out_data
.data
,
9608 MIN(r
->in
.out_data_size
, out_data
.length
));
9614 /****************************************************************
9615 _spoolss_AddPrintProcessor
9616 ****************************************************************/
9618 WERROR
_spoolss_AddPrintProcessor(pipes_struct
*p
,
9619 struct spoolss_AddPrintProcessor
*r
)
9621 /* for now, just indicate success and ignore the add. We'll
9622 automatically set the winprint processor for printer
9623 entries later. Used to debug the LexMark Optra S 1855 PCL
9629 /****************************************************************
9631 ****************************************************************/
9633 WERROR
_spoolss_AddPort(pipes_struct
*p
,
9634 struct spoolss_AddPort
*r
)
9636 /* do what w2k3 does */
9638 return WERR_NOT_SUPPORTED
;
9641 /****************************************************************
9642 _spoolss_GetPrinterDriver
9643 ****************************************************************/
9645 WERROR
_spoolss_GetPrinterDriver(pipes_struct
*p
,
9646 struct spoolss_GetPrinterDriver
*r
)
9648 p
->rng_fault_state
= true;
9649 return WERR_NOT_SUPPORTED
;
9652 /****************************************************************
9653 _spoolss_ReadPrinter
9654 ****************************************************************/
9656 WERROR
_spoolss_ReadPrinter(pipes_struct
*p
,
9657 struct spoolss_ReadPrinter
*r
)
9659 p
->rng_fault_state
= true;
9660 return WERR_NOT_SUPPORTED
;
9663 /****************************************************************
9664 _spoolss_WaitForPrinterChange
9665 ****************************************************************/
9667 WERROR
_spoolss_WaitForPrinterChange(pipes_struct
*p
,
9668 struct spoolss_WaitForPrinterChange
*r
)
9670 p
->rng_fault_state
= true;
9671 return WERR_NOT_SUPPORTED
;
9674 /****************************************************************
9675 _spoolss_ConfigurePort
9676 ****************************************************************/
9678 WERROR
_spoolss_ConfigurePort(pipes_struct
*p
,
9679 struct spoolss_ConfigurePort
*r
)
9681 p
->rng_fault_state
= true;
9682 return WERR_NOT_SUPPORTED
;
9685 /****************************************************************
9687 ****************************************************************/
9689 WERROR
_spoolss_DeletePort(pipes_struct
*p
,
9690 struct spoolss_DeletePort
*r
)
9692 p
->rng_fault_state
= true;
9693 return WERR_NOT_SUPPORTED
;
9696 /****************************************************************
9697 _spoolss_CreatePrinterIC
9698 ****************************************************************/
9700 WERROR
_spoolss_CreatePrinterIC(pipes_struct
*p
,
9701 struct spoolss_CreatePrinterIC
*r
)
9703 p
->rng_fault_state
= true;
9704 return WERR_NOT_SUPPORTED
;
9707 /****************************************************************
9708 _spoolss_PlayGDIScriptOnPrinterIC
9709 ****************************************************************/
9711 WERROR
_spoolss_PlayGDIScriptOnPrinterIC(pipes_struct
*p
,
9712 struct spoolss_PlayGDIScriptOnPrinterIC
*r
)
9714 p
->rng_fault_state
= true;
9715 return WERR_NOT_SUPPORTED
;
9718 /****************************************************************
9719 _spoolss_DeletePrinterIC
9720 ****************************************************************/
9722 WERROR
_spoolss_DeletePrinterIC(pipes_struct
*p
,
9723 struct spoolss_DeletePrinterIC
*r
)
9725 p
->rng_fault_state
= true;
9726 return WERR_NOT_SUPPORTED
;
9729 /****************************************************************
9730 _spoolss_AddPrinterConnection
9731 ****************************************************************/
9733 WERROR
_spoolss_AddPrinterConnection(pipes_struct
*p
,
9734 struct spoolss_AddPrinterConnection
*r
)
9736 p
->rng_fault_state
= true;
9737 return WERR_NOT_SUPPORTED
;
9740 /****************************************************************
9741 _spoolss_DeletePrinterConnection
9742 ****************************************************************/
9744 WERROR
_spoolss_DeletePrinterConnection(pipes_struct
*p
,
9745 struct spoolss_DeletePrinterConnection
*r
)
9747 p
->rng_fault_state
= true;
9748 return WERR_NOT_SUPPORTED
;
9751 /****************************************************************
9752 _spoolss_PrinterMessageBox
9753 ****************************************************************/
9755 WERROR
_spoolss_PrinterMessageBox(pipes_struct
*p
,
9756 struct spoolss_PrinterMessageBox
*r
)
9758 p
->rng_fault_state
= true;
9759 return WERR_NOT_SUPPORTED
;
9762 /****************************************************************
9764 ****************************************************************/
9766 WERROR
_spoolss_AddMonitor(pipes_struct
*p
,
9767 struct spoolss_AddMonitor
*r
)
9769 p
->rng_fault_state
= true;
9770 return WERR_NOT_SUPPORTED
;
9773 /****************************************************************
9774 _spoolss_DeleteMonitor
9775 ****************************************************************/
9777 WERROR
_spoolss_DeleteMonitor(pipes_struct
*p
,
9778 struct spoolss_DeleteMonitor
*r
)
9780 p
->rng_fault_state
= true;
9781 return WERR_NOT_SUPPORTED
;
9784 /****************************************************************
9785 _spoolss_DeletePrintProcessor
9786 ****************************************************************/
9788 WERROR
_spoolss_DeletePrintProcessor(pipes_struct
*p
,
9789 struct spoolss_DeletePrintProcessor
*r
)
9791 p
->rng_fault_state
= true;
9792 return WERR_NOT_SUPPORTED
;
9795 /****************************************************************
9796 _spoolss_AddPrintProvidor
9797 ****************************************************************/
9799 WERROR
_spoolss_AddPrintProvidor(pipes_struct
*p
,
9800 struct spoolss_AddPrintProvidor
*r
)
9802 p
->rng_fault_state
= true;
9803 return WERR_NOT_SUPPORTED
;
9806 /****************************************************************
9807 _spoolss_DeletePrintProvidor
9808 ****************************************************************/
9810 WERROR
_spoolss_DeletePrintProvidor(pipes_struct
*p
,
9811 struct spoolss_DeletePrintProvidor
*r
)
9813 p
->rng_fault_state
= true;
9814 return WERR_NOT_SUPPORTED
;
9817 /****************************************************************
9818 _spoolss_FindFirstPrinterChangeNotification
9819 ****************************************************************/
9821 WERROR
_spoolss_FindFirstPrinterChangeNotification(pipes_struct
*p
,
9822 struct spoolss_FindFirstPrinterChangeNotification
*r
)
9824 p
->rng_fault_state
= true;
9825 return WERR_NOT_SUPPORTED
;
9828 /****************************************************************
9829 _spoolss_FindNextPrinterChangeNotification
9830 ****************************************************************/
9832 WERROR
_spoolss_FindNextPrinterChangeNotification(pipes_struct
*p
,
9833 struct spoolss_FindNextPrinterChangeNotification
*r
)
9835 p
->rng_fault_state
= true;
9836 return WERR_NOT_SUPPORTED
;
9839 /****************************************************************
9840 _spoolss_RouterFindFirstPrinterChangeNotificationOld
9841 ****************************************************************/
9843 WERROR
_spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct
*p
,
9844 struct spoolss_RouterFindFirstPrinterChangeNotificationOld
*r
)
9846 p
->rng_fault_state
= true;
9847 return WERR_NOT_SUPPORTED
;
9850 /****************************************************************
9851 _spoolss_ReplyOpenPrinter
9852 ****************************************************************/
9854 WERROR
_spoolss_ReplyOpenPrinter(pipes_struct
*p
,
9855 struct spoolss_ReplyOpenPrinter
*r
)
9857 p
->rng_fault_state
= true;
9858 return WERR_NOT_SUPPORTED
;
9861 /****************************************************************
9862 _spoolss_RouterReplyPrinter
9863 ****************************************************************/
9865 WERROR
_spoolss_RouterReplyPrinter(pipes_struct
*p
,
9866 struct spoolss_RouterReplyPrinter
*r
)
9868 p
->rng_fault_state
= true;
9869 return WERR_NOT_SUPPORTED
;
9872 /****************************************************************
9873 _spoolss_ReplyClosePrinter
9874 ****************************************************************/
9876 WERROR
_spoolss_ReplyClosePrinter(pipes_struct
*p
,
9877 struct spoolss_ReplyClosePrinter
*r
)
9879 p
->rng_fault_state
= true;
9880 return WERR_NOT_SUPPORTED
;
9883 /****************************************************************
9885 ****************************************************************/
9887 WERROR
_spoolss_AddPortEx(pipes_struct
*p
,
9888 struct spoolss_AddPortEx
*r
)
9890 p
->rng_fault_state
= true;
9891 return WERR_NOT_SUPPORTED
;
9894 /****************************************************************
9895 _spoolss_RouterFindFirstPrinterChangeNotification
9896 ****************************************************************/
9898 WERROR
_spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct
*p
,
9899 struct spoolss_RouterFindFirstPrinterChangeNotification
*r
)
9901 p
->rng_fault_state
= true;
9902 return WERR_NOT_SUPPORTED
;
9905 /****************************************************************
9906 _spoolss_SpoolerInit
9907 ****************************************************************/
9909 WERROR
_spoolss_SpoolerInit(pipes_struct
*p
,
9910 struct spoolss_SpoolerInit
*r
)
9912 p
->rng_fault_state
= true;
9913 return WERR_NOT_SUPPORTED
;
9916 /****************************************************************
9917 _spoolss_ResetPrinterEx
9918 ****************************************************************/
9920 WERROR
_spoolss_ResetPrinterEx(pipes_struct
*p
,
9921 struct spoolss_ResetPrinterEx
*r
)
9923 p
->rng_fault_state
= true;
9924 return WERR_NOT_SUPPORTED
;
9927 /****************************************************************
9928 _spoolss_RouterReplyPrinterEx
9929 ****************************************************************/
9931 WERROR
_spoolss_RouterReplyPrinterEx(pipes_struct
*p
,
9932 struct spoolss_RouterReplyPrinterEx
*r
)
9934 p
->rng_fault_state
= true;
9935 return WERR_NOT_SUPPORTED
;
9938 /****************************************************************
9940 ****************************************************************/
9942 WERROR
_spoolss_44(pipes_struct
*p
,
9943 struct spoolss_44
*r
)
9945 p
->rng_fault_state
= true;
9946 return WERR_NOT_SUPPORTED
;
9949 /****************************************************************
9951 ****************************************************************/
9953 WERROR
_spoolss_47(pipes_struct
*p
,
9954 struct spoolss_47
*r
)
9956 p
->rng_fault_state
= true;
9957 return WERR_NOT_SUPPORTED
;
9960 /****************************************************************
9962 ****************************************************************/
9964 WERROR
_spoolss_4a(pipes_struct
*p
,
9965 struct spoolss_4a
*r
)
9967 p
->rng_fault_state
= true;
9968 return WERR_NOT_SUPPORTED
;
9971 /****************************************************************
9973 ****************************************************************/
9975 WERROR
_spoolss_4b(pipes_struct
*p
,
9976 struct spoolss_4b
*r
)
9978 p
->rng_fault_state
= true;
9979 return WERR_NOT_SUPPORTED
;
9982 /****************************************************************
9984 ****************************************************************/
9986 WERROR
_spoolss_4c(pipes_struct
*p
,
9987 struct spoolss_4c
*r
)
9989 p
->rng_fault_state
= true;
9990 return WERR_NOT_SUPPORTED
;
9993 /****************************************************************
9995 ****************************************************************/
9997 WERROR
_spoolss_53(pipes_struct
*p
,
9998 struct spoolss_53
*r
)
10000 p
->rng_fault_state
= true;
10001 return WERR_NOT_SUPPORTED
;
10004 /****************************************************************
10006 ****************************************************************/
10008 WERROR
_spoolss_55(pipes_struct
*p
,
10009 struct spoolss_55
*r
)
10011 p
->rng_fault_state
= true;
10012 return WERR_NOT_SUPPORTED
;
10015 /****************************************************************
10017 ****************************************************************/
10019 WERROR
_spoolss_56(pipes_struct
*p
,
10020 struct spoolss_56
*r
)
10022 p
->rng_fault_state
= true;
10023 return WERR_NOT_SUPPORTED
;
10026 /****************************************************************
10028 ****************************************************************/
10030 WERROR
_spoolss_57(pipes_struct
*p
,
10031 struct spoolss_57
*r
)
10033 p
->rng_fault_state
= true;
10034 return WERR_NOT_SUPPORTED
;
10037 /****************************************************************
10039 ****************************************************************/
10041 WERROR
_spoolss_5a(pipes_struct
*p
,
10042 struct spoolss_5a
*r
)
10044 p
->rng_fault_state
= true;
10045 return WERR_NOT_SUPPORTED
;
10048 /****************************************************************
10050 ****************************************************************/
10052 WERROR
_spoolss_5b(pipes_struct
*p
,
10053 struct spoolss_5b
*r
)
10055 p
->rng_fault_state
= true;
10056 return WERR_NOT_SUPPORTED
;
10059 /****************************************************************
10061 ****************************************************************/
10063 WERROR
_spoolss_5c(pipes_struct
*p
,
10064 struct spoolss_5c
*r
)
10066 p
->rng_fault_state
= true;
10067 return WERR_NOT_SUPPORTED
;
10070 /****************************************************************
10072 ****************************************************************/
10074 WERROR
_spoolss_5d(pipes_struct
*p
,
10075 struct spoolss_5d
*r
)
10077 p
->rng_fault_state
= true;
10078 return WERR_NOT_SUPPORTED
;
10081 /****************************************************************
10083 ****************************************************************/
10085 WERROR
_spoolss_5e(pipes_struct
*p
,
10086 struct spoolss_5e
*r
)
10088 p
->rng_fault_state
= true;
10089 return WERR_NOT_SUPPORTED
;
10092 /****************************************************************
10094 ****************************************************************/
10096 WERROR
_spoolss_5f(pipes_struct
*p
,
10097 struct spoolss_5f
*r
)
10099 p
->rng_fault_state
= true;
10100 return WERR_NOT_SUPPORTED
;
10103 /****************************************************************
10105 ****************************************************************/
10107 WERROR
_spoolss_60(pipes_struct
*p
,
10108 struct spoolss_60
*r
)
10110 p
->rng_fault_state
= true;
10111 return WERR_NOT_SUPPORTED
;
10114 /****************************************************************
10116 ****************************************************************/
10118 WERROR
_spoolss_61(pipes_struct
*p
,
10119 struct spoolss_61
*r
)
10121 p
->rng_fault_state
= true;
10122 return WERR_NOT_SUPPORTED
;
10125 /****************************************************************
10127 ****************************************************************/
10129 WERROR
_spoolss_62(pipes_struct
*p
,
10130 struct spoolss_62
*r
)
10132 p
->rng_fault_state
= true;
10133 return WERR_NOT_SUPPORTED
;
10136 /****************************************************************
10138 ****************************************************************/
10140 WERROR
_spoolss_63(pipes_struct
*p
,
10141 struct spoolss_63
*r
)
10143 p
->rng_fault_state
= true;
10144 return WERR_NOT_SUPPORTED
;
10147 /****************************************************************
10149 ****************************************************************/
10151 WERROR
_spoolss_64(pipes_struct
*p
,
10152 struct spoolss_64
*r
)
10154 p
->rng_fault_state
= true;
10155 return WERR_NOT_SUPPORTED
;
10158 /****************************************************************
10160 ****************************************************************/
10162 WERROR
_spoolss_65(pipes_struct
*p
,
10163 struct spoolss_65
*r
)
10165 p
->rng_fault_state
= true;
10166 return WERR_NOT_SUPPORTED
;
10169 /****************************************************************
10170 _spoolss_GetCorePrinterDrivers
10171 ****************************************************************/
10173 WERROR
_spoolss_GetCorePrinterDrivers(pipes_struct
*p
,
10174 struct spoolss_GetCorePrinterDrivers
*r
)
10176 p
->rng_fault_state
= true;
10177 return WERR_NOT_SUPPORTED
;
10180 /****************************************************************
10182 ****************************************************************/
10184 WERROR
_spoolss_67(pipes_struct
*p
,
10185 struct spoolss_67
*r
)
10187 p
->rng_fault_state
= true;
10188 return WERR_NOT_SUPPORTED
;
10191 /****************************************************************
10192 _spoolss_GetPrinterDriverPackagePath
10193 ****************************************************************/
10195 WERROR
_spoolss_GetPrinterDriverPackagePath(pipes_struct
*p
,
10196 struct spoolss_GetPrinterDriverPackagePath
*r
)
10198 p
->rng_fault_state
= true;
10199 return WERR_NOT_SUPPORTED
;
10202 /****************************************************************
10204 ****************************************************************/
10206 WERROR
_spoolss_69(pipes_struct
*p
,
10207 struct spoolss_69
*r
)
10209 p
->rng_fault_state
= true;
10210 return WERR_NOT_SUPPORTED
;
10213 /****************************************************************
10215 ****************************************************************/
10217 WERROR
_spoolss_6a(pipes_struct
*p
,
10218 struct spoolss_6a
*r
)
10220 p
->rng_fault_state
= true;
10221 return WERR_NOT_SUPPORTED
;
10224 /****************************************************************
10226 ****************************************************************/
10228 WERROR
_spoolss_6b(pipes_struct
*p
,
10229 struct spoolss_6b
*r
)
10231 p
->rng_fault_state
= true;
10232 return WERR_NOT_SUPPORTED
;
10235 /****************************************************************
10237 ****************************************************************/
10239 WERROR
_spoolss_6c(pipes_struct
*p
,
10240 struct spoolss_6c
*r
)
10242 p
->rng_fault_state
= true;
10243 return WERR_NOT_SUPPORTED
;
10246 /****************************************************************
10248 ****************************************************************/
10250 WERROR
_spoolss_6d(pipes_struct
*p
,
10251 struct spoolss_6d
*r
)
10253 p
->rng_fault_state
= true;
10254 return WERR_NOT_SUPPORTED
;