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.
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")) {
2274 data
->string
= talloc_strdup(mem_ctx
, "Windows 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
;
2344 if ( is_zero_addr((struct sockaddr
*)client_ss
) ) {
2345 if ( !resolve_name( remote_machine
, &rm_addr
, 0x20, false) ) {
2346 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine
));
2350 if (ismyaddr((struct sockaddr
*)&rm_addr
)) {
2351 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine
));
2355 char addr
[INET6_ADDRSTRLEN
];
2356 rm_addr
= *client_ss
;
2357 print_sockaddr(addr
, sizeof(addr
), &rm_addr
);
2358 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2362 /* setup the connection */
2364 ret
= cli_full_connection( &the_cli
, global_myname(), remote_machine
,
2365 &rm_addr
, 0, "IPC$", "IPC",
2369 0, lp_client_signing(), NULL
);
2371 if ( !NT_STATUS_IS_OK( ret
) ) {
2372 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2377 if ( the_cli
->protocol
!= PROTOCOL_NT1
) {
2378 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine
));
2379 cli_shutdown(the_cli
);
2384 * Ok - we have an anonymous connection to the IPC$ share.
2385 * Now start the NT Domain stuff :-).
2388 ret
= cli_rpc_pipe_open_noauth(the_cli
, &ndr_table_spoolss
.syntax_id
, pp_pipe
);
2389 if (!NT_STATUS_IS_OK(ret
)) {
2390 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2391 remote_machine
, nt_errstr(ret
)));
2392 cli_shutdown(the_cli
);
2399 /***************************************************************************
2400 Connect to the client.
2401 ****************************************************************************/
2403 static bool srv_spoolss_replyopenprinter(int snum
, const char *printer
,
2404 uint32_t localprinter
, uint32_t type
,
2405 struct policy_handle
*handle
,
2406 struct sockaddr_storage
*client_ss
)
2412 * If it's the first connection, contact the client
2413 * and connect to the IPC$ share anonymously
2415 if (smb_connections
==0) {
2416 fstring unix_printer
;
2418 fstrcpy(unix_printer
, printer
+2); /* the +2 is to strip the leading 2 backslashs */
2420 if ( !spoolss_connect_to_client( ¬ify_cli_pipe
, client_ss
, unix_printer
))
2423 messaging_register(smbd_messaging_context(), NULL
,
2424 MSG_PRINTER_NOTIFY2
,
2425 receive_notify2_message_list
);
2426 /* Tell the connections db we're now interested in printer
2427 * notify messages. */
2428 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY
);
2432 * Tell the specific printing tdb we want messages for this printer
2433 * by registering our PID.
2436 if (!print_notify_register_pid(snum
))
2437 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer
));
2441 status
= rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe
, talloc_tos(),
2449 if (!NT_STATUS_IS_OK(status
) || !W_ERROR_IS_OK(result
))
2450 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2451 win_errstr(result
)));
2453 return (W_ERROR_IS_OK(result
));
2456 /****************************************************************
2457 ****************************************************************/
2459 static struct spoolss_NotifyOption
*dup_spoolss_NotifyOption(TALLOC_CTX
*mem_ctx
,
2460 const struct spoolss_NotifyOption
*r
)
2462 struct spoolss_NotifyOption
*option
;
2469 option
= talloc_zero(mem_ctx
, struct spoolss_NotifyOption
);
2476 if (!option
->count
) {
2480 option
->types
= talloc_zero_array(option
,
2481 struct spoolss_NotifyOptionType
, option
->count
);
2482 if (!option
->types
) {
2483 talloc_free(option
);
2487 for (i
=0; i
< option
->count
; i
++) {
2488 option
->types
[i
] = r
->types
[i
];
2490 if (option
->types
[i
].count
) {
2491 option
->types
[i
].fields
= talloc_zero_array(option
,
2492 union spoolss_Field
, option
->types
[i
].count
);
2493 if (!option
->types
[i
].fields
) {
2494 talloc_free(option
);
2497 for (k
=0; k
<option
->types
[i
].count
; k
++) {
2498 option
->types
[i
].fields
[k
] =
2499 r
->types
[i
].fields
[k
];
2507 /****************************************************************
2508 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2510 * before replying OK: status=0 a rpc call is made to the workstation
2511 * asking ReplyOpenPrinter
2513 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2514 * called from api_spoolss_rffpcnex
2515 ****************************************************************/
2517 WERROR
_spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct
*p
,
2518 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx
*r
)
2521 struct spoolss_NotifyOption
*option
= r
->in
.notify_options
;
2522 struct sockaddr_storage client_ss
;
2524 /* store the notify value in the printer struct */
2526 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
2529 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2530 "Invalid handle (%s:%u:%u).\n",
2531 OUR_HANDLE(r
->in
.handle
)));
2535 Printer
->notify
.flags
= r
->in
.flags
;
2536 Printer
->notify
.options
= r
->in
.options
;
2537 Printer
->notify
.printerlocal
= r
->in
.printer_local
;
2539 TALLOC_FREE(Printer
->notify
.option
);
2540 Printer
->notify
.option
= dup_spoolss_NotifyOption(Printer
, option
);
2542 fstrcpy(Printer
->notify
.localmachine
, r
->in
.local_machine
);
2544 /* Connect to the client machine and send a ReplyOpenPrinter */
2546 if ( Printer
->printer_type
== SPLHND_SERVER
)
2548 else if ( (Printer
->printer_type
== SPLHND_PRINTER
) &&
2549 !get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
) )
2552 if (!interpret_string_addr(&client_ss
, p
->client_address
,
2554 return WERR_SERVER_UNAVAILABLE
;
2557 if(!srv_spoolss_replyopenprinter(snum
, Printer
->notify
.localmachine
,
2558 Printer
->notify
.printerlocal
, 1,
2559 &Printer
->notify
.client_hnd
, &client_ss
))
2560 return WERR_SERVER_UNAVAILABLE
;
2562 Printer
->notify
.client_connected
= true;
2567 /*******************************************************************
2568 * fill a notify_info_data with the servername
2569 ********************************************************************/
2571 void spoolss_notify_server_name(int snum
,
2572 struct spoolss_Notify
*data
,
2573 print_queue_struct
*queue
,
2574 NT_PRINTER_INFO_LEVEL
*printer
,
2575 TALLOC_CTX
*mem_ctx
)
2577 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, printer
->info_2
->servername
);
2580 /*******************************************************************
2581 * fill a notify_info_data with the printername (not including the servername).
2582 ********************************************************************/
2584 void spoolss_notify_printer_name(int snum
,
2585 struct spoolss_Notify
*data
,
2586 print_queue_struct
*queue
,
2587 NT_PRINTER_INFO_LEVEL
*printer
,
2588 TALLOC_CTX
*mem_ctx
)
2590 /* the notify name should not contain the \\server\ part */
2591 char *p
= strrchr(printer
->info_2
->printername
, '\\');
2594 p
= printer
->info_2
->printername
;
2599 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, p
);
2602 /*******************************************************************
2603 * fill a notify_info_data with the servicename
2604 ********************************************************************/
2606 void spoolss_notify_share_name(int snum
,
2607 struct spoolss_Notify
*data
,
2608 print_queue_struct
*queue
,
2609 NT_PRINTER_INFO_LEVEL
*printer
,
2610 TALLOC_CTX
*mem_ctx
)
2612 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, lp_servicename(snum
));
2615 /*******************************************************************
2616 * fill a notify_info_data with the port name
2617 ********************************************************************/
2619 void spoolss_notify_port_name(int snum
,
2620 struct spoolss_Notify
*data
,
2621 print_queue_struct
*queue
,
2622 NT_PRINTER_INFO_LEVEL
*printer
,
2623 TALLOC_CTX
*mem_ctx
)
2625 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, printer
->info_2
->portname
);
2628 /*******************************************************************
2629 * fill a notify_info_data with the printername
2630 * but it doesn't exist, have to see what to do
2631 ********************************************************************/
2633 void spoolss_notify_driver_name(int snum
,
2634 struct spoolss_Notify
*data
,
2635 print_queue_struct
*queue
,
2636 NT_PRINTER_INFO_LEVEL
*printer
,
2637 TALLOC_CTX
*mem_ctx
)
2639 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, printer
->info_2
->drivername
);
2642 /*******************************************************************
2643 * fill a notify_info_data with the comment
2644 ********************************************************************/
2646 void spoolss_notify_comment(int snum
,
2647 struct spoolss_Notify
*data
,
2648 print_queue_struct
*queue
,
2649 NT_PRINTER_INFO_LEVEL
*printer
,
2650 TALLOC_CTX
*mem_ctx
)
2654 if (*printer
->info_2
->comment
== '\0') {
2655 p
= lp_comment(snum
);
2657 p
= printer
->info_2
->comment
;
2660 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, printer
->info_2
->comment
);
2663 /*******************************************************************
2664 * fill a notify_info_data with the comment
2665 * location = "Room 1, floor 2, building 3"
2666 ********************************************************************/
2668 void spoolss_notify_location(int snum
,
2669 struct spoolss_Notify
*data
,
2670 print_queue_struct
*queue
,
2671 NT_PRINTER_INFO_LEVEL
*printer
,
2672 TALLOC_CTX
*mem_ctx
)
2674 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, printer
->info_2
->location
);
2677 /*******************************************************************
2678 * fill a notify_info_data with the device mode
2679 * jfm:xxxx don't to it for know but that's a real problem !!!
2680 ********************************************************************/
2682 static void spoolss_notify_devmode(int snum
,
2683 struct spoolss_Notify
*data
,
2684 print_queue_struct
*queue
,
2685 NT_PRINTER_INFO_LEVEL
*printer
,
2686 TALLOC_CTX
*mem_ctx
)
2688 /* for a dummy implementation we have to zero the fields */
2689 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data
, NULL
);
2692 /*******************************************************************
2693 * fill a notify_info_data with the separator file name
2694 ********************************************************************/
2696 void spoolss_notify_sepfile(int snum
,
2697 struct spoolss_Notify
*data
,
2698 print_queue_struct
*queue
,
2699 NT_PRINTER_INFO_LEVEL
*printer
,
2700 TALLOC_CTX
*mem_ctx
)
2702 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, printer
->info_2
->sepfile
);
2705 /*******************************************************************
2706 * fill a notify_info_data with the print processor
2707 * jfm:xxxx return always winprint to indicate we don't do anything to it
2708 ********************************************************************/
2710 void spoolss_notify_print_processor(int snum
,
2711 struct spoolss_Notify
*data
,
2712 print_queue_struct
*queue
,
2713 NT_PRINTER_INFO_LEVEL
*printer
,
2714 TALLOC_CTX
*mem_ctx
)
2716 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, printer
->info_2
->printprocessor
);
2719 /*******************************************************************
2720 * fill a notify_info_data with the print processor options
2721 * jfm:xxxx send an empty string
2722 ********************************************************************/
2724 void spoolss_notify_parameters(int snum
,
2725 struct spoolss_Notify
*data
,
2726 print_queue_struct
*queue
,
2727 NT_PRINTER_INFO_LEVEL
*printer
,
2728 TALLOC_CTX
*mem_ctx
)
2730 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, printer
->info_2
->parameters
);
2733 /*******************************************************************
2734 * fill a notify_info_data with the data type
2735 * jfm:xxxx always send RAW as data type
2736 ********************************************************************/
2738 void spoolss_notify_datatype(int snum
,
2739 struct spoolss_Notify
*data
,
2740 print_queue_struct
*queue
,
2741 NT_PRINTER_INFO_LEVEL
*printer
,
2742 TALLOC_CTX
*mem_ctx
)
2744 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, printer
->info_2
->datatype
);
2747 /*******************************************************************
2748 * fill a notify_info_data with the security descriptor
2749 * jfm:xxxx send an null pointer to say no security desc
2750 * have to implement security before !
2751 ********************************************************************/
2753 static void spoolss_notify_security_desc(int snum
,
2754 struct spoolss_Notify
*data
,
2755 print_queue_struct
*queue
,
2756 NT_PRINTER_INFO_LEVEL
*printer
,
2757 TALLOC_CTX
*mem_ctx
)
2759 SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data
,
2760 printer
->info_2
->secdesc_buf
->sd_size
,
2761 printer
->info_2
->secdesc_buf
->sd
);
2764 /*******************************************************************
2765 * fill a notify_info_data with the attributes
2766 * jfm:xxxx a samba printer is always shared
2767 ********************************************************************/
2769 void spoolss_notify_attributes(int snum
,
2770 struct spoolss_Notify
*data
,
2771 print_queue_struct
*queue
,
2772 NT_PRINTER_INFO_LEVEL
*printer
,
2773 TALLOC_CTX
*mem_ctx
)
2775 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, printer
->info_2
->attributes
);
2778 /*******************************************************************
2779 * fill a notify_info_data with the priority
2780 ********************************************************************/
2782 static void spoolss_notify_priority(int snum
,
2783 struct spoolss_Notify
*data
,
2784 print_queue_struct
*queue
,
2785 NT_PRINTER_INFO_LEVEL
*printer
,
2786 TALLOC_CTX
*mem_ctx
)
2788 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, printer
->info_2
->priority
);
2791 /*******************************************************************
2792 * fill a notify_info_data with the default priority
2793 ********************************************************************/
2795 static void spoolss_notify_default_priority(int snum
,
2796 struct spoolss_Notify
*data
,
2797 print_queue_struct
*queue
,
2798 NT_PRINTER_INFO_LEVEL
*printer
,
2799 TALLOC_CTX
*mem_ctx
)
2801 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, printer
->info_2
->default_priority
);
2804 /*******************************************************************
2805 * fill a notify_info_data with the start time
2806 ********************************************************************/
2808 static void spoolss_notify_start_time(int snum
,
2809 struct spoolss_Notify
*data
,
2810 print_queue_struct
*queue
,
2811 NT_PRINTER_INFO_LEVEL
*printer
,
2812 TALLOC_CTX
*mem_ctx
)
2814 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, printer
->info_2
->starttime
);
2817 /*******************************************************************
2818 * fill a notify_info_data with the until time
2819 ********************************************************************/
2821 static void spoolss_notify_until_time(int snum
,
2822 struct spoolss_Notify
*data
,
2823 print_queue_struct
*queue
,
2824 NT_PRINTER_INFO_LEVEL
*printer
,
2825 TALLOC_CTX
*mem_ctx
)
2827 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, printer
->info_2
->untiltime
);
2830 /*******************************************************************
2831 * fill a notify_info_data with the status
2832 ********************************************************************/
2834 static void spoolss_notify_status(int snum
,
2835 struct spoolss_Notify
*data
,
2836 print_queue_struct
*queue
,
2837 NT_PRINTER_INFO_LEVEL
*printer
,
2838 TALLOC_CTX
*mem_ctx
)
2840 print_status_struct status
;
2842 print_queue_length(snum
, &status
);
2843 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, status
.status
);
2846 /*******************************************************************
2847 * fill a notify_info_data with the number of jobs queued
2848 ********************************************************************/
2850 void spoolss_notify_cjobs(int snum
,
2851 struct spoolss_Notify
*data
,
2852 print_queue_struct
*queue
,
2853 NT_PRINTER_INFO_LEVEL
*printer
,
2854 TALLOC_CTX
*mem_ctx
)
2856 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, print_queue_length(snum
, NULL
));
2859 /*******************************************************************
2860 * fill a notify_info_data with the average ppm
2861 ********************************************************************/
2863 static void spoolss_notify_average_ppm(int snum
,
2864 struct spoolss_Notify
*data
,
2865 print_queue_struct
*queue
,
2866 NT_PRINTER_INFO_LEVEL
*printer
,
2867 TALLOC_CTX
*mem_ctx
)
2869 /* always respond 8 pages per minutes */
2870 /* a little hard ! */
2871 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, printer
->info_2
->averageppm
);
2874 /*******************************************************************
2875 * fill a notify_info_data with username
2876 ********************************************************************/
2878 static void spoolss_notify_username(int snum
,
2879 struct spoolss_Notify
*data
,
2880 print_queue_struct
*queue
,
2881 NT_PRINTER_INFO_LEVEL
*printer
,
2882 TALLOC_CTX
*mem_ctx
)
2884 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, queue
->fs_user
);
2887 /*******************************************************************
2888 * fill a notify_info_data with job status
2889 ********************************************************************/
2891 static void spoolss_notify_job_status(int snum
,
2892 struct spoolss_Notify
*data
,
2893 print_queue_struct
*queue
,
2894 NT_PRINTER_INFO_LEVEL
*printer
,
2895 TALLOC_CTX
*mem_ctx
)
2897 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, nt_printj_status(queue
->status
));
2900 /*******************************************************************
2901 * fill a notify_info_data with job name
2902 ********************************************************************/
2904 static void spoolss_notify_job_name(int snum
,
2905 struct spoolss_Notify
*data
,
2906 print_queue_struct
*queue
,
2907 NT_PRINTER_INFO_LEVEL
*printer
,
2908 TALLOC_CTX
*mem_ctx
)
2910 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, queue
->fs_file
);
2913 /*******************************************************************
2914 * fill a notify_info_data with job status
2915 ********************************************************************/
2917 static void spoolss_notify_job_status_string(int snum
,
2918 struct spoolss_Notify
*data
,
2919 print_queue_struct
*queue
,
2920 NT_PRINTER_INFO_LEVEL
*printer
,
2921 TALLOC_CTX
*mem_ctx
)
2924 * Now we're returning job status codes we just return a "" here. JRA.
2929 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
2932 switch (queue
->status
) {
2937 p
= ""; /* NT provides the paused string */
2946 #endif /* NO LONGER NEEDED. */
2948 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data
, p
);
2951 /*******************************************************************
2952 * fill a notify_info_data with job time
2953 ********************************************************************/
2955 static void spoolss_notify_job_time(int snum
,
2956 struct spoolss_Notify
*data
,
2957 print_queue_struct
*queue
,
2958 NT_PRINTER_INFO_LEVEL
*printer
,
2959 TALLOC_CTX
*mem_ctx
)
2961 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, 0);
2964 /*******************************************************************
2965 * fill a notify_info_data with job size
2966 ********************************************************************/
2968 static void spoolss_notify_job_size(int snum
,
2969 struct spoolss_Notify
*data
,
2970 print_queue_struct
*queue
,
2971 NT_PRINTER_INFO_LEVEL
*printer
,
2972 TALLOC_CTX
*mem_ctx
)
2974 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, queue
->size
);
2977 /*******************************************************************
2978 * fill a notify_info_data with page info
2979 ********************************************************************/
2980 static void spoolss_notify_total_pages(int snum
,
2981 struct spoolss_Notify
*data
,
2982 print_queue_struct
*queue
,
2983 NT_PRINTER_INFO_LEVEL
*printer
,
2984 TALLOC_CTX
*mem_ctx
)
2986 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, queue
->page_count
);
2989 /*******************************************************************
2990 * fill a notify_info_data with pages printed info.
2991 ********************************************************************/
2992 static void spoolss_notify_pages_printed(int snum
,
2993 struct spoolss_Notify
*data
,
2994 print_queue_struct
*queue
,
2995 NT_PRINTER_INFO_LEVEL
*printer
,
2996 TALLOC_CTX
*mem_ctx
)
2998 /* Add code when back-end tracks this */
2999 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, 0);
3002 /*******************************************************************
3003 Fill a notify_info_data with job position.
3004 ********************************************************************/
3006 static void spoolss_notify_job_position(int snum
,
3007 struct spoolss_Notify
*data
,
3008 print_queue_struct
*queue
,
3009 NT_PRINTER_INFO_LEVEL
*printer
,
3010 TALLOC_CTX
*mem_ctx
)
3012 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data
, queue
->job
);
3015 /*******************************************************************
3016 Fill a notify_info_data with submitted time.
3017 ********************************************************************/
3019 static void spoolss_notify_submitted_time(int snum
,
3020 struct spoolss_Notify
*data
,
3021 print_queue_struct
*queue
,
3022 NT_PRINTER_INFO_LEVEL
*printer
,
3023 TALLOC_CTX
*mem_ctx
)
3025 data
->data
.string
.string
= NULL
;
3026 data
->data
.string
.size
= 0;
3028 init_systemtime_buffer(mem_ctx
, gmtime(&queue
->time
),
3029 &data
->data
.string
.string
,
3030 &data
->data
.string
.size
);
3034 struct s_notify_info_data_table
3036 enum spoolss_NotifyType type
;
3039 enum spoolss_NotifyTable variable_type
;
3040 void (*fn
) (int snum
, struct spoolss_Notify
*data
,
3041 print_queue_struct
*queue
,
3042 NT_PRINTER_INFO_LEVEL
*printer
, TALLOC_CTX
*mem_ctx
);
3045 /* A table describing the various print notification constants and
3046 whether the notification data is a pointer to a variable sized
3047 buffer, a one value uint32_t or a two value uint32_t. */
3049 static const struct s_notify_info_data_table notify_info_data_table
[] =
3051 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_SERVER_NAME
, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_server_name
},
3052 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_PRINTER_NAME
, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_printer_name
},
3053 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_SHARE_NAME
, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_share_name
},
3054 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_PORT_NAME
, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_port_name
},
3055 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_DRIVER_NAME
, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_driver_name
},
3056 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_COMMENT
, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING
, spoolss_notify_comment
},
3057 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_LOCATION
, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING
, spoolss_notify_location
},
3058 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_DEVMODE
, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE
, spoolss_notify_devmode
},
3059 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_SEPFILE
, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING
, spoolss_notify_sepfile
},
3060 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR
, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING
, spoolss_notify_print_processor
},
3061 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_PARAMETERS
, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING
, spoolss_notify_parameters
},
3062 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_DATATYPE
, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING
, spoolss_notify_datatype
},
3063 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR
, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR
, spoolss_notify_security_desc
},
3064 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_ATTRIBUTES
, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD
, spoolss_notify_attributes
},
3065 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_PRIORITY
, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD
, spoolss_notify_priority
},
3066 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY
, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD
, spoolss_notify_default_priority
},
3067 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_START_TIME
, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD
, spoolss_notify_start_time
},
3068 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_UNTIL_TIME
, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD
, spoolss_notify_until_time
},
3069 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_STATUS
, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD
, spoolss_notify_status
},
3070 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_STATUS_STRING
, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING
, NULL
},
3071 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_CJOBS
, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD
, spoolss_notify_cjobs
},
3072 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_AVERAGE_PPM
, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD
, spoolss_notify_average_ppm
},
3073 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_TOTAL_PAGES
, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD
, NULL
},
3074 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_PAGES_PRINTED
, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD
, NULL
},
3075 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_TOTAL_BYTES
, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD
, NULL
},
3076 { PRINTER_NOTIFY_TYPE
, PRINTER_NOTIFY_FIELD_BYTES_PRINTED
, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD
, NULL
},
3077 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_PRINTER_NAME
, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_printer_name
},
3078 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_MACHINE_NAME
, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_server_name
},
3079 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_PORT_NAME
, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_port_name
},
3080 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_USER_NAME
, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_username
},
3081 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_NOTIFY_NAME
, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_username
},
3082 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_DATATYPE
, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING
, spoolss_notify_datatype
},
3083 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_PRINT_PROCESSOR
, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING
, spoolss_notify_print_processor
},
3084 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_PARAMETERS
, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING
, spoolss_notify_parameters
},
3085 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_DRIVER_NAME
, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING
, spoolss_notify_driver_name
},
3086 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_DEVMODE
, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE
, spoolss_notify_devmode
},
3087 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_STATUS
, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD
, spoolss_notify_job_status
},
3088 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_STATUS_STRING
, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING
, spoolss_notify_job_status_string
},
3089 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR
, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR
, NULL
},
3090 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_DOCUMENT
, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING
, spoolss_notify_job_name
},
3091 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_PRIORITY
, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD
, spoolss_notify_priority
},
3092 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_POSITION
, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD
, spoolss_notify_job_position
},
3093 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_SUBMITTED
, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME
, spoolss_notify_submitted_time
},
3094 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_START_TIME
, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD
, spoolss_notify_start_time
},
3095 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_UNTIL_TIME
, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD
, spoolss_notify_until_time
},
3096 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_TIME
, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD
, spoolss_notify_job_time
},
3097 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_TOTAL_PAGES
, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD
, spoolss_notify_total_pages
},
3098 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_PAGES_PRINTED
, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD
, spoolss_notify_pages_printed
},
3099 { JOB_NOTIFY_TYPE
, JOB_NOTIFY_FIELD_TOTAL_BYTES
, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD
, spoolss_notify_job_size
},
3102 /*******************************************************************
3103 Return the variable_type of info_data structure.
3104 ********************************************************************/
3106 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type
,
3111 for (i
= 0; i
< ARRAY_SIZE(notify_info_data_table
); i
++) {
3112 if ( (notify_info_data_table
[i
].type
== type
) &&
3113 (notify_info_data_table
[i
].field
== field
) ) {
3114 return notify_info_data_table
[i
].variable_type
;
3118 DEBUG(5, ("invalid notify data type %d/%d\n", type
, field
));
3123 /****************************************************************************
3124 ****************************************************************************/
3126 static bool search_notify(enum spoolss_NotifyType type
,
3132 for (i
= 0; i
< ARRAY_SIZE(notify_info_data_table
); i
++) {
3133 if (notify_info_data_table
[i
].type
== type
&&
3134 notify_info_data_table
[i
].field
== field
&&
3135 notify_info_data_table
[i
].fn
!= NULL
) {
3144 /****************************************************************************
3145 ****************************************************************************/
3147 void construct_info_data(struct spoolss_Notify
*info_data
,
3148 enum spoolss_NotifyType type
,
3152 info_data
->type
= type
;
3153 info_data
->field
.field
= field
;
3154 info_data
->variable_type
= variable_type_of_notify_info_data(type
, field
);
3155 info_data
->job_id
= id
;
3158 /*******************************************************************
3160 * fill a notify_info struct with info asked
3162 ********************************************************************/
3164 static bool construct_notify_printer_info(Printer_entry
*print_hnd
,
3165 struct spoolss_NotifyInfo
*info
,
3167 const struct spoolss_NotifyOptionType
*option_type
,
3169 TALLOC_CTX
*mem_ctx
)
3172 enum spoolss_NotifyType type
;
3175 struct spoolss_Notify
*current_data
;
3176 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
3177 print_queue_struct
*queue
=NULL
;
3179 type
= option_type
->type
;
3181 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3182 (type
== PRINTER_NOTIFY_TYPE
? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3183 option_type
->count
, lp_servicename(snum
)));
3185 if (!W_ERROR_IS_OK(get_a_printer(print_hnd
, &printer
, 2, lp_const_servicename(snum
))))
3188 for(field_num
=0; field_num
< option_type
->count
; field_num
++) {
3189 field
= option_type
->fields
[field_num
].field
;
3191 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num
, type
, field
));
3193 if (!search_notify(type
, field
, &j
) )
3196 info
->notifies
= TALLOC_REALLOC_ARRAY(info
, info
->notifies
,
3197 struct spoolss_Notify
,
3199 if (info
->notifies
== NULL
) {
3200 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3201 free_a_printer(&printer
, 2);
3205 current_data
= &info
->notifies
[info
->count
];
3207 construct_info_data(current_data
, type
, field
, id
);
3209 DEBUG(10,("construct_notify_printer_info: calling [%s] snum=%d printername=[%s])\n",
3210 notify_info_data_table
[j
].name
, snum
, printer
->info_2
->printername
));
3212 notify_info_data_table
[j
].fn(snum
, current_data
, queue
,
3218 free_a_printer(&printer
, 2);
3222 /*******************************************************************
3224 * fill a notify_info struct with info asked
3226 ********************************************************************/
3228 static bool construct_notify_jobs_info(print_queue_struct
*queue
,
3229 struct spoolss_NotifyInfo
*info
,
3230 NT_PRINTER_INFO_LEVEL
*printer
,
3232 const struct spoolss_NotifyOptionType
*option_type
,
3234 TALLOC_CTX
*mem_ctx
)
3237 enum spoolss_NotifyType type
;
3239 struct spoolss_Notify
*current_data
;
3241 DEBUG(4,("construct_notify_jobs_info\n"));
3243 type
= option_type
->type
;
3245 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3246 (type
== PRINTER_NOTIFY_TYPE
? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3247 option_type
->count
));
3249 for(field_num
=0; field_num
<option_type
->count
; field_num
++) {
3250 field
= option_type
->fields
[field_num
].field
;
3252 if (!search_notify(type
, field
, &j
) )
3255 info
->notifies
= TALLOC_REALLOC_ARRAY(info
, info
->notifies
,
3256 struct spoolss_Notify
,
3258 if (info
->notifies
== NULL
) {
3259 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3263 current_data
=&(info
->notifies
[info
->count
]);
3265 construct_info_data(current_data
, type
, field
, id
);
3266 notify_info_data_table
[j
].fn(snum
, current_data
, queue
,
3275 * JFM: The enumeration is not that simple, it's even non obvious.
3277 * let's take an example: I want to monitor the PRINTER SERVER for
3278 * the printer's name and the number of jobs currently queued.
3279 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3280 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3282 * I have 3 printers on the back of my server.
3284 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3287 * 1 printer 1 name 1
3288 * 2 printer 1 cjob 1
3289 * 3 printer 2 name 2
3290 * 4 printer 2 cjob 2
3291 * 5 printer 3 name 3
3292 * 6 printer 3 name 3
3294 * that's the print server case, the printer case is even worse.
3297 /*******************************************************************
3299 * enumerate all printers on the printserver
3300 * fill a notify_info struct with info asked
3302 ********************************************************************/
3304 static WERROR
printserver_notify_info(pipes_struct
*p
,
3305 struct policy_handle
*hnd
,
3306 struct spoolss_NotifyInfo
*info
,
3307 TALLOC_CTX
*mem_ctx
)
3310 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, hnd
);
3311 int n_services
=lp_numservices();
3313 struct spoolss_NotifyOption
*option
;
3314 struct spoolss_NotifyOptionType option_type
;
3316 DEBUG(4,("printserver_notify_info\n"));
3321 option
= Printer
->notify
.option
;
3324 info
->notifies
= NULL
;
3327 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3328 sending a ffpcn() request first */
3333 for (i
=0; i
<option
->count
; i
++) {
3334 option_type
= option
->types
[i
];
3336 if (option_type
.type
!= PRINTER_NOTIFY_TYPE
)
3339 for (snum
=0; snum
<n_services
; snum
++)
3341 if ( lp_browseable(snum
) && lp_snum_ok(snum
) && lp_print_ok(snum
) )
3342 construct_notify_printer_info ( Printer
, info
, snum
, &option_type
, snum
, mem_ctx
);
3348 * Debugging information, don't delete.
3351 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3352 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info
->version
, info
->flags
, info
->count
));
3353 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3355 for (i
=0; i
<info
->count
; i
++) {
3356 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3357 i
, info
->data
[i
].type
, info
->data
[i
].field
, info
->data
[i
].reserved
,
3358 info
->data
[i
].id
, info
->data
[i
].size
, info
->data
[i
].enc_type
));
3365 /*******************************************************************
3367 * fill a notify_info struct with info asked
3369 ********************************************************************/
3371 static WERROR
printer_notify_info(pipes_struct
*p
, struct policy_handle
*hnd
,
3372 struct spoolss_NotifyInfo
*info
,
3373 TALLOC_CTX
*mem_ctx
)
3376 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, hnd
);
3379 struct spoolss_NotifyOption
*option
;
3380 struct spoolss_NotifyOptionType option_type
;
3382 print_queue_struct
*queue
=NULL
;
3383 print_status_struct status
;
3385 DEBUG(4,("printer_notify_info\n"));
3390 option
= Printer
->notify
.option
;
3394 info
->notifies
= NULL
;
3397 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3398 sending a ffpcn() request first */
3403 get_printer_snum(p
, hnd
, &snum
, NULL
);
3405 for (i
=0; i
<option
->count
; i
++) {
3406 option_type
= option
->types
[i
];
3408 switch (option_type
.type
) {
3409 case PRINTER_NOTIFY_TYPE
:
3410 if(construct_notify_printer_info(Printer
, info
, snum
,
3416 case JOB_NOTIFY_TYPE
: {
3417 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
3419 count
= print_queue_status(snum
, &queue
, &status
);
3421 if (!W_ERROR_IS_OK(get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
))))
3424 for (j
=0; j
<count
; j
++) {
3425 construct_notify_jobs_info(&queue
[j
], info
,
3432 free_a_printer(&printer
, 2);
3442 * Debugging information, don't delete.
3445 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3446 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3447 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3449 for (i=0; i<info->count; i++) {
3450 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3451 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3452 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3458 /****************************************************************
3459 _spoolss_RouterRefreshPrinterChangeNotify
3460 ****************************************************************/
3462 WERROR
_spoolss_RouterRefreshPrinterChangeNotify(pipes_struct
*p
,
3463 struct spoolss_RouterRefreshPrinterChangeNotify
*r
)
3465 struct spoolss_NotifyInfo
*info
;
3467 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
3468 WERROR result
= WERR_BADFID
;
3470 /* we always have a spoolss_NotifyInfo struct */
3471 info
= talloc_zero(p
->mem_ctx
, struct spoolss_NotifyInfo
);
3473 result
= WERR_NOMEM
;
3477 *r
->out
.info
= info
;
3480 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3481 "Invalid handle (%s:%u:%u).\n",
3482 OUR_HANDLE(r
->in
.handle
)));
3486 DEBUG(4,("Printer type %x\n",Printer
->printer_type
));
3489 * We are now using the change value, and
3490 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3491 * I don't have a global notification system, I'm sending back all the
3492 * informations even when _NOTHING_ has changed.
3495 /* We need to keep track of the change value to send back in
3496 RRPCN replies otherwise our updates are ignored. */
3498 Printer
->notify
.fnpcn
= true;
3500 if (Printer
->notify
.client_connected
) {
3501 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3502 "Saving change value in request [%x]\n",
3504 Printer
->notify
.change
= r
->in
.change_low
;
3507 /* just ignore the spoolss_NotifyOption */
3509 switch (Printer
->printer_type
) {
3511 result
= printserver_notify_info(p
, r
->in
.handle
,
3515 case SPLHND_PRINTER
:
3516 result
= printer_notify_info(p
, r
->in
.handle
,
3521 Printer
->notify
.fnpcn
= false;
3527 /********************************************************************
3528 * construct_printer_info_0
3529 * fill a printer_info_0 struct
3530 ********************************************************************/
3532 static WERROR
construct_printer_info0(TALLOC_CTX
*mem_ctx
,
3533 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3534 struct spoolss_PrinterInfo0
*r
,
3538 counter_printer_0
*session_counter
;
3540 print_status_struct status
;
3542 r
->printername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printername
);
3543 W_ERROR_HAVE_NO_MEMORY(r
->printername
);
3545 r
->servername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->servername
);
3546 W_ERROR_HAVE_NO_MEMORY(r
->servername
);
3548 count
= print_queue_length(snum
, &status
);
3550 /* check if we already have a counter for this printer */
3551 for (session_counter
= counter_list
; session_counter
; session_counter
= session_counter
->next
) {
3552 if (session_counter
->snum
== snum
)
3556 /* it's the first time, add it to the list */
3557 if (session_counter
== NULL
) {
3558 session_counter
= SMB_MALLOC_P(counter_printer_0
);
3559 W_ERROR_HAVE_NO_MEMORY(session_counter
);
3560 ZERO_STRUCTP(session_counter
);
3561 session_counter
->snum
= snum
;
3562 session_counter
->counter
= 0;
3563 DLIST_ADD(counter_list
, session_counter
);
3567 session_counter
->counter
++;
3573 setuptime
= (time_t)ntprinter
->info_2
->setuptime
;
3575 init_systemtime(&r
->time
, gmtime(&setuptime
));
3578 * the global_counter should be stored in a TDB as it's common to all the clients
3579 * and should be zeroed on samba startup
3581 r
->global_counter
= session_counter
->counter
;
3583 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3584 r
->version
= 0x0005; /* NT 5 */
3585 r
->free_build
= 0x0893; /* build 2195 */
3587 r
->max_spooling
= 0;
3588 r
->session_counter
= session_counter
->counter
;
3589 r
->num_error_out_of_paper
= 0x0;
3590 r
->num_error_not_ready
= 0x0; /* number of print failure */
3592 r
->number_of_processors
= 0x1;
3593 r
->processor_type
= PROCESSOR_INTEL_PENTIUM
; /* 586 Pentium ? */
3594 r
->high_part_total_bytes
= 0x0;
3595 r
->change_id
= ntprinter
->info_2
->changeid
; /* ChangeID in milliseconds*/
3596 r
->last_error
= WERR_OK
;
3597 r
->status
= nt_printq_status(status
.status
);
3598 r
->enumerate_network_printers
= 0x0;
3599 r
->c_setprinter
= get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3600 r
->processor_architecture
= 0x0;
3601 r
->processor_level
= 0x6; /* 6 ???*/
3609 /****************************************************************************
3610 Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure. Both pointers
3611 should be valid upon entry
3612 ****************************************************************************/
3614 static WERROR
convert_nt_devicemode(TALLOC_CTX
*mem_ctx
,
3615 struct spoolss_DeviceMode
*r
,
3616 const NT_DEVICEMODE
*ntdevmode
)
3618 if (!r
|| !ntdevmode
) {
3619 return WERR_INVALID_PARAM
;
3622 r
->devicename
= talloc_strdup(mem_ctx
, ntdevmode
->devicename
);
3623 W_ERROR_HAVE_NO_MEMORY(r
->devicename
);
3625 r
->specversion
= ntdevmode
->specversion
;
3626 r
->driverversion
= ntdevmode
->driverversion
;
3627 r
->size
= ntdevmode
->size
;
3628 r
->__driverextra_length
= ntdevmode
->driverextra
;
3629 r
->fields
= ntdevmode
->fields
;
3631 r
->orientation
= ntdevmode
->orientation
;
3632 r
->papersize
= ntdevmode
->papersize
;
3633 r
->paperlength
= ntdevmode
->paperlength
;
3634 r
->paperwidth
= ntdevmode
->paperwidth
;
3635 r
->scale
= ntdevmode
->scale
;
3636 r
->copies
= ntdevmode
->copies
;
3637 r
->defaultsource
= ntdevmode
->defaultsource
;
3638 r
->printquality
= ntdevmode
->printquality
;
3639 r
->color
= ntdevmode
->color
;
3640 r
->duplex
= ntdevmode
->duplex
;
3641 r
->yresolution
= ntdevmode
->yresolution
;
3642 r
->ttoption
= ntdevmode
->ttoption
;
3643 r
->collate
= ntdevmode
->collate
;
3645 r
->formname
= talloc_strdup(mem_ctx
, ntdevmode
->formname
);
3646 W_ERROR_HAVE_NO_MEMORY(r
->formname
);
3648 /* all 0 below are values that have not been set in the old parsing/copy
3649 * function, maybe they should... - gd */
3655 r
->displayflags
= 0;
3656 r
->displayfrequency
= 0;
3657 r
->icmmethod
= ntdevmode
->icmmethod
;
3658 r
->icmintent
= ntdevmode
->icmintent
;
3659 r
->mediatype
= ntdevmode
->mediatype
;
3660 r
->dithertype
= ntdevmode
->dithertype
;
3663 r
->panningwidth
= 0;
3664 r
->panningheight
= 0;
3666 if (ntdevmode
->nt_dev_private
!= NULL
) {
3667 r
->driverextra_data
= data_blob_talloc(mem_ctx
,
3668 ntdevmode
->nt_dev_private
,
3669 ntdevmode
->driverextra
);
3670 W_ERROR_HAVE_NO_MEMORY(r
->driverextra_data
.data
);
3677 /****************************************************************************
3678 Create a spoolss_DeviceMode struct. Returns talloced memory.
3679 ****************************************************************************/
3681 struct spoolss_DeviceMode
*construct_dev_mode(TALLOC_CTX
*mem_ctx
,
3682 const char *servicename
)
3685 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
3686 struct spoolss_DeviceMode
*devmode
= NULL
;
3688 DEBUG(7,("construct_dev_mode\n"));
3690 DEBUGADD(8,("getting printer characteristics\n"));
3692 if (!W_ERROR_IS_OK(get_a_printer(NULL
, &printer
, 2, servicename
)))
3695 if (!printer
->info_2
->devmode
) {
3696 DEBUG(5, ("BONG! There was no device mode!\n"));
3700 devmode
= TALLOC_ZERO_P(mem_ctx
, struct spoolss_DeviceMode
);
3702 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3706 DEBUGADD(8,("loading DEVICEMODE\n"));
3708 result
= convert_nt_devicemode(mem_ctx
, devmode
, printer
->info_2
->devmode
);
3709 if (!W_ERROR_IS_OK(result
)) {
3710 TALLOC_FREE(devmode
);
3714 free_a_printer(&printer
,2);
3719 /********************************************************************
3720 * construct_printer_info1
3721 * fill a spoolss_PrinterInfo1 struct
3722 ********************************************************************/
3724 static WERROR
construct_printer_info1(TALLOC_CTX
*mem_ctx
,
3725 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3727 struct spoolss_PrinterInfo1
*r
,
3732 r
->description
= talloc_asprintf(mem_ctx
, "%s,%s,%s",
3733 ntprinter
->info_2
->printername
,
3734 ntprinter
->info_2
->drivername
,
3735 ntprinter
->info_2
->location
);
3736 W_ERROR_HAVE_NO_MEMORY(r
->description
);
3738 if (*ntprinter
->info_2
->comment
== '\0') {
3739 r
->comment
= talloc_strdup(mem_ctx
, lp_comment(snum
));
3741 r
->comment
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->comment
); /* saved comment */
3743 W_ERROR_HAVE_NO_MEMORY(r
->comment
);
3745 r
->name
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printername
);
3746 W_ERROR_HAVE_NO_MEMORY(r
->name
);
3751 /********************************************************************
3752 * construct_printer_info2
3753 * fill a spoolss_PrinterInfo2 struct
3754 ********************************************************************/
3756 static WERROR
construct_printer_info2(TALLOC_CTX
*mem_ctx
,
3757 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3758 struct spoolss_PrinterInfo2
*r
,
3763 print_status_struct status
;
3765 count
= print_queue_length(snum
, &status
);
3767 r
->servername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->servername
);
3768 W_ERROR_HAVE_NO_MEMORY(r
->servername
);
3769 r
->printername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printername
);
3770 W_ERROR_HAVE_NO_MEMORY(r
->printername
);
3771 r
->sharename
= talloc_strdup(mem_ctx
, lp_servicename(snum
));
3772 W_ERROR_HAVE_NO_MEMORY(r
->sharename
);
3773 r
->portname
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->portname
);
3774 W_ERROR_HAVE_NO_MEMORY(r
->portname
);
3775 r
->drivername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->drivername
);
3776 W_ERROR_HAVE_NO_MEMORY(r
->drivername
);
3778 if (*ntprinter
->info_2
->comment
== '\0') {
3779 r
->comment
= talloc_strdup(mem_ctx
, lp_comment(snum
));
3781 r
->comment
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->comment
);
3783 W_ERROR_HAVE_NO_MEMORY(r
->comment
);
3785 r
->location
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->location
);
3786 W_ERROR_HAVE_NO_MEMORY(r
->location
);
3787 r
->sepfile
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->sepfile
);
3788 W_ERROR_HAVE_NO_MEMORY(r
->sepfile
);
3789 r
->printprocessor
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printprocessor
);
3790 W_ERROR_HAVE_NO_MEMORY(r
->printprocessor
);
3791 r
->datatype
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->datatype
);
3792 W_ERROR_HAVE_NO_MEMORY(r
->datatype
);
3793 r
->parameters
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->parameters
);
3794 W_ERROR_HAVE_NO_MEMORY(r
->parameters
);
3796 r
->attributes
= ntprinter
->info_2
->attributes
;
3798 r
->priority
= ntprinter
->info_2
->priority
;
3799 r
->defaultpriority
= ntprinter
->info_2
->default_priority
;
3800 r
->starttime
= ntprinter
->info_2
->starttime
;
3801 r
->untiltime
= ntprinter
->info_2
->untiltime
;
3802 r
->status
= nt_printq_status(status
.status
);
3804 r
->averageppm
= ntprinter
->info_2
->averageppm
;
3806 r
->devmode
= construct_dev_mode(mem_ctx
, lp_const_servicename(snum
));
3808 DEBUG(8,("Returning NULL Devicemode!\n"));
3813 if (ntprinter
->info_2
->secdesc_buf
&& ntprinter
->info_2
->secdesc_buf
->sd_size
!= 0) {
3814 /* don't use talloc_steal() here unless you do a deep steal of all
3815 the SEC_DESC members */
3817 r
->secdesc
= dup_sec_desc(mem_ctx
, ntprinter
->info_2
->secdesc_buf
->sd
);
3823 /********************************************************************
3824 * construct_printer_info3
3825 * fill a spoolss_PrinterInfo3 struct
3826 ********************************************************************/
3828 static WERROR
construct_printer_info3(TALLOC_CTX
*mem_ctx
,
3829 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3830 struct spoolss_PrinterInfo3
*r
,
3833 /* These are the components of the SD we are returning. */
3835 if (ntprinter
->info_2
->secdesc_buf
&& ntprinter
->info_2
->secdesc_buf
->sd_size
!= 0) {
3836 /* don't use talloc_steal() here unless you do a deep steal of all
3837 the SEC_DESC members */
3839 r
->secdesc
= dup_sec_desc(mem_ctx
,
3840 ntprinter
->info_2
->secdesc_buf
->sd
);
3841 W_ERROR_HAVE_NO_MEMORY(r
->secdesc
);
3847 /********************************************************************
3848 * construct_printer_info4
3849 * fill a spoolss_PrinterInfo4 struct
3850 ********************************************************************/
3852 static WERROR
construct_printer_info4(TALLOC_CTX
*mem_ctx
,
3853 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3854 struct spoolss_PrinterInfo4
*r
,
3857 r
->printername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printername
);
3858 W_ERROR_HAVE_NO_MEMORY(r
->printername
);
3859 r
->servername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->servername
);
3860 W_ERROR_HAVE_NO_MEMORY(r
->servername
);
3862 r
->attributes
= ntprinter
->info_2
->attributes
;
3867 /********************************************************************
3868 * construct_printer_info5
3869 * fill a spoolss_PrinterInfo5 struct
3870 ********************************************************************/
3872 static WERROR
construct_printer_info5(TALLOC_CTX
*mem_ctx
,
3873 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3874 struct spoolss_PrinterInfo5
*r
,
3877 r
->printername
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->printername
);
3878 W_ERROR_HAVE_NO_MEMORY(r
->printername
);
3879 r
->portname
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->portname
);
3880 W_ERROR_HAVE_NO_MEMORY(r
->portname
);
3882 r
->attributes
= ntprinter
->info_2
->attributes
;
3884 /* these two are not used by NT+ according to MSDN */
3886 r
->device_not_selected_timeout
= 0x0; /* have seen 0x3a98 */
3887 r
->transmission_retry_timeout
= 0x0; /* have seen 0xafc8 */
3892 /********************************************************************
3893 * construct_printer_info_6
3894 * fill a spoolss_PrinterInfo6 struct
3895 ********************************************************************/
3897 static WERROR
construct_printer_info6(TALLOC_CTX
*mem_ctx
,
3898 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3899 struct spoolss_PrinterInfo6
*r
,
3903 print_status_struct status
;
3905 count
= print_queue_length(snum
, &status
);
3907 r
->status
= nt_printq_status(status
.status
);
3912 /********************************************************************
3913 * construct_printer_info7
3914 * fill a spoolss_PrinterInfo7 struct
3915 ********************************************************************/
3917 static WERROR
construct_printer_info7(TALLOC_CTX
*mem_ctx
,
3918 Printer_entry
*print_hnd
,
3919 struct spoolss_PrinterInfo7
*r
,
3924 if (is_printer_published(print_hnd
, snum
, &guid
)) {
3925 r
->guid
= talloc_strdup_upper(mem_ctx
, GUID_string2(mem_ctx
, &guid
));
3926 r
->action
= DSPRINT_PUBLISH
;
3928 r
->guid
= talloc_strdup(mem_ctx
, "");
3929 r
->action
= DSPRINT_UNPUBLISH
;
3931 W_ERROR_HAVE_NO_MEMORY(r
->guid
);
3936 /********************************************************************
3937 * construct_printer_info8
3938 * fill a spoolss_PrinterInfo8 struct
3939 ********************************************************************/
3941 static WERROR
construct_printer_info8(TALLOC_CTX
*mem_ctx
,
3942 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
3943 struct spoolss_DeviceModeInfo
*r
,
3946 struct spoolss_DeviceMode
*devmode
;
3949 if (!ntprinter
->info_2
->devmode
) {
3954 devmode
= TALLOC_ZERO_P(mem_ctx
, struct spoolss_DeviceMode
);
3955 W_ERROR_HAVE_NO_MEMORY(devmode
);
3957 result
= convert_nt_devicemode(mem_ctx
, devmode
, ntprinter
->info_2
->devmode
);
3958 if (!W_ERROR_IS_OK(result
)) {
3959 TALLOC_FREE(devmode
);
3963 r
->devmode
= devmode
;
3969 /********************************************************************
3970 ********************************************************************/
3972 static bool snum_is_shared_printer(int snum
)
3974 return (lp_browseable(snum
) && lp_snum_ok(snum
) && lp_print_ok(snum
));
3977 /********************************************************************
3978 Spoolss_enumprinters.
3979 ********************************************************************/
3981 static WERROR
enum_all_printers_info_level(TALLOC_CTX
*mem_ctx
,
3984 union spoolss_PrinterInfo
**info_p
,
3988 int n_services
= lp_numservices();
3989 union spoolss_PrinterInfo
*info
= NULL
;
3991 WERROR result
= WERR_OK
;
3996 for (snum
= 0; snum
< n_services
; snum
++) {
3998 NT_PRINTER_INFO_LEVEL
*ntprinter
= NULL
;
4000 if (!snum_is_shared_printer(snum
)) {
4004 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4005 lp_servicename(snum
), snum
));
4007 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4008 union spoolss_PrinterInfo
,
4011 result
= WERR_NOMEM
;
4015 result
= get_a_printer(NULL
, &ntprinter
, 2,
4016 lp_const_servicename(snum
));
4017 if (!W_ERROR_IS_OK(result
)) {
4023 result
= construct_printer_info0(info
, ntprinter
,
4024 &info
[count
].info0
, snum
);
4027 result
= construct_printer_info1(info
, ntprinter
, flags
,
4028 &info
[count
].info1
, snum
);
4031 result
= construct_printer_info2(info
, ntprinter
,
4032 &info
[count
].info2
, snum
);
4035 result
= construct_printer_info4(info
, ntprinter
,
4036 &info
[count
].info4
, snum
);
4039 result
= construct_printer_info5(info
, ntprinter
,
4040 &info
[count
].info5
, snum
);
4044 result
= WERR_UNKNOWN_LEVEL
;
4045 free_a_printer(&ntprinter
, 2);
4049 free_a_printer(&ntprinter
, 2);
4050 if (!W_ERROR_IS_OK(result
)) {
4061 if (!W_ERROR_IS_OK(result
)) {
4071 /********************************************************************
4072 * handle enumeration of printers at level 0
4073 ********************************************************************/
4075 static WERROR
enumprinters_level0(TALLOC_CTX
*mem_ctx
,
4077 const char *servername
,
4078 union spoolss_PrinterInfo
**info
,
4081 DEBUG(4,("enum_all_printers_info_0\n"));
4083 return enum_all_printers_info_level(mem_ctx
, 0, flags
, info
, count
);
4087 /********************************************************************
4088 ********************************************************************/
4090 static WERROR
enum_all_printers_info_1(TALLOC_CTX
*mem_ctx
,
4092 union spoolss_PrinterInfo
**info
,
4095 DEBUG(4,("enum_all_printers_info_1\n"));
4097 return enum_all_printers_info_level(mem_ctx
, 1, flags
, info
, count
);
4100 /********************************************************************
4101 enum_all_printers_info_1_local.
4102 *********************************************************************/
4104 static WERROR
enum_all_printers_info_1_local(TALLOC_CTX
*mem_ctx
,
4105 union spoolss_PrinterInfo
**info
,
4108 DEBUG(4,("enum_all_printers_info_1_local\n"));
4110 return enum_all_printers_info_1(mem_ctx
, PRINTER_ENUM_ICON8
, info
, count
);
4113 /********************************************************************
4114 enum_all_printers_info_1_name.
4115 *********************************************************************/
4117 static WERROR
enum_all_printers_info_1_name(TALLOC_CTX
*mem_ctx
,
4119 union spoolss_PrinterInfo
**info
,
4122 const char *s
= name
;
4124 DEBUG(4,("enum_all_printers_info_1_name\n"));
4126 if ((name
[0] == '\\') && (name
[1] == '\\')) {
4130 if (!is_myname_or_ipaddr(s
)) {
4131 return WERR_INVALID_NAME
;
4134 return enum_all_printers_info_1(mem_ctx
, PRINTER_ENUM_ICON8
, info
, count
);
4137 /********************************************************************
4138 enum_all_printers_info_1_network.
4139 *********************************************************************/
4141 static WERROR
enum_all_printers_info_1_network(TALLOC_CTX
*mem_ctx
,
4143 union spoolss_PrinterInfo
**info
,
4146 const char *s
= name
;
4148 DEBUG(4,("enum_all_printers_info_1_network\n"));
4150 /* If we respond to a enum_printers level 1 on our name with flags
4151 set to PRINTER_ENUM_REMOTE with a list of printers then these
4152 printers incorrectly appear in the APW browse list.
4153 Specifically the printers for the server appear at the workgroup
4154 level where all the other servers in the domain are
4155 listed. Windows responds to this call with a
4156 WERR_CAN_NOT_COMPLETE so we should do the same. */
4158 if (name
[0] == '\\' && name
[1] == '\\') {
4162 if (is_myname_or_ipaddr(s
)) {
4163 return WERR_CAN_NOT_COMPLETE
;
4166 return enum_all_printers_info_1(mem_ctx
, PRINTER_ENUM_NAME
, info
, count
);
4169 /********************************************************************
4170 * api_spoolss_enumprinters
4172 * called from api_spoolss_enumprinters (see this to understand)
4173 ********************************************************************/
4175 static WERROR
enum_all_printers_info_2(TALLOC_CTX
*mem_ctx
,
4176 union spoolss_PrinterInfo
**info
,
4179 DEBUG(4,("enum_all_printers_info_2\n"));
4181 return enum_all_printers_info_level(mem_ctx
, 2, 0, info
, count
);
4184 /********************************************************************
4185 * handle enumeration of printers at level 1
4186 ********************************************************************/
4188 static WERROR
enumprinters_level1(TALLOC_CTX
*mem_ctx
,
4191 union spoolss_PrinterInfo
**info
,
4194 /* Not all the flags are equals */
4196 if (flags
& PRINTER_ENUM_LOCAL
) {
4197 return enum_all_printers_info_1_local(mem_ctx
, info
, count
);
4200 if (flags
& PRINTER_ENUM_NAME
) {
4201 return enum_all_printers_info_1_name(mem_ctx
, name
, info
, count
);
4204 if (flags
& PRINTER_ENUM_NETWORK
) {
4205 return enum_all_printers_info_1_network(mem_ctx
, name
, info
, count
);
4208 return WERR_OK
; /* NT4sp5 does that */
4211 /********************************************************************
4212 * handle enumeration of printers at level 2
4213 ********************************************************************/
4215 static WERROR
enumprinters_level2(TALLOC_CTX
*mem_ctx
,
4217 const char *servername
,
4218 union spoolss_PrinterInfo
**info
,
4221 if (flags
& PRINTER_ENUM_LOCAL
) {
4222 return enum_all_printers_info_2(mem_ctx
, info
, count
);
4225 if (flags
& PRINTER_ENUM_NAME
) {
4226 if (!is_myname_or_ipaddr(canon_servername(servername
))) {
4227 return WERR_INVALID_NAME
;
4230 return enum_all_printers_info_2(mem_ctx
, info
, count
);
4233 if (flags
& PRINTER_ENUM_REMOTE
) {
4234 return WERR_UNKNOWN_LEVEL
;
4240 /********************************************************************
4241 * handle enumeration of printers at level 4
4242 ********************************************************************/
4244 static WERROR
enumprinters_level4(TALLOC_CTX
*mem_ctx
,
4246 const char *servername
,
4247 union spoolss_PrinterInfo
**info
,
4250 DEBUG(4,("enum_all_printers_info_4\n"));
4252 return enum_all_printers_info_level(mem_ctx
, 4, flags
, info
, count
);
4256 /********************************************************************
4257 * handle enumeration of printers at level 5
4258 ********************************************************************/
4260 static WERROR
enumprinters_level5(TALLOC_CTX
*mem_ctx
,
4262 const char *servername
,
4263 union spoolss_PrinterInfo
**info
,
4266 DEBUG(4,("enum_all_printers_info_5\n"));
4268 return enum_all_printers_info_level(mem_ctx
, 5, flags
, info
, count
);
4271 /****************************************************************
4272 _spoolss_EnumPrinters
4273 ****************************************************************/
4275 WERROR
_spoolss_EnumPrinters(pipes_struct
*p
,
4276 struct spoolss_EnumPrinters
*r
)
4281 /* that's an [in out] buffer */
4283 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
4284 return WERR_INVALID_PARAM
;
4287 DEBUG(4,("_spoolss_EnumPrinters\n"));
4291 *r
->out
.info
= NULL
;
4295 * flags==PRINTER_ENUM_NAME
4296 * if name=="" then enumerates all printers
4297 * if name!="" then enumerate the printer
4298 * flags==PRINTER_ENUM_REMOTE
4299 * name is NULL, enumerate printers
4300 * Level 2: name!="" enumerates printers, name can't be NULL
4301 * Level 3: doesn't exist
4302 * Level 4: does a local registry lookup
4303 * Level 5: same as Level 2
4306 name
= talloc_strdup_upper(p
->mem_ctx
, r
->in
.server
);
4307 W_ERROR_HAVE_NO_MEMORY(name
);
4309 switch (r
->in
.level
) {
4311 result
= enumprinters_level0(p
->mem_ctx
, r
->in
.flags
, name
,
4312 r
->out
.info
, r
->out
.count
);
4315 result
= enumprinters_level1(p
->mem_ctx
, r
->in
.flags
, name
,
4316 r
->out
.info
, r
->out
.count
);
4319 result
= enumprinters_level2(p
->mem_ctx
, r
->in
.flags
, name
,
4320 r
->out
.info
, r
->out
.count
);
4323 result
= enumprinters_level4(p
->mem_ctx
, r
->in
.flags
, name
,
4324 r
->out
.info
, r
->out
.count
);
4327 result
= enumprinters_level5(p
->mem_ctx
, r
->in
.flags
, name
,
4328 r
->out
.info
, r
->out
.count
);
4331 return WERR_UNKNOWN_LEVEL
;
4334 if (!W_ERROR_IS_OK(result
)) {
4338 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
4339 spoolss_EnumPrinters
, NULL
,
4340 *r
->out
.info
, r
->in
.level
,
4342 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
4343 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
4345 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
4348 /****************************************************************
4350 ****************************************************************/
4352 WERROR
_spoolss_GetPrinter(pipes_struct
*p
,
4353 struct spoolss_GetPrinter
*r
)
4355 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
4356 NT_PRINTER_INFO_LEVEL
*ntprinter
= NULL
;
4357 WERROR result
= WERR_OK
;
4361 /* that's an [in out] buffer */
4363 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
4364 return WERR_INVALID_PARAM
;
4369 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
4373 result
= get_a_printer(Printer
, &ntprinter
, 2,
4374 lp_const_servicename(snum
));
4375 if (!W_ERROR_IS_OK(result
)) {
4379 switch (r
->in
.level
) {
4381 result
= construct_printer_info0(p
->mem_ctx
, ntprinter
,
4382 &r
->out
.info
->info0
, snum
);
4385 result
= construct_printer_info1(p
->mem_ctx
, ntprinter
,
4387 &r
->out
.info
->info1
, snum
);
4390 result
= construct_printer_info2(p
->mem_ctx
, ntprinter
,
4391 &r
->out
.info
->info2
, snum
);
4394 result
= construct_printer_info3(p
->mem_ctx
, ntprinter
,
4395 &r
->out
.info
->info3
, snum
);
4398 result
= construct_printer_info4(p
->mem_ctx
, ntprinter
,
4399 &r
->out
.info
->info4
, snum
);
4402 result
= construct_printer_info5(p
->mem_ctx
, ntprinter
,
4403 &r
->out
.info
->info5
, snum
);
4406 result
= construct_printer_info6(p
->mem_ctx
, ntprinter
,
4407 &r
->out
.info
->info6
, snum
);
4410 result
= construct_printer_info7(p
->mem_ctx
, Printer
,
4411 &r
->out
.info
->info7
, snum
);
4414 result
= construct_printer_info8(p
->mem_ctx
, ntprinter
,
4415 &r
->out
.info
->info8
, snum
);
4418 result
= WERR_UNKNOWN_LEVEL
;
4422 free_a_printer(&ntprinter
, 2);
4424 if (!W_ERROR_IS_OK(result
)) {
4425 TALLOC_FREE(r
->out
.info
);
4429 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo
, NULL
,
4430 r
->out
.info
, r
->in
.level
);
4431 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
4433 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
4436 /********************************************************************
4437 ********************************************************************/
4439 static const char **string_array_from_driver_info(TALLOC_CTX
*mem_ctx
,
4440 const char **string_array
,
4441 const char *cservername
)
4443 int i
, num_strings
= 0;
4444 const char **array
= NULL
;
4446 if (!string_array
) {
4450 for (i
=0; string_array
[i
] && string_array
[i
][0] != '\0'; i
++) {
4452 const char *str
= talloc_asprintf(mem_ctx
, "\\\\%s%s",
4453 cservername
, string_array
[i
]);
4460 if (!add_string_to_array(mem_ctx
, str
, &array
, &num_strings
)) {
4467 ADD_TO_ARRAY(mem_ctx
, const char *, NULL
,
4468 &array
, &num_strings
);
4474 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4476 if (in && strlen(in)) { \
4477 out = talloc_strdup(mem_ctx, in); \
4478 W_ERROR_HAVE_NO_MEMORY(out); \
4484 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, in, out) \
4486 if (in && strlen(in)) { \
4487 out = talloc_asprintf(mem_ctx, "\\\\%s%s", server, in); \
4489 out = talloc_strdup(mem_ctx, ""); \
4491 W_ERROR_HAVE_NO_MEMORY(out); \
4494 /********************************************************************
4495 * fill a spoolss_DriverInfo1 struct
4496 ********************************************************************/
4498 static WERROR
fill_printer_driver_info1(TALLOC_CTX
*mem_ctx
,
4499 struct spoolss_DriverInfo1
*r
,
4500 const struct spoolss_DriverInfo8
*driver
,
4501 const char *servername
)
4503 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4504 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4509 /********************************************************************
4510 * fill a spoolss_DriverInfo2 struct
4511 ********************************************************************/
4513 static WERROR
fill_printer_driver_info2(TALLOC_CTX
*mem_ctx
,
4514 struct spoolss_DriverInfo2
*r
,
4515 const struct spoolss_DriverInfo8
*driver
,
4516 const char *servername
)
4519 const char *cservername
= canon_servername(servername
);
4521 r
->version
= driver
->version
;
4523 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4524 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4525 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4526 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4528 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4529 driver
->driver_path
,
4532 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4536 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4537 driver
->config_file
,
4543 /********************************************************************
4544 * fill a spoolss_DriverInfo3 struct
4545 ********************************************************************/
4547 static WERROR
fill_printer_driver_info3(TALLOC_CTX
*mem_ctx
,
4548 struct spoolss_DriverInfo3
*r
,
4549 const struct spoolss_DriverInfo8
*driver
,
4550 const char *servername
)
4552 const char *cservername
= canon_servername(servername
);
4554 r
->version
= driver
->version
;
4556 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4557 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4558 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4559 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4561 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4562 driver
->driver_path
,
4565 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4569 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4570 driver
->config_file
,
4573 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4577 FILL_DRIVER_STRING(mem_ctx
,
4578 driver
->monitor_name
,
4581 FILL_DRIVER_STRING(mem_ctx
,
4582 driver
->default_datatype
,
4583 r
->default_datatype
);
4585 r
->dependent_files
= string_array_from_driver_info(mem_ctx
,
4586 driver
->dependent_files
,
4591 /********************************************************************
4592 * fill a spoolss_DriverInfo4 struct
4593 ********************************************************************/
4595 static WERROR
fill_printer_driver_info4(TALLOC_CTX
*mem_ctx
,
4596 struct spoolss_DriverInfo4
*r
,
4597 const struct spoolss_DriverInfo8
*driver
,
4598 const char *servername
)
4600 const char *cservername
= canon_servername(servername
);
4602 r
->version
= driver
->version
;
4604 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4605 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4606 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4607 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4609 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4610 driver
->driver_path
,
4613 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4617 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4618 driver
->config_file
,
4621 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4625 r
->dependent_files
= string_array_from_driver_info(mem_ctx
,
4626 driver
->dependent_files
,
4629 FILL_DRIVER_STRING(mem_ctx
,
4630 driver
->monitor_name
,
4633 FILL_DRIVER_STRING(mem_ctx
,
4634 driver
->default_datatype
,
4635 r
->default_datatype
);
4637 r
->previous_names
= string_array_from_driver_info(mem_ctx
,
4638 driver
->previous_names
,
4644 /********************************************************************
4645 * fill a spoolss_DriverInfo5 struct
4646 ********************************************************************/
4648 static WERROR
fill_printer_driver_info5(TALLOC_CTX
*mem_ctx
,
4649 struct spoolss_DriverInfo5
*r
,
4650 const struct spoolss_DriverInfo8
*driver
,
4651 const char *servername
)
4653 const char *cservername
= canon_servername(servername
);
4655 r
->version
= driver
->version
;
4657 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4658 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4659 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4660 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4662 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4663 driver
->driver_path
,
4666 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4670 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4671 driver
->config_file
,
4674 r
->driver_attributes
= 0;
4675 r
->config_version
= 0;
4676 r
->driver_version
= 0;
4680 /********************************************************************
4681 * fill a spoolss_DriverInfo6 struct
4682 ********************************************************************/
4684 static WERROR
fill_printer_driver_info6(TALLOC_CTX
*mem_ctx
,
4685 struct spoolss_DriverInfo6
*r
,
4686 const struct spoolss_DriverInfo8
*driver
,
4687 const char *servername
)
4689 const char *cservername
= canon_servername(servername
);
4691 r
->version
= driver
->version
;
4693 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4694 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4695 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4696 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4698 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4699 driver
->driver_path
,
4702 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4706 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4707 driver
->config_file
,
4710 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4714 FILL_DRIVER_STRING(mem_ctx
,
4715 driver
->monitor_name
,
4718 FILL_DRIVER_STRING(mem_ctx
,
4719 driver
->default_datatype
,
4720 r
->default_datatype
);
4722 r
->dependent_files
= string_array_from_driver_info(mem_ctx
,
4723 driver
->dependent_files
,
4725 r
->previous_names
= string_array_from_driver_info(mem_ctx
,
4726 driver
->previous_names
,
4729 r
->driver_date
= driver
->driver_date
;
4730 r
->driver_version
= driver
->driver_version
;
4732 FILL_DRIVER_STRING(mem_ctx
,
4733 driver
->manufacturer_name
,
4734 r
->manufacturer_name
);
4735 FILL_DRIVER_STRING(mem_ctx
,
4736 driver
->manufacturer_url
,
4737 r
->manufacturer_url
);
4738 FILL_DRIVER_STRING(mem_ctx
,
4739 driver
->hardware_id
,
4741 FILL_DRIVER_STRING(mem_ctx
,
4748 /********************************************************************
4749 * fill a spoolss_DriverInfo8 struct
4750 ********************************************************************/
4752 static WERROR
fill_printer_driver_info8(TALLOC_CTX
*mem_ctx
,
4753 struct spoolss_DriverInfo8
*r
,
4754 const struct spoolss_DriverInfo8
*driver
,
4755 const char *servername
)
4757 const char *cservername
= canon_servername(servername
);
4759 r
->version
= driver
->version
;
4761 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4762 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4763 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4764 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4766 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4767 driver
->driver_path
,
4770 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4774 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4775 driver
->config_file
,
4778 FILL_DRIVER_UNC_STRING(mem_ctx
, cservername
,
4782 FILL_DRIVER_STRING(mem_ctx
,
4783 driver
->monitor_name
,
4786 FILL_DRIVER_STRING(mem_ctx
,
4787 driver
->default_datatype
,
4788 r
->default_datatype
);
4790 r
->dependent_files
= string_array_from_driver_info(mem_ctx
,
4791 driver
->dependent_files
,
4793 r
->previous_names
= string_array_from_driver_info(mem_ctx
,
4794 driver
->previous_names
,
4797 r
->driver_date
= driver
->driver_date
;
4798 r
->driver_version
= driver
->driver_version
;
4800 FILL_DRIVER_STRING(mem_ctx
,
4801 driver
->manufacturer_name
,
4802 r
->manufacturer_name
);
4803 FILL_DRIVER_STRING(mem_ctx
,
4804 driver
->manufacturer_url
,
4805 r
->manufacturer_url
);
4806 FILL_DRIVER_STRING(mem_ctx
,
4807 driver
->hardware_id
,
4809 FILL_DRIVER_STRING(mem_ctx
,
4813 FILL_DRIVER_STRING(mem_ctx
,
4814 driver
->print_processor
,
4815 r
->print_processor
);
4816 FILL_DRIVER_STRING(mem_ctx
,
4817 driver
->vendor_setup
,
4820 r
->color_profiles
= string_array_from_driver_info(mem_ctx
,
4821 driver
->color_profiles
,
4824 FILL_DRIVER_STRING(mem_ctx
,
4828 r
->printer_driver_attributes
= driver
->printer_driver_attributes
;
4830 r
->core_driver_dependencies
= string_array_from_driver_info(mem_ctx
,
4831 driver
->core_driver_dependencies
,
4834 r
->min_inbox_driver_ver_date
= driver
->min_inbox_driver_ver_date
;
4835 r
->min_inbox_driver_ver_version
= driver
->min_inbox_driver_ver_version
;
4840 #if 0 /* disabled until marshalling issues are resolved - gd */
4841 /********************************************************************
4842 ********************************************************************/
4844 static WERROR
fill_spoolss_DriverFileInfo(TALLOC_CTX
*mem_ctx
,
4845 struct spoolss_DriverFileInfo
*r
,
4846 const char *cservername
,
4847 const char *file_name
,
4848 enum spoolss_DriverFileType file_type
,
4849 uint32_t file_version
)
4851 r
->file_name
= talloc_asprintf(mem_ctx
, "\\\\%s%s",
4852 cservername
, file_name
);
4853 W_ERROR_HAVE_NO_MEMORY(r
->file_name
);
4854 r
->file_type
= file_type
;
4855 r
->file_version
= file_version
;
4860 /********************************************************************
4861 ********************************************************************/
4863 static WERROR
spoolss_DriverFileInfo_from_driver(TALLOC_CTX
*mem_ctx
,
4864 const struct spoolss_DriverInfo8
*driver
,
4865 const char *cservername
,
4866 struct spoolss_DriverFileInfo
**info_p
,
4869 struct spoolss_DriverFileInfo
*info
= NULL
;
4877 if (strlen(driver
->driver_path
)) {
4878 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4879 struct spoolss_DriverFileInfo
,
4881 W_ERROR_HAVE_NO_MEMORY(info
);
4882 result
= fill_spoolss_DriverFileInfo(info
,
4885 driver
->driver_path
,
4886 SPOOLSS_DRIVER_FILE_TYPE_RENDERING
,
4888 W_ERROR_NOT_OK_RETURN(result
);
4892 if (strlen(driver
->config_file
)) {
4893 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4894 struct spoolss_DriverFileInfo
,
4896 W_ERROR_HAVE_NO_MEMORY(info
);
4897 result
= fill_spoolss_DriverFileInfo(info
,
4900 driver
->config_file
,
4901 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION
,
4903 W_ERROR_NOT_OK_RETURN(result
);
4907 if (strlen(driver
->data_file
)) {
4908 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4909 struct spoolss_DriverFileInfo
,
4911 W_ERROR_HAVE_NO_MEMORY(info
);
4912 result
= fill_spoolss_DriverFileInfo(info
,
4916 SPOOLSS_DRIVER_FILE_TYPE_DATA
,
4918 W_ERROR_NOT_OK_RETURN(result
);
4922 if (strlen(driver
->help_file
)) {
4923 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4924 struct spoolss_DriverFileInfo
,
4926 W_ERROR_HAVE_NO_MEMORY(info
);
4927 result
= fill_spoolss_DriverFileInfo(info
,
4931 SPOOLSS_DRIVER_FILE_TYPE_HELP
,
4933 W_ERROR_NOT_OK_RETURN(result
);
4937 for (i
=0; driver
->dependent_files
[i
] && driver
->dependent_files
[i
][0] != '\0'; i
++) {
4938 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
4939 struct spoolss_DriverFileInfo
,
4941 W_ERROR_HAVE_NO_MEMORY(info
);
4942 result
= fill_spoolss_DriverFileInfo(info
,
4945 driver
->dependent_files
[i
],
4946 SPOOLSS_DRIVER_FILE_TYPE_OTHER
,
4948 W_ERROR_NOT_OK_RETURN(result
);
4958 /********************************************************************
4959 * fill a spoolss_DriverInfo101 struct
4960 ********************************************************************/
4962 static WERROR
fill_printer_driver_info101(TALLOC_CTX
*mem_ctx
,
4963 struct spoolss_DriverInfo101
*r
,
4964 const struct spoolss_DriverInfo8
*driver
,
4965 const char *servername
)
4967 const char *cservername
= canon_servername(servername
);
4970 r
->version
= driver
->version
;
4972 r
->driver_name
= talloc_strdup(mem_ctx
, driver
->driver_name
);
4973 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
4974 r
->architecture
= talloc_strdup(mem_ctx
, driver
->architecture
);
4975 W_ERROR_HAVE_NO_MEMORY(r
->architecture
);
4977 result
= spoolss_DriverFileInfo_from_driver(mem_ctx
, driver
,
4981 if (!W_ERROR_IS_OK(result
)) {
4985 FILL_DRIVER_STRING(mem_ctx
,
4986 driver
->monitor_name
,
4989 FILL_DRIVER_STRING(mem_ctx
,
4990 driver
->default_datatype
,
4991 r
->default_datatype
);
4993 r
->previous_names
= string_array_from_driver_info(mem_ctx
,
4994 driver
->previous_names
,
4996 r
->driver_date
= driver
->driver_date
;
4997 r
->driver_version
= driver
->driver_version
;
4999 FILL_DRIVER_STRING(mem_ctx
,
5000 driver
->manufacturer_name
,
5001 r
->manufacturer_name
);
5002 FILL_DRIVER_STRING(mem_ctx
,
5003 driver
->manufacturer_url
,
5004 r
->manufacturer_url
);
5005 FILL_DRIVER_STRING(mem_ctx
,
5006 driver
->hardware_id
,
5008 FILL_DRIVER_STRING(mem_ctx
,
5015 /********************************************************************
5016 ********************************************************************/
5018 static WERROR
construct_printer_driver_info_level(TALLOC_CTX
*mem_ctx
,
5020 union spoolss_DriverInfo
*r
,
5022 const char *servername
,
5023 const char *architecture
,
5026 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
5027 struct spoolss_DriverInfo8
*driver
;
5030 result
= get_a_printer(NULL
, &printer
, 2, lp_const_servicename(snum
));
5032 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5033 win_errstr(result
)));
5035 if (!W_ERROR_IS_OK(result
)) {
5036 return WERR_INVALID_PRINTER_NAME
;
5039 result
= get_a_printer_driver(mem_ctx
, &driver
, printer
->info_2
->drivername
,
5040 architecture
, version
);
5042 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5043 win_errstr(result
)));
5045 if (!W_ERROR_IS_OK(result
)) {
5047 * Is this a W2k client ?
5051 free_a_printer(&printer
, 2);
5052 return WERR_UNKNOWN_PRINTER_DRIVER
;
5055 /* Yes - try again with a WinNT driver. */
5057 result
= get_a_printer_driver(mem_ctx
, &driver
, printer
->info_2
->drivername
,
5058 architecture
, version
);
5059 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5060 win_errstr(result
)));
5061 if (!W_ERROR_IS_OK(result
)) {
5062 free_a_printer(&printer
, 2);
5063 return WERR_UNKNOWN_PRINTER_DRIVER
;
5069 result
= fill_printer_driver_info1(mem_ctx
, &r
->info1
, driver
, servername
);
5072 result
= fill_printer_driver_info2(mem_ctx
, &r
->info2
, driver
, servername
);
5075 result
= fill_printer_driver_info3(mem_ctx
, &r
->info3
, driver
, servername
);
5078 result
= fill_printer_driver_info4(mem_ctx
, &r
->info4
, driver
, servername
);
5081 result
= fill_printer_driver_info5(mem_ctx
, &r
->info5
, driver
, servername
);
5084 result
= fill_printer_driver_info6(mem_ctx
, &r
->info6
, driver
, servername
);
5087 result
= fill_printer_driver_info8(mem_ctx
, &r
->info8
, driver
, servername
);
5089 #if 0 /* disabled until marshalling issues are resolved - gd */
5091 result
= fill_printer_driver_info101(mem_ctx
, &r
->info101
, driver
, servername
);
5095 result
= WERR_UNKNOWN_LEVEL
;
5099 free_a_printer(&printer
, 2);
5100 free_a_printer_driver(driver
);
5105 /****************************************************************
5106 _spoolss_GetPrinterDriver2
5107 ****************************************************************/
5109 WERROR
_spoolss_GetPrinterDriver2(pipes_struct
*p
,
5110 struct spoolss_GetPrinterDriver2
*r
)
5112 Printer_entry
*printer
;
5115 const char *servername
;
5118 /* that's an [in out] buffer */
5120 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
5121 return WERR_INVALID_PARAM
;
5124 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5126 if (!(printer
= find_printer_index_by_hnd(p
, r
->in
.handle
))) {
5127 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5128 return WERR_INVALID_PRINTER_NAME
;
5132 *r
->out
.server_major_version
= 0;
5133 *r
->out
.server_minor_version
= 0;
5135 servername
= get_server_name(printer
);
5137 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
5141 result
= construct_printer_driver_info_level(p
->mem_ctx
, r
->in
.level
,
5145 r
->in
.client_major_version
);
5146 if (!W_ERROR_IS_OK(result
)) {
5147 TALLOC_FREE(r
->out
.info
);
5151 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_DriverInfo
, NULL
,
5152 r
->out
.info
, r
->in
.level
);
5153 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
5155 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
5159 /****************************************************************
5160 _spoolss_StartPagePrinter
5161 ****************************************************************/
5163 WERROR
_spoolss_StartPagePrinter(pipes_struct
*p
,
5164 struct spoolss_StartPagePrinter
*r
)
5166 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5169 DEBUG(3,("_spoolss_StartPagePrinter: "
5170 "Error in startpageprinter printer handle\n"));
5174 Printer
->page_started
= true;
5178 /****************************************************************
5179 _spoolss_EndPagePrinter
5180 ****************************************************************/
5182 WERROR
_spoolss_EndPagePrinter(pipes_struct
*p
,
5183 struct spoolss_EndPagePrinter
*r
)
5187 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5190 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5191 OUR_HANDLE(r
->in
.handle
)));
5195 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
5198 Printer
->page_started
= false;
5199 print_job_endpage(snum
, Printer
->jobid
);
5204 /****************************************************************
5205 _spoolss_StartDocPrinter
5206 ****************************************************************/
5208 WERROR
_spoolss_StartDocPrinter(pipes_struct
*p
,
5209 struct spoolss_StartDocPrinter
*r
)
5211 struct spoolss_DocumentInfo1
*info_1
;
5213 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5216 DEBUG(2,("_spoolss_StartDocPrinter: "
5217 "Invalid handle (%s:%u:%u)\n",
5218 OUR_HANDLE(r
->in
.handle
)));
5222 if (r
->in
.level
!= 1) {
5223 return WERR_UNKNOWN_LEVEL
;
5226 info_1
= r
->in
.info
.info1
;
5229 * a nice thing with NT is it doesn't listen to what you tell it.
5230 * when asked to send _only_ RAW datas, it tries to send datas
5233 * So I add checks like in NT Server ...
5236 if (info_1
->datatype
) {
5237 if (strcmp(info_1
->datatype
, "RAW") != 0) {
5239 return WERR_INVALID_DATATYPE
;
5243 /* get the share number of the printer */
5244 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
5248 Printer
->jobid
= print_job_start(p
->server_info
, snum
,
5249 info_1
->document_name
,
5250 Printer
->nt_devmode
);
5252 /* An error occured in print_job_start() so return an appropriate
5255 if (Printer
->jobid
== -1) {
5256 return map_werror_from_unix(errno
);
5259 Printer
->document_started
= true;
5260 *r
->out
.job_id
= Printer
->jobid
;
5265 /****************************************************************
5266 _spoolss_EndDocPrinter
5267 ****************************************************************/
5269 WERROR
_spoolss_EndDocPrinter(pipes_struct
*p
,
5270 struct spoolss_EndDocPrinter
*r
)
5272 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5276 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5277 OUR_HANDLE(r
->in
.handle
)));
5281 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
5285 Printer
->document_started
= false;
5286 print_job_end(snum
, Printer
->jobid
, NORMAL_CLOSE
);
5287 /* error codes unhandled so far ... */
5292 /****************************************************************
5293 _spoolss_WritePrinter
5294 ****************************************************************/
5296 WERROR
_spoolss_WritePrinter(pipes_struct
*p
,
5297 struct spoolss_WritePrinter
*r
)
5299 uint32_t buffer_written
;
5301 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5304 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5305 OUR_HANDLE(r
->in
.handle
)));
5306 *r
->out
.num_written
= r
->in
._data_size
;
5310 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
5313 buffer_written
= (uint32_t)print_job_write(snum
, Printer
->jobid
,
5314 (const char *)r
->in
.data
.data
,
5316 (size_t)r
->in
._data_size
);
5317 if (buffer_written
== (uint32_t)-1) {
5318 *r
->out
.num_written
= 0;
5319 if (errno
== ENOSPC
)
5320 return WERR_NO_SPOOL_SPACE
;
5322 return WERR_ACCESS_DENIED
;
5325 *r
->out
.num_written
= r
->in
._data_size
;
5330 /********************************************************************
5331 * api_spoolss_getprinter
5332 * called from the spoolss dispatcher
5334 ********************************************************************/
5336 static WERROR
control_printer(struct policy_handle
*handle
, uint32_t command
,
5340 WERROR errcode
= WERR_BADFUNC
;
5341 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, handle
);
5344 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5345 OUR_HANDLE(handle
)));
5349 if (!get_printer_snum(p
, handle
, &snum
, NULL
))
5353 case SPOOLSS_PRINTER_CONTROL_PAUSE
:
5354 errcode
= print_queue_pause(p
->server_info
, snum
);
5356 case SPOOLSS_PRINTER_CONTROL_RESUME
:
5357 case SPOOLSS_PRINTER_CONTROL_UNPAUSE
:
5358 errcode
= print_queue_resume(p
->server_info
, snum
);
5360 case SPOOLSS_PRINTER_CONTROL_PURGE
:
5361 errcode
= print_queue_purge(p
->server_info
, snum
);
5364 return WERR_UNKNOWN_LEVEL
;
5371 /****************************************************************
5372 _spoolss_AbortPrinter
5373 * From MSDN: "Deletes printer's spool file if printer is configured
5375 ****************************************************************/
5377 WERROR
_spoolss_AbortPrinter(pipes_struct
*p
,
5378 struct spoolss_AbortPrinter
*r
)
5380 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5382 WERROR errcode
= WERR_OK
;
5385 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5386 OUR_HANDLE(r
->in
.handle
)));
5390 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
5393 print_job_delete(p
->server_info
, snum
, Printer
->jobid
, &errcode
);
5398 /********************************************************************
5399 * called by spoolss_api_setprinter
5400 * when updating a printer description
5401 ********************************************************************/
5403 static WERROR
update_printer_sec(struct policy_handle
*handle
,
5404 pipes_struct
*p
, SEC_DESC_BUF
*secdesc_ctr
)
5406 SEC_DESC_BUF
*new_secdesc_ctr
= NULL
, *old_secdesc_ctr
= NULL
;
5410 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, handle
);
5412 if (!Printer
|| !get_printer_snum(p
, handle
, &snum
, NULL
)) {
5413 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5414 OUR_HANDLE(handle
)));
5416 result
= WERR_BADFID
;
5421 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5422 result
= WERR_INVALID_PARAM
;
5426 /* Check the user has permissions to change the security
5427 descriptor. By experimentation with two NT machines, the user
5428 requires Full Access to the printer to change security
5431 if ( Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
5432 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5433 result
= WERR_ACCESS_DENIED
;
5437 /* NT seems to like setting the security descriptor even though
5438 nothing may have actually changed. */
5440 if ( !nt_printing_getsec(p
->mem_ctx
, Printer
->sharename
, &old_secdesc_ctr
)) {
5441 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5442 result
= WERR_BADFID
;
5446 if (DEBUGLEVEL
>= 10) {
5450 the_acl
= old_secdesc_ctr
->sd
->dacl
;
5451 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5452 PRINTERNAME(snum
), the_acl
->num_aces
));
5454 for (i
= 0; i
< the_acl
->num_aces
; i
++) {
5455 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5456 &the_acl
->aces
[i
].trustee
),
5457 the_acl
->aces
[i
].access_mask
));
5460 the_acl
= secdesc_ctr
->sd
->dacl
;
5463 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5464 PRINTERNAME(snum
), the_acl
->num_aces
));
5466 for (i
= 0; i
< the_acl
->num_aces
; i
++) {
5467 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5468 &the_acl
->aces
[i
].trustee
),
5469 the_acl
->aces
[i
].access_mask
));
5472 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5476 new_secdesc_ctr
= sec_desc_merge(p
->mem_ctx
, secdesc_ctr
, old_secdesc_ctr
);
5477 if (!new_secdesc_ctr
) {
5478 result
= WERR_NOMEM
;
5482 if (security_descriptor_equal(new_secdesc_ctr
->sd
, old_secdesc_ctr
->sd
)) {
5487 result
= nt_printing_setsec(Printer
->sharename
, new_secdesc_ctr
);
5494 /********************************************************************
5495 Canonicalize printer info from a client
5497 ATTN: It does not matter what we set the servername to hear
5498 since we do the necessary work in get_a_printer() to set it to
5499 the correct value based on what the client sent in the
5500 _spoolss_open_printer_ex().
5501 ********************************************************************/
5503 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2
*info
, int snum
)
5505 fstring printername
;
5508 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5509 "portname=%s drivername=%s comment=%s location=%s\n",
5510 info
->servername
, info
->printername
, info
->sharename
,
5511 info
->portname
, info
->drivername
, info
->comment
, info
->location
));
5513 /* we force some elements to "correct" values */
5514 slprintf(info
->servername
, sizeof(info
->servername
)-1, "\\\\%s", global_myname());
5515 fstrcpy(info
->sharename
, lp_servicename(snum
));
5517 /* check to see if we allow printername != sharename */
5519 if ( lp_force_printername(snum
) ) {
5520 slprintf(info
->printername
, sizeof(info
->printername
)-1, "\\\\%s\\%s",
5521 global_myname(), info
->sharename
);
5524 /* make sure printername is in \\server\printername format */
5526 fstrcpy( printername
, info
->printername
);
5528 if ( printername
[0] == '\\' && printername
[1] == '\\' ) {
5529 if ( (p
= strchr_m( &printername
[2], '\\' )) != NULL
)
5533 slprintf(info
->printername
, sizeof(info
->printername
)-1, "\\\\%s\\%s",
5534 global_myname(), p
);
5537 info
->attributes
|= PRINTER_ATTRIBUTE_SAMBA
;
5538 info
->attributes
&= ~PRINTER_ATTRIBUTE_NOT_SAMBA
;
5545 /****************************************************************************
5546 ****************************************************************************/
5548 static WERROR
add_port_hook(TALLOC_CTX
*ctx
, NT_USER_TOKEN
*token
, const char *portname
, const char *uri
)
5550 char *cmd
= lp_addport_cmd();
5551 char *command
= NULL
;
5553 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
5554 bool is_print_op
= false;
5557 return WERR_ACCESS_DENIED
;
5560 command
= talloc_asprintf(ctx
,
5561 "%s \"%s\" \"%s\"", cmd
, portname
, uri
);
5567 is_print_op
= user_has_privileges( token
, &se_printop
);
5569 DEBUG(10,("Running [%s]\n", command
));
5571 /********* BEGIN SePrintOperatorPrivilege **********/
5576 ret
= smbrun(command
, NULL
);
5581 /********* END SePrintOperatorPrivilege **********/
5583 DEBUGADD(10,("returned [%d]\n", ret
));
5585 TALLOC_FREE(command
);
5588 return WERR_ACCESS_DENIED
;
5594 /****************************************************************************
5595 ****************************************************************************/
5597 bool add_printer_hook(TALLOC_CTX
*ctx
, NT_USER_TOKEN
*token
, NT_PRINTER_INFO_LEVEL
*printer
)
5599 char *cmd
= lp_addprinter_cmd();
5601 char *command
= NULL
;
5605 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
5606 bool is_print_op
= false;
5607 char *remote_machine
= talloc_strdup(ctx
, "%m");
5609 if (!remote_machine
) {
5612 remote_machine
= talloc_sub_basic(ctx
,
5613 current_user_info
.smb_name
,
5614 current_user_info
.domain
,
5616 if (!remote_machine
) {
5620 command
= talloc_asprintf(ctx
,
5621 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5622 cmd
, printer
->info_2
->printername
, printer
->info_2
->sharename
,
5623 printer
->info_2
->portname
, printer
->info_2
->drivername
,
5624 printer
->info_2
->location
, printer
->info_2
->comment
, remote_machine
);
5630 is_print_op
= user_has_privileges( token
, &se_printop
);
5632 DEBUG(10,("Running [%s]\n", command
));
5634 /********* BEGIN SePrintOperatorPrivilege **********/
5639 if ( (ret
= smbrun(command
, &fd
)) == 0 ) {
5640 /* Tell everyone we updated smb.conf. */
5641 message_send_all(smbd_messaging_context(),
5642 MSG_SMB_CONF_UPDATED
, NULL
, 0, NULL
);
5648 /********* END SePrintOperatorPrivilege **********/
5650 DEBUGADD(10,("returned [%d]\n", ret
));
5652 TALLOC_FREE(command
);
5653 TALLOC_FREE(remote_machine
);
5661 /* reload our services immediately */
5663 reload_services(false);
5667 /* Get lines and convert them back to dos-codepage */
5668 qlines
= fd_lines_load(fd
, &numlines
, 0, NULL
);
5669 DEBUGADD(10,("Lines returned = [%d]\n", numlines
));
5672 /* Set the portname to what the script says the portname should be. */
5673 /* but don't require anything to be return from the script exit a good error code */
5676 /* Set the portname to what the script says the portname should be. */
5677 strncpy(printer
->info_2
->portname
, qlines
[0], sizeof(printer
->info_2
->portname
));
5678 DEBUGADD(6,("Line[0] = [%s]\n", qlines
[0]));
5681 TALLOC_FREE(qlines
);
5686 /********************************************************************
5687 * Called by spoolss_api_setprinter
5688 * when updating a printer description.
5689 ********************************************************************/
5691 static WERROR
update_printer(pipes_struct
*p
, struct policy_handle
*handle
,
5692 struct spoolss_SetPrinterInfoCtr
*info_ctr
,
5693 struct spoolss_DeviceMode
*devmode
)
5696 NT_PRINTER_INFO_LEVEL
*printer
= NULL
, *old_printer
= NULL
;
5697 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, handle
);
5702 DEBUG(8,("update_printer\n"));
5707 result
= WERR_BADFID
;
5711 if (!get_printer_snum(p
, handle
, &snum
, NULL
)) {
5712 result
= WERR_BADFID
;
5716 if (!W_ERROR_IS_OK(get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
))) ||
5717 (!W_ERROR_IS_OK(get_a_printer(Printer
, &old_printer
, 2, lp_const_servicename(snum
))))) {
5718 result
= WERR_BADFID
;
5722 DEBUGADD(8,("Converting info_2 struct\n"));
5725 * convert_printer_info converts the incoming
5726 * info from the client and overwrites the info
5727 * just read from the tdb in the pointer 'printer'.
5730 if (!convert_printer_info(info_ctr
, printer
)) {
5731 result
= WERR_NOMEM
;
5736 /* we have a valid devmode
5737 convert it and link it*/
5739 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5740 if (!convert_devicemode(printer
->info_2
->printername
, devmode
,
5741 &printer
->info_2
->devmode
)) {
5742 result
= WERR_NOMEM
;
5747 /* Do sanity check on the requested changes for Samba */
5749 if (!check_printer_ok(printer
->info_2
, snum
)) {
5750 result
= WERR_INVALID_PARAM
;
5754 /* FIXME!!! If the driver has changed we really should verify that
5755 it is installed before doing much else --jerry */
5757 /* Check calling user has permission to update printer description */
5759 if (Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
5760 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5761 result
= WERR_ACCESS_DENIED
;
5765 /* Call addprinter hook */
5766 /* Check changes to see if this is really needed */
5768 if ( *lp_addprinter_cmd()
5769 && (!strequal(printer
->info_2
->drivername
, old_printer
->info_2
->drivername
)
5770 || !strequal(printer
->info_2
->comment
, old_printer
->info_2
->comment
)
5771 || !strequal(printer
->info_2
->portname
, old_printer
->info_2
->portname
)
5772 || !strequal(printer
->info_2
->location
, old_printer
->info_2
->location
)) )
5774 /* add_printer_hook() will call reload_services() */
5776 if ( !add_printer_hook(p
->mem_ctx
, p
->server_info
->ptok
,
5778 result
= WERR_ACCESS_DENIED
;
5784 * When a *new* driver is bound to a printer, the drivername is used to
5785 * lookup previously saved driver initialization info, which is then
5786 * bound to the printer, simulating what happens in the Windows arch.
5788 if (!strequal(printer
->info_2
->drivername
, old_printer
->info_2
->drivername
))
5790 if (!set_driver_init(printer
, 2))
5792 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
5793 printer
->info_2
->drivername
));
5796 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
5797 printer
->info_2
->drivername
));
5799 notify_printer_driver(snum
, printer
->info_2
->drivername
);
5803 * flag which changes actually occured. This is a small subset of
5804 * all the possible changes. We also have to update things in the
5808 if (!strequal(printer
->info_2
->comment
, old_printer
->info_2
->comment
)) {
5809 push_reg_sz(talloc_tos(), &buffer
, printer
->info_2
->comment
);
5810 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "description",
5811 REG_SZ
, buffer
.data
, buffer
.length
);
5813 notify_printer_comment(snum
, printer
->info_2
->comment
);
5816 if (!strequal(printer
->info_2
->sharename
, old_printer
->info_2
->sharename
)) {
5817 push_reg_sz(talloc_tos(), &buffer
, printer
->info_2
->sharename
);
5818 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "shareName",
5819 REG_SZ
, buffer
.data
, buffer
.length
);
5821 notify_printer_sharename(snum
, printer
->info_2
->sharename
);
5824 if (!strequal(printer
->info_2
->printername
, old_printer
->info_2
->printername
)) {
5827 if ( (pname
= strchr_m( printer
->info_2
->printername
+2, '\\' )) != NULL
)
5830 pname
= printer
->info_2
->printername
;
5833 push_reg_sz(talloc_tos(), &buffer
, pname
);
5834 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "printerName",
5835 REG_SZ
, buffer
.data
, buffer
.length
);
5837 notify_printer_printername( snum
, pname
);
5840 if (!strequal(printer
->info_2
->portname
, old_printer
->info_2
->portname
)) {
5841 push_reg_sz(talloc_tos(), &buffer
, printer
->info_2
->portname
);
5842 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "portName",
5843 REG_SZ
, buffer
.data
, buffer
.length
);
5845 notify_printer_port(snum
, printer
->info_2
->portname
);
5848 if (!strequal(printer
->info_2
->location
, old_printer
->info_2
->location
)) {
5849 push_reg_sz(talloc_tos(), &buffer
, printer
->info_2
->location
);
5850 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "location",
5851 REG_SZ
, buffer
.data
, buffer
.length
);
5853 notify_printer_location(snum
, printer
->info_2
->location
);
5856 /* here we need to update some more DsSpooler keys */
5857 /* uNCName, serverName, shortServerName */
5859 push_reg_sz(talloc_tos(), &buffer
, global_myname());
5860 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "serverName",
5861 REG_SZ
, buffer
.data
, buffer
.length
);
5862 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "shortServerName",
5863 REG_SZ
, buffer
.data
, buffer
.length
);
5865 slprintf( asc_buffer
, sizeof(asc_buffer
)-1, "\\\\%s\\%s",
5866 global_myname(), printer
->info_2
->sharename
);
5867 push_reg_sz(talloc_tos(), &buffer
, asc_buffer
);
5868 set_printer_dataex( printer
, SPOOL_DSSPOOLER_KEY
, "uNCName",
5869 REG_SZ
, buffer
.data
, buffer
.length
);
5871 /* Update printer info */
5872 result
= mod_a_printer(printer
, 2);
5875 free_a_printer(&printer
, 2);
5876 free_a_printer(&old_printer
, 2);
5882 /****************************************************************************
5883 ****************************************************************************/
5884 static WERROR
publish_or_unpublish_printer(pipes_struct
*p
,
5885 struct policy_handle
*handle
,
5886 struct spoolss_SetPrinterInfo7
*info7
)
5890 Printer_entry
*Printer
;
5892 if ( lp_security() != SEC_ADS
) {
5893 return WERR_UNKNOWN_LEVEL
;
5896 Printer
= find_printer_index_by_hnd(p
, handle
);
5898 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7
->action
));
5903 if (!get_printer_snum(p
, handle
, &snum
, NULL
))
5906 nt_printer_publish(Printer
, snum
, info7
->action
);
5910 return WERR_UNKNOWN_LEVEL
;
5914 /****************************************************************
5916 ****************************************************************/
5918 WERROR
_spoolss_SetPrinter(pipes_struct
*p
,
5919 struct spoolss_SetPrinter
*r
)
5923 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5926 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
5927 OUR_HANDLE(r
->in
.handle
)));
5931 /* check the level */
5932 switch (r
->in
.info_ctr
->level
) {
5934 return control_printer(r
->in
.handle
, r
->in
.command
, p
);
5936 result
= update_printer(p
, r
->in
.handle
,
5938 r
->in
.devmode_ctr
->devmode
);
5939 if (!W_ERROR_IS_OK(result
))
5941 if (r
->in
.secdesc_ctr
->sd
)
5942 result
= update_printer_sec(r
->in
.handle
, p
,
5946 return update_printer_sec(r
->in
.handle
, p
,
5949 return publish_or_unpublish_printer(p
, r
->in
.handle
,
5950 r
->in
.info_ctr
->info
.info7
);
5952 return WERR_UNKNOWN_LEVEL
;
5956 /****************************************************************
5957 _spoolss_FindClosePrinterNotify
5958 ****************************************************************/
5960 WERROR
_spoolss_FindClosePrinterNotify(pipes_struct
*p
,
5961 struct spoolss_FindClosePrinterNotify
*r
)
5963 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
5966 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
5967 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r
->in
.handle
)));
5971 if (Printer
->notify
.client_connected
== true) {
5974 if ( Printer
->printer_type
== SPLHND_SERVER
)
5976 else if ( (Printer
->printer_type
== SPLHND_PRINTER
) &&
5977 !get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
) )
5980 srv_spoolss_replycloseprinter(snum
, &Printer
->notify
.client_hnd
);
5983 Printer
->notify
.flags
=0;
5984 Printer
->notify
.options
=0;
5985 Printer
->notify
.localmachine
[0]='\0';
5986 Printer
->notify
.printerlocal
=0;
5987 TALLOC_FREE(Printer
->notify
.option
);
5988 Printer
->notify
.client_connected
= false;
5993 /****************************************************************
5995 ****************************************************************/
5997 WERROR
_spoolss_AddJob(pipes_struct
*p
,
5998 struct spoolss_AddJob
*r
)
6000 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
6001 return WERR_INVALID_PARAM
;
6004 /* this is what a NT server returns for AddJob. AddJob must fail on
6005 * non-local printers */
6007 if (r
->in
.level
!= 1) {
6008 return WERR_UNKNOWN_LEVEL
;
6011 return WERR_INVALID_PARAM
;
6014 /****************************************************************************
6016 ****************************************************************************/
6018 static WERROR
fill_job_info1(TALLOC_CTX
*mem_ctx
,
6019 struct spoolss_JobInfo1
*r
,
6020 const print_queue_struct
*queue
,
6021 int position
, int snum
,
6022 const NT_PRINTER_INFO_LEVEL
*ntprinter
)
6026 t
= gmtime(&queue
->time
);
6028 r
->job_id
= queue
->job
;
6030 r
->printer_name
= talloc_strdup(mem_ctx
, lp_servicename(snum
));
6031 W_ERROR_HAVE_NO_MEMORY(r
->printer_name
);
6032 r
->server_name
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->servername
);
6033 W_ERROR_HAVE_NO_MEMORY(r
->server_name
);
6034 r
->user_name
= talloc_strdup(mem_ctx
, queue
->fs_user
);
6035 W_ERROR_HAVE_NO_MEMORY(r
->user_name
);
6036 r
->document_name
= talloc_strdup(mem_ctx
, queue
->fs_file
);
6037 W_ERROR_HAVE_NO_MEMORY(r
->document_name
);
6038 r
->data_type
= talloc_strdup(mem_ctx
, "RAW");
6039 W_ERROR_HAVE_NO_MEMORY(r
->data_type
);
6040 r
->text_status
= talloc_strdup(mem_ctx
, "");
6041 W_ERROR_HAVE_NO_MEMORY(r
->text_status
);
6043 r
->status
= nt_printj_status(queue
->status
);
6044 r
->priority
= queue
->priority
;
6045 r
->position
= position
;
6046 r
->total_pages
= queue
->page_count
;
6047 r
->pages_printed
= 0; /* ??? */
6049 init_systemtime(&r
->submitted
, t
);
6054 /****************************************************************************
6056 ****************************************************************************/
6058 static WERROR
fill_job_info2(TALLOC_CTX
*mem_ctx
,
6059 struct spoolss_JobInfo2
*r
,
6060 const print_queue_struct
*queue
,
6061 int position
, int snum
,
6062 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
6063 struct spoolss_DeviceMode
*devmode
)
6067 t
= gmtime(&queue
->time
);
6069 r
->job_id
= queue
->job
;
6071 r
->printer_name
= talloc_strdup(mem_ctx
, lp_servicename(snum
));
6072 W_ERROR_HAVE_NO_MEMORY(r
->printer_name
);
6073 r
->server_name
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->servername
);
6074 W_ERROR_HAVE_NO_MEMORY(r
->server_name
);
6075 r
->user_name
= talloc_strdup(mem_ctx
, queue
->fs_user
);
6076 W_ERROR_HAVE_NO_MEMORY(r
->user_name
);
6077 r
->document_name
= talloc_strdup(mem_ctx
, queue
->fs_file
);
6078 W_ERROR_HAVE_NO_MEMORY(r
->document_name
);
6079 r
->notify_name
= talloc_strdup(mem_ctx
, queue
->fs_user
);
6080 W_ERROR_HAVE_NO_MEMORY(r
->notify_name
);
6081 r
->data_type
= talloc_strdup(mem_ctx
, "RAW");
6082 W_ERROR_HAVE_NO_MEMORY(r
->data_type
);
6083 r
->print_processor
= talloc_strdup(mem_ctx
, "winprint");
6084 W_ERROR_HAVE_NO_MEMORY(r
->print_processor
);
6085 r
->parameters
= talloc_strdup(mem_ctx
, "");
6086 W_ERROR_HAVE_NO_MEMORY(r
->parameters
);
6087 r
->driver_name
= talloc_strdup(mem_ctx
, ntprinter
->info_2
->drivername
);
6088 W_ERROR_HAVE_NO_MEMORY(r
->driver_name
);
6090 r
->devmode
= devmode
;
6092 r
->text_status
= talloc_strdup(mem_ctx
, "");
6093 W_ERROR_HAVE_NO_MEMORY(r
->text_status
);
6097 r
->status
= nt_printj_status(queue
->status
);
6098 r
->priority
= queue
->priority
;
6099 r
->position
= position
;
6102 r
->total_pages
= queue
->page_count
;
6103 r
->size
= queue
->size
;
6104 init_systemtime(&r
->submitted
, t
);
6106 r
->pages_printed
= 0; /* ??? */
6111 /****************************************************************************
6113 ****************************************************************************/
6115 static WERROR
fill_job_info3(TALLOC_CTX
*mem_ctx
,
6116 struct spoolss_JobInfo3
*r
,
6117 const print_queue_struct
*queue
,
6118 const print_queue_struct
*next_queue
,
6119 int position
, int snum
,
6120 const NT_PRINTER_INFO_LEVEL
*ntprinter
)
6122 r
->job_id
= queue
->job
;
6125 r
->next_job_id
= next_queue
->job
;
6132 /****************************************************************************
6133 Enumjobs at level 1.
6134 ****************************************************************************/
6136 static WERROR
enumjobs_level1(TALLOC_CTX
*mem_ctx
,
6137 const print_queue_struct
*queue
,
6138 uint32_t num_queues
, int snum
,
6139 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
6140 union spoolss_JobInfo
**info_p
,
6143 union spoolss_JobInfo
*info
;
6145 WERROR result
= WERR_OK
;
6147 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_JobInfo
, num_queues
);
6148 W_ERROR_HAVE_NO_MEMORY(info
);
6150 *count
= num_queues
;
6152 for (i
=0; i
<*count
; i
++) {
6153 result
= fill_job_info1(info
,
6159 if (!W_ERROR_IS_OK(result
)) {
6165 if (!W_ERROR_IS_OK(result
)) {
6176 /****************************************************************************
6177 Enumjobs at level 2.
6178 ****************************************************************************/
6180 static WERROR
enumjobs_level2(TALLOC_CTX
*mem_ctx
,
6181 const print_queue_struct
*queue
,
6182 uint32_t num_queues
, int snum
,
6183 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
6184 union spoolss_JobInfo
**info_p
,
6187 union spoolss_JobInfo
*info
;
6189 WERROR result
= WERR_OK
;
6191 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_JobInfo
, num_queues
);
6192 W_ERROR_HAVE_NO_MEMORY(info
);
6194 *count
= num_queues
;
6196 for (i
=0; i
<*count
; i
++) {
6198 struct spoolss_DeviceMode
*devmode
;
6200 devmode
= construct_dev_mode(info
, lp_const_servicename(snum
));
6202 result
= WERR_NOMEM
;
6206 result
= fill_job_info2(info
,
6213 if (!W_ERROR_IS_OK(result
)) {
6219 if (!W_ERROR_IS_OK(result
)) {
6230 /****************************************************************************
6231 Enumjobs at level 3.
6232 ****************************************************************************/
6234 static WERROR
enumjobs_level3(TALLOC_CTX
*mem_ctx
,
6235 const print_queue_struct
*queue
,
6236 uint32_t num_queues
, int snum
,
6237 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
6238 union spoolss_JobInfo
**info_p
,
6241 union spoolss_JobInfo
*info
;
6243 WERROR result
= WERR_OK
;
6245 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_JobInfo
, num_queues
);
6246 W_ERROR_HAVE_NO_MEMORY(info
);
6248 *count
= num_queues
;
6250 for (i
=0; i
<*count
; i
++) {
6251 const print_queue_struct
*next_queue
= NULL
;
6254 next_queue
= &queue
[i
+1];
6257 result
= fill_job_info3(info
,
6264 if (!W_ERROR_IS_OK(result
)) {
6270 if (!W_ERROR_IS_OK(result
)) {
6281 /****************************************************************
6283 ****************************************************************/
6285 WERROR
_spoolss_EnumJobs(pipes_struct
*p
,
6286 struct spoolss_EnumJobs
*r
)
6289 NT_PRINTER_INFO_LEVEL
*ntprinter
= NULL
;
6291 print_status_struct prt_status
;
6292 print_queue_struct
*queue
= NULL
;
6295 /* that's an [in out] buffer */
6297 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
6298 return WERR_INVALID_PARAM
;
6301 DEBUG(4,("_spoolss_EnumJobs\n"));
6305 *r
->out
.info
= NULL
;
6307 /* lookup the printer snum and tdb entry */
6309 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
6313 result
= get_a_printer(NULL
, &ntprinter
, 2, lp_servicename(snum
));
6314 if (!W_ERROR_IS_OK(result
)) {
6318 count
= print_queue_status(snum
, &queue
, &prt_status
);
6319 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6320 count
, prt_status
.status
, prt_status
.message
));
6324 free_a_printer(&ntprinter
, 2);
6328 switch (r
->in
.level
) {
6330 result
= enumjobs_level1(p
->mem_ctx
, queue
, count
, snum
,
6331 ntprinter
, r
->out
.info
, r
->out
.count
);
6334 result
= enumjobs_level2(p
->mem_ctx
, queue
, count
, snum
,
6335 ntprinter
, r
->out
.info
, r
->out
.count
);
6338 result
= enumjobs_level3(p
->mem_ctx
, queue
, count
, snum
,
6339 ntprinter
, r
->out
.info
, r
->out
.count
);
6342 result
= WERR_UNKNOWN_LEVEL
;
6347 free_a_printer(&ntprinter
, 2);
6349 if (!W_ERROR_IS_OK(result
)) {
6353 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
6354 spoolss_EnumJobs
, NULL
,
6355 *r
->out
.info
, r
->in
.level
,
6357 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
6358 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
6360 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
6363 /****************************************************************
6364 _spoolss_ScheduleJob
6365 ****************************************************************/
6367 WERROR
_spoolss_ScheduleJob(pipes_struct
*p
,
6368 struct spoolss_ScheduleJob
*r
)
6373 /****************************************************************
6375 ****************************************************************/
6377 WERROR
_spoolss_SetJob(pipes_struct
*p
,
6378 struct spoolss_SetJob
*r
)
6381 WERROR errcode
= WERR_BADFUNC
;
6383 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
6387 if (!print_job_exists(lp_const_servicename(snum
), r
->in
.job_id
)) {
6388 return WERR_INVALID_PRINTER_NAME
;
6391 switch (r
->in
.command
) {
6392 case SPOOLSS_JOB_CONTROL_CANCEL
:
6393 case SPOOLSS_JOB_CONTROL_DELETE
:
6394 if (print_job_delete(p
->server_info
, snum
, r
->in
.job_id
, &errcode
)) {
6398 case SPOOLSS_JOB_CONTROL_PAUSE
:
6399 if (print_job_pause(p
->server_info
, snum
, r
->in
.job_id
, &errcode
)) {
6403 case SPOOLSS_JOB_CONTROL_RESTART
:
6404 case SPOOLSS_JOB_CONTROL_RESUME
:
6405 if (print_job_resume(p
->server_info
, snum
, r
->in
.job_id
, &errcode
)) {
6410 return WERR_UNKNOWN_LEVEL
;
6416 /****************************************************************************
6417 Enumerates all printer drivers by level and architecture.
6418 ****************************************************************************/
6420 static WERROR
enumprinterdrivers_level_by_architecture(TALLOC_CTX
*mem_ctx
,
6421 const char *servername
,
6422 const char *architecture
,
6424 union spoolss_DriverInfo
**info_p
,
6430 fstring
*list
= NULL
;
6431 struct spoolss_DriverInfo8
*driver
;
6432 union spoolss_DriverInfo
*info
= NULL
;
6434 WERROR result
= WERR_OK
;
6439 for (version
=0; version
<DRIVER_MAX_VERSION
; version
++) {
6441 ndrivers
= get_ntdrivers(&list
, architecture
, version
);
6442 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6443 ndrivers
, architecture
, version
));
6445 if (ndrivers
== -1) {
6446 result
= WERR_NOMEM
;
6450 if (ndrivers
!= 0) {
6451 info
= TALLOC_REALLOC_ARRAY(mem_ctx
, info
,
6452 union spoolss_DriverInfo
,
6455 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
6456 "failed to enlarge driver info buffer!\n"));
6457 result
= WERR_NOMEM
;
6462 for (i
=0; i
<ndrivers
; i
++) {
6463 DEBUGADD(5,("\tdriver: [%s]\n", list
[i
]));
6464 ZERO_STRUCT(driver
);
6465 result
= get_a_printer_driver(mem_ctx
, &driver
, list
[i
],
6466 architecture
, version
);
6467 if (!W_ERROR_IS_OK(result
)) {
6473 result
= fill_printer_driver_info1(info
, &info
[count
+i
].info1
,
6474 driver
, servername
);
6477 result
= fill_printer_driver_info2(info
, &info
[count
+i
].info2
,
6478 driver
, servername
);
6481 result
= fill_printer_driver_info3(info
, &info
[count
+i
].info3
,
6482 driver
, servername
);
6485 result
= fill_printer_driver_info4(info
, &info
[count
+i
].info4
,
6486 driver
, servername
);
6489 result
= fill_printer_driver_info5(info
, &info
[count
+i
].info5
,
6490 driver
, servername
);
6493 result
= fill_printer_driver_info6(info
, &info
[count
+i
].info6
,
6494 driver
, servername
);
6497 result
= fill_printer_driver_info8(info
, &info
[count
+i
].info8
,
6498 driver
, servername
);
6501 result
= WERR_UNKNOWN_LEVEL
;
6505 free_a_printer_driver(driver
);
6507 if (!W_ERROR_IS_OK(result
)) {
6519 if (!W_ERROR_IS_OK(result
)) {
6530 /****************************************************************************
6531 Enumerates all printer drivers by level.
6532 ****************************************************************************/
6534 static WERROR
enumprinterdrivers_level(TALLOC_CTX
*mem_ctx
,
6535 const char *servername
,
6536 const char *architecture
,
6538 union spoolss_DriverInfo
**info_p
,
6542 WERROR result
= WERR_OK
;
6544 if (strequal(architecture
, SPOOLSS_ARCHITECTURE_ALL
)) {
6546 for (a
=0; archi_table
[a
].long_archi
!= NULL
; a
++) {
6548 union spoolss_DriverInfo
*info
= NULL
;
6551 result
= enumprinterdrivers_level_by_architecture(mem_ctx
,
6553 archi_table
[a
].long_archi
,
6557 if (!W_ERROR_IS_OK(result
)) {
6561 for (i
=0; i
< count
; i
++) {
6562 ADD_TO_ARRAY(mem_ctx
, union spoolss_DriverInfo
,
6563 info
[i
], info_p
, count_p
);
6570 return enumprinterdrivers_level_by_architecture(mem_ctx
,
6578 /****************************************************************
6579 _spoolss_EnumPrinterDrivers
6580 ****************************************************************/
6582 WERROR
_spoolss_EnumPrinterDrivers(pipes_struct
*p
,
6583 struct spoolss_EnumPrinterDrivers
*r
)
6585 const char *cservername
;
6588 /* that's an [in out] buffer */
6590 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
6591 return WERR_INVALID_PARAM
;
6594 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6598 *r
->out
.info
= NULL
;
6600 cservername
= canon_servername(r
->in
.server
);
6602 if (!is_myname_or_ipaddr(cservername
)) {
6603 return WERR_UNKNOWN_PRINTER_DRIVER
;
6606 result
= enumprinterdrivers_level(p
->mem_ctx
, cservername
,
6611 if (!W_ERROR_IS_OK(result
)) {
6615 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
6616 spoolss_EnumPrinterDrivers
, NULL
,
6617 *r
->out
.info
, r
->in
.level
,
6619 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
6620 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
6622 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
6625 /****************************************************************************
6626 ****************************************************************************/
6628 static WERROR
fill_form_info_1(TALLOC_CTX
*mem_ctx
,
6629 struct spoolss_FormInfo1
*r
,
6630 const nt_forms_struct
*form
)
6632 r
->form_name
= talloc_strdup(mem_ctx
, form
->name
);
6633 W_ERROR_HAVE_NO_MEMORY(r
->form_name
);
6635 r
->flags
= form
->flag
;
6636 r
->size
.width
= form
->width
;
6637 r
->size
.height
= form
->length
;
6638 r
->area
.left
= form
->left
;
6639 r
->area
.top
= form
->top
;
6640 r
->area
.right
= form
->right
;
6641 r
->area
.bottom
= form
->bottom
;
6646 /****************************************************************
6647 spoolss_enumforms_level1
6648 ****************************************************************/
6650 static WERROR
spoolss_enumforms_level1(TALLOC_CTX
*mem_ctx
,
6651 const nt_forms_struct
*builtin_forms
,
6652 uint32_t num_builtin_forms
,
6653 const nt_forms_struct
*user_forms
,
6654 uint32_t num_user_forms
,
6655 union spoolss_FormInfo
**info_p
,
6658 union spoolss_FormInfo
*info
;
6659 WERROR result
= WERR_OK
;
6662 *count
= num_builtin_forms
+ num_user_forms
;
6664 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_FormInfo
, *count
);
6665 W_ERROR_HAVE_NO_MEMORY(info
);
6667 /* construct the list of form structures */
6668 for (i
=0; i
<num_builtin_forms
; i
++) {
6669 DEBUGADD(6,("Filling builtin form number [%d]\n",i
));
6670 result
= fill_form_info_1(info
, &info
[i
].info1
,
6672 if (!W_ERROR_IS_OK(result
)) {
6677 for (i
=0; i
<num_user_forms
; i
++) {
6678 DEBUGADD(6,("Filling user form number [%d]\n",i
));
6679 result
= fill_form_info_1(info
, &info
[i
+num_builtin_forms
].info1
,
6681 if (!W_ERROR_IS_OK(result
)) {
6687 if (!W_ERROR_IS_OK(result
)) {
6698 /****************************************************************
6700 ****************************************************************/
6702 WERROR
_spoolss_EnumForms(pipes_struct
*p
,
6703 struct spoolss_EnumForms
*r
)
6706 nt_forms_struct
*user_forms
= NULL
;
6707 nt_forms_struct
*builtin_forms
= NULL
;
6708 uint32_t num_user_forms
;
6709 uint32_t num_builtin_forms
;
6713 *r
->out
.info
= NULL
;
6715 /* that's an [in out] buffer */
6717 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0) ) {
6718 return WERR_INVALID_PARAM
;
6721 DEBUG(4,("_spoolss_EnumForms\n"));
6722 DEBUGADD(5,("Offered buffer size [%d]\n", r
->in
.offered
));
6723 DEBUGADD(5,("Info level [%d]\n", r
->in
.level
));
6725 num_builtin_forms
= get_builtin_ntforms(&builtin_forms
);
6726 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms
));
6727 num_user_forms
= get_ntforms(&user_forms
);
6728 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms
));
6730 if (num_user_forms
+ num_builtin_forms
== 0) {
6731 SAFE_FREE(builtin_forms
);
6732 SAFE_FREE(user_forms
);
6733 return WERR_NO_MORE_ITEMS
;
6736 switch (r
->in
.level
) {
6738 result
= spoolss_enumforms_level1(p
->mem_ctx
,
6747 result
= WERR_UNKNOWN_LEVEL
;
6751 SAFE_FREE(user_forms
);
6752 SAFE_FREE(builtin_forms
);
6754 if (!W_ERROR_IS_OK(result
)) {
6758 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
6759 spoolss_EnumForms
, NULL
,
6760 *r
->out
.info
, r
->in
.level
,
6762 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
6763 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
6765 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
6768 /****************************************************************
6769 ****************************************************************/
6771 static WERROR
find_form_byname(const char *name
,
6772 nt_forms_struct
*form
)
6774 nt_forms_struct
*list
= NULL
;
6775 int num_forms
= 0, i
= 0;
6777 if (get_a_builtin_ntform_by_string(name
, form
)) {
6781 num_forms
= get_ntforms(&list
);
6782 DEBUGADD(5,("Number of forms [%d]\n", num_forms
));
6784 if (num_forms
== 0) {
6788 /* Check if the requested name is in the list of form structures */
6789 for (i
= 0; i
< num_forms
; i
++) {
6791 DEBUG(4,("checking form %s (want %s)\n", list
[i
].name
, name
));
6793 if (strequal(name
, list
[i
].name
)) {
6794 DEBUGADD(6,("Found form %s number [%d]\n", name
, i
));
6806 /****************************************************************
6808 ****************************************************************/
6810 WERROR
_spoolss_GetForm(pipes_struct
*p
,
6811 struct spoolss_GetForm
*r
)
6814 nt_forms_struct form
;
6816 /* that's an [in out] buffer */
6818 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
6819 return WERR_INVALID_PARAM
;
6822 DEBUG(4,("_spoolss_GetForm\n"));
6823 DEBUGADD(5,("Offered buffer size [%d]\n", r
->in
.offered
));
6824 DEBUGADD(5,("Info level [%d]\n", r
->in
.level
));
6826 result
= find_form_byname(r
->in
.form_name
, &form
);
6827 if (!W_ERROR_IS_OK(result
)) {
6828 TALLOC_FREE(r
->out
.info
);
6832 switch (r
->in
.level
) {
6834 result
= fill_form_info_1(p
->mem_ctx
,
6835 &r
->out
.info
->info1
,
6840 result
= WERR_UNKNOWN_LEVEL
;
6844 if (!W_ERROR_IS_OK(result
)) {
6845 TALLOC_FREE(r
->out
.info
);
6849 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_FormInfo
, NULL
,
6850 r
->out
.info
, r
->in
.level
);
6851 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
6853 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
6856 /****************************************************************************
6857 ****************************************************************************/
6859 static WERROR
fill_port_1(TALLOC_CTX
*mem_ctx
,
6860 struct spoolss_PortInfo1
*r
,
6863 r
->port_name
= talloc_strdup(mem_ctx
, name
);
6864 W_ERROR_HAVE_NO_MEMORY(r
->port_name
);
6869 /****************************************************************************
6870 TODO: This probably needs distinguish between TCP/IP and Local ports
6872 ****************************************************************************/
6874 static WERROR
fill_port_2(TALLOC_CTX
*mem_ctx
,
6875 struct spoolss_PortInfo2
*r
,
6878 r
->port_name
= talloc_strdup(mem_ctx
, name
);
6879 W_ERROR_HAVE_NO_MEMORY(r
->port_name
);
6881 r
->monitor_name
= talloc_strdup(mem_ctx
, "Local Monitor");
6882 W_ERROR_HAVE_NO_MEMORY(r
->monitor_name
);
6884 r
->description
= talloc_strdup(mem_ctx
, SPL_LOCAL_PORT
);
6885 W_ERROR_HAVE_NO_MEMORY(r
->description
);
6887 r
->port_type
= SPOOLSS_PORT_TYPE_WRITE
;
6894 /****************************************************************************
6895 wrapper around the enumer ports command
6896 ****************************************************************************/
6898 static WERROR
enumports_hook(TALLOC_CTX
*ctx
, int *count
, char ***lines
)
6900 char *cmd
= lp_enumports_cmd();
6901 char **qlines
= NULL
;
6902 char *command
= NULL
;
6910 /* if no hook then just fill in the default port */
6913 if (!(qlines
= TALLOC_ARRAY( NULL
, char*, 2 ))) {
6916 if (!(qlines
[0] = talloc_strdup(qlines
, SAMBA_PRINTER_PORT_NAME
))) {
6917 TALLOC_FREE(qlines
);
6924 /* we have a valid enumport command */
6926 command
= talloc_asprintf(ctx
, "%s \"%d\"", cmd
, 1);
6931 DEBUG(10,("Running [%s]\n", command
));
6932 ret
= smbrun(command
, &fd
);
6933 DEBUG(10,("Returned [%d]\n", ret
));
6934 TALLOC_FREE(command
);
6939 return WERR_ACCESS_DENIED
;
6943 qlines
= fd_lines_load(fd
, &numlines
, 0, NULL
);
6944 DEBUGADD(10,("Lines returned = [%d]\n", numlines
));
6954 /****************************************************************************
6956 ****************************************************************************/
6958 static WERROR
enumports_level_1(TALLOC_CTX
*mem_ctx
,
6959 union spoolss_PortInfo
**info_p
,
6962 union spoolss_PortInfo
*info
= NULL
;
6964 WERROR result
= WERR_OK
;
6965 char **qlines
= NULL
;
6968 result
= enumports_hook(talloc_tos(), &numlines
, &qlines
);
6969 if (!W_ERROR_IS_OK(result
)) {
6974 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_PortInfo
, numlines
);
6976 DEBUG(10,("Returning WERR_NOMEM\n"));
6977 result
= WERR_NOMEM
;
6981 for (i
=0; i
<numlines
; i
++) {
6982 DEBUG(6,("Filling port number [%d] with port [%s]\n", i
, qlines
[i
]));
6983 result
= fill_port_1(info
, &info
[i
].info1
, qlines
[i
]);
6984 if (!W_ERROR_IS_OK(result
)) {
6989 TALLOC_FREE(qlines
);
6992 if (!W_ERROR_IS_OK(result
)) {
6994 TALLOC_FREE(qlines
);
7006 /****************************************************************************
7008 ****************************************************************************/
7010 static WERROR
enumports_level_2(TALLOC_CTX
*mem_ctx
,
7011 union spoolss_PortInfo
**info_p
,
7014 union spoolss_PortInfo
*info
= NULL
;
7016 WERROR result
= WERR_OK
;
7017 char **qlines
= NULL
;
7020 result
= enumports_hook(talloc_tos(), &numlines
, &qlines
);
7021 if (!W_ERROR_IS_OK(result
)) {
7026 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_PortInfo
, numlines
);
7028 DEBUG(10,("Returning WERR_NOMEM\n"));
7029 result
= WERR_NOMEM
;
7033 for (i
=0; i
<numlines
; i
++) {
7034 DEBUG(6,("Filling port number [%d] with port [%s]\n", i
, qlines
[i
]));
7035 result
= fill_port_2(info
, &info
[i
].info2
, qlines
[i
]);
7036 if (!W_ERROR_IS_OK(result
)) {
7041 TALLOC_FREE(qlines
);
7044 if (!W_ERROR_IS_OK(result
)) {
7046 TALLOC_FREE(qlines
);
7058 /****************************************************************
7060 ****************************************************************/
7062 WERROR
_spoolss_EnumPorts(pipes_struct
*p
,
7063 struct spoolss_EnumPorts
*r
)
7067 /* that's an [in out] buffer */
7069 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
7070 return WERR_INVALID_PARAM
;
7073 DEBUG(4,("_spoolss_EnumPorts\n"));
7077 *r
->out
.info
= NULL
;
7079 switch (r
->in
.level
) {
7081 result
= enumports_level_1(p
->mem_ctx
, r
->out
.info
,
7085 result
= enumports_level_2(p
->mem_ctx
, r
->out
.info
,
7089 return WERR_UNKNOWN_LEVEL
;
7092 if (!W_ERROR_IS_OK(result
)) {
7096 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
7097 spoolss_EnumPorts
, NULL
,
7098 *r
->out
.info
, r
->in
.level
,
7100 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
7101 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
7103 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
7106 /****************************************************************************
7107 ****************************************************************************/
7109 static WERROR
spoolss_addprinterex_level_2(pipes_struct
*p
,
7111 struct spoolss_SetPrinterInfoCtr
*info_ctr
,
7112 struct spoolss_DeviceMode
*devmode
,
7113 struct security_descriptor
*sec_desc
,
7114 struct spoolss_UserLevelCtr
*user_ctr
,
7115 struct policy_handle
*handle
)
7117 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
7120 WERROR err
= WERR_OK
;
7122 if ( !(printer
= TALLOC_ZERO_P(NULL
, NT_PRINTER_INFO_LEVEL
)) ) {
7123 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7127 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7128 if (!convert_printer_info(info_ctr
, printer
)) {
7129 free_a_printer(&printer
, 2);
7133 /* check to see if the printer already exists */
7135 if ((snum
= print_queue_snum(printer
->info_2
->sharename
)) != -1) {
7136 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7137 printer
->info_2
->sharename
));
7138 free_a_printer(&printer
, 2);
7139 return WERR_PRINTER_ALREADY_EXISTS
;
7142 /* FIXME!!! smbd should check to see if the driver is installed before
7143 trying to add a printer like this --jerry */
7145 if (*lp_addprinter_cmd() ) {
7146 if ( !add_printer_hook(p
->mem_ctx
, p
->server_info
->ptok
,
7148 free_a_printer(&printer
,2);
7149 return WERR_ACCESS_DENIED
;
7152 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7153 "smb.conf parameter \"addprinter command\" is defined. This"
7154 "parameter must exist for this call to succeed\n",
7155 printer
->info_2
->sharename
));
7158 /* use our primary netbios name since get_a_printer() will convert
7159 it to what the client expects on a case by case basis */
7161 slprintf(name
, sizeof(name
)-1, "\\\\%s\\%s", global_myname(),
7162 printer
->info_2
->sharename
);
7165 if ((snum
= print_queue_snum(printer
->info_2
->sharename
)) == -1) {
7166 free_a_printer(&printer
,2);
7167 return WERR_ACCESS_DENIED
;
7170 /* you must be a printer admin to add a new printer */
7171 if (!print_access_check(p
->server_info
, snum
, PRINTER_ACCESS_ADMINISTER
)) {
7172 free_a_printer(&printer
,2);
7173 return WERR_ACCESS_DENIED
;
7177 * Do sanity check on the requested changes for Samba.
7180 if (!check_printer_ok(printer
->info_2
, snum
)) {
7181 free_a_printer(&printer
,2);
7182 return WERR_INVALID_PARAM
;
7186 * When a printer is created, the drivername bound to the printer is used
7187 * to lookup previously saved driver initialization info, which is then
7188 * bound to the new printer, simulating what happens in the Windows arch.
7193 set_driver_init(printer
, 2);
7197 /* A valid devmode was included, convert and link it
7199 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7201 if (!convert_devicemode(printer
->info_2
->printername
, devmode
,
7202 &printer
->info_2
->devmode
)) {
7207 /* write the ASCII on disk */
7208 err
= mod_a_printer(printer
, 2);
7209 if (!W_ERROR_IS_OK(err
)) {
7210 free_a_printer(&printer
,2);
7214 if (!open_printer_hnd(p
, handle
, name
, PRINTER_ACCESS_ADMINISTER
)) {
7215 /* Handle open failed - remove addition. */
7216 del_a_printer(printer
->info_2
->sharename
);
7217 free_a_printer(&printer
,2);
7218 ZERO_STRUCTP(handle
);
7219 return WERR_ACCESS_DENIED
;
7222 update_c_setprinter(false);
7223 free_a_printer(&printer
,2);
7228 /****************************************************************
7229 _spoolss_AddPrinterEx
7230 ****************************************************************/
7232 WERROR
_spoolss_AddPrinterEx(pipes_struct
*p
,
7233 struct spoolss_AddPrinterEx
*r
)
7235 switch (r
->in
.info_ctr
->level
) {
7237 /* we don't handle yet */
7238 /* but I know what to do ... */
7239 return WERR_UNKNOWN_LEVEL
;
7241 return spoolss_addprinterex_level_2(p
, r
->in
.server
,
7243 r
->in
.devmode_ctr
->devmode
,
7244 r
->in
.secdesc_ctr
->sd
,
7245 r
->in
.userlevel_ctr
,
7248 return WERR_UNKNOWN_LEVEL
;
7252 /****************************************************************
7254 ****************************************************************/
7256 WERROR
_spoolss_AddPrinter(pipes_struct
*p
,
7257 struct spoolss_AddPrinter
*r
)
7259 struct spoolss_AddPrinterEx a
;
7260 struct spoolss_UserLevelCtr userlevel_ctr
;
7262 ZERO_STRUCT(userlevel_ctr
);
7264 userlevel_ctr
.level
= 1;
7266 a
.in
.server
= r
->in
.server
;
7267 a
.in
.info_ctr
= r
->in
.info_ctr
;
7268 a
.in
.devmode_ctr
= r
->in
.devmode_ctr
;
7269 a
.in
.secdesc_ctr
= r
->in
.secdesc_ctr
;
7270 a
.in
.userlevel_ctr
= &userlevel_ctr
;
7271 a
.out
.handle
= r
->out
.handle
;
7273 return _spoolss_AddPrinterEx(p
, &a
);
7276 /****************************************************************
7277 _spoolss_AddPrinterDriver
7278 ****************************************************************/
7280 WERROR
_spoolss_AddPrinterDriver(pipes_struct
*p
,
7281 struct spoolss_AddPrinterDriver
*r
)
7283 WERROR err
= WERR_OK
;
7284 char *driver_name
= NULL
;
7288 switch (p
->hdr_req
.opnum
) {
7289 case NDR_SPOOLSS_ADDPRINTERDRIVER
:
7290 fn
= "_spoolss_AddPrinterDriver";
7292 case NDR_SPOOLSS_ADDPRINTERDRIVEREX
:
7293 fn
= "_spoolss_AddPrinterDriverEx";
7296 return WERR_INVALID_PARAM
;
7301 if (r
->in
.info_ctr
->level
!= 3 && r
->in
.info_ctr
->level
!= 6) {
7302 /* Clever hack from Martin Zielinski <mz@seh.de>
7303 * to allow downgrade from level 8 (Vista).
7305 DEBUG(0,("%s: level %d not yet implemented\n", fn
,
7306 r
->in
.info_ctr
->level
));
7307 return WERR_UNKNOWN_LEVEL
;
7310 DEBUG(5,("Cleaning driver's information\n"));
7311 err
= clean_up_driver_struct(p
, r
->in
.info_ctr
);
7312 if (!W_ERROR_IS_OK(err
))
7315 DEBUG(5,("Moving driver to final destination\n"));
7316 if( !W_ERROR_IS_OK(err
= move_driver_to_download_area(p
, r
->in
.info_ctr
,
7321 if (add_a_printer_driver(p
->mem_ctx
, r
->in
.info_ctr
, &driver_name
, &version
)!=0) {
7322 err
= WERR_ACCESS_DENIED
;
7327 * I think this is where he DrvUpgradePrinter() hook would be
7328 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7329 * server. Right now, we just need to send ourselves a message
7330 * to update each printer bound to this driver. --jerry
7333 if (!srv_spoolss_drv_upgrade_printer(driver_name
)) {
7334 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7339 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7340 * decide if the driver init data should be deleted. The rules are:
7341 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7342 * 2) delete init data only if there is no 2k/Xp driver
7343 * 3) always delete init data
7344 * The generalized rule is always use init data from the highest order driver.
7345 * It is necessary to follow the driver install by an initialization step to
7346 * finish off this process.
7351 * 9x printer driver - never delete init data
7354 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7359 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7360 * there is no 2k/Xp driver init data for this driver name.
7364 struct spoolss_DriverInfo8
*driver1
;
7366 if (!W_ERROR_IS_OK(get_a_printer_driver(p
->mem_ctx
, &driver1
, driver_name
, "Windows NT x86", 3))) {
7368 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7370 if (!del_driver_init(driver_name
))
7371 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7375 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7377 free_a_printer_driver(driver1
);
7378 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7385 * 2k or Xp printer driver - always delete init data
7388 if (!del_driver_init(driver_name
))
7389 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7394 DEBUG(0,("%s: invalid level=%d\n", fn
,
7395 r
->in
.info_ctr
->level
));
7404 /****************************************************************
7405 _spoolss_AddPrinterDriverEx
7406 ****************************************************************/
7408 WERROR
_spoolss_AddPrinterDriverEx(pipes_struct
*p
,
7409 struct spoolss_AddPrinterDriverEx
*r
)
7411 struct spoolss_AddPrinterDriver a
;
7414 * we only support the semantics of AddPrinterDriver()
7415 * i.e. only copy files that are newer than existing ones
7418 if (r
->in
.flags
!= APD_COPY_NEW_FILES
) {
7419 return WERR_ACCESS_DENIED
;
7422 a
.in
.servername
= r
->in
.servername
;
7423 a
.in
.info_ctr
= r
->in
.info_ctr
;
7425 return _spoolss_AddPrinterDriver(p
, &a
);
7428 /****************************************************************************
7429 ****************************************************************************/
7431 struct _spoolss_paths
{
7437 enum { SPOOLSS_DRIVER_PATH
, SPOOLSS_PRTPROCS_PATH
};
7439 static const struct _spoolss_paths spoolss_paths
[]= {
7440 { SPOOLSS_DRIVER_PATH
, "print$", "DRIVERS" },
7441 { SPOOLSS_PRTPROCS_PATH
, "prnproc$", "PRTPROCS" }
7444 static WERROR
compose_spoolss_server_path(TALLOC_CTX
*mem_ctx
,
7445 const char *servername
,
7446 const char *environment
,
7450 const char *pservername
= NULL
;
7451 const char *long_archi
= SPOOLSS_ARCHITECTURE_NT_X86
;
7452 const char *short_archi
;
7456 /* environment may be empty */
7457 if (environment
&& strlen(environment
)) {
7458 long_archi
= environment
;
7461 /* servername may be empty */
7462 if (servername
&& strlen(servername
)) {
7463 pservername
= canon_servername(servername
);
7465 if (!is_myname_or_ipaddr(pservername
)) {
7466 return WERR_INVALID_PARAM
;
7470 if (!(short_archi
= get_short_archi(long_archi
))) {
7471 return WERR_INVALID_ENVIRONMENT
;
7474 switch (component
) {
7475 case SPOOLSS_PRTPROCS_PATH
:
7476 case SPOOLSS_DRIVER_PATH
:
7478 *path
= talloc_asprintf(mem_ctx
,
7481 spoolss_paths
[component
].share
,
7484 *path
= talloc_asprintf(mem_ctx
, "%s\\%s\\%s",
7485 SPOOLSS_DEFAULT_SERVER_PATH
,
7486 spoolss_paths
[component
].dir
,
7491 return WERR_INVALID_PARAM
;
7501 /****************************************************************************
7502 ****************************************************************************/
7504 static WERROR
getprinterdriverdir_level_1(TALLOC_CTX
*mem_ctx
,
7505 const char *servername
,
7506 const char *environment
,
7507 struct spoolss_DriverDirectoryInfo1
*r
)
7512 werr
= compose_spoolss_server_path(mem_ctx
,
7515 SPOOLSS_DRIVER_PATH
,
7517 if (!W_ERROR_IS_OK(werr
)) {
7521 DEBUG(4,("printer driver directory: [%s]\n", path
));
7523 r
->directory_name
= path
;
7528 /****************************************************************
7529 _spoolss_GetPrinterDriverDirectory
7530 ****************************************************************/
7532 WERROR
_spoolss_GetPrinterDriverDirectory(pipes_struct
*p
,
7533 struct spoolss_GetPrinterDriverDirectory
*r
)
7537 /* that's an [in out] buffer */
7539 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
7540 return WERR_INVALID_PARAM
;
7543 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7548 /* r->in.level is ignored */
7550 werror
= getprinterdriverdir_level_1(p
->mem_ctx
,
7553 &r
->out
.info
->info1
);
7554 if (!W_ERROR_IS_OK(werror
)) {
7555 TALLOC_FREE(r
->out
.info
);
7559 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo
, NULL
,
7560 r
->out
.info
, r
->in
.level
);
7561 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
7563 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
7566 /****************************************************************
7567 _spoolss_EnumPrinterData
7568 ****************************************************************/
7570 WERROR
_spoolss_EnumPrinterData(pipes_struct
*p
,
7571 struct spoolss_EnumPrinterData
*r
)
7573 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
7574 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
7577 struct regval_blob
*val
= NULL
;
7578 NT_PRINTER_DATA
*p_data
;
7579 int i
, key_index
, num_values
;
7582 *r
->out
.value_needed
= 0;
7583 *r
->out
.type
= REG_NONE
;
7584 *r
->out
.data_needed
= 0;
7586 DEBUG(5,("_spoolss_EnumPrinterData\n"));
7589 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
7590 OUR_HANDLE(r
->in
.handle
)));
7594 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
7598 result
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
7599 if (!W_ERROR_IS_OK(result
)) {
7603 p_data
= printer
->info_2
->data
;
7604 key_index
= lookup_printerkey( p_data
, SPOOL_PRINTERDATA_KEY
);
7609 * The NT machine wants to know the biggest size of value and data
7611 * cf: MSDN EnumPrinterData remark section
7614 if (!r
->in
.value_offered
&& !r
->in
.data_offered
&& (key_index
!= -1)) {
7616 uint32_t biggest_valuesize
= 0;
7617 uint32_t biggest_datasize
= 0;
7619 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7621 num_values
= regval_ctr_numvals( p_data
->keys
[key_index
].values
);
7623 for ( i
=0; i
<num_values
; i
++ )
7625 val
= regval_ctr_specific_value( p_data
->keys
[key_index
].values
, i
);
7627 name_length
= strlen(val
->valuename
);
7628 if ( strlen(val
->valuename
) > biggest_valuesize
)
7629 biggest_valuesize
= name_length
;
7631 if ( val
->size
> biggest_datasize
)
7632 biggest_datasize
= val
->size
;
7634 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize
,
7638 /* the value is an UNICODE string but real_value_size is the length
7639 in bytes including the trailing 0 */
7641 *r
->out
.value_needed
= 2 * (1 + biggest_valuesize
);
7642 *r
->out
.data_needed
= biggest_datasize
;
7644 DEBUG(6,("final values: [%d], [%d]\n",
7645 *r
->out
.value_needed
, *r
->out
.data_needed
));
7651 * the value len is wrong in NT sp3
7652 * that's the number of bytes not the number of unicode chars
7655 if (key_index
!= -1) {
7656 val
= regval_ctr_specific_value(p_data
->keys
[key_index
].values
,
7662 /* out_value should default to "" or else NT4 has
7663 problems unmarshalling the response */
7665 if (r
->in
.value_offered
) {
7666 *r
->out
.value_needed
= 1;
7667 r
->out
.value_name
= talloc_strdup(r
, "");
7668 if (!r
->out
.value_name
) {
7669 result
= WERR_NOMEM
;
7673 r
->out
.value_name
= NULL
;
7674 *r
->out
.value_needed
= 0;
7677 /* the data is counted in bytes */
7679 *r
->out
.data_needed
= r
->in
.data_offered
;
7681 result
= WERR_NO_MORE_ITEMS
;
7685 * - counted in bytes in the request
7686 * - counted in UNICODE chars in the max reply
7687 * - counted in bytes in the real size
7689 * take a pause *before* coding not *during* coding
7693 if (r
->in
.value_offered
) {
7694 r
->out
.value_name
= talloc_strdup(r
, regval_name(val
));
7695 if (!r
->out
.value_name
) {
7696 result
= WERR_NOMEM
;
7699 *r
->out
.value_needed
= strlen_m_term(regval_name(val
)) * 2;
7701 r
->out
.value_name
= NULL
;
7702 *r
->out
.value_needed
= 0;
7707 *r
->out
.type
= regval_type(val
);
7709 /* data - counted in bytes */
7712 * See the section "Dynamically Typed Query Parameters"
7716 if (r
->out
.data
&& regval_data_p(val
) &&
7717 regval_size(val
) && r
->in
.data_offered
) {
7718 memcpy(r
->out
.data
, regval_data_p(val
),
7719 MIN(regval_size(val
),r
->in
.data_offered
));
7722 *r
->out
.data_needed
= regval_size(val
);
7726 free_a_printer(&printer
, 2);
7730 /****************************************************************
7731 _spoolss_SetPrinterData
7732 ****************************************************************/
7734 WERROR
_spoolss_SetPrinterData(pipes_struct
*p
,
7735 struct spoolss_SetPrinterData
*r
)
7737 struct spoolss_SetPrinterDataEx r2
;
7739 r2
.in
.handle
= r
->in
.handle
;
7740 r2
.in
.key_name
= "PrinterDriverData";
7741 r2
.in
.value_name
= r
->in
.value_name
;
7742 r2
.in
.type
= r
->in
.type
;
7743 r2
.in
.data
= r
->in
.data
;
7744 r2
.in
.offered
= r
->in
.offered
;
7746 return _spoolss_SetPrinterDataEx(p
, &r2
);
7749 /****************************************************************
7750 _spoolss_ResetPrinter
7751 ****************************************************************/
7753 WERROR
_spoolss_ResetPrinter(pipes_struct
*p
,
7754 struct spoolss_ResetPrinter
*r
)
7756 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
7759 DEBUG(5,("_spoolss_ResetPrinter\n"));
7762 * All we do is to check to see if the handle and queue is valid.
7763 * This call really doesn't mean anything to us because we only
7764 * support RAW printing. --jerry
7768 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
7769 OUR_HANDLE(r
->in
.handle
)));
7773 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
7777 /* blindly return success */
7781 /****************************************************************
7782 _spoolss_DeletePrinterData
7783 ****************************************************************/
7785 WERROR
_spoolss_DeletePrinterData(pipes_struct
*p
,
7786 struct spoolss_DeletePrinterData
*r
)
7788 struct spoolss_DeletePrinterDataEx r2
;
7790 r2
.in
.handle
= r
->in
.handle
;
7791 r2
.in
.key_name
= "PrinterDriverData";
7792 r2
.in
.value_name
= r
->in
.value_name
;
7794 return _spoolss_DeletePrinterDataEx(p
, &r2
);
7797 /****************************************************************
7799 ****************************************************************/
7801 WERROR
_spoolss_AddForm(pipes_struct
*p
,
7802 struct spoolss_AddForm
*r
)
7804 struct spoolss_AddFormInfo1
*form
= r
->in
.info
.info1
;
7805 nt_forms_struct tmpForm
;
7807 WERROR status
= WERR_OK
;
7808 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
7809 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
7812 nt_forms_struct
*list
=NULL
;
7813 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
7815 DEBUG(5,("_spoolss_AddForm\n"));
7818 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
7819 OUR_HANDLE(r
->in
.handle
)));
7824 /* forms can be added on printer of on the print server handle */
7826 if ( Printer
->printer_type
== SPLHND_PRINTER
)
7828 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
7831 status
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
7832 if (!W_ERROR_IS_OK(status
))
7836 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
7837 and not a printer admin, then fail */
7839 if ((p
->server_info
->utok
.uid
!= sec_initial_uid()) &&
7840 !user_has_privileges(p
->server_info
->ptok
, &se_printop
) &&
7841 !token_contains_name_in_list(uidtoname(p
->server_info
->utok
.uid
),
7843 p
->server_info
->ptok
,
7844 lp_printer_admin(snum
))) {
7845 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
7846 return WERR_ACCESS_DENIED
;
7849 /* can't add if builtin */
7851 if (get_a_builtin_ntform_by_string(form
->form_name
, &tmpForm
)) {
7852 status
= WERR_FILE_EXISTS
;
7856 count
= get_ntforms(&list
);
7858 if(!add_a_form(&list
, form
, &count
)) {
7859 status
= WERR_NOMEM
;
7864 write_ntforms(&list
, count
);
7868 * ChangeID must always be set if this is a printer
7871 if ( Printer
->printer_type
== SPLHND_PRINTER
)
7872 status
= mod_a_printer(printer
, 2);
7876 free_a_printer(&printer
, 2);
7882 /****************************************************************
7884 ****************************************************************/
7886 WERROR
_spoolss_DeleteForm(pipes_struct
*p
,
7887 struct spoolss_DeleteForm
*r
)
7889 const char *form_name
= r
->in
.form_name
;
7890 nt_forms_struct tmpForm
;
7892 nt_forms_struct
*list
=NULL
;
7893 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
7895 WERROR status
= WERR_OK
;
7896 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
7897 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
7900 DEBUG(5,("_spoolss_DeleteForm\n"));
7903 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
7904 OUR_HANDLE(r
->in
.handle
)));
7908 /* forms can be deleted on printer of on the print server handle */
7910 if ( Printer
->printer_type
== SPLHND_PRINTER
)
7912 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
7915 status
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
7916 if (!W_ERROR_IS_OK(status
))
7920 if ((p
->server_info
->utok
.uid
!= sec_initial_uid()) &&
7921 !user_has_privileges(p
->server_info
->ptok
, &se_printop
) &&
7922 !token_contains_name_in_list(uidtoname(p
->server_info
->utok
.uid
),
7924 p
->server_info
->ptok
,
7925 lp_printer_admin(snum
))) {
7926 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
7927 return WERR_ACCESS_DENIED
;
7931 /* can't delete if builtin */
7933 if (get_a_builtin_ntform_by_string(form_name
,&tmpForm
)) {
7934 status
= WERR_INVALID_PARAM
;
7938 count
= get_ntforms(&list
);
7941 ret
= delete_a_form(&list
, form_name
, &count
, &status
);
7948 * ChangeID must always be set if this is a printer
7951 if ( Printer
->printer_type
== SPLHND_PRINTER
)
7952 status
= mod_a_printer(printer
, 2);
7956 free_a_printer(&printer
, 2);
7962 /****************************************************************
7964 ****************************************************************/
7966 WERROR
_spoolss_SetForm(pipes_struct
*p
,
7967 struct spoolss_SetForm
*r
)
7969 struct spoolss_AddFormInfo1
*form
= r
->in
.info
.info1
;
7970 nt_forms_struct tmpForm
;
7972 WERROR status
= WERR_OK
;
7973 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
7974 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
7977 nt_forms_struct
*list
=NULL
;
7978 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
7980 DEBUG(5,("_spoolss_SetForm\n"));
7983 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
7984 OUR_HANDLE(r
->in
.handle
)));
7988 /* forms can be modified on printer of on the print server handle */
7990 if ( Printer
->printer_type
== SPLHND_PRINTER
)
7992 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
7995 status
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
7996 if (!W_ERROR_IS_OK(status
))
8000 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8001 and not a printer admin, then fail */
8003 if ((p
->server_info
->utok
.uid
!= sec_initial_uid()) &&
8004 !user_has_privileges(p
->server_info
->ptok
, &se_printop
) &&
8005 !token_contains_name_in_list(uidtoname(p
->server_info
->utok
.uid
),
8007 p
->server_info
->ptok
,
8008 lp_printer_admin(snum
))) {
8009 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8010 return WERR_ACCESS_DENIED
;
8013 /* can't set if builtin */
8014 if (get_a_builtin_ntform_by_string(form
->form_name
, &tmpForm
)) {
8015 status
= WERR_INVALID_PARAM
;
8019 count
= get_ntforms(&list
);
8020 update_a_form(&list
, form
, count
);
8022 write_ntforms(&list
, count
);
8026 * ChangeID must always be set if this is a printer
8029 if ( Printer
->printer_type
== SPLHND_PRINTER
)
8030 status
= mod_a_printer(printer
, 2);
8035 free_a_printer(&printer
, 2);
8041 /****************************************************************************
8042 fill_print_processor1
8043 ****************************************************************************/
8045 static WERROR
fill_print_processor1(TALLOC_CTX
*mem_ctx
,
8046 struct spoolss_PrintProcessorInfo1
*r
,
8047 const char *print_processor_name
)
8049 r
->print_processor_name
= talloc_strdup(mem_ctx
, print_processor_name
);
8050 W_ERROR_HAVE_NO_MEMORY(r
->print_processor_name
);
8055 /****************************************************************************
8056 enumprintprocessors level 1.
8057 ****************************************************************************/
8059 static WERROR
enumprintprocessors_level_1(TALLOC_CTX
*mem_ctx
,
8060 union spoolss_PrintProcessorInfo
**info_p
,
8063 union spoolss_PrintProcessorInfo
*info
;
8066 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_PrintProcessorInfo
, 1);
8067 W_ERROR_HAVE_NO_MEMORY(info
);
8071 result
= fill_print_processor1(info
, &info
[0].info1
, "winprint");
8072 if (!W_ERROR_IS_OK(result
)) {
8077 if (!W_ERROR_IS_OK(result
)) {
8088 /****************************************************************
8089 _spoolss_EnumPrintProcessors
8090 ****************************************************************/
8092 WERROR
_spoolss_EnumPrintProcessors(pipes_struct
*p
,
8093 struct spoolss_EnumPrintProcessors
*r
)
8097 /* that's an [in out] buffer */
8099 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
8100 return WERR_INVALID_PARAM
;
8103 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8106 * Enumerate the print processors ...
8108 * Just reply with "winprint", to keep NT happy
8109 * and I can use my nice printer checker.
8114 *r
->out
.info
= NULL
;
8116 switch (r
->in
.level
) {
8118 result
= enumprintprocessors_level_1(p
->mem_ctx
, r
->out
.info
,
8122 return WERR_UNKNOWN_LEVEL
;
8125 if (!W_ERROR_IS_OK(result
)) {
8129 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
8130 spoolss_EnumPrintProcessors
, NULL
,
8131 *r
->out
.info
, r
->in
.level
,
8133 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
8134 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
8136 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
8139 /****************************************************************************
8140 fill_printprocdatatype1
8141 ****************************************************************************/
8143 static WERROR
fill_printprocdatatype1(TALLOC_CTX
*mem_ctx
,
8144 struct spoolss_PrintProcDataTypesInfo1
*r
,
8145 const char *name_array
)
8147 r
->name_array
= talloc_strdup(mem_ctx
, name_array
);
8148 W_ERROR_HAVE_NO_MEMORY(r
->name_array
);
8153 /****************************************************************************
8154 enumprintprocdatatypes level 1.
8155 ****************************************************************************/
8157 static WERROR
enumprintprocdatatypes_level_1(TALLOC_CTX
*mem_ctx
,
8158 union spoolss_PrintProcDataTypesInfo
**info_p
,
8162 union spoolss_PrintProcDataTypesInfo
*info
;
8164 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_PrintProcDataTypesInfo
, 1);
8165 W_ERROR_HAVE_NO_MEMORY(info
);
8169 result
= fill_printprocdatatype1(info
, &info
[0].info1
, "RAW");
8170 if (!W_ERROR_IS_OK(result
)) {
8175 if (!W_ERROR_IS_OK(result
)) {
8186 /****************************************************************
8187 _spoolss_EnumPrintProcDataTypes
8188 ****************************************************************/
8190 WERROR
_spoolss_EnumPrintProcDataTypes(pipes_struct
*p
,
8191 struct spoolss_EnumPrintProcDataTypes
*r
)
8195 /* that's an [in out] buffer */
8197 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
8198 return WERR_INVALID_PARAM
;
8201 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8205 *r
->out
.info
= NULL
;
8207 switch (r
->in
.level
) {
8209 result
= enumprintprocdatatypes_level_1(p
->mem_ctx
, r
->out
.info
,
8213 return WERR_UNKNOWN_LEVEL
;
8216 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
8217 spoolss_EnumPrintProcDataTypes
, NULL
,
8218 *r
->out
.info
, r
->in
.level
,
8220 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
8221 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
8223 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
8226 /****************************************************************************
8228 ****************************************************************************/
8230 static WERROR
fill_monitor_1(TALLOC_CTX
*mem_ctx
,
8231 struct spoolss_MonitorInfo1
*r
,
8232 const char *monitor_name
)
8234 r
->monitor_name
= talloc_strdup(mem_ctx
, monitor_name
);
8235 W_ERROR_HAVE_NO_MEMORY(r
->monitor_name
);
8240 /****************************************************************************
8242 ****************************************************************************/
8244 static WERROR
fill_monitor_2(TALLOC_CTX
*mem_ctx
,
8245 struct spoolss_MonitorInfo2
*r
,
8246 const char *monitor_name
,
8247 const char *environment
,
8248 const char *dll_name
)
8250 r
->monitor_name
= talloc_strdup(mem_ctx
, monitor_name
);
8251 W_ERROR_HAVE_NO_MEMORY(r
->monitor_name
);
8252 r
->environment
= talloc_strdup(mem_ctx
, environment
);
8253 W_ERROR_HAVE_NO_MEMORY(r
->environment
);
8254 r
->dll_name
= talloc_strdup(mem_ctx
, dll_name
);
8255 W_ERROR_HAVE_NO_MEMORY(r
->dll_name
);
8260 /****************************************************************************
8261 enumprintmonitors level 1.
8262 ****************************************************************************/
8264 static WERROR
enumprintmonitors_level_1(TALLOC_CTX
*mem_ctx
,
8265 union spoolss_MonitorInfo
**info_p
,
8268 union spoolss_MonitorInfo
*info
;
8269 WERROR result
= WERR_OK
;
8271 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_MonitorInfo
, 2);
8272 W_ERROR_HAVE_NO_MEMORY(info
);
8276 result
= fill_monitor_1(info
, &info
[0].info1
,
8278 if (!W_ERROR_IS_OK(result
)) {
8282 result
= fill_monitor_1(info
, &info
[1].info1
,
8284 if (!W_ERROR_IS_OK(result
)) {
8289 if (!W_ERROR_IS_OK(result
)) {
8300 /****************************************************************************
8301 enumprintmonitors level 2.
8302 ****************************************************************************/
8304 static WERROR
enumprintmonitors_level_2(TALLOC_CTX
*mem_ctx
,
8305 union spoolss_MonitorInfo
**info_p
,
8308 union spoolss_MonitorInfo
*info
;
8309 WERROR result
= WERR_OK
;
8311 info
= TALLOC_ARRAY(mem_ctx
, union spoolss_MonitorInfo
, 2);
8312 W_ERROR_HAVE_NO_MEMORY(info
);
8316 result
= fill_monitor_2(info
, &info
[0].info2
,
8318 "Windows NT X86", /* FIXME */
8320 if (!W_ERROR_IS_OK(result
)) {
8324 result
= fill_monitor_2(info
, &info
[1].info2
,
8326 "Windows NT X86", /* FIXME */
8328 if (!W_ERROR_IS_OK(result
)) {
8333 if (!W_ERROR_IS_OK(result
)) {
8344 /****************************************************************
8345 _spoolss_EnumMonitors
8346 ****************************************************************/
8348 WERROR
_spoolss_EnumMonitors(pipes_struct
*p
,
8349 struct spoolss_EnumMonitors
*r
)
8353 /* that's an [in out] buffer */
8355 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
8356 return WERR_INVALID_PARAM
;
8359 DEBUG(5,("_spoolss_EnumMonitors\n"));
8362 * Enumerate the print monitors ...
8364 * Just reply with "Local Port", to keep NT happy
8365 * and I can use my nice printer checker.
8370 *r
->out
.info
= NULL
;
8372 switch (r
->in
.level
) {
8374 result
= enumprintmonitors_level_1(p
->mem_ctx
, r
->out
.info
,
8378 result
= enumprintmonitors_level_2(p
->mem_ctx
, r
->out
.info
,
8382 return WERR_UNKNOWN_LEVEL
;
8385 if (!W_ERROR_IS_OK(result
)) {
8389 *r
->out
.needed
= SPOOLSS_BUFFER_UNION_ARRAY(p
->mem_ctx
,
8390 spoolss_EnumMonitors
, NULL
,
8391 *r
->out
.info
, r
->in
.level
,
8393 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
8394 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, 0);
8396 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
8399 /****************************************************************************
8400 ****************************************************************************/
8402 static WERROR
getjob_level_1(TALLOC_CTX
*mem_ctx
,
8403 const print_queue_struct
*queue
,
8404 int count
, int snum
,
8405 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
8407 struct spoolss_JobInfo1
*r
)
8412 for (i
=0; i
<count
&& found
== false; i
++) {
8413 if (queue
[i
].job
== (int)jobid
) {
8418 if (found
== false) {
8419 /* NT treats not found as bad param... yet another bad choice */
8420 return WERR_INVALID_PARAM
;
8423 return fill_job_info1(mem_ctx
,
8431 /****************************************************************************
8432 ****************************************************************************/
8434 static WERROR
getjob_level_2(TALLOC_CTX
*mem_ctx
,
8435 const print_queue_struct
*queue
,
8436 int count
, int snum
,
8437 const NT_PRINTER_INFO_LEVEL
*ntprinter
,
8439 struct spoolss_JobInfo2
*r
)
8443 struct spoolss_DeviceMode
*devmode
;
8444 NT_DEVICEMODE
*nt_devmode
;
8447 for (i
=0; i
<count
&& found
== false; i
++) {
8448 if (queue
[i
].job
== (int)jobid
) {
8453 if (found
== false) {
8454 /* NT treats not found as bad param... yet another bad
8456 return WERR_INVALID_PARAM
;
8460 * if the print job does not have a DEVMODE associated with it,
8461 * just use the one for the printer. A NULL devicemode is not
8462 * a failure condition
8465 nt_devmode
= print_job_devmode(lp_const_servicename(snum
), jobid
);
8467 devmode
= TALLOC_ZERO_P(mem_ctx
, struct spoolss_DeviceMode
);
8468 W_ERROR_HAVE_NO_MEMORY(devmode
);
8469 result
= convert_nt_devicemode(devmode
, devmode
, nt_devmode
);
8470 if (!W_ERROR_IS_OK(result
)) {
8474 devmode
= construct_dev_mode(mem_ctx
, lp_const_servicename(snum
));
8475 W_ERROR_HAVE_NO_MEMORY(devmode
);
8478 return fill_job_info2(mem_ctx
,
8487 /****************************************************************
8489 ****************************************************************/
8491 WERROR
_spoolss_GetJob(pipes_struct
*p
,
8492 struct spoolss_GetJob
*r
)
8494 WERROR result
= WERR_OK
;
8495 NT_PRINTER_INFO_LEVEL
*ntprinter
= NULL
;
8498 print_queue_struct
*queue
= NULL
;
8499 print_status_struct prt_status
;
8501 /* that's an [in out] buffer */
8503 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
8504 return WERR_INVALID_PARAM
;
8507 DEBUG(5,("_spoolss_GetJob\n"));
8511 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
8515 result
= get_a_printer(NULL
, &ntprinter
, 2, lp_servicename(snum
));
8516 if (!W_ERROR_IS_OK(result
)) {
8520 count
= print_queue_status(snum
, &queue
, &prt_status
);
8522 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8523 count
, prt_status
.status
, prt_status
.message
));
8525 switch (r
->in
.level
) {
8527 result
= getjob_level_1(p
->mem_ctx
,
8528 queue
, count
, snum
, ntprinter
,
8529 r
->in
.job_id
, &r
->out
.info
->info1
);
8532 result
= getjob_level_2(p
->mem_ctx
,
8533 queue
, count
, snum
, ntprinter
,
8534 r
->in
.job_id
, &r
->out
.info
->info2
);
8537 result
= WERR_UNKNOWN_LEVEL
;
8542 free_a_printer(&ntprinter
, 2);
8544 if (!W_ERROR_IS_OK(result
)) {
8545 TALLOC_FREE(r
->out
.info
);
8549 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_JobInfo
, NULL
,
8550 r
->out
.info
, r
->in
.level
);
8551 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
8553 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
8556 /****************************************************************
8557 _spoolss_GetPrinterDataEx
8558 ****************************************************************/
8560 WERROR
_spoolss_GetPrinterDataEx(pipes_struct
*p
,
8561 struct spoolss_GetPrinterDataEx
*r
)
8564 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
8565 struct regval_blob
*val
= NULL
;
8566 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
8568 WERROR result
= WERR_OK
;
8571 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8573 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8574 r
->in
.key_name
, r
->in
.value_name
));
8576 /* in case of problem, return some default values */
8579 *r
->out
.type
= REG_NONE
;
8582 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8583 OUR_HANDLE(r
->in
.handle
)));
8584 result
= WERR_BADFID
;
8588 /* Is the handle to a printer or to the server? */
8590 if (Printer
->printer_type
== SPLHND_SERVER
) {
8592 union spoolss_PrinterData data
;
8594 result
= getprinterdata_printer_server(p
->mem_ctx
,
8598 if (!W_ERROR_IS_OK(result
)) {
8602 result
= push_spoolss_PrinterData(p
->mem_ctx
, &blob
,
8603 *r
->out
.type
, &data
);
8604 if (!W_ERROR_IS_OK(result
)) {
8608 *r
->out
.needed
= blob
.length
;
8610 if (r
->in
.offered
>= *r
->out
.needed
) {
8611 memcpy(r
->out
.data
, blob
.data
, blob
.length
);
8614 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_MORE_DATA
);
8617 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
8618 result
= WERR_BADFID
;
8622 result
= get_a_printer(Printer
, &printer
, 2, lp_servicename(snum
));
8623 if (!W_ERROR_IS_OK(result
)) {
8627 /* check to see if the keyname is valid */
8628 if (!strlen(r
->in
.key_name
)) {
8629 result
= WERR_INVALID_PARAM
;
8633 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
8635 if (strequal(r
->in
.key_name
, SPOOL_PRINTERDATA_KEY
) &&
8636 strequal(r
->in
.value_name
, "ChangeId")) {
8637 *r
->out
.type
= REG_DWORD
;
8639 if (r
->in
.offered
>= *r
->out
.needed
) {
8640 SIVAL(r
->out
.data
, 0, printer
->info_2
->changeid
);
8646 if (lookup_printerkey(printer
->info_2
->data
, r
->in
.key_name
) == -1) {
8647 DEBUG(4,("_spoolss_GetPrinterDataEx: "
8648 "Invalid keyname [%s]\n", r
->in
.key_name
));
8649 result
= WERR_BADFILE
;
8653 val
= get_printer_data(printer
->info_2
,
8654 r
->in
.key_name
, r
->in
.value_name
);
8656 result
= WERR_BADFILE
;
8660 *r
->out
.needed
= regval_size(val
);
8661 *r
->out
.type
= regval_type(val
);
8663 if (r
->in
.offered
>= *r
->out
.needed
) {
8664 memcpy(r
->out
.data
, regval_data_p(val
), regval_size(val
));
8668 free_a_printer(&printer
, 2);
8671 if (!W_ERROR_IS_OK(result
)) {
8675 *r
->out
.type
= SPOOLSS_BUFFER_OK(*r
->out
.type
, REG_NONE
);
8676 r
->out
.data
= SPOOLSS_BUFFER_OK(r
->out
.data
, r
->out
.data
);
8678 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_MORE_DATA
);
8681 /****************************************************************
8682 _spoolss_SetPrinterDataEx
8683 ****************************************************************/
8685 WERROR
_spoolss_SetPrinterDataEx(pipes_struct
*p
,
8686 struct spoolss_SetPrinterDataEx
*r
)
8688 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
8690 WERROR result
= WERR_OK
;
8691 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
8694 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
8696 /* From MSDN documentation of SetPrinterDataEx: pass request to
8697 SetPrinterData if key is "PrinterDriverData" */
8700 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8701 OUR_HANDLE(r
->in
.handle
)));
8705 if (Printer
->printer_type
== SPLHND_SERVER
) {
8706 DEBUG(10,("_spoolss_SetPrinterDataEx: "
8707 "Not implemented for server handles yet\n"));
8708 return WERR_INVALID_PARAM
;
8711 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
8716 * Access check : NT returns "access denied" if you make a
8717 * SetPrinterData call without the necessary privildge.
8718 * we were originally returning OK if nothing changed
8719 * which made Win2k issue **a lot** of SetPrinterData
8720 * when connecting to a printer --jerry
8723 if (Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
8724 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
8725 "change denied by handle access permissions\n"));
8726 return WERR_ACCESS_DENIED
;
8729 result
= get_a_printer(Printer
, &printer
, 2, lp_servicename(snum
));
8730 if (!W_ERROR_IS_OK(result
)) {
8734 /* check for OID in valuename */
8736 oid_string
= strchr(r
->in
.value_name
, ',');
8743 * When client side code sets a magic printer data key, detect it and save
8744 * the current printer data and the magic key's data (its the DEVMODE) for
8745 * future printer/driver initializations.
8747 if ((r
->in
.type
== REG_BINARY
) && strequal(r
->in
.value_name
, PHANTOM_DEVMODE_KEY
)) {
8748 /* Set devmode and printer initialization info */
8749 result
= save_driver_init(printer
, 2, r
->in
.data
, r
->in
.offered
);
8751 srv_spoolss_reset_printerdata(printer
->info_2
->drivername
);
8756 /* save the registry data */
8758 result
= set_printer_dataex(printer
, r
->in
.key_name
, r
->in
.value_name
,
8759 r
->in
.type
, r
->in
.data
, r
->in
.offered
);
8761 if (W_ERROR_IS_OK(result
)) {
8762 /* save the OID if one was specified */
8764 char *str
= talloc_asprintf(p
->mem_ctx
, "%s\\%s",
8765 r
->in
.key_name
, SPOOL_OID_KEY
);
8767 result
= WERR_NOMEM
;
8772 * I'm not checking the status here on purpose. Don't know
8773 * if this is right, but I'm returning the status from the
8774 * previous set_printer_dataex() call. I have no idea if
8775 * this is right. --jerry
8778 set_printer_dataex(printer
, str
, r
->in
.value_name
,
8779 REG_SZ
, (uint8_t *)oid_string
,
8780 strlen(oid_string
)+1);
8783 result
= mod_a_printer(printer
, 2);
8787 free_a_printer(&printer
, 2);
8792 /****************************************************************
8793 _spoolss_DeletePrinterDataEx
8794 ****************************************************************/
8796 WERROR
_spoolss_DeletePrinterDataEx(pipes_struct
*p
,
8797 struct spoolss_DeletePrinterDataEx
*r
)
8799 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
8801 WERROR status
= WERR_OK
;
8802 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
8804 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
8807 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
8808 "Invalid handle (%s:%u:%u).\n",
8809 OUR_HANDLE(r
->in
.handle
)));
8813 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
8816 if (Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
8817 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
8818 "printer properties change denied by handle\n"));
8819 return WERR_ACCESS_DENIED
;
8822 if (!r
->in
.value_name
|| !r
->in
.key_name
) {
8826 status
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
8827 if (!W_ERROR_IS_OK(status
))
8830 status
= delete_printer_dataex( printer
, r
->in
.key_name
, r
->in
.value_name
);
8832 if ( W_ERROR_IS_OK(status
) )
8833 mod_a_printer( printer
, 2 );
8835 free_a_printer(&printer
, 2);
8840 /****************************************************************
8841 _spoolss_EnumPrinterKey
8842 ****************************************************************/
8844 WERROR
_spoolss_EnumPrinterKey(pipes_struct
*p
,
8845 struct spoolss_EnumPrinterKey
*r
)
8847 fstring
*keynames
= NULL
;
8849 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
8850 NT_PRINTER_DATA
*data
;
8851 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
8853 WERROR result
= WERR_BADFILE
;
8855 const char **array
= NULL
;
8858 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
8861 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
8862 OUR_HANDLE(r
->in
.handle
)));
8866 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
8870 result
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
8871 if (!W_ERROR_IS_OK(result
)) {
8875 /* get the list of subkey names */
8877 data
= printer
->info_2
->data
;
8879 num_keys
= get_printer_subkeys(data
, r
->in
.key_name
, &keynames
);
8880 if (num_keys
== -1) {
8881 result
= WERR_BADFILE
;
8885 array
= talloc_zero_array(r
->out
.key_buffer
, const char *, num_keys
+ 2);
8887 result
= WERR_NOMEM
;
8892 array
[0] = talloc_strdup(array
, "");
8894 result
= WERR_NOMEM
;
8899 for (i
=0; i
< num_keys
; i
++) {
8901 DEBUG(10,("_spoolss_EnumPrinterKey: adding keyname: %s\n",
8904 array
[i
] = talloc_strdup(array
, keynames
[i
]);
8906 result
= WERR_NOMEM
;
8911 if (!push_reg_multi_sz(p
->mem_ctx
, &blob
, array
)) {
8912 result
= WERR_NOMEM
;
8916 *r
->out
._ndr_size
= r
->in
.offered
/ 2;
8917 *r
->out
.needed
= blob
.length
;
8919 if (r
->in
.offered
< *r
->out
.needed
) {
8920 result
= WERR_MORE_DATA
;
8923 r
->out
.key_buffer
->string_array
= array
;
8927 if (!W_ERROR_IS_OK(result
)) {
8929 if (!W_ERROR_EQUAL(result
, WERR_MORE_DATA
)) {
8934 free_a_printer(&printer
, 2);
8935 SAFE_FREE(keynames
);
8940 /****************************************************************
8941 _spoolss_DeletePrinterKey
8942 ****************************************************************/
8944 WERROR
_spoolss_DeletePrinterKey(pipes_struct
*p
,
8945 struct spoolss_DeletePrinterKey
*r
)
8947 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
8948 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
8952 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
8955 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
8956 OUR_HANDLE(r
->in
.handle
)));
8960 /* if keyname == NULL, return error */
8962 if ( !r
->in
.key_name
)
8963 return WERR_INVALID_PARAM
;
8965 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
))
8968 if (Printer
->access_granted
!= PRINTER_ACCESS_ADMINISTER
) {
8969 DEBUG(3, ("_spoolss_DeletePrinterKey: "
8970 "printer properties change denied by handle\n"));
8971 return WERR_ACCESS_DENIED
;
8974 status
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
8975 if (!W_ERROR_IS_OK(status
))
8978 /* delete the key and all subneys */
8980 status
= delete_all_printer_data( printer
->info_2
, r
->in
.key_name
);
8982 if ( W_ERROR_IS_OK(status
) )
8983 status
= mod_a_printer(printer
, 2);
8985 free_a_printer( &printer
, 2 );
8990 /****************************************************************
8991 ****************************************************************/
8993 static WERROR
registry_value_to_printer_enum_value(TALLOC_CTX
*mem_ctx
,
8994 struct regval_blob
*v
,
8995 struct spoolss_PrinterEnumValues
*r
)
8997 r
->data
= TALLOC_ZERO_P(mem_ctx
, DATA_BLOB
);
8998 W_ERROR_HAVE_NO_MEMORY(r
->data
);
9000 r
->value_name
= talloc_strdup(mem_ctx
, regval_name(v
));
9001 W_ERROR_HAVE_NO_MEMORY(r
->value_name
);
9003 r
->type
= regval_type(v
);
9004 r
->data_length
= regval_size(v
);
9006 if (r
->data_length
) {
9007 *r
->data
= data_blob_talloc(r
->data
, regval_data_p(v
), regval_size(v
));
9013 /****************************************************************
9014 _spoolss_EnumPrinterDataEx
9015 ****************************************************************/
9017 WERROR
_spoolss_EnumPrinterDataEx(pipes_struct
*p
,
9018 struct spoolss_EnumPrinterDataEx
*r
)
9021 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
9022 struct spoolss_PrinterEnumValues
*info
= NULL
;
9023 NT_PRINTER_DATA
*p_data
;
9024 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
9030 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9034 *r
->out
.info
= NULL
;
9037 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9038 OUR_HANDLE(r
->in
.handle
)));
9043 * first check for a keyname of NULL or "". Win2k seems to send
9044 * this a lot and we should send back WERR_INVALID_PARAM
9045 * no need to spend time looking up the printer in this case.
9049 if (!strlen(r
->in
.key_name
)) {
9050 result
= WERR_INVALID_PARAM
;
9054 /* get the printer off of disk */
9056 if (!get_printer_snum(p
, r
->in
.handle
, &snum
, NULL
)) {
9060 ZERO_STRUCT(printer
);
9061 result
= get_a_printer(Printer
, &printer
, 2, lp_const_servicename(snum
));
9062 if (!W_ERROR_IS_OK(result
)) {
9066 /* now look for a match on the key name */
9068 p_data
= printer
->info_2
->data
;
9070 key_index
= lookup_printerkey(p_data
, r
->in
.key_name
);
9071 if (key_index
== -1) {
9072 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9074 result
= WERR_INVALID_PARAM
;
9078 /* allocate the memory for the array of pointers -- if necessary */
9080 count
= regval_ctr_numvals(p_data
->keys
[key_index
].values
);
9082 result
= WERR_OK
; /* ??? */
9086 info
= TALLOC_ZERO_ARRAY(p
->mem_ctx
,
9087 struct spoolss_PrinterEnumValues
,
9090 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9091 result
= WERR_NOMEM
;
9096 * loop through all params and build the array to pass
9097 * back to the client
9100 for (i
=0; i
< count
; i
++) {
9102 struct regval_blob
*val
;
9104 /* lookup the registry value */
9106 val
= regval_ctr_specific_value(p_data
->keys
[key_index
].values
, i
);
9108 DEBUG(10,("retrieved value number [%d] [%s]\n", i
, regval_name(val
)));
9112 result
= registry_value_to_printer_enum_value(info
, val
, &info
[i
]);
9113 if (!W_ERROR_IS_OK(result
)) {
9118 #if 0 /* FIXME - gd */
9119 /* housekeeping information in the reply */
9121 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9122 * the hand marshalled container size is a multiple
9123 * of 4 bytes for RPC alignment.
9127 needed
+= 4-(needed
% 4);
9130 *r
->out
.count
= count
;
9131 *r
->out
.info
= info
;
9136 free_a_printer(&printer
, 2);
9139 if (!W_ERROR_IS_OK(result
)) {
9143 *r
->out
.needed
= SPOOLSS_BUFFER_ARRAY(p
->mem_ctx
,
9144 spoolss_EnumPrinterDataEx
, NULL
,
9147 *r
->out
.info
= SPOOLSS_BUFFER_OK(*r
->out
.info
, NULL
);
9148 *r
->out
.count
= SPOOLSS_BUFFER_OK(*r
->out
.count
, *r
->out
.count
);
9150 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_MORE_DATA
);
9153 /****************************************************************************
9154 ****************************************************************************/
9156 static WERROR
getprintprocessordirectory_level_1(TALLOC_CTX
*mem_ctx
,
9157 const char *servername
,
9158 const char *environment
,
9159 struct spoolss_PrintProcessorDirectoryInfo1
*r
)
9164 werr
= compose_spoolss_server_path(mem_ctx
,
9167 SPOOLSS_PRTPROCS_PATH
,
9169 if (!W_ERROR_IS_OK(werr
)) {
9173 DEBUG(4,("print processor directory: [%s]\n", path
));
9175 r
->directory_name
= path
;
9180 /****************************************************************
9181 _spoolss_GetPrintProcessorDirectory
9182 ****************************************************************/
9184 WERROR
_spoolss_GetPrintProcessorDirectory(pipes_struct
*p
,
9185 struct spoolss_GetPrintProcessorDirectory
*r
)
9189 /* that's an [in out] buffer */
9191 if (!r
->in
.buffer
&& (r
->in
.offered
!= 0)) {
9192 return WERR_INVALID_PARAM
;
9195 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9200 /* r->in.level is ignored */
9202 /* We always should reply with a local print processor directory so that
9203 * users are not forced to have a [prnproc$] share on the Samba spoolss
9204 * server - Guenther */
9206 result
= getprintprocessordirectory_level_1(p
->mem_ctx
,
9207 NULL
, /* r->in.server */
9209 &r
->out
.info
->info1
);
9210 if (!W_ERROR_IS_OK(result
)) {
9211 TALLOC_FREE(r
->out
.info
);
9215 *r
->out
.needed
= SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo
, NULL
,
9216 r
->out
.info
, r
->in
.level
);
9217 r
->out
.info
= SPOOLSS_BUFFER_OK(r
->out
.info
, NULL
);
9219 return SPOOLSS_BUFFER_OK(WERR_OK
, WERR_INSUFFICIENT_BUFFER
);
9222 /*******************************************************************
9223 ********************************************************************/
9225 static bool push_monitorui_buf(TALLOC_CTX
*mem_ctx
, DATA_BLOB
*buf
,
9226 const char *dllname
)
9228 enum ndr_err_code ndr_err
;
9229 struct spoolss_MonitorUi ui
;
9231 ui
.dll_name
= dllname
;
9233 ndr_err
= ndr_push_struct_blob(buf
, mem_ctx
, NULL
, &ui
,
9234 (ndr_push_flags_fn_t
)ndr_push_spoolss_MonitorUi
);
9235 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err
) && (DEBUGLEVEL
>= 10)) {
9236 NDR_PRINT_DEBUG(spoolss_MonitorUi
, &ui
);
9238 return NDR_ERR_CODE_IS_SUCCESS(ndr_err
);
9241 /*******************************************************************
9242 Streams the monitor UI DLL name in UNICODE
9243 *******************************************************************/
9245 static WERROR
xcvtcp_monitorui(TALLOC_CTX
*mem_ctx
,
9246 NT_USER_TOKEN
*token
, DATA_BLOB
*in
,
9247 DATA_BLOB
*out
, uint32_t *needed
)
9249 const char *dllname
= "tcpmonui.dll";
9251 *needed
= (strlen(dllname
)+1) * 2;
9253 if (out
->length
< *needed
) {
9254 return WERR_INSUFFICIENT_BUFFER
;
9257 if (!push_monitorui_buf(mem_ctx
, out
, dllname
)) {
9264 /*******************************************************************
9265 ********************************************************************/
9267 static bool pull_port_data_1(TALLOC_CTX
*mem_ctx
,
9268 struct spoolss_PortData1
*port1
,
9269 const DATA_BLOB
*buf
)
9271 enum ndr_err_code ndr_err
;
9272 ndr_err
= ndr_pull_struct_blob(buf
, mem_ctx
, NULL
, port1
,
9273 (ndr_pull_flags_fn_t
)ndr_pull_spoolss_PortData1
);
9274 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err
) && (DEBUGLEVEL
>= 10)) {
9275 NDR_PRINT_DEBUG(spoolss_PortData1
, port1
);
9277 return NDR_ERR_CODE_IS_SUCCESS(ndr_err
);
9280 /*******************************************************************
9281 ********************************************************************/
9283 static bool pull_port_data_2(TALLOC_CTX
*mem_ctx
,
9284 struct spoolss_PortData2
*port2
,
9285 const DATA_BLOB
*buf
)
9287 enum ndr_err_code ndr_err
;
9288 ndr_err
= ndr_pull_struct_blob(buf
, mem_ctx
, NULL
, port2
,
9289 (ndr_pull_flags_fn_t
)ndr_pull_spoolss_PortData2
);
9290 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err
) && (DEBUGLEVEL
>= 10)) {
9291 NDR_PRINT_DEBUG(spoolss_PortData2
, port2
);
9293 return NDR_ERR_CODE_IS_SUCCESS(ndr_err
);
9296 /*******************************************************************
9297 Create a new TCP/IP port
9298 *******************************************************************/
9300 static WERROR
xcvtcp_addport(TALLOC_CTX
*mem_ctx
,
9301 NT_USER_TOKEN
*token
, DATA_BLOB
*in
,
9302 DATA_BLOB
*out
, uint32_t *needed
)
9304 struct spoolss_PortData1 port1
;
9305 struct spoolss_PortData2 port2
;
9306 char *device_uri
= NULL
;
9309 const char *portname
;
9310 const char *hostaddress
;
9312 uint32_t port_number
;
9315 /* peek for spoolss_PortData version */
9317 if (!in
|| (in
->length
< (128 + 4))) {
9318 return WERR_GENERAL_FAILURE
;
9321 version
= IVAL(in
->data
, 128);
9327 if (!pull_port_data_1(mem_ctx
, &port1
, in
)) {
9331 portname
= port1
.portname
;
9332 hostaddress
= port1
.hostaddress
;
9333 queue
= port1
.queue
;
9334 protocol
= port1
.protocol
;
9335 port_number
= port1
.port_number
;
9341 if (!pull_port_data_2(mem_ctx
, &port2
, in
)) {
9345 portname
= port2
.portname
;
9346 hostaddress
= port2
.hostaddress
;
9347 queue
= port2
.queue
;
9348 protocol
= port2
.protocol
;
9349 port_number
= port2
.port_number
;
9353 DEBUG(1,("xcvtcp_addport: "
9354 "unknown version of port_data: %d\n", version
));
9355 return WERR_UNKNOWN_PORT
;
9358 /* create the device URI and call the add_port_hook() */
9361 case PROTOCOL_RAWTCP_TYPE
:
9362 device_uri
= talloc_asprintf(mem_ctx
,
9363 "socket://%s:%d/", hostaddress
,
9367 case PROTOCOL_LPR_TYPE
:
9368 device_uri
= talloc_asprintf(mem_ctx
,
9369 "lpr://%s/%s", hostaddress
, queue
);
9373 return WERR_UNKNOWN_PORT
;
9380 return add_port_hook(mem_ctx
, token
, portname
, device_uri
);
9383 /*******************************************************************
9384 *******************************************************************/
9386 struct xcv_api_table xcvtcp_cmds
[] = {
9387 { "MonitorUI", xcvtcp_monitorui
},
9388 { "AddPort", xcvtcp_addport
},
9392 static WERROR
process_xcvtcp_command(TALLOC_CTX
*mem_ctx
,
9393 NT_USER_TOKEN
*token
, const char *command
,
9400 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command
));
9402 for ( i
=0; xcvtcp_cmds
[i
].name
; i
++ ) {
9403 if ( strcmp( command
, xcvtcp_cmds
[i
].name
) == 0 )
9404 return xcvtcp_cmds
[i
].fn(mem_ctx
, token
, inbuf
, outbuf
, needed
);
9407 return WERR_BADFUNC
;
9410 /*******************************************************************
9411 *******************************************************************/
9412 #if 0 /* don't support management using the "Local Port" monitor */
9414 static WERROR
xcvlocal_monitorui(TALLOC_CTX
*mem_ctx
,
9415 NT_USER_TOKEN
*token
, DATA_BLOB
*in
,
9416 DATA_BLOB
*out
, uint32_t *needed
)
9418 const char *dllname
= "localui.dll";
9420 *needed
= (strlen(dllname
)+1) * 2;
9422 if (out
->length
< *needed
) {
9423 return WERR_INSUFFICIENT_BUFFER
;
9426 if (!push_monitorui_buf(mem_ctx
, out
, dllname
)) {
9433 /*******************************************************************
9434 *******************************************************************/
9436 struct xcv_api_table xcvlocal_cmds
[] = {
9437 { "MonitorUI", xcvlocal_monitorui
},
9441 struct xcv_api_table xcvlocal_cmds
[] = {
9448 /*******************************************************************
9449 *******************************************************************/
9451 static WERROR
process_xcvlocal_command(TALLOC_CTX
*mem_ctx
,
9452 NT_USER_TOKEN
*token
, const char *command
,
9453 DATA_BLOB
*inbuf
, DATA_BLOB
*outbuf
,
9458 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command
));
9460 for ( i
=0; xcvlocal_cmds
[i
].name
; i
++ ) {
9461 if ( strcmp( command
, xcvlocal_cmds
[i
].name
) == 0 )
9462 return xcvlocal_cmds
[i
].fn(mem_ctx
, token
, inbuf
, outbuf
, needed
);
9464 return WERR_BADFUNC
;
9467 /****************************************************************
9469 ****************************************************************/
9471 WERROR
_spoolss_XcvData(pipes_struct
*p
,
9472 struct spoolss_XcvData
*r
)
9474 Printer_entry
*Printer
= find_printer_index_by_hnd(p
, r
->in
.handle
);
9475 DATA_BLOB out_data
= data_blob_null
;
9479 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9480 OUR_HANDLE(r
->in
.handle
)));
9484 /* Has to be a handle to the TCP/IP port monitor */
9486 if ( !(Printer
->printer_type
& (SPLHND_PORTMON_LOCAL
|SPLHND_PORTMON_TCP
)) ) {
9487 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9491 /* requires administrative access to the server */
9493 if ( !(Printer
->access_granted
& SERVER_ACCESS_ADMINISTER
) ) {
9494 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9495 return WERR_ACCESS_DENIED
;
9498 /* Allocate the outgoing buffer */
9500 if (r
->in
.out_data_size
) {
9501 out_data
= data_blob_talloc_zero(p
->mem_ctx
, r
->in
.out_data_size
);
9502 if (out_data
.data
== NULL
) {
9507 switch ( Printer
->printer_type
) {
9508 case SPLHND_PORTMON_TCP
:
9509 werror
= process_xcvtcp_command(p
->mem_ctx
,
9510 p
->server_info
->ptok
,
9511 r
->in
.function_name
,
9512 &r
->in
.in_data
, &out_data
,
9515 case SPLHND_PORTMON_LOCAL
:
9516 werror
= process_xcvlocal_command(p
->mem_ctx
,
9517 p
->server_info
->ptok
,
9518 r
->in
.function_name
,
9519 &r
->in
.in_data
, &out_data
,
9523 werror
= WERR_INVALID_PRINT_MONITOR
;
9526 if (!W_ERROR_IS_OK(werror
)) {
9530 *r
->out
.status_code
= 0;
9532 if (r
->out
.out_data
&& out_data
.data
&& r
->in
.out_data_size
&& out_data
.length
) {
9533 memcpy(r
->out
.out_data
, out_data
.data
,
9534 MIN(r
->in
.out_data_size
, out_data
.length
));
9540 /****************************************************************
9541 _spoolss_AddPrintProcessor
9542 ****************************************************************/
9544 WERROR
_spoolss_AddPrintProcessor(pipes_struct
*p
,
9545 struct spoolss_AddPrintProcessor
*r
)
9547 /* for now, just indicate success and ignore the add. We'll
9548 automatically set the winprint processor for printer
9549 entries later. Used to debug the LexMark Optra S 1855 PCL
9555 /****************************************************************
9557 ****************************************************************/
9559 WERROR
_spoolss_AddPort(pipes_struct
*p
,
9560 struct spoolss_AddPort
*r
)
9562 /* do what w2k3 does */
9564 return WERR_NOT_SUPPORTED
;
9567 /****************************************************************
9568 _spoolss_GetPrinterDriver
9569 ****************************************************************/
9571 WERROR
_spoolss_GetPrinterDriver(pipes_struct
*p
,
9572 struct spoolss_GetPrinterDriver
*r
)
9574 p
->rng_fault_state
= true;
9575 return WERR_NOT_SUPPORTED
;
9578 /****************************************************************
9579 _spoolss_ReadPrinter
9580 ****************************************************************/
9582 WERROR
_spoolss_ReadPrinter(pipes_struct
*p
,
9583 struct spoolss_ReadPrinter
*r
)
9585 p
->rng_fault_state
= true;
9586 return WERR_NOT_SUPPORTED
;
9589 /****************************************************************
9590 _spoolss_WaitForPrinterChange
9591 ****************************************************************/
9593 WERROR
_spoolss_WaitForPrinterChange(pipes_struct
*p
,
9594 struct spoolss_WaitForPrinterChange
*r
)
9596 p
->rng_fault_state
= true;
9597 return WERR_NOT_SUPPORTED
;
9600 /****************************************************************
9601 _spoolss_ConfigurePort
9602 ****************************************************************/
9604 WERROR
_spoolss_ConfigurePort(pipes_struct
*p
,
9605 struct spoolss_ConfigurePort
*r
)
9607 p
->rng_fault_state
= true;
9608 return WERR_NOT_SUPPORTED
;
9611 /****************************************************************
9613 ****************************************************************/
9615 WERROR
_spoolss_DeletePort(pipes_struct
*p
,
9616 struct spoolss_DeletePort
*r
)
9618 p
->rng_fault_state
= true;
9619 return WERR_NOT_SUPPORTED
;
9622 /****************************************************************
9623 _spoolss_CreatePrinterIC
9624 ****************************************************************/
9626 WERROR
_spoolss_CreatePrinterIC(pipes_struct
*p
,
9627 struct spoolss_CreatePrinterIC
*r
)
9629 p
->rng_fault_state
= true;
9630 return WERR_NOT_SUPPORTED
;
9633 /****************************************************************
9634 _spoolss_PlayGDIScriptOnPrinterIC
9635 ****************************************************************/
9637 WERROR
_spoolss_PlayGDIScriptOnPrinterIC(pipes_struct
*p
,
9638 struct spoolss_PlayGDIScriptOnPrinterIC
*r
)
9640 p
->rng_fault_state
= true;
9641 return WERR_NOT_SUPPORTED
;
9644 /****************************************************************
9645 _spoolss_DeletePrinterIC
9646 ****************************************************************/
9648 WERROR
_spoolss_DeletePrinterIC(pipes_struct
*p
,
9649 struct spoolss_DeletePrinterIC
*r
)
9651 p
->rng_fault_state
= true;
9652 return WERR_NOT_SUPPORTED
;
9655 /****************************************************************
9656 _spoolss_AddPrinterConnection
9657 ****************************************************************/
9659 WERROR
_spoolss_AddPrinterConnection(pipes_struct
*p
,
9660 struct spoolss_AddPrinterConnection
*r
)
9662 p
->rng_fault_state
= true;
9663 return WERR_NOT_SUPPORTED
;
9666 /****************************************************************
9667 _spoolss_DeletePrinterConnection
9668 ****************************************************************/
9670 WERROR
_spoolss_DeletePrinterConnection(pipes_struct
*p
,
9671 struct spoolss_DeletePrinterConnection
*r
)
9673 p
->rng_fault_state
= true;
9674 return WERR_NOT_SUPPORTED
;
9677 /****************************************************************
9678 _spoolss_PrinterMessageBox
9679 ****************************************************************/
9681 WERROR
_spoolss_PrinterMessageBox(pipes_struct
*p
,
9682 struct spoolss_PrinterMessageBox
*r
)
9684 p
->rng_fault_state
= true;
9685 return WERR_NOT_SUPPORTED
;
9688 /****************************************************************
9690 ****************************************************************/
9692 WERROR
_spoolss_AddMonitor(pipes_struct
*p
,
9693 struct spoolss_AddMonitor
*r
)
9695 p
->rng_fault_state
= true;
9696 return WERR_NOT_SUPPORTED
;
9699 /****************************************************************
9700 _spoolss_DeleteMonitor
9701 ****************************************************************/
9703 WERROR
_spoolss_DeleteMonitor(pipes_struct
*p
,
9704 struct spoolss_DeleteMonitor
*r
)
9706 p
->rng_fault_state
= true;
9707 return WERR_NOT_SUPPORTED
;
9710 /****************************************************************
9711 _spoolss_DeletePrintProcessor
9712 ****************************************************************/
9714 WERROR
_spoolss_DeletePrintProcessor(pipes_struct
*p
,
9715 struct spoolss_DeletePrintProcessor
*r
)
9717 p
->rng_fault_state
= true;
9718 return WERR_NOT_SUPPORTED
;
9721 /****************************************************************
9722 _spoolss_AddPrintProvidor
9723 ****************************************************************/
9725 WERROR
_spoolss_AddPrintProvidor(pipes_struct
*p
,
9726 struct spoolss_AddPrintProvidor
*r
)
9728 p
->rng_fault_state
= true;
9729 return WERR_NOT_SUPPORTED
;
9732 /****************************************************************
9733 _spoolss_DeletePrintProvidor
9734 ****************************************************************/
9736 WERROR
_spoolss_DeletePrintProvidor(pipes_struct
*p
,
9737 struct spoolss_DeletePrintProvidor
*r
)
9739 p
->rng_fault_state
= true;
9740 return WERR_NOT_SUPPORTED
;
9743 /****************************************************************
9744 _spoolss_FindFirstPrinterChangeNotification
9745 ****************************************************************/
9747 WERROR
_spoolss_FindFirstPrinterChangeNotification(pipes_struct
*p
,
9748 struct spoolss_FindFirstPrinterChangeNotification
*r
)
9750 p
->rng_fault_state
= true;
9751 return WERR_NOT_SUPPORTED
;
9754 /****************************************************************
9755 _spoolss_FindNextPrinterChangeNotification
9756 ****************************************************************/
9758 WERROR
_spoolss_FindNextPrinterChangeNotification(pipes_struct
*p
,
9759 struct spoolss_FindNextPrinterChangeNotification
*r
)
9761 p
->rng_fault_state
= true;
9762 return WERR_NOT_SUPPORTED
;
9765 /****************************************************************
9766 _spoolss_RouterFindFirstPrinterChangeNotificationOld
9767 ****************************************************************/
9769 WERROR
_spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct
*p
,
9770 struct spoolss_RouterFindFirstPrinterChangeNotificationOld
*r
)
9772 p
->rng_fault_state
= true;
9773 return WERR_NOT_SUPPORTED
;
9776 /****************************************************************
9777 _spoolss_ReplyOpenPrinter
9778 ****************************************************************/
9780 WERROR
_spoolss_ReplyOpenPrinter(pipes_struct
*p
,
9781 struct spoolss_ReplyOpenPrinter
*r
)
9783 p
->rng_fault_state
= true;
9784 return WERR_NOT_SUPPORTED
;
9787 /****************************************************************
9788 _spoolss_RouterReplyPrinter
9789 ****************************************************************/
9791 WERROR
_spoolss_RouterReplyPrinter(pipes_struct
*p
,
9792 struct spoolss_RouterReplyPrinter
*r
)
9794 p
->rng_fault_state
= true;
9795 return WERR_NOT_SUPPORTED
;
9798 /****************************************************************
9799 _spoolss_ReplyClosePrinter
9800 ****************************************************************/
9802 WERROR
_spoolss_ReplyClosePrinter(pipes_struct
*p
,
9803 struct spoolss_ReplyClosePrinter
*r
)
9805 p
->rng_fault_state
= true;
9806 return WERR_NOT_SUPPORTED
;
9809 /****************************************************************
9811 ****************************************************************/
9813 WERROR
_spoolss_AddPortEx(pipes_struct
*p
,
9814 struct spoolss_AddPortEx
*r
)
9816 p
->rng_fault_state
= true;
9817 return WERR_NOT_SUPPORTED
;
9820 /****************************************************************
9821 _spoolss_RouterFindFirstPrinterChangeNotification
9822 ****************************************************************/
9824 WERROR
_spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct
*p
,
9825 struct spoolss_RouterFindFirstPrinterChangeNotification
*r
)
9827 p
->rng_fault_state
= true;
9828 return WERR_NOT_SUPPORTED
;
9831 /****************************************************************
9832 _spoolss_SpoolerInit
9833 ****************************************************************/
9835 WERROR
_spoolss_SpoolerInit(pipes_struct
*p
,
9836 struct spoolss_SpoolerInit
*r
)
9838 p
->rng_fault_state
= true;
9839 return WERR_NOT_SUPPORTED
;
9842 /****************************************************************
9843 _spoolss_ResetPrinterEx
9844 ****************************************************************/
9846 WERROR
_spoolss_ResetPrinterEx(pipes_struct
*p
,
9847 struct spoolss_ResetPrinterEx
*r
)
9849 p
->rng_fault_state
= true;
9850 return WERR_NOT_SUPPORTED
;
9853 /****************************************************************
9854 _spoolss_RouterReplyPrinterEx
9855 ****************************************************************/
9857 WERROR
_spoolss_RouterReplyPrinterEx(pipes_struct
*p
,
9858 struct spoolss_RouterReplyPrinterEx
*r
)
9860 p
->rng_fault_state
= true;
9861 return WERR_NOT_SUPPORTED
;
9864 /****************************************************************
9866 ****************************************************************/
9868 WERROR
_spoolss_44(pipes_struct
*p
,
9869 struct spoolss_44
*r
)
9871 p
->rng_fault_state
= true;
9872 return WERR_NOT_SUPPORTED
;
9875 /****************************************************************
9877 ****************************************************************/
9879 WERROR
_spoolss_47(pipes_struct
*p
,
9880 struct spoolss_47
*r
)
9882 p
->rng_fault_state
= true;
9883 return WERR_NOT_SUPPORTED
;
9886 /****************************************************************
9888 ****************************************************************/
9890 WERROR
_spoolss_4a(pipes_struct
*p
,
9891 struct spoolss_4a
*r
)
9893 p
->rng_fault_state
= true;
9894 return WERR_NOT_SUPPORTED
;
9897 /****************************************************************
9899 ****************************************************************/
9901 WERROR
_spoolss_4b(pipes_struct
*p
,
9902 struct spoolss_4b
*r
)
9904 p
->rng_fault_state
= true;
9905 return WERR_NOT_SUPPORTED
;
9908 /****************************************************************
9910 ****************************************************************/
9912 WERROR
_spoolss_4c(pipes_struct
*p
,
9913 struct spoolss_4c
*r
)
9915 p
->rng_fault_state
= true;
9916 return WERR_NOT_SUPPORTED
;
9919 /****************************************************************
9921 ****************************************************************/
9923 WERROR
_spoolss_53(pipes_struct
*p
,
9924 struct spoolss_53
*r
)
9926 p
->rng_fault_state
= true;
9927 return WERR_NOT_SUPPORTED
;
9930 /****************************************************************
9932 ****************************************************************/
9934 WERROR
_spoolss_55(pipes_struct
*p
,
9935 struct spoolss_55
*r
)
9937 p
->rng_fault_state
= true;
9938 return WERR_NOT_SUPPORTED
;
9941 /****************************************************************
9943 ****************************************************************/
9945 WERROR
_spoolss_56(pipes_struct
*p
,
9946 struct spoolss_56
*r
)
9948 p
->rng_fault_state
= true;
9949 return WERR_NOT_SUPPORTED
;
9952 /****************************************************************
9954 ****************************************************************/
9956 WERROR
_spoolss_57(pipes_struct
*p
,
9957 struct spoolss_57
*r
)
9959 p
->rng_fault_state
= true;
9960 return WERR_NOT_SUPPORTED
;
9963 /****************************************************************
9965 ****************************************************************/
9967 WERROR
_spoolss_5a(pipes_struct
*p
,
9968 struct spoolss_5a
*r
)
9970 p
->rng_fault_state
= true;
9971 return WERR_NOT_SUPPORTED
;
9974 /****************************************************************
9976 ****************************************************************/
9978 WERROR
_spoolss_5b(pipes_struct
*p
,
9979 struct spoolss_5b
*r
)
9981 p
->rng_fault_state
= true;
9982 return WERR_NOT_SUPPORTED
;
9985 /****************************************************************
9987 ****************************************************************/
9989 WERROR
_spoolss_5c(pipes_struct
*p
,
9990 struct spoolss_5c
*r
)
9992 p
->rng_fault_state
= true;
9993 return WERR_NOT_SUPPORTED
;
9996 /****************************************************************
9998 ****************************************************************/
10000 WERROR
_spoolss_5d(pipes_struct
*p
,
10001 struct spoolss_5d
*r
)
10003 p
->rng_fault_state
= true;
10004 return WERR_NOT_SUPPORTED
;
10007 /****************************************************************
10009 ****************************************************************/
10011 WERROR
_spoolss_5e(pipes_struct
*p
,
10012 struct spoolss_5e
*r
)
10014 p
->rng_fault_state
= true;
10015 return WERR_NOT_SUPPORTED
;
10018 /****************************************************************
10020 ****************************************************************/
10022 WERROR
_spoolss_5f(pipes_struct
*p
,
10023 struct spoolss_5f
*r
)
10025 p
->rng_fault_state
= true;
10026 return WERR_NOT_SUPPORTED
;
10029 /****************************************************************
10031 ****************************************************************/
10033 WERROR
_spoolss_60(pipes_struct
*p
,
10034 struct spoolss_60
*r
)
10036 p
->rng_fault_state
= true;
10037 return WERR_NOT_SUPPORTED
;
10040 /****************************************************************
10042 ****************************************************************/
10044 WERROR
_spoolss_61(pipes_struct
*p
,
10045 struct spoolss_61
*r
)
10047 p
->rng_fault_state
= true;
10048 return WERR_NOT_SUPPORTED
;
10051 /****************************************************************
10053 ****************************************************************/
10055 WERROR
_spoolss_62(pipes_struct
*p
,
10056 struct spoolss_62
*r
)
10058 p
->rng_fault_state
= true;
10059 return WERR_NOT_SUPPORTED
;
10062 /****************************************************************
10064 ****************************************************************/
10066 WERROR
_spoolss_63(pipes_struct
*p
,
10067 struct spoolss_63
*r
)
10069 p
->rng_fault_state
= true;
10070 return WERR_NOT_SUPPORTED
;
10073 /****************************************************************
10075 ****************************************************************/
10077 WERROR
_spoolss_64(pipes_struct
*p
,
10078 struct spoolss_64
*r
)
10080 p
->rng_fault_state
= true;
10081 return WERR_NOT_SUPPORTED
;
10084 /****************************************************************
10086 ****************************************************************/
10088 WERROR
_spoolss_65(pipes_struct
*p
,
10089 struct spoolss_65
*r
)
10091 p
->rng_fault_state
= true;
10092 return WERR_NOT_SUPPORTED
;
10095 /****************************************************************
10096 _spoolss_GetCorePrinterDrivers
10097 ****************************************************************/
10099 WERROR
_spoolss_GetCorePrinterDrivers(pipes_struct
*p
,
10100 struct spoolss_GetCorePrinterDrivers
*r
)
10102 p
->rng_fault_state
= true;
10103 return WERR_NOT_SUPPORTED
;
10106 /****************************************************************
10108 ****************************************************************/
10110 WERROR
_spoolss_67(pipes_struct
*p
,
10111 struct spoolss_67
*r
)
10113 p
->rng_fault_state
= true;
10114 return WERR_NOT_SUPPORTED
;
10117 /****************************************************************
10118 _spoolss_GetPrinterDriverPackagePath
10119 ****************************************************************/
10121 WERROR
_spoolss_GetPrinterDriverPackagePath(pipes_struct
*p
,
10122 struct spoolss_GetPrinterDriverPackagePath
*r
)
10124 p
->rng_fault_state
= true;
10125 return WERR_NOT_SUPPORTED
;
10128 /****************************************************************
10130 ****************************************************************/
10132 WERROR
_spoolss_69(pipes_struct
*p
,
10133 struct spoolss_69
*r
)
10135 p
->rng_fault_state
= true;
10136 return WERR_NOT_SUPPORTED
;
10139 /****************************************************************
10141 ****************************************************************/
10143 WERROR
_spoolss_6a(pipes_struct
*p
,
10144 struct spoolss_6a
*r
)
10146 p
->rng_fault_state
= true;
10147 return WERR_NOT_SUPPORTED
;
10150 /****************************************************************
10152 ****************************************************************/
10154 WERROR
_spoolss_6b(pipes_struct
*p
,
10155 struct spoolss_6b
*r
)
10157 p
->rng_fault_state
= true;
10158 return WERR_NOT_SUPPORTED
;
10161 /****************************************************************
10163 ****************************************************************/
10165 WERROR
_spoolss_6c(pipes_struct
*p
,
10166 struct spoolss_6c
*r
)
10168 p
->rng_fault_state
= true;
10169 return WERR_NOT_SUPPORTED
;
10172 /****************************************************************
10174 ****************************************************************/
10176 WERROR
_spoolss_6d(pipes_struct
*p
,
10177 struct spoolss_6d
*r
)
10179 p
->rng_fault_state
= true;
10180 return WERR_NOT_SUPPORTED
;