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. */
31 /* macros stolen from s4 spoolss server */
32 #define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
33 ((info)?ndr_size_##fn(info, level, ic, 0):0)
35 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,ic,info,level,count) \
36 ((info)?ndr_size_##fn##_info(mem_ctx, ic, level, count, info):0)
38 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,ic,info,count) \
39 ((info)?ndr_size_##fn##_info(mem_ctx, ic, count, info):0)
41 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
44 extern userdom_struct current_user_info;
47 #define DBGC_CLASS DBGC_RPC_SRV
49 #ifndef MAX_OPEN_PRINTER_EXS
50 #define MAX_OPEN_PRINTER_EXS 50
53 #define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
54 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
56 static Printer_entry *printers_list;
58 typedef struct _counter_printer_0 {
59 struct _counter_printer_0 *next;
60 struct _counter_printer_0 *prev;
66 static counter_printer_0 *counter_list;
68 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
69 static uint32_t smb_connections = 0;
72 /* in printing/nt_printing.c */
74 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
76 /* API table for Xcv Monitor functions */
78 struct xcv_api_table {
80 WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
83 /********************************************************************
84 * Canonicalize servername.
85 ********************************************************************/
87 static const char *canon_servername(const char *servername)
89 const char *pservername = servername;
90 while (*pservername == '\\') {
96 /* translate between internal status numbers and NT status numbers */
97 static int nt_printj_status(int v)
103 return JOB_STATUS_PAUSED;
105 return JOB_STATUS_SPOOLING;
107 return JOB_STATUS_PRINTING;
109 return JOB_STATUS_ERROR;
111 return JOB_STATUS_DELETING;
113 return JOB_STATUS_OFFLINE;
115 return JOB_STATUS_PAPEROUT;
117 return JOB_STATUS_PRINTED;
119 return JOB_STATUS_DELETED;
121 return JOB_STATUS_BLOCKED_DEVQ;
122 case LPQ_USER_INTERVENTION:
123 return JOB_STATUS_USER_INTERVENTION;
128 static int nt_printq_status(int v)
132 return PRINTER_STATUS_PAUSED;
141 /***************************************************************************
142 Disconnect from the client
143 ****************************************************************************/
145 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
151 * Tell the specific printing tdb we no longer want messages for this printer
152 * by deregistering our PID.
155 if (!print_notify_deregister_pid(snum))
156 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
158 /* weird if the test succeds !!! */
159 if (smb_connections==0) {
160 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
164 status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
167 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
168 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
169 win_errstr(result)));
171 /* if it's the last connection, deconnect the IPC$ share */
172 if (smb_connections==1) {
174 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
175 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
177 messaging_deregister(smbd_messaging_context(),
178 MSG_PRINTER_NOTIFY2, NULL);
180 /* Tell the connections db we're no longer interested in
181 * printer notify messages. */
183 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
189 /****************************************************************************
190 Functions to free a printer entry datastruct.
191 ****************************************************************************/
193 static int printer_entry_destructor(Printer_entry *Printer)
195 if (Printer->notify.client_connected == true) {
198 if ( Printer->printer_type == SPLHND_SERVER) {
200 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
201 } else if (Printer->printer_type == SPLHND_PRINTER) {
202 snum = print_queue_snum(Printer->sharename);
204 srv_spoolss_replycloseprinter(snum,
205 &Printer->notify.client_hnd);
209 Printer->notify.flags=0;
210 Printer->notify.options=0;
211 Printer->notify.localmachine[0]='\0';
212 Printer->notify.printerlocal=0;
213 TALLOC_FREE(Printer->notify.option);
214 Printer->notify.client_connected = false;
216 free_nt_devicemode( &Printer->nt_devmode );
217 free_a_printer( &Printer->printer_info, 2 );
219 /* Remove from the internal list. */
220 DLIST_REMOVE(printers_list, Printer);
224 /****************************************************************************
225 find printer index by handle
226 ****************************************************************************/
228 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
229 struct policy_handle *hnd)
231 Printer_entry *find_printer = NULL;
233 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
234 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
241 /****************************************************************************
242 Close printer index by handle.
243 ****************************************************************************/
245 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
247 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
250 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
255 close_policy_hnd(p, hnd);
260 /****************************************************************************
261 Delete a printer given a handle.
262 ****************************************************************************/
264 static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename)
266 char *cmd = lp_deleteprinter_cmd();
267 char *command = NULL;
269 SE_PRIV se_printop = SE_PRINT_OPERATOR;
270 bool is_print_op = false;
272 /* can't fail if we don't try */
277 command = talloc_asprintf(ctx,
284 is_print_op = user_has_privileges( token, &se_printop );
286 DEBUG(10,("Running [%s]\n", command));
288 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
293 if ( (ret = smbrun(command, NULL)) == 0 ) {
294 /* Tell everyone we updated smb.conf. */
295 message_send_all(smbd_messaging_context(),
296 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
302 /********** END SePrintOperatorPrivlege BLOCK **********/
304 DEBUGADD(10,("returned [%d]\n", ret));
306 TALLOC_FREE(command);
309 return WERR_BADFID; /* What to return here? */
311 /* go ahead and re-read the services immediately */
312 reload_services(false);
314 if ( lp_servicenumber( sharename ) < 0 )
315 return WERR_ACCESS_DENIED;
320 /****************************************************************************
321 Delete a printer given a handle.
322 ****************************************************************************/
324 static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
326 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
329 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
335 * It turns out that Windows allows delete printer on a handle
336 * opened by an admin user, then used on a pipe handle created
337 * by an anonymous user..... but they're working on security.... riiight !
341 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
342 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
343 return WERR_ACCESS_DENIED;
346 /* this does not need a become root since the access check has been
347 done on the handle already */
349 if (del_a_printer( Printer->sharename ) != 0) {
350 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
354 return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
355 Printer->sharename );
358 /****************************************************************************
359 Return the snum of a printer corresponding to an handle.
360 ****************************************************************************/
362 static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
363 int *number, struct share_params **params)
365 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
368 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
373 switch (Printer->printer_type) {
375 DEBUG(4,("short name:%s\n", Printer->sharename));
376 *number = print_queue_snum(Printer->sharename);
377 return (*number != -1);
385 /****************************************************************************
386 Set printer handle type.
387 Check if it's \\server or \\server\printer
388 ****************************************************************************/
390 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
392 DEBUG(3,("Setting printer type=%s\n", handlename));
394 if ( strlen(handlename) < 3 ) {
395 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
399 /* it's a print server */
400 if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
401 DEBUGADD(4,("Printer is a print server\n"));
402 Printer->printer_type = SPLHND_SERVER;
404 /* it's a printer (set_printer_hnd_name() will handle port monitors */
406 DEBUGADD(4,("Printer is a printer\n"));
407 Printer->printer_type = SPLHND_PRINTER;
413 /****************************************************************************
414 Set printer handle name.. Accept names like \\server, \\server\printer,
415 \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port" See
416 the MSDN docs regarding OpenPrinter() for details on the XcvData() and
417 XcvDataPort() interface.
418 ****************************************************************************/
420 static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
423 int n_services=lp_numservices();
424 char *aprinter, *printername;
425 const char *servername;
428 NT_PRINTER_INFO_LEVEL *printer = NULL;
431 DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
432 (unsigned long)strlen(handlename)));
434 aprinter = CONST_DISCARD(char *, handlename);
435 if ( *handlename == '\\' ) {
436 servername = canon_servername(handlename);
437 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
442 servername = global_myname();
445 /* save the servername to fill in replies on this handle */
447 if ( !is_myname_or_ipaddr( servername ) )
450 fstrcpy( Printer->servername, servername );
452 if ( Printer->printer_type == SPLHND_SERVER )
455 if ( Printer->printer_type != SPLHND_PRINTER )
458 DEBUGADD(5, ("searching for [%s]\n", aprinter ));
460 /* check for the Port Monitor Interface */
462 if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
463 Printer->printer_type = SPLHND_PORTMON_TCP;
464 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
467 else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
468 Printer->printer_type = SPLHND_PORTMON_LOCAL;
469 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
473 /* Search all sharenames first as this is easier than pulling
474 the printer_info_2 off of disk. Don't use find_service() since
475 that calls out to map_username() */
477 /* do another loop to look for printernames */
479 for (snum=0; !found && snum<n_services; snum++) {
481 /* no point going on if this is not a printer */
483 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
486 fstrcpy(sname, lp_servicename(snum));
487 if ( strequal( aprinter, sname ) ) {
492 /* no point looking up the printer object if
493 we aren't allowing printername != sharename */
495 if ( lp_force_printername(snum) )
498 fstrcpy(sname, lp_servicename(snum));
502 /* This call doesn't fill in the location or comment from
503 * a CUPS server for efficiency with large numbers of printers.
507 result = get_a_printer_search( NULL, &printer, 2, sname );
508 if ( !W_ERROR_IS_OK(result) ) {
509 DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
510 sname, win_errstr(result)));
514 /* printername is always returned as \\server\printername */
515 if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
516 DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
517 printer->info_2->printername));
518 free_a_printer( &printer, 2);
524 if ( strequal(printername, aprinter) ) {
525 free_a_printer( &printer, 2);
530 DEBUGADD(10, ("printername: %s\n", printername));
532 free_a_printer( &printer, 2);
535 free_a_printer( &printer, 2);
538 DEBUGADD(4,("Printer not found\n"));
542 DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
544 fstrcpy(Printer->sharename, sname);
549 /****************************************************************************
550 Find first available printer slot. creates a printer handle for you.
551 ****************************************************************************/
553 static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
554 const char *name, uint32_t access_granted)
556 Printer_entry *new_printer;
558 DEBUG(10,("open_printer_hnd: name [%s]\n", name));
560 new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
561 if (new_printer == NULL) {
564 talloc_set_destructor(new_printer, printer_entry_destructor);
566 if (!create_policy_hnd(p, hnd, new_printer)) {
567 TALLOC_FREE(new_printer);
571 /* Add to the internal list. */
572 DLIST_ADD(printers_list, new_printer);
574 new_printer->notify.option=NULL;
576 if (!set_printer_hnd_printertype(new_printer, name)) {
577 close_printer_handle(p, hnd);
581 if (!set_printer_hnd_name(new_printer, name)) {
582 close_printer_handle(p, hnd);
586 new_printer->access_granted = access_granted;
588 DEBUG(5, ("%d printer handles active\n",
589 (int)num_pipe_handles(p->pipe_handles)));
594 /***************************************************************************
595 check to see if the client motify handle is monitoring the notification
596 given by (notify_type, notify_field).
597 **************************************************************************/
599 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
600 uint16_t notify_field)
605 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
606 uint16_t notify_field)
608 struct spoolss_NotifyOption *option = p->notify.option;
612 * Flags should always be zero when the change notify
613 * is registered by the client's spooler. A user Win32 app
614 * might use the flags though instead of the NOTIFY_OPTION_INFO
623 return is_monitoring_event_flags(
624 p->notify.flags, notify_type, notify_field);
626 for (i = 0; i < option->count; i++) {
628 /* Check match for notify_type */
630 if (option->types[i].type != notify_type)
633 /* Check match for field */
635 for (j = 0; j < option->types[i].count; j++) {
636 if (option->types[i].fields[j].field == notify_field) {
642 DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
643 p->servername, p->sharename, notify_type, notify_field));
648 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
649 _data->data.integer[0] = _integer; \
650 _data->data.integer[1] = 0;
653 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
654 _data->data.string.string = talloc_strdup(mem_ctx, _p); \
655 if (!_data->data.string.string) {\
656 _data->data.string.size = 0; \
658 _data->data.string.size = strlen_m_term(_p) * 2;
660 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
661 _data->data.devmode.devmode = _devmode;
663 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
664 _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
665 if (!_data->data.sd.sd) { \
666 _data->data.sd.sd_size = 0; \
668 _data->data.sd.sd_size = _size;
670 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
675 struct spoolss_Time st;
679 if (!init_systemtime(&st, t)) {
683 p = talloc_array(mem_ctx, char, len);
689 * Systemtime must be linearized as a set of UINT16's.
690 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
693 SSVAL(p, 0, st.year);
694 SSVAL(p, 2, st.month);
695 SSVAL(p, 4, st.day_of_week);
697 SSVAL(p, 8, st.hour);
698 SSVAL(p, 10, st.minute);
699 SSVAL(p, 12, st.second);
700 SSVAL(p, 14, st.millisecond);
706 /* Convert a notification message to a struct spoolss_Notify */
708 static void notify_one_value(struct spoolss_notify_msg *msg,
709 struct spoolss_Notify *data,
712 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
715 static void notify_string(struct spoolss_notify_msg *msg,
716 struct spoolss_Notify *data,
719 /* The length of the message includes the trailing \0 */
721 data->data.string.size = msg->len * 2;
722 data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
723 if (!data->data.string.string) {
724 data->data.string.size = 0;
729 static void notify_system_time(struct spoolss_notify_msg *msg,
730 struct spoolss_Notify *data,
733 data->data.string.string = NULL;
734 data->data.string.size = 0;
736 if (msg->len != sizeof(time_t)) {
737 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
742 init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
743 &data->data.string.string,
744 &data->data.string.size);
747 struct notify2_message_table {
749 void (*fn)(struct spoolss_notify_msg *msg,
750 struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
753 static struct notify2_message_table printer_notify_table[] = {
754 /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
755 /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
756 /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
757 /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
758 /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
759 /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
760 /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
761 /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
762 /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
763 /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
764 /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
765 /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
766 /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
767 /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
768 /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
769 /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
770 /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
771 /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
772 /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
775 static struct notify2_message_table job_notify_table[] = {
776 /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
777 /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
778 /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
779 /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
780 /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
781 /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
782 /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
783 /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
784 /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
785 /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
786 /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
787 /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
788 /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
789 /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
790 /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
791 /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
792 /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
793 /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
794 /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
795 /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
796 /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
797 /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
798 /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
799 /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
803 /***********************************************************************
804 Allocate talloc context for container object
805 **********************************************************************/
807 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
812 ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
817 /***********************************************************************
818 release all allocated memory and zero out structure
819 **********************************************************************/
821 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
827 talloc_destroy(ctr->ctx);
834 /***********************************************************************
835 **********************************************************************/
837 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
845 /***********************************************************************
846 **********************************************************************/
848 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
850 if ( !ctr || !ctr->msg_groups )
853 if ( idx >= ctr->num_groups )
856 return &ctr->msg_groups[idx];
860 /***********************************************************************
861 How many groups of change messages do we have ?
862 **********************************************************************/
864 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
869 return ctr->num_groups;
872 /***********************************************************************
873 Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
874 **********************************************************************/
876 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
878 SPOOLSS_NOTIFY_MSG_GROUP *groups = NULL;
879 SPOOLSS_NOTIFY_MSG_GROUP *msg_grp = NULL;
880 SPOOLSS_NOTIFY_MSG *msg_list = NULL;
886 /* loop over all groups looking for a matching printer name */
888 for ( i=0; i<ctr->num_groups; i++ ) {
889 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
893 /* add a new group? */
895 if ( i == ctr->num_groups ) {
898 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
899 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
902 ctr->msg_groups = groups;
904 /* clear the new entry and set the printer name */
906 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
907 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
910 /* add the change messages; 'i' is the correct index now regardless */
912 msg_grp = &ctr->msg_groups[i];
916 if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
917 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
920 msg_grp->msgs = msg_list;
922 new_slot = msg_grp->num_msgs-1;
923 memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
925 /* need to allocate own copy of data */
928 msg_grp->msgs[new_slot].notify.data = (char *)
929 TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
931 return ctr->num_groups;
934 /***********************************************************************
935 Send a change notication message on all handles which have a call
937 **********************************************************************/
939 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
942 TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
943 SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
944 SPOOLSS_NOTIFY_MSG *messages;
945 int sending_msg_count;
948 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
952 messages = msg_group->msgs;
955 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
959 DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
961 /* loop over all printers */
963 for (p = printers_list; p; p = p->next) {
964 struct spoolss_Notify *notifies;
969 /* Is there notification on this handle? */
971 if ( !p->notify.client_connected )
974 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
976 /* For this printer? Print servers always receive
979 if ( ( p->printer_type == SPLHND_PRINTER ) &&
980 ( !strequal(msg_group->printername, p->sharename) ) )
983 DEBUG(10,("Our printer\n"));
985 /* allocate the max entries possible */
987 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
992 /* build the array of change notifications */
994 sending_msg_count = 0;
996 for ( i=0; i<msg_group->num_msgs; i++ ) {
997 SPOOLSS_NOTIFY_MSG *msg = &messages[i];
999 /* Are we monitoring this event? */
1001 if (!is_monitoring_event(p, msg->type, msg->field))
1004 sending_msg_count++;
1007 DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1008 msg->type, msg->field, p->sharename));
1011 * if the is a printer notification handle and not a job notification
1012 * type, then set the id to 0. Other wise just use what was specified
1015 * When registering change notification on a print server handle
1016 * we always need to send back the id (snum) matching the printer
1017 * for which the change took place. For change notify registered
1018 * on a printer handle, this does not matter and the id should be 0.
1023 if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1029 /* Convert unix jobid to smb jobid */
1031 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1032 id = sysjob_to_jobid(msg->id);
1035 DEBUG(3, ("no such unix jobid %d\n", msg->id));
1040 construct_info_data( ¬ifies[count], msg->type, msg->field, id );
1043 case PRINTER_NOTIFY_TYPE:
1044 if ( printer_notify_table[msg->field].fn )
1045 printer_notify_table[msg->field].fn(msg, ¬ifies[count], mem_ctx);
1048 case JOB_NOTIFY_TYPE:
1049 if ( job_notify_table[msg->field].fn )
1050 job_notify_table[msg->field].fn(msg, ¬ifies[count], mem_ctx);
1054 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1061 if ( sending_msg_count ) {
1064 union spoolss_ReplyPrinterInfo info;
1065 struct spoolss_NotifyInfo info0;
1066 uint32_t reply_result;
1068 info0.version = 0x2;
1069 info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1070 info0.count = count;
1071 info0.notifies = notifies;
1073 info.info0 = &info0;
1075 status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1076 &p->notify.client_hnd,
1077 p->notify.change, /* color */
1080 0, /* reply_type, must be 0 */
1083 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1084 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1085 notify_cli_pipe->srv_name_slash,
1088 switch (reply_result) {
1091 case PRINTER_NOTIFY_INFO_DISCARDED:
1092 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1093 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1102 DEBUG(8,("send_notify2_changes: Exit...\n"));
1106 /***********************************************************************
1107 **********************************************************************/
1109 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1112 uint32_t tv_sec, tv_usec;
1115 /* Unpack message */
1117 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1120 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1122 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1125 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1126 &msg->notify.value[0], &msg->notify.value[1]);
1128 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1129 &msg->len, &msg->notify.data);
1131 DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1132 msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1134 tv->tv_sec = tv_sec;
1135 tv->tv_usec = tv_usec;
1138 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1139 msg->notify.value[1]));
1141 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1146 /********************************************************************
1147 Receive a notify2 message list
1148 ********************************************************************/
1150 static void receive_notify2_message_list(struct messaging_context *msg,
1153 struct server_id server_id,
1156 size_t msg_count, i;
1157 char *buf = (char *)data->data;
1160 SPOOLSS_NOTIFY_MSG notify;
1161 SPOOLSS_NOTIFY_MSG_CTR messages;
1164 if (data->length < 4) {
1165 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1169 msg_count = IVAL(buf, 0);
1172 DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1174 if (msg_count == 0) {
1175 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1179 /* initialize the container */
1181 ZERO_STRUCT( messages );
1182 notify_msg_ctr_init( &messages );
1185 * build message groups for each printer identified
1186 * in a change_notify msg. Remember that a PCN message
1187 * includes the handle returned for the srv_spoolss_replyopenprinter()
1188 * call. Therefore messages are grouped according to printer handle.
1191 for ( i=0; i<msg_count; i++ ) {
1192 struct timeval msg_tv;
1194 if (msg_ptr + 4 - buf > data->length) {
1195 DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1199 msg_len = IVAL(msg_ptr,0);
1202 if (msg_ptr + msg_len - buf > data->length) {
1203 DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1207 /* unpack messages */
1209 ZERO_STRUCT( notify );
1210 notify2_unpack_msg( ¬ify, &msg_tv, msg_ptr, msg_len );
1213 /* add to correct list in container */
1215 notify_msg_ctr_addmsg( &messages, ¬ify );
1217 /* free memory that might have been allocated by notify2_unpack_msg() */
1219 if ( notify.len != 0 )
1220 SAFE_FREE( notify.notify.data );
1223 /* process each group of messages */
1225 num_groups = notify_msg_ctr_numgroups( &messages );
1226 for ( i=0; i<num_groups; i++ )
1227 send_notify2_changes( &messages, i );
1232 DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1233 (uint32_t)msg_count ));
1235 notify_msg_ctr_destroy( &messages );
1240 /********************************************************************
1241 Send a message to ourself about new driver being installed
1242 so we can upgrade the information for each printer bound to this
1244 ********************************************************************/
1246 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1248 int len = strlen(drivername);
1253 DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1256 messaging_send_buf(smbd_messaging_context(), procid_self(),
1257 MSG_PRINTER_DRVUPGRADE,
1258 (uint8_t *)drivername, len+1);
1263 /**********************************************************************
1264 callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1265 over all printers, upgrading ones as necessary
1266 **********************************************************************/
1268 void do_drv_upgrade_printer(struct messaging_context *msg,
1271 struct server_id server_id,
1276 int n_services = lp_numservices();
1279 len = MIN(data->length,sizeof(drivername)-1);
1280 strncpy(drivername, (const char *)data->data, len);
1282 DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1284 /* Iterate the printer list */
1286 for (snum=0; snum<n_services; snum++)
1288 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1291 NT_PRINTER_INFO_LEVEL *printer = NULL;
1293 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1294 if (!W_ERROR_IS_OK(result))
1297 if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1299 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1301 /* all we care about currently is the change_id */
1303 result = mod_a_printer(printer, 2);
1304 if (!W_ERROR_IS_OK(result)) {
1305 DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1306 win_errstr(result)));
1310 free_a_printer(&printer, 2);
1317 /********************************************************************
1318 Update the cache for all printq's with a registered client
1320 ********************************************************************/
1322 void update_monitored_printq_cache( void )
1324 Printer_entry *printer = printers_list;
1327 /* loop through all printers and update the cache where
1328 client_connected == true */
1331 if ( (printer->printer_type == SPLHND_PRINTER)
1332 && printer->notify.client_connected )
1334 snum = print_queue_snum(printer->sharename);
1335 print_queue_status( snum, NULL, NULL );
1338 printer = printer->next;
1343 /********************************************************************
1344 Send a message to ourself about new driver being installed
1345 so we can upgrade the information for each printer bound to this
1347 ********************************************************************/
1349 static bool srv_spoolss_reset_printerdata(char* drivername)
1351 int len = strlen(drivername);
1356 DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1359 messaging_send_buf(smbd_messaging_context(), procid_self(),
1360 MSG_PRINTERDATA_INIT_RESET,
1361 (uint8_t *)drivername, len+1);
1366 /**********************************************************************
1367 callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1368 over all printers, resetting printer data as neessary
1369 **********************************************************************/
1371 void reset_all_printerdata(struct messaging_context *msg,
1374 struct server_id server_id,
1379 int n_services = lp_numservices();
1382 len = MIN( data->length, sizeof(drivername)-1 );
1383 strncpy( drivername, (const char *)data->data, len );
1385 DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1387 /* Iterate the printer list */
1389 for ( snum=0; snum<n_services; snum++ )
1391 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1394 NT_PRINTER_INFO_LEVEL *printer = NULL;
1396 result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1397 if ( !W_ERROR_IS_OK(result) )
1401 * if the printer is bound to the driver,
1402 * then reset to the new driver initdata
1405 if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1407 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1409 if ( !set_driver_init(printer, 2) ) {
1410 DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1411 printer->info_2->printername, printer->info_2->drivername));
1414 result = mod_a_printer( printer, 2 );
1415 if ( !W_ERROR_IS_OK(result) ) {
1416 DEBUG(3,("reset_all_printerdata: mod_a_printer() failed! (%s)\n",
1417 get_dos_error_msg(result)));
1421 free_a_printer( &printer, 2 );
1430 /****************************************************************
1431 _spoolss_OpenPrinter
1432 ****************************************************************/
1434 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1435 struct spoolss_OpenPrinter *r)
1437 struct spoolss_OpenPrinterEx e;
1440 ZERO_STRUCT(e.in.userlevel);
1442 e.in.printername = r->in.printername;
1443 e.in.datatype = r->in.datatype;
1444 e.in.devmode_ctr = r->in.devmode_ctr;
1445 e.in.access_mask = r->in.access_mask;
1448 e.out.handle = r->out.handle;
1450 werr = _spoolss_OpenPrinterEx(p, &e);
1452 if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1453 /* OpenPrinterEx returns this for a bad
1454 * printer name. We must return WERR_INVALID_PRINTER_NAME
1457 werr = WERR_INVALID_PRINTER_NAME;
1463 /********************************************************************
1464 ********************************************************************/
1466 bool convert_devicemode(const char *printername,
1467 const struct spoolss_DeviceMode *devmode,
1468 NT_DEVICEMODE **pp_nt_devmode)
1470 NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1473 * Ensure nt_devmode is a valid pointer
1474 * as we will be overwriting it.
1477 if (nt_devmode == NULL) {
1478 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1479 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1483 rpcstr_push(nt_devmode->devicename, devmode->devicename, 31, 0);
1484 rpcstr_push(nt_devmode->formname, devmode->formname, 31, 0);
1486 nt_devmode->specversion = devmode->specversion;
1487 nt_devmode->driverversion = devmode->driverversion;
1488 nt_devmode->size = devmode->size;
1489 nt_devmode->fields = devmode->fields;
1490 nt_devmode->orientation = devmode->orientation;
1491 nt_devmode->papersize = devmode->papersize;
1492 nt_devmode->paperlength = devmode->paperlength;
1493 nt_devmode->paperwidth = devmode->paperwidth;
1494 nt_devmode->scale = devmode->scale;
1495 nt_devmode->copies = devmode->copies;
1496 nt_devmode->defaultsource = devmode->defaultsource;
1497 nt_devmode->printquality = devmode->printquality;
1498 nt_devmode->color = devmode->color;
1499 nt_devmode->duplex = devmode->duplex;
1500 nt_devmode->yresolution = devmode->yresolution;
1501 nt_devmode->ttoption = devmode->ttoption;
1502 nt_devmode->collate = devmode->collate;
1504 nt_devmode->logpixels = devmode->logpixels;
1505 nt_devmode->bitsperpel = devmode->bitsperpel;
1506 nt_devmode->pelswidth = devmode->pelswidth;
1507 nt_devmode->pelsheight = devmode->pelsheight;
1508 nt_devmode->displayflags = devmode->displayflags;
1509 nt_devmode->displayfrequency = devmode->displayfrequency;
1510 nt_devmode->icmmethod = devmode->icmmethod;
1511 nt_devmode->icmintent = devmode->icmintent;
1512 nt_devmode->mediatype = devmode->mediatype;
1513 nt_devmode->dithertype = devmode->dithertype;
1514 nt_devmode->reserved1 = devmode->reserved1;
1515 nt_devmode->reserved2 = devmode->reserved2;
1516 nt_devmode->panningwidth = devmode->panningwidth;
1517 nt_devmode->panningheight = devmode->panningheight;
1520 * Only change private and driverextra if the incoming devmode
1521 * has a new one. JRA.
1524 if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1525 SAFE_FREE(nt_devmode->nt_dev_private);
1526 nt_devmode->driverextra = devmode->__driverextra_length;
1527 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1529 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1532 *pp_nt_devmode = nt_devmode;
1537 /****************************************************************
1538 _spoolss_OpenPrinterEx
1539 ****************************************************************/
1541 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1542 struct spoolss_OpenPrinterEx *r)
1545 Printer_entry *Printer=NULL;
1547 if (!r->in.printername) {
1548 return WERR_INVALID_PARAM;
1551 /* some sanity check because you can open a printer or a print server */
1552 /* aka: \\server\printer or \\server */
1554 DEBUGADD(3,("checking name: %s\n", r->in.printername));
1556 if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1557 ZERO_STRUCTP(r->out.handle);
1558 return WERR_INVALID_PARAM;
1561 Printer = find_printer_index_by_hnd(p, r->out.handle);
1563 DEBUG(0,("_spoolss_OpenPrinterEx: logic error. Can't find printer "
1564 "handle we created for printer %s\n", r->in.printername));
1565 close_printer_handle(p, r->out.handle);
1566 ZERO_STRUCTP(r->out.handle);
1567 return WERR_INVALID_PARAM;
1571 * First case: the user is opening the print server:
1573 * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1574 * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1576 * Then both Win2k and WinNT clients try an OpenPrinterEx with
1577 * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1578 * or if the user is listed in the smb.conf printer admin parameter.
1580 * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1581 * client view printer folder, but does not show the MSAPW.
1583 * Note: this test needs code to check access rights here too. Jeremy
1584 * could you look at this?
1586 * Second case: the user is opening a printer:
1587 * NT doesn't let us connect to a printer if the connecting user
1588 * doesn't have print permission.
1590 * Third case: user is opening a Port Monitor
1591 * access checks same as opening a handle to the print server.
1594 switch (Printer->printer_type )
1597 case SPLHND_PORTMON_TCP:
1598 case SPLHND_PORTMON_LOCAL:
1599 /* Printserver handles use global struct... */
1603 /* Map standard access rights to object specific access rights */
1605 se_map_standard(&r->in.access_mask,
1606 &printserver_std_mapping);
1608 /* Deny any object specific bits that don't apply to print
1609 servers (i.e printer and job specific bits) */
1611 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1613 if (r->in.access_mask &
1614 ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1615 DEBUG(3, ("access DENIED for non-printserver bits\n"));
1616 close_printer_handle(p, r->out.handle);
1617 ZERO_STRUCTP(r->out.handle);
1618 return WERR_ACCESS_DENIED;
1621 /* Allow admin access */
1623 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1625 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1627 if (!lp_ms_add_printer_wizard()) {
1628 close_printer_handle(p, r->out.handle);
1629 ZERO_STRUCTP(r->out.handle);
1630 return WERR_ACCESS_DENIED;
1633 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1634 and not a printer admin, then fail */
1636 if ((p->server_info->utok.uid != sec_initial_uid()) &&
1637 !user_has_privileges(p->server_info->ptok,
1639 !token_contains_name_in_list(
1640 uidtoname(p->server_info->utok.uid),
1642 p->server_info->ptok,
1643 lp_printer_admin(snum))) {
1644 close_printer_handle(p, r->out.handle);
1645 ZERO_STRUCTP(r->out.handle);
1646 return WERR_ACCESS_DENIED;
1649 r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1653 r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1656 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1657 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1659 /* We fall through to return WERR_OK */
1662 case SPLHND_PRINTER:
1663 /* NT doesn't let us connect to a printer if the connecting user
1664 doesn't have print permission. */
1666 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1667 close_printer_handle(p, r->out.handle);
1668 ZERO_STRUCTP(r->out.handle);
1672 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1674 /* map an empty access mask to the minimum access mask */
1675 if (r->in.access_mask == 0x0)
1676 r->in.access_mask = PRINTER_ACCESS_USE;
1679 * If we are not serving the printer driver for this printer,
1680 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1681 * will keep NT clients happy --jerry
1684 if (lp_use_client_driver(snum)
1685 && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1687 r->in.access_mask = PRINTER_ACCESS_USE;
1690 /* check smb.conf parameters and the the sec_desc */
1692 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1693 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1694 ZERO_STRUCTP(r->out.handle);
1695 return WERR_ACCESS_DENIED;
1698 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1699 p->server_info->ptok, snum) ||
1700 !print_access_check(p->server_info, snum,
1701 r->in.access_mask)) {
1702 DEBUG(3, ("access DENIED for printer open\n"));
1703 close_printer_handle(p, r->out.handle);
1704 ZERO_STRUCTP(r->out.handle);
1705 return WERR_ACCESS_DENIED;
1708 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1709 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1710 close_printer_handle(p, r->out.handle);
1711 ZERO_STRUCTP(r->out.handle);
1712 return WERR_ACCESS_DENIED;
1715 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1716 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1718 r->in.access_mask = PRINTER_ACCESS_USE;
1720 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1721 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1726 /* sanity check to prevent programmer error */
1727 ZERO_STRUCTP(r->out.handle);
1731 Printer->access_granted = r->in.access_mask;
1734 * If the client sent a devmode in the OpenPrinter() call, then
1735 * save it here in case we get a job submission on this handle
1738 if ((Printer->printer_type != SPLHND_SERVER) &&
1739 r->in.devmode_ctr.devmode) {
1740 convert_devicemode(Printer->sharename,
1741 r->in.devmode_ctr.devmode,
1742 &Printer->nt_devmode);
1745 #if 0 /* JERRY -- I'm doubtful this is really effective */
1746 /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1747 optimization in Windows 2000 clients --jerry */
1749 if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1750 && (RA_WIN2K == get_remote_arch()) )
1752 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1753 sys_usleep( 500000 );
1760 /****************************************************************************
1761 ****************************************************************************/
1763 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1764 NT_PRINTER_INFO_LEVEL_2 *d)
1766 DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1772 d->attributes = r->attributes;
1773 d->priority = r->priority;
1774 d->default_priority = r->defaultpriority;
1775 d->starttime = r->starttime;
1776 d->untiltime = r->untiltime;
1777 d->status = r->status;
1778 d->cjobs = r->cjobs;
1780 fstrcpy(d->servername, r->servername);
1781 fstrcpy(d->printername, r->printername);
1782 fstrcpy(d->sharename, r->sharename);
1783 fstrcpy(d->portname, r->portname);
1784 fstrcpy(d->drivername, r->drivername);
1785 slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1786 fstrcpy(d->location, r->location);
1787 fstrcpy(d->sepfile, r->sepfile);
1788 fstrcpy(d->printprocessor, r->printprocessor);
1789 fstrcpy(d->datatype, r->datatype);
1790 fstrcpy(d->parameters, r->parameters);
1795 /****************************************************************************
1796 ****************************************************************************/
1798 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1799 NT_PRINTER_INFO_LEVEL *printer)
1803 switch (info_ctr->level) {
1805 /* allocate memory if needed. Messy because
1806 convert_printer_info is used to update an existing
1807 printer or build a new one */
1809 if (!printer->info_2) {
1810 printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1811 if (!printer->info_2) {
1812 DEBUG(0,("convert_printer_info: "
1813 "talloc() failed!\n"));
1818 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1820 printer->info_2->setuptime = time(NULL);
1827 /*******************************************************************
1828 ********************************************************************/
1830 static bool string_array_to_fstring_array(const char **sarray, fstring **farray)
1839 *farray = SMB_MALLOC_ARRAY(fstring, 1);
1844 for (i=0; sarray[i] != NULL; i++) {
1845 *farray = SMB_REALLOC_ARRAY(*farray, fstring, i+2);
1849 fstrcpy((*farray)[i], sarray[i]);
1852 fstrcpy((*farray)[i], "");
1857 /*******************************************************************
1858 ********************************************************************/
1860 static bool driver_info3_to_nt_driver_info3(struct spoolss_AddDriverInfo3 *r,
1861 NT_PRINTER_DRIVER_INFO_LEVEL_3 **p)
1863 NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
1865 DEBUG(7,("driver_info3_to_nt_driver_info3: Converting from UNICODE to ASCII\n"));
1868 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
1877 d->cversion = r->version;
1879 fstrcpy(d->name, r->driver_name);
1880 fstrcpy(d->environment, r->architecture);
1881 fstrcpy(d->driverpath, r->driver_path);
1882 fstrcpy(d->datafile, r->data_file);
1883 fstrcpy(d->configfile, r->config_file);
1884 fstrcpy(d->helpfile, r->help_file);
1885 fstrcpy(d->monitorname, r->monitor_name);
1886 fstrcpy(d->defaultdatatype, r->default_datatype);
1888 DEBUGADD(8,( "version: %d\n", d->cversion));
1889 DEBUGADD(8,( "name: %s\n", d->name));
1890 DEBUGADD(8,( "environment: %s\n", d->environment));
1891 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
1892 DEBUGADD(8,( "datafile: %s\n", d->datafile));
1893 DEBUGADD(8,( "configfile: %s\n", d->configfile));
1894 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
1895 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
1896 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1898 if (r->dependent_files) {
1899 if (!string_array_to_fstring_array(r->dependent_files->string,
1900 &d->dependentfiles)) {
1909 /*******************************************************************
1910 ********************************************************************/
1912 static bool driver_info6_to_nt_driver_info6(struct spoolss_AddDriverInfo6 *r,
1913 NT_PRINTER_DRIVER_INFO_LEVEL_6 **p)
1915 NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
1917 DEBUG(7,("driver_info6_to_nt_driver_info6: Converting from UNICODE to ASCII\n"));
1920 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
1929 d->version = r->version;
1931 fstrcpy(d->name, r->driver_name);
1932 fstrcpy(d->environment, r->architecture);
1933 fstrcpy(d->driverpath, r->driver_path);
1934 fstrcpy(d->datafile, r->data_file);
1935 fstrcpy(d->configfile, r->config_file);
1936 fstrcpy(d->helpfile, r->help_file);
1937 fstrcpy(d->monitorname, r->monitor_name);
1938 fstrcpy(d->defaultdatatype, r->default_datatype);
1940 DEBUGADD(8,( "version: %d\n", d->version));
1941 DEBUGADD(8,( "name: %s\n", d->name));
1942 DEBUGADD(8,( "environment: %s\n", d->environment));
1943 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
1944 DEBUGADD(8,( "datafile: %s\n", d->datafile));
1945 DEBUGADD(8,( "configfile: %s\n", d->configfile));
1946 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
1947 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
1948 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1950 if (r->dependent_files) {
1951 if (!string_array_to_fstring_array(r->dependent_files->string,
1952 &d->dependentfiles)) {
1957 if (r->previous_names) {
1958 if (!string_array_to_fstring_array(r->previous_names->string,
1959 &d->previousnames)) {
1971 /********************************************************************
1972 ********************************************************************/
1974 static bool convert_printer_driver_info(const struct spoolss_AddDriverInfoCtr *r,
1975 NT_PRINTER_DRIVER_INFO_LEVEL *printer,
1980 printer->info_3 = NULL;
1981 if (!driver_info3_to_nt_driver_info3(r->info.info3, &printer->info_3)) {
1986 printer->info_6 = NULL;
1987 if (!driver_info6_to_nt_driver_info6(r->info.info6, &printer->info_6)) {
1998 /****************************************************************
1999 _spoolss_ClosePrinter
2000 ****************************************************************/
2002 WERROR _spoolss_ClosePrinter(pipes_struct *p,
2003 struct spoolss_ClosePrinter *r)
2005 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2007 if (Printer && Printer->document_started) {
2008 struct spoolss_EndDocPrinter e;
2010 e.in.handle = r->in.handle;
2012 _spoolss_EndDocPrinter(p, &e);
2015 if (!close_printer_handle(p, r->in.handle))
2018 /* clear the returned printer handle. Observed behavior
2019 from Win2k server. Don't think this really matters.
2020 Previous code just copied the value of the closed
2023 ZERO_STRUCTP(r->out.handle);
2028 /****************************************************************
2029 _spoolss_DeletePrinter
2030 ****************************************************************/
2032 WERROR _spoolss_DeletePrinter(pipes_struct *p,
2033 struct spoolss_DeletePrinter *r)
2035 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2038 if (Printer && Printer->document_started) {
2039 struct spoolss_EndDocPrinter e;
2041 e.in.handle = r->in.handle;
2043 _spoolss_EndDocPrinter(p, &e);
2046 result = delete_printer_handle(p, r->in.handle);
2048 update_c_setprinter(false);
2053 /*******************************************************************
2054 * static function to lookup the version id corresponding to an
2055 * long architecture string
2056 ******************************************************************/
2058 static int get_version_id(const char *arch)
2061 struct print_architecture_table_node archi_table[]= {
2063 {"Windows 4.0", "WIN40", 0 },
2064 {"Windows NT x86", "W32X86", 2 },
2065 {"Windows NT R4000", "W32MIPS", 2 },
2066 {"Windows NT Alpha_AXP", "W32ALPHA", 2 },
2067 {"Windows NT PowerPC", "W32PPC", 2 },
2068 {"Windows IA64", "IA64", 3 },
2069 {"Windows x64", "x64", 3 },
2073 for (i=0; archi_table[i].long_archi != NULL; i++)
2075 if (strcmp(arch, archi_table[i].long_archi) == 0)
2076 return (archi_table[i].version);
2082 /****************************************************************
2083 _spoolss_DeletePrinterDriver
2084 ****************************************************************/
2086 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
2087 struct spoolss_DeletePrinterDriver *r)
2089 NT_PRINTER_DRIVER_INFO_LEVEL info;
2090 NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
2093 WERROR status_win2k = WERR_ACCESS_DENIED;
2094 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2096 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2097 and not a printer admin, then fail */
2099 if ( (p->server_info->utok.uid != sec_initial_uid())
2100 && !user_has_privileges(p->server_info->ptok, &se_printop )
2101 && !token_contains_name_in_list(
2102 uidtoname(p->server_info->utok.uid), NULL,
2103 NULL, p->server_info->ptok,
2104 lp_printer_admin(-1)) )
2106 return WERR_ACCESS_DENIED;
2109 /* check that we have a valid driver name first */
2111 if ((version = get_version_id(r->in.architecture)) == -1)
2112 return WERR_INVALID_ENVIRONMENT;
2115 ZERO_STRUCT(info_win2k);
2117 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2121 /* try for Win2k driver if "Windows NT x86" */
2123 if ( version == 2 ) {
2125 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3,
2129 status = WERR_UNKNOWN_PRINTER_DRIVER;
2133 /* otherwise it was a failure */
2135 status = WERR_UNKNOWN_PRINTER_DRIVER;
2141 if (printer_driver_in_use(info.info_3)) {
2142 status = WERR_PRINTER_DRIVER_IN_USE;
2148 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2150 r->in.architecture, 3)))
2152 /* if we get to here, we now have 2 driver info structures to remove */
2153 /* remove the Win2k driver first*/
2155 status_win2k = delete_printer_driver(
2156 p, info_win2k.info_3, 3, false);
2157 free_a_printer_driver( info_win2k, 3 );
2159 /* this should not have failed---if it did, report to client */
2160 if ( !W_ERROR_IS_OK(status_win2k) )
2162 status = status_win2k;
2168 status = delete_printer_driver(p, info.info_3, version, false);
2170 /* if at least one of the deletes succeeded return OK */
2172 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2176 free_a_printer_driver( info, 3 );
2181 /****************************************************************
2182 _spoolss_DeletePrinterDriverEx
2183 ****************************************************************/
2185 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2186 struct spoolss_DeletePrinterDriverEx *r)
2188 NT_PRINTER_DRIVER_INFO_LEVEL info;
2189 NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
2193 WERROR status_win2k = WERR_ACCESS_DENIED;
2194 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2196 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2197 and not a printer admin, then fail */
2199 if ( (p->server_info->utok.uid != sec_initial_uid())
2200 && !user_has_privileges(p->server_info->ptok, &se_printop )
2201 && !token_contains_name_in_list(
2202 uidtoname(p->server_info->utok.uid), NULL, NULL,
2203 p->server_info->ptok, lp_printer_admin(-1)) )
2205 return WERR_ACCESS_DENIED;
2208 /* check that we have a valid driver name first */
2209 if ((version = get_version_id(r->in.architecture)) == -1) {
2210 /* this is what NT returns */
2211 return WERR_INVALID_ENVIRONMENT;
2214 if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2215 version = r->in.version;
2218 ZERO_STRUCT(info_win2k);
2220 status = get_a_printer_driver(&info, 3, r->in.driver,
2221 r->in.architecture, version);
2223 if ( !W_ERROR_IS_OK(status) )
2226 * if the client asked for a specific version,
2227 * or this is something other than Windows NT x86,
2231 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2234 /* try for Win2k driver if "Windows NT x86" */
2237 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2240 status = WERR_UNKNOWN_PRINTER_DRIVER;
2245 if ( printer_driver_in_use(info.info_3) ) {
2246 status = WERR_PRINTER_DRIVER_IN_USE;
2251 * we have a couple of cases to consider.
2252 * (1) Are any files in use? If so and DPD_DELTE_ALL_FILE is set,
2253 * then the delete should fail if **any** files overlap with
2255 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2256 * non-overlapping files
2257 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2258 * is set, the do not delete any files
2259 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2262 delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2264 /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2266 if ( delete_files && printer_driver_files_in_use(info.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2267 /* no idea of the correct error here */
2268 status = WERR_ACCESS_DENIED;
2273 /* also check for W32X86/3 if necessary; maybe we already have? */
2275 if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
2276 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2278 r->in.architecture, 3)))
2281 if ( delete_files && printer_driver_files_in_use(info_win2k.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2282 /* no idea of the correct error here */
2283 free_a_printer_driver( info_win2k, 3 );
2284 status = WERR_ACCESS_DENIED;
2288 /* if we get to here, we now have 2 driver info structures to remove */
2289 /* remove the Win2k driver first*/
2291 status_win2k = delete_printer_driver(
2292 p, info_win2k.info_3, 3, delete_files);
2293 free_a_printer_driver( info_win2k, 3 );
2295 /* this should not have failed---if it did, report to client */
2297 if ( !W_ERROR_IS_OK(status_win2k) )
2302 status = delete_printer_driver(p, info.info_3, version, delete_files);
2304 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2307 free_a_printer_driver( info, 3 );
2313 /****************************************************************************
2314 Internal routine for removing printerdata
2315 ***************************************************************************/
2317 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2319 return delete_printer_data( printer->info_2, key, value );
2322 /****************************************************************************
2323 Internal routine for storing printerdata
2324 ***************************************************************************/
2326 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2327 const char *key, const char *value,
2328 uint32_t type, uint8_t *data, int real_len)
2330 /* the registry objects enforce uniqueness based on value name */
2332 return add_printer_data( printer->info_2, key, value, type, data, real_len );
2335 /********************************************************************
2336 GetPrinterData on a printer server Handle.
2337 ********************************************************************/
2339 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2341 enum winreg_Type *type,
2342 union spoolss_PrinterData *data)
2344 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2346 if (!StrCaseCmp(value, "W3SvcInstalled")) {
2352 if (!StrCaseCmp(value, "BeepEnabled")) {
2358 if (!StrCaseCmp(value, "EventLog")) {
2360 /* formally was 0x1b */
2365 if (!StrCaseCmp(value, "NetPopup")) {
2371 if (!StrCaseCmp(value, "MajorVersion")) {
2374 /* Windows NT 4.0 seems to not allow uploading of drivers
2375 to a server that reports 0x3 as the MajorVersion.
2376 need to investigate more how Win2k gets around this .
2379 if (RA_WINNT == get_remote_arch()) {
2388 if (!StrCaseCmp(value, "MinorVersion")) {
2395 * uint32_t size = 0x114
2396 * uint32_t major = 5
2397 * uint32_t minor = [0|1]
2398 * uint32_t build = [2195|2600]
2399 * extra unicode string = e.g. "Service Pack 3"
2401 if (!StrCaseCmp(value, "OSVersion")) {
2403 enum ndr_err_code ndr_err;
2404 struct spoolss_OSVersion os;
2406 os.major = 5; /* Windows 2000 == 5.0 */
2408 os.build = 2195; /* build */
2409 os.extra_string = ""; /* leave extra string empty */
2411 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2412 (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2413 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2414 return WERR_GENERAL_FAILURE;
2418 data->binary = blob;
2424 if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2427 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2428 W_ERROR_HAVE_NO_MEMORY(data->string);
2433 if (!StrCaseCmp(value, "Architecture")) {
2436 data->string = talloc_strdup(mem_ctx, "Windows NT x86");
2437 W_ERROR_HAVE_NO_MEMORY(data->string);
2442 if (!StrCaseCmp(value, "DsPresent")) {
2445 /* only show the publish check box if we are a
2446 member of a AD domain */
2448 if (lp_security() == SEC_ADS) {
2456 if (!StrCaseCmp(value, "DNSMachineName")) {
2457 const char *hostname = get_mydnsfullname();
2460 return WERR_BADFILE;
2464 data->string = talloc_strdup(mem_ctx, hostname);
2465 W_ERROR_HAVE_NO_MEMORY(data->string);
2470 return WERR_INVALID_PARAM;
2473 /****************************************************************
2474 _spoolss_GetPrinterData
2475 ****************************************************************/
2477 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2478 struct spoolss_GetPrinterData *r)
2481 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2482 NT_PRINTER_INFO_LEVEL *printer = NULL;
2486 * Reminder: when it's a string, the length is in BYTES
2487 * even if UNICODE is negociated.
2492 /* in case of problem, return some default values */
2497 DEBUG(4,("_spoolss_GetPrinterData\n"));
2500 DEBUG(2,("_spoolss_GetPrinterData: Invalid handle (%s:%u:%u).\n",
2501 OUR_HANDLE(r->in.handle)));
2502 result = WERR_BADFID;
2506 if (Printer->printer_type == SPLHND_SERVER) {
2507 result = getprinterdata_printer_server(p->mem_ctx,
2512 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
2513 result = WERR_BADFID;
2517 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
2518 if (!W_ERROR_IS_OK(result)) {
2522 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
2524 if (strequal(r->in.value_name, "ChangeId")) {
2525 *r->out.type = REG_DWORD;
2526 r->out.data->value = printer->info_2->changeid;
2529 struct regval_blob *v;
2532 v = get_printer_data(printer->info_2,
2533 SPOOL_PRINTERDATA_KEY,
2536 result = WERR_BADFILE;
2540 *r->out.type = v->type;
2542 blob = data_blob_const(v->data_p, v->size);
2544 result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
2551 /* cleanup & exit */
2554 free_a_printer(&printer, 2);
2557 if (!W_ERROR_IS_OK(result)) {
2561 *r->out.needed = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
2562 *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
2563 r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
2565 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
2568 /*********************************************************
2569 Connect to the client machine.
2570 **********************************************************/
2572 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2573 struct sockaddr_storage *client_ss, const char *remote_machine)
2576 struct cli_state *the_cli;
2577 struct sockaddr_storage rm_addr;
2579 if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2580 if ( !resolve_name( remote_machine, &rm_addr, 0x20) ) {
2581 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2585 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2586 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
2590 char addr[INET6_ADDRSTRLEN];
2591 rm_addr = *client_ss;
2592 print_sockaddr(addr, sizeof(addr), &rm_addr);
2593 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2597 /* setup the connection */
2599 ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2600 &rm_addr, 0, "IPC$", "IPC",
2604 0, lp_client_signing(), NULL );
2606 if ( !NT_STATUS_IS_OK( ret ) ) {
2607 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2612 if ( the_cli->protocol != PROTOCOL_NT1 ) {
2613 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2614 cli_shutdown(the_cli);
2619 * Ok - we have an anonymous connection to the IPC$ share.
2620 * Now start the NT Domain stuff :-).
2623 ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2624 if (!NT_STATUS_IS_OK(ret)) {
2625 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2626 remote_machine, nt_errstr(ret)));
2627 cli_shutdown(the_cli);
2634 /***************************************************************************
2635 Connect to the client.
2636 ****************************************************************************/
2638 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2639 uint32_t localprinter, uint32_t type,
2640 struct policy_handle *handle,
2641 struct sockaddr_storage *client_ss)
2647 * If it's the first connection, contact the client
2648 * and connect to the IPC$ share anonymously
2650 if (smb_connections==0) {
2651 fstring unix_printer;
2653 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2655 if ( !spoolss_connect_to_client( ¬ify_cli_pipe, client_ss, unix_printer ))
2658 messaging_register(smbd_messaging_context(), NULL,
2659 MSG_PRINTER_NOTIFY2,
2660 receive_notify2_message_list);
2661 /* Tell the connections db we're now interested in printer
2662 * notify messages. */
2663 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2667 * Tell the specific printing tdb we want messages for this printer
2668 * by registering our PID.
2671 if (!print_notify_register_pid(snum))
2672 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2676 status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2684 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2685 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2686 win_errstr(result)));
2688 return (W_ERROR_IS_OK(result));
2691 /****************************************************************
2692 ****************************************************************/
2694 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2695 const struct spoolss_NotifyOption *r)
2697 struct spoolss_NotifyOption *option;
2704 option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2711 if (!option->count) {
2715 option->types = talloc_zero_array(option,
2716 struct spoolss_NotifyOptionType, option->count);
2717 if (!option->types) {
2718 talloc_free(option);
2722 for (i=0; i < option->count; i++) {
2723 option->types[i] = r->types[i];
2725 if (option->types[i].count) {
2726 option->types[i].fields = talloc_zero_array(option,
2727 union spoolss_Field, option->types[i].count);
2728 if (!option->types[i].fields) {
2729 talloc_free(option);
2732 for (k=0; k<option->types[i].count; k++) {
2733 option->types[i].fields[k] =
2734 r->types[i].fields[k];
2742 /****************************************************************
2743 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2745 * before replying OK: status=0 a rpc call is made to the workstation
2746 * asking ReplyOpenPrinter
2748 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2749 * called from api_spoolss_rffpcnex
2750 ****************************************************************/
2752 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2753 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2756 struct spoolss_NotifyOption *option = r->in.notify_options;
2757 struct sockaddr_storage client_ss;
2759 /* store the notify value in the printer struct */
2761 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2764 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2765 "Invalid handle (%s:%u:%u).\n",
2766 OUR_HANDLE(r->in.handle)));
2770 Printer->notify.flags = r->in.flags;
2771 Printer->notify.options = r->in.options;
2772 Printer->notify.printerlocal = r->in.printer_local;
2774 TALLOC_FREE(Printer->notify.option);
2775 Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2777 fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2779 /* Connect to the client machine and send a ReplyOpenPrinter */
2781 if ( Printer->printer_type == SPLHND_SERVER)
2783 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2784 !get_printer_snum(p, r->in.handle, &snum, NULL) )
2787 if (!interpret_string_addr(&client_ss, p->client_address,
2789 return WERR_SERVER_UNAVAILABLE;
2792 if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2793 Printer->notify.printerlocal, 1,
2794 &Printer->notify.client_hnd, &client_ss))
2795 return WERR_SERVER_UNAVAILABLE;
2797 Printer->notify.client_connected = true;
2802 /*******************************************************************
2803 * fill a notify_info_data with the servername
2804 ********************************************************************/
2806 void spoolss_notify_server_name(int snum,
2807 struct spoolss_Notify *data,
2808 print_queue_struct *queue,
2809 NT_PRINTER_INFO_LEVEL *printer,
2810 TALLOC_CTX *mem_ctx)
2812 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2815 /*******************************************************************
2816 * fill a notify_info_data with the printername (not including the servername).
2817 ********************************************************************/
2819 void spoolss_notify_printer_name(int snum,
2820 struct spoolss_Notify *data,
2821 print_queue_struct *queue,
2822 NT_PRINTER_INFO_LEVEL *printer,
2823 TALLOC_CTX *mem_ctx)
2825 /* the notify name should not contain the \\server\ part */
2826 char *p = strrchr(printer->info_2->printername, '\\');
2829 p = printer->info_2->printername;
2834 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2837 /*******************************************************************
2838 * fill a notify_info_data with the servicename
2839 ********************************************************************/
2841 void spoolss_notify_share_name(int snum,
2842 struct spoolss_Notify *data,
2843 print_queue_struct *queue,
2844 NT_PRINTER_INFO_LEVEL *printer,
2845 TALLOC_CTX *mem_ctx)
2847 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2850 /*******************************************************************
2851 * fill a notify_info_data with the port name
2852 ********************************************************************/
2854 void spoolss_notify_port_name(int snum,
2855 struct spoolss_Notify *data,
2856 print_queue_struct *queue,
2857 NT_PRINTER_INFO_LEVEL *printer,
2858 TALLOC_CTX *mem_ctx)
2860 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2863 /*******************************************************************
2864 * fill a notify_info_data with the printername
2865 * but it doesn't exist, have to see what to do
2866 ********************************************************************/
2868 void spoolss_notify_driver_name(int snum,
2869 struct spoolss_Notify *data,
2870 print_queue_struct *queue,
2871 NT_PRINTER_INFO_LEVEL *printer,
2872 TALLOC_CTX *mem_ctx)
2874 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2877 /*******************************************************************
2878 * fill a notify_info_data with the comment
2879 ********************************************************************/
2881 void spoolss_notify_comment(int snum,
2882 struct spoolss_Notify *data,
2883 print_queue_struct *queue,
2884 NT_PRINTER_INFO_LEVEL *printer,
2885 TALLOC_CTX *mem_ctx)
2889 if (*printer->info_2->comment == '\0') {
2890 p = lp_comment(snum);
2892 p = printer->info_2->comment;
2895 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2898 /*******************************************************************
2899 * fill a notify_info_data with the comment
2900 * location = "Room 1, floor 2, building 3"
2901 ********************************************************************/
2903 void spoolss_notify_location(int snum,
2904 struct spoolss_Notify *data,
2905 print_queue_struct *queue,
2906 NT_PRINTER_INFO_LEVEL *printer,
2907 TALLOC_CTX *mem_ctx)
2909 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2912 /*******************************************************************
2913 * fill a notify_info_data with the device mode
2914 * jfm:xxxx don't to it for know but that's a real problem !!!
2915 ********************************************************************/
2917 static void spoolss_notify_devmode(int snum,
2918 struct spoolss_Notify *data,
2919 print_queue_struct *queue,
2920 NT_PRINTER_INFO_LEVEL *printer,
2921 TALLOC_CTX *mem_ctx)
2923 /* for a dummy implementation we have to zero the fields */
2924 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2927 /*******************************************************************
2928 * fill a notify_info_data with the separator file name
2929 ********************************************************************/
2931 void spoolss_notify_sepfile(int snum,
2932 struct spoolss_Notify *data,
2933 print_queue_struct *queue,
2934 NT_PRINTER_INFO_LEVEL *printer,
2935 TALLOC_CTX *mem_ctx)
2937 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2940 /*******************************************************************
2941 * fill a notify_info_data with the print processor
2942 * jfm:xxxx return always winprint to indicate we don't do anything to it
2943 ********************************************************************/
2945 void spoolss_notify_print_processor(int snum,
2946 struct spoolss_Notify *data,
2947 print_queue_struct *queue,
2948 NT_PRINTER_INFO_LEVEL *printer,
2949 TALLOC_CTX *mem_ctx)
2951 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2954 /*******************************************************************
2955 * fill a notify_info_data with the print processor options
2956 * jfm:xxxx send an empty string
2957 ********************************************************************/
2959 void spoolss_notify_parameters(int snum,
2960 struct spoolss_Notify *data,
2961 print_queue_struct *queue,
2962 NT_PRINTER_INFO_LEVEL *printer,
2963 TALLOC_CTX *mem_ctx)
2965 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2968 /*******************************************************************
2969 * fill a notify_info_data with the data type
2970 * jfm:xxxx always send RAW as data type
2971 ********************************************************************/
2973 void spoolss_notify_datatype(int snum,
2974 struct spoolss_Notify *data,
2975 print_queue_struct *queue,
2976 NT_PRINTER_INFO_LEVEL *printer,
2977 TALLOC_CTX *mem_ctx)
2979 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
2982 /*******************************************************************
2983 * fill a notify_info_data with the security descriptor
2984 * jfm:xxxx send an null pointer to say no security desc
2985 * have to implement security before !
2986 ********************************************************************/
2988 static void spoolss_notify_security_desc(int snum,
2989 struct spoolss_Notify *data,
2990 print_queue_struct *queue,
2991 NT_PRINTER_INFO_LEVEL *printer,
2992 TALLOC_CTX *mem_ctx)
2994 SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
2995 printer->info_2->secdesc_buf->sd_size,
2996 printer->info_2->secdesc_buf->sd);
2999 /*******************************************************************
3000 * fill a notify_info_data with the attributes
3001 * jfm:xxxx a samba printer is always shared
3002 ********************************************************************/
3004 void spoolss_notify_attributes(int snum,
3005 struct spoolss_Notify *data,
3006 print_queue_struct *queue,
3007 NT_PRINTER_INFO_LEVEL *printer,
3008 TALLOC_CTX *mem_ctx)
3010 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
3013 /*******************************************************************
3014 * fill a notify_info_data with the priority
3015 ********************************************************************/
3017 static void spoolss_notify_priority(int snum,
3018 struct spoolss_Notify *data,
3019 print_queue_struct *queue,
3020 NT_PRINTER_INFO_LEVEL *printer,
3021 TALLOC_CTX *mem_ctx)
3023 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
3026 /*******************************************************************
3027 * fill a notify_info_data with the default priority
3028 ********************************************************************/
3030 static void spoolss_notify_default_priority(int snum,
3031 struct spoolss_Notify *data,
3032 print_queue_struct *queue,
3033 NT_PRINTER_INFO_LEVEL *printer,
3034 TALLOC_CTX *mem_ctx)
3036 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
3039 /*******************************************************************
3040 * fill a notify_info_data with the start time
3041 ********************************************************************/
3043 static void spoolss_notify_start_time(int snum,
3044 struct spoolss_Notify *data,
3045 print_queue_struct *queue,
3046 NT_PRINTER_INFO_LEVEL *printer,
3047 TALLOC_CTX *mem_ctx)
3049 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
3052 /*******************************************************************
3053 * fill a notify_info_data with the until time
3054 ********************************************************************/
3056 static void spoolss_notify_until_time(int snum,
3057 struct spoolss_Notify *data,
3058 print_queue_struct *queue,
3059 NT_PRINTER_INFO_LEVEL *printer,
3060 TALLOC_CTX *mem_ctx)
3062 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
3065 /*******************************************************************
3066 * fill a notify_info_data with the status
3067 ********************************************************************/
3069 static void spoolss_notify_status(int snum,
3070 struct spoolss_Notify *data,
3071 print_queue_struct *queue,
3072 NT_PRINTER_INFO_LEVEL *printer,
3073 TALLOC_CTX *mem_ctx)
3075 print_status_struct status;
3077 print_queue_length(snum, &status);
3078 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3081 /*******************************************************************
3082 * fill a notify_info_data with the number of jobs queued
3083 ********************************************************************/
3085 void spoolss_notify_cjobs(int snum,
3086 struct spoolss_Notify *data,
3087 print_queue_struct *queue,
3088 NT_PRINTER_INFO_LEVEL *printer,
3089 TALLOC_CTX *mem_ctx)
3091 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
3094 /*******************************************************************
3095 * fill a notify_info_data with the average ppm
3096 ********************************************************************/
3098 static void spoolss_notify_average_ppm(int snum,
3099 struct spoolss_Notify *data,
3100 print_queue_struct *queue,
3101 NT_PRINTER_INFO_LEVEL *printer,
3102 TALLOC_CTX *mem_ctx)
3104 /* always respond 8 pages per minutes */
3105 /* a little hard ! */
3106 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
3109 /*******************************************************************
3110 * fill a notify_info_data with username
3111 ********************************************************************/
3113 static void spoolss_notify_username(int snum,
3114 struct spoolss_Notify *data,
3115 print_queue_struct *queue,
3116 NT_PRINTER_INFO_LEVEL *printer,
3117 TALLOC_CTX *mem_ctx)
3119 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3122 /*******************************************************************
3123 * fill a notify_info_data with job status
3124 ********************************************************************/
3126 static void spoolss_notify_job_status(int snum,
3127 struct spoolss_Notify *data,
3128 print_queue_struct *queue,
3129 NT_PRINTER_INFO_LEVEL *printer,
3130 TALLOC_CTX *mem_ctx)
3132 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3135 /*******************************************************************
3136 * fill a notify_info_data with job name
3137 ********************************************************************/
3139 static void spoolss_notify_job_name(int snum,
3140 struct spoolss_Notify *data,
3141 print_queue_struct *queue,
3142 NT_PRINTER_INFO_LEVEL *printer,
3143 TALLOC_CTX *mem_ctx)
3145 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3148 /*******************************************************************
3149 * fill a notify_info_data with job status
3150 ********************************************************************/
3152 static void spoolss_notify_job_status_string(int snum,
3153 struct spoolss_Notify *data,
3154 print_queue_struct *queue,
3155 NT_PRINTER_INFO_LEVEL *printer,
3156 TALLOC_CTX *mem_ctx)
3159 * Now we're returning job status codes we just return a "" here. JRA.
3164 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3167 switch (queue->status) {
3172 p = ""; /* NT provides the paused string */
3181 #endif /* NO LONGER NEEDED. */
3183 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3186 /*******************************************************************
3187 * fill a notify_info_data with job time
3188 ********************************************************************/
3190 static void spoolss_notify_job_time(int snum,
3191 struct spoolss_Notify *data,
3192 print_queue_struct *queue,
3193 NT_PRINTER_INFO_LEVEL *printer,
3194 TALLOC_CTX *mem_ctx)
3196 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3199 /*******************************************************************
3200 * fill a notify_info_data with job size
3201 ********************************************************************/
3203 static void spoolss_notify_job_size(int snum,
3204 struct spoolss_Notify *data,
3205 print_queue_struct *queue,
3206 NT_PRINTER_INFO_LEVEL *printer,
3207 TALLOC_CTX *mem_ctx)
3209 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3212 /*******************************************************************
3213 * fill a notify_info_data with page info
3214 ********************************************************************/
3215 static void spoolss_notify_total_pages(int snum,
3216 struct spoolss_Notify *data,
3217 print_queue_struct *queue,
3218 NT_PRINTER_INFO_LEVEL *printer,
3219 TALLOC_CTX *mem_ctx)
3221 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3224 /*******************************************************************
3225 * fill a notify_info_data with pages printed info.
3226 ********************************************************************/
3227 static void spoolss_notify_pages_printed(int snum,
3228 struct spoolss_Notify *data,
3229 print_queue_struct *queue,
3230 NT_PRINTER_INFO_LEVEL *printer,
3231 TALLOC_CTX *mem_ctx)
3233 /* Add code when back-end tracks this */
3234 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3237 /*******************************************************************
3238 Fill a notify_info_data with job position.
3239 ********************************************************************/
3241 static void spoolss_notify_job_position(int snum,
3242 struct spoolss_Notify *data,
3243 print_queue_struct *queue,
3244 NT_PRINTER_INFO_LEVEL *printer,
3245 TALLOC_CTX *mem_ctx)
3247 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3250 /*******************************************************************
3251 Fill a notify_info_data with submitted time.
3252 ********************************************************************/
3254 static void spoolss_notify_submitted_time(int snum,
3255 struct spoolss_Notify *data,
3256 print_queue_struct *queue,
3257 NT_PRINTER_INFO_LEVEL *printer,
3258 TALLOC_CTX *mem_ctx)
3260 data->data.string.string = NULL;
3261 data->data.string.size = 0;
3263 init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3264 &data->data.string.string,
3265 &data->data.string.size);
3269 struct s_notify_info_data_table
3271 enum spoolss_NotifyType type;
3274 enum spoolss_NotifyTable variable_type;
3275 void (*fn) (int snum, struct spoolss_Notify *data,
3276 print_queue_struct *queue,
3277 NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3280 /* A table describing the various print notification constants and
3281 whether the notification data is a pointer to a variable sized
3282 buffer, a one value uint32_t or a two value uint32_t. */
3284 static const struct s_notify_info_data_table notify_info_data_table[] =
3286 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3287 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3288 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_share_name },
3289 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3290 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3291 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING, spoolss_notify_comment },
3292 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING, spoolss_notify_location },
3293 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3294 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING, spoolss_notify_sepfile },
3295 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3296 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3297 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3298 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, spoolss_notify_security_desc },
3299 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD, spoolss_notify_attributes },
3300 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3301 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_default_priority },
3302 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3303 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3304 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_status },
3305 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, NULL },
3306 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD, spoolss_notify_cjobs },
3307 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD, spoolss_notify_average_ppm },
3308 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, NULL },
3309 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3310 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, NULL },
3311 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3312 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINTER_NAME, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3313 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_MACHINE_NAME, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3314 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PORT_NAME, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3315 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3316 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_NOTIFY_NAME, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3317 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DATATYPE, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3318 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINT_PROCESSOR, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3319 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PARAMETERS, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3320 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DRIVER_NAME, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3321 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DEVMODE, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3322 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_job_status },
3323 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS_STRING, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, spoolss_notify_job_status_string },
3324 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, NULL },
3325 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING, spoolss_notify_job_name },
3326 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRIORITY, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3327 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_POSITION, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD, spoolss_notify_job_position },
3328 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME, spoolss_notify_submitted_time },
3329 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_START_TIME, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3330 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_UNTIL_TIME, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3331 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TIME, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_job_time },
3332 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_PAGES, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, spoolss_notify_total_pages },
3333 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PAGES_PRINTED, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, spoolss_notify_pages_printed },
3334 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_BYTES, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, spoolss_notify_job_size },
3337 /*******************************************************************
3338 Return the variable_type of info_data structure.
3339 ********************************************************************/
3341 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3346 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3347 if ( (notify_info_data_table[i].type == type) &&
3348 (notify_info_data_table[i].field == field) ) {
3349 return notify_info_data_table[i].variable_type;
3353 DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3358 /****************************************************************************
3359 ****************************************************************************/
3361 static bool search_notify(enum spoolss_NotifyType type,
3367 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3368 if (notify_info_data_table[i].type == type &&
3369 notify_info_data_table[i].field == field &&
3370 notify_info_data_table[i].fn != NULL) {
3379 /****************************************************************************
3380 ****************************************************************************/
3382 void construct_info_data(struct spoolss_Notify *info_data,
3383 enum spoolss_NotifyType type,
3387 info_data->type = type;
3388 info_data->field.field = field;
3389 info_data->variable_type = variable_type_of_notify_info_data(type, field);
3390 info_data->job_id = id;
3393 /*******************************************************************
3395 * fill a notify_info struct with info asked
3397 ********************************************************************/
3399 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3400 struct spoolss_NotifyInfo *info,
3402 const struct spoolss_NotifyOptionType *option_type,
3404 TALLOC_CTX *mem_ctx)
3407 enum spoolss_NotifyType type;
3410 struct spoolss_Notify *current_data;
3411 NT_PRINTER_INFO_LEVEL *printer = NULL;
3412 print_queue_struct *queue=NULL;
3414 type = option_type->type;
3416 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3417 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3418 option_type->count, lp_servicename(snum)));
3420 if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3423 for(field_num=0; field_num < option_type->count; field_num++) {
3424 field = option_type->fields[field_num].field;
3426 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3428 if (!search_notify(type, field, &j) )
3431 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3432 struct spoolss_Notify,
3434 if (info->notifies == NULL) {
3435 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3436 free_a_printer(&printer, 2);
3440 current_data = &info->notifies[info->count];
3442 construct_info_data(current_data, type, field, id);
3444 DEBUG(10,("construct_notify_printer_info: calling [%s] snum=%d printername=[%s])\n",
3445 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3447 notify_info_data_table[j].fn(snum, current_data, queue,
3453 free_a_printer(&printer, 2);
3457 /*******************************************************************
3459 * fill a notify_info struct with info asked
3461 ********************************************************************/
3463 static bool construct_notify_jobs_info(print_queue_struct *queue,
3464 struct spoolss_NotifyInfo *info,
3465 NT_PRINTER_INFO_LEVEL *printer,
3467 const struct spoolss_NotifyOptionType *option_type,
3469 TALLOC_CTX *mem_ctx)
3472 enum spoolss_NotifyType type;
3474 struct spoolss_Notify *current_data;
3476 DEBUG(4,("construct_notify_jobs_info\n"));
3478 type = option_type->type;
3480 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3481 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3482 option_type->count));
3484 for(field_num=0; field_num<option_type->count; field_num++) {
3485 field = option_type->fields[field_num].field;
3487 if (!search_notify(type, field, &j) )
3490 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3491 struct spoolss_Notify,
3493 if (info->notifies == NULL) {
3494 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3498 current_data=&(info->notifies[info->count]);
3500 construct_info_data(current_data, type, field, id);
3501 notify_info_data_table[j].fn(snum, current_data, queue,
3510 * JFM: The enumeration is not that simple, it's even non obvious.
3512 * let's take an example: I want to monitor the PRINTER SERVER for
3513 * the printer's name and the number of jobs currently queued.
3514 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3515 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3517 * I have 3 printers on the back of my server.
3519 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3522 * 1 printer 1 name 1
3523 * 2 printer 1 cjob 1
3524 * 3 printer 2 name 2
3525 * 4 printer 2 cjob 2
3526 * 5 printer 3 name 3
3527 * 6 printer 3 name 3
3529 * that's the print server case, the printer case is even worse.
3532 /*******************************************************************
3534 * enumerate all printers on the printserver
3535 * fill a notify_info struct with info asked
3537 ********************************************************************/
3539 static WERROR printserver_notify_info(pipes_struct *p,
3540 struct policy_handle *hnd,
3541 struct spoolss_NotifyInfo *info,
3542 TALLOC_CTX *mem_ctx)
3545 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3546 int n_services=lp_numservices();
3548 struct spoolss_NotifyOption *option;
3549 struct spoolss_NotifyOptionType option_type;
3551 DEBUG(4,("printserver_notify_info\n"));
3556 option = Printer->notify.option;
3559 info->notifies = NULL;
3562 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3563 sending a ffpcn() request first */
3568 for (i=0; i<option->count; i++) {
3569 option_type = option->types[i];
3571 if (option_type.type != PRINTER_NOTIFY_TYPE)
3574 for (snum=0; snum<n_services; snum++)
3576 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3577 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3583 * Debugging information, don't delete.
3586 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3587 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3588 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3590 for (i=0; i<info->count; i++) {
3591 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3592 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3593 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3600 /*******************************************************************
3602 * fill a notify_info struct with info asked
3604 ********************************************************************/
3606 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3607 struct spoolss_NotifyInfo *info,
3608 TALLOC_CTX *mem_ctx)
3611 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3614 struct spoolss_NotifyOption *option;
3615 struct spoolss_NotifyOptionType option_type;
3617 print_queue_struct *queue=NULL;
3618 print_status_struct status;
3620 DEBUG(4,("printer_notify_info\n"));
3625 option = Printer->notify.option;
3629 info->notifies = NULL;
3632 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3633 sending a ffpcn() request first */
3638 get_printer_snum(p, hnd, &snum, NULL);
3640 for (i=0; i<option->count; i++) {
3641 option_type = option->types[i];
3643 switch (option_type.type) {
3644 case PRINTER_NOTIFY_TYPE:
3645 if(construct_notify_printer_info(Printer, info, snum,
3651 case JOB_NOTIFY_TYPE: {
3652 NT_PRINTER_INFO_LEVEL *printer = NULL;
3654 count = print_queue_status(snum, &queue, &status);
3656 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3659 for (j=0; j<count; j++) {
3660 construct_notify_jobs_info(&queue[j], info,
3667 free_a_printer(&printer, 2);
3677 * Debugging information, don't delete.
3680 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3681 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3682 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3684 for (i=0; i<info->count; i++) {
3685 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3686 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3687 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3693 /****************************************************************
3694 _spoolss_RouterRefreshPrinterChangeNotify
3695 ****************************************************************/
3697 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3698 struct spoolss_RouterRefreshPrinterChangeNotify *r)
3700 struct spoolss_NotifyInfo *info;
3702 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3703 WERROR result = WERR_BADFID;
3705 /* we always have a spoolss_NotifyInfo struct */
3706 info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3708 result = WERR_NOMEM;
3712 *r->out.info = info;
3715 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3716 "Invalid handle (%s:%u:%u).\n",
3717 OUR_HANDLE(r->in.handle)));
3721 DEBUG(4,("Printer type %x\n",Printer->printer_type));
3724 * We are now using the change value, and
3725 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3726 * I don't have a global notification system, I'm sending back all the
3727 * informations even when _NOTHING_ has changed.
3730 /* We need to keep track of the change value to send back in
3731 RRPCN replies otherwise our updates are ignored. */
3733 Printer->notify.fnpcn = true;
3735 if (Printer->notify.client_connected) {
3736 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3737 "Saving change value in request [%x]\n",
3739 Printer->notify.change = r->in.change_low;
3742 /* just ignore the spoolss_NotifyOption */
3744 switch (Printer->printer_type) {
3746 result = printserver_notify_info(p, r->in.handle,
3750 case SPLHND_PRINTER:
3751 result = printer_notify_info(p, r->in.handle,
3756 Printer->notify.fnpcn = false;
3762 /********************************************************************
3763 * construct_printer_info_0
3764 * fill a printer_info_0 struct
3765 ********************************************************************/
3767 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3768 const NT_PRINTER_INFO_LEVEL *ntprinter,
3769 struct spoolss_PrinterInfo0 *r,
3773 counter_printer_0 *session_counter;
3775 print_status_struct status;
3777 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3778 W_ERROR_HAVE_NO_MEMORY(r->printername);
3780 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3781 W_ERROR_HAVE_NO_MEMORY(r->servername);
3783 count = print_queue_length(snum, &status);
3785 /* check if we already have a counter for this printer */
3786 for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3787 if (session_counter->snum == snum)
3791 /* it's the first time, add it to the list */
3792 if (session_counter == NULL) {
3793 session_counter = SMB_MALLOC_P(counter_printer_0);
3794 W_ERROR_HAVE_NO_MEMORY(session_counter);
3795 ZERO_STRUCTP(session_counter);
3796 session_counter->snum = snum;
3797 session_counter->counter = 0;
3798 DLIST_ADD(counter_list, session_counter);
3802 session_counter->counter++;
3808 setuptime = (time_t)ntprinter->info_2->setuptime;
3810 init_systemtime(&r->time, gmtime(&setuptime));
3813 * the global_counter should be stored in a TDB as it's common to all the clients
3814 * and should be zeroed on samba startup
3816 r->global_counter = session_counter->counter;
3818 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3819 r->version = 0x0005; /* NT 5 */
3820 r->free_build = 0x0893; /* build 2195 */
3822 r->max_spooling = 0;
3823 r->session_counter = session_counter->counter;
3824 r->num_error_out_of_paper = 0x0;
3825 r->num_error_not_ready = 0x0; /* number of print failure */
3827 r->number_of_processors = 0x1;
3828 r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3829 r->high_part_total_bytes = 0x0;
3830 r->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3831 r->last_error = WERR_OK;
3832 r->status = nt_printq_status(status.status);
3833 r->enumerate_network_printers = 0x0;
3834 r->c_setprinter = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3835 r->processor_architecture = 0x0;
3836 r->processor_level = 0x6; /* 6 ???*/
3844 /****************************************************************************
3845 Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure. Both pointers
3846 should be valid upon entry
3847 ****************************************************************************/
3849 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3850 struct spoolss_DeviceMode *r,
3851 const NT_DEVICEMODE *ntdevmode)
3853 if (!r || !ntdevmode) {
3854 return WERR_INVALID_PARAM;
3857 r->devicename = talloc_strdup(mem_ctx, ntdevmode->devicename);
3858 W_ERROR_HAVE_NO_MEMORY(r->devicename);
3860 r->specversion = ntdevmode->specversion;
3861 r->driverversion = ntdevmode->driverversion;
3862 r->size = ntdevmode->size;
3863 r->__driverextra_length = ntdevmode->driverextra;
3864 r->fields = ntdevmode->fields;
3866 r->orientation = ntdevmode->orientation;
3867 r->papersize = ntdevmode->papersize;
3868 r->paperlength = ntdevmode->paperlength;
3869 r->paperwidth = ntdevmode->paperwidth;
3870 r->scale = ntdevmode->scale;
3871 r->copies = ntdevmode->copies;
3872 r->defaultsource = ntdevmode->defaultsource;
3873 r->printquality = ntdevmode->printquality;
3874 r->color = ntdevmode->color;
3875 r->duplex = ntdevmode->duplex;
3876 r->yresolution = ntdevmode->yresolution;
3877 r->ttoption = ntdevmode->ttoption;
3878 r->collate = ntdevmode->collate;
3880 r->formname = talloc_strdup(mem_ctx, ntdevmode->formname);
3881 W_ERROR_HAVE_NO_MEMORY(r->formname);
3883 /* all 0 below are values that have not been set in the old parsing/copy
3884 * function, maybe they should... - gd */
3890 r->displayflags = 0;
3891 r->displayfrequency = 0;
3892 r->icmmethod = ntdevmode->icmmethod;
3893 r->icmintent = ntdevmode->icmintent;
3894 r->mediatype = ntdevmode->mediatype;
3895 r->dithertype = ntdevmode->dithertype;
3898 r->panningwidth = 0;
3899 r->panningheight = 0;
3901 if (ntdevmode->nt_dev_private != NULL) {
3902 r->driverextra_data = data_blob_talloc(mem_ctx,
3903 ntdevmode->nt_dev_private,
3904 ntdevmode->driverextra);
3905 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3912 /****************************************************************************
3913 Create a spoolss_DeviceMode struct. Returns talloced memory.
3914 ****************************************************************************/
3916 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3917 const char *servicename)
3920 NT_PRINTER_INFO_LEVEL *printer = NULL;
3921 struct spoolss_DeviceMode *devmode = NULL;
3923 DEBUG(7,("construct_dev_mode\n"));
3925 DEBUGADD(8,("getting printer characteristics\n"));
3927 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3930 if (!printer->info_2->devmode) {
3931 DEBUG(5, ("BONG! There was no device mode!\n"));
3935 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3937 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3941 DEBUGADD(8,("loading DEVICEMODE\n"));
3943 result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3944 if (!W_ERROR_IS_OK(result)) {
3945 TALLOC_FREE(devmode);
3949 free_a_printer(&printer,2);
3954 /********************************************************************
3955 * construct_printer_info3
3956 * fill a spoolss_PrinterInfo3 struct
3957 ********************************************************************/
3959 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3960 const NT_PRINTER_INFO_LEVEL *ntprinter,
3961 struct spoolss_PrinterInfo3 *r,
3964 /* These are the components of the SD we are returning. */
3966 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3967 /* don't use talloc_steal() here unless you do a deep steal of all
3968 the SEC_DESC members */
3970 r->secdesc = dup_sec_desc(mem_ctx,
3971 ntprinter->info_2->secdesc_buf->sd);
3972 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3978 /********************************************************************
3979 * construct_printer_info4
3980 * fill a spoolss_PrinterInfo4 struct
3981 ********************************************************************/
3983 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
3984 const NT_PRINTER_INFO_LEVEL *ntprinter,
3985 struct spoolss_PrinterInfo4 *r,
3988 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3989 W_ERROR_HAVE_NO_MEMORY(r->printername);
3990 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3991 W_ERROR_HAVE_NO_MEMORY(r->servername);
3993 r->attributes = ntprinter->info_2->attributes;
3998 /********************************************************************
3999 * construct_printer_info5
4000 * fill a spoolss_PrinterInfo5 struct
4001 ********************************************************************/
4003 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
4004 const NT_PRINTER_INFO_LEVEL *ntprinter,
4005 struct spoolss_PrinterInfo5 *r,
4008 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4009 W_ERROR_HAVE_NO_MEMORY(r->printername);
4010 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4011 W_ERROR_HAVE_NO_MEMORY(r->portname);
4013 r->attributes = ntprinter->info_2->attributes;
4015 /* these two are not used by NT+ according to MSDN */
4017 r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
4018 r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
4023 /********************************************************************
4024 * construct_printer_info_6
4025 * fill a spoolss_PrinterInfo6 struct
4026 ********************************************************************/
4028 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
4029 const NT_PRINTER_INFO_LEVEL *ntprinter,
4030 struct spoolss_PrinterInfo6 *r,
4034 print_status_struct status;
4036 count = print_queue_length(snum, &status);
4038 r->status = nt_printq_status(status.status);
4043 /********************************************************************
4044 * construct_printer_info7
4045 * fill a spoolss_PrinterInfo7 struct
4046 ********************************************************************/
4048 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4049 Printer_entry *print_hnd,
4050 struct spoolss_PrinterInfo7 *r,
4055 if (is_printer_published(print_hnd, snum, &guid)) {
4056 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
4057 r->action = DSPRINT_PUBLISH;
4059 r->guid = talloc_strdup(mem_ctx, "");
4060 r->action = DSPRINT_UNPUBLISH;
4062 W_ERROR_HAVE_NO_MEMORY(r->guid);
4067 /********************************************************************
4068 * construct_printer_info8
4069 * fill a spoolss_PrinterInfo8 struct
4070 ********************************************************************/
4072 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4073 const NT_PRINTER_INFO_LEVEL *ntprinter,
4074 struct spoolss_DeviceModeInfo *r,
4077 struct spoolss_DeviceMode *devmode;
4080 if (!ntprinter->info_2->devmode) {
4085 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
4086 W_ERROR_HAVE_NO_MEMORY(devmode);
4088 result = convert_nt_devicemode(mem_ctx, devmode, ntprinter->info_2->devmode);
4089 if (!W_ERROR_IS_OK(result)) {
4090 TALLOC_FREE(devmode);
4094 r->devmode = devmode;
4100 /********************************************************************
4101 * construct_printer_info1
4102 * fill a spoolss_PrinterInfo1 struct
4103 ********************************************************************/
4105 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
4106 const NT_PRINTER_INFO_LEVEL *ntprinter,
4108 struct spoolss_PrinterInfo1 *r,
4113 r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
4114 ntprinter->info_2->printername,
4115 ntprinter->info_2->drivername,
4116 ntprinter->info_2->location);
4117 W_ERROR_HAVE_NO_MEMORY(r->description);
4119 if (*ntprinter->info_2->comment == '\0') {
4120 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
4122 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
4124 W_ERROR_HAVE_NO_MEMORY(r->comment);
4126 r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4127 W_ERROR_HAVE_NO_MEMORY(r->name);
4132 /********************************************************************
4133 * construct_printer_info2
4134 * fill a spoolss_PrinterInfo2 struct
4135 ********************************************************************/
4137 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
4138 const NT_PRINTER_INFO_LEVEL *ntprinter,
4139 struct spoolss_PrinterInfo2 *r,
4144 print_status_struct status;
4146 count = print_queue_length(snum, &status);
4148 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
4149 W_ERROR_HAVE_NO_MEMORY(r->servername);
4150 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4151 W_ERROR_HAVE_NO_MEMORY(r->printername);
4152 r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
4153 W_ERROR_HAVE_NO_MEMORY(r->sharename);
4154 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4155 W_ERROR_HAVE_NO_MEMORY(r->portname);
4156 r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
4157 W_ERROR_HAVE_NO_MEMORY(r->drivername);
4159 if (*ntprinter->info_2->comment == '\0') {
4160 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
4162 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
4164 W_ERROR_HAVE_NO_MEMORY(r->comment);
4166 r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
4167 W_ERROR_HAVE_NO_MEMORY(r->location);
4168 r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
4169 W_ERROR_HAVE_NO_MEMORY(r->sepfile);
4170 r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
4171 W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
4172 r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
4173 W_ERROR_HAVE_NO_MEMORY(r->datatype);
4174 r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
4175 W_ERROR_HAVE_NO_MEMORY(r->parameters);
4177 r->attributes = ntprinter->info_2->attributes;
4179 r->priority = ntprinter->info_2->priority;
4180 r->defaultpriority = ntprinter->info_2->default_priority;
4181 r->starttime = ntprinter->info_2->starttime;
4182 r->untiltime = ntprinter->info_2->untiltime;
4183 r->status = nt_printq_status(status.status);
4185 r->averageppm = ntprinter->info_2->averageppm;
4187 r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
4189 DEBUG(8,("Returning NULL Devicemode!\n"));
4194 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
4195 /* don't use talloc_steal() here unless you do a deep steal of all
4196 the SEC_DESC members */
4198 r->secdesc = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
4204 /********************************************************************
4205 ********************************************************************/
4207 static bool snum_is_shared_printer(int snum)
4209 return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
4212 /********************************************************************
4213 Spoolss_enumprinters.
4214 ********************************************************************/
4216 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4219 union spoolss_PrinterInfo **info_p,
4223 int n_services = lp_numservices();
4224 union spoolss_PrinterInfo *info = NULL;
4226 WERROR result = WERR_OK;
4231 for (snum = 0; snum < n_services; snum++) {
4233 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4235 if (!snum_is_shared_printer(snum)) {
4239 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4240 lp_servicename(snum), snum));
4242 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4243 union spoolss_PrinterInfo,
4246 result = WERR_NOMEM;
4250 result = get_a_printer(NULL, &ntprinter, 2,
4251 lp_const_servicename(snum));
4252 if (!W_ERROR_IS_OK(result)) {
4258 result = construct_printer_info0(info, ntprinter,
4259 &info[count].info0, snum);
4262 result = construct_printer_info1(info, ntprinter, flags,
4263 &info[count].info1, snum);
4266 result = construct_printer_info2(info, ntprinter,
4267 &info[count].info2, snum);
4270 result = construct_printer_info4(info, ntprinter,
4271 &info[count].info4, snum);
4274 result = construct_printer_info5(info, ntprinter,
4275 &info[count].info5, snum);
4279 result = WERR_UNKNOWN_LEVEL;
4280 free_a_printer(&ntprinter, 2);
4284 free_a_printer(&ntprinter, 2);
4285 if (!W_ERROR_IS_OK(result)) {
4296 if (!W_ERROR_IS_OK(result)) {
4306 /********************************************************************
4307 * handle enumeration of printers at level 0
4308 ********************************************************************/
4310 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4312 const char *servername,
4313 union spoolss_PrinterInfo **info,
4316 DEBUG(4,("enum_all_printers_info_0\n"));
4318 return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4322 /********************************************************************
4323 ********************************************************************/
4325 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4327 union spoolss_PrinterInfo **info,
4330 DEBUG(4,("enum_all_printers_info_1\n"));
4332 return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4335 /********************************************************************
4336 enum_all_printers_info_1_local.
4337 *********************************************************************/
4339 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4340 union spoolss_PrinterInfo **info,
4343 DEBUG(4,("enum_all_printers_info_1_local\n"));
4345 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4348 /********************************************************************
4349 enum_all_printers_info_1_name.
4350 *********************************************************************/
4352 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4354 union spoolss_PrinterInfo **info,
4357 const char *s = name;
4359 DEBUG(4,("enum_all_printers_info_1_name\n"));
4361 if ((name[0] == '\\') && (name[1] == '\\')) {
4365 if (!is_myname_or_ipaddr(s)) {
4366 return WERR_INVALID_NAME;
4369 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4372 /********************************************************************
4373 enum_all_printers_info_1_network.
4374 *********************************************************************/
4376 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4378 union spoolss_PrinterInfo **info,
4381 const char *s = name;
4383 DEBUG(4,("enum_all_printers_info_1_network\n"));
4385 /* If we respond to a enum_printers level 1 on our name with flags
4386 set to PRINTER_ENUM_REMOTE with a list of printers then these
4387 printers incorrectly appear in the APW browse list.
4388 Specifically the printers for the server appear at the workgroup
4389 level where all the other servers in the domain are
4390 listed. Windows responds to this call with a
4391 WERR_CAN_NOT_COMPLETE so we should do the same. */
4393 if (name[0] == '\\' && name[1] == '\\') {
4397 if (is_myname_or_ipaddr(s)) {
4398 return WERR_CAN_NOT_COMPLETE;
4401 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4404 /********************************************************************
4405 * api_spoolss_enumprinters
4407 * called from api_spoolss_enumprinters (see this to understand)
4408 ********************************************************************/
4410 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4411 union spoolss_PrinterInfo **info,
4414 DEBUG(4,("enum_all_printers_info_2\n"));
4416 return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4419 /********************************************************************
4420 * handle enumeration of printers at level 1
4421 ********************************************************************/
4423 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4426 union spoolss_PrinterInfo **info,
4429 /* Not all the flags are equals */
4431 if (flags & PRINTER_ENUM_LOCAL) {
4432 return enum_all_printers_info_1_local(mem_ctx, info, count);
4435 if (flags & PRINTER_ENUM_NAME) {
4436 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4439 if (flags & PRINTER_ENUM_NETWORK) {
4440 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4443 return WERR_OK; /* NT4sp5 does that */
4446 /********************************************************************
4447 * handle enumeration of printers at level 2
4448 ********************************************************************/
4450 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4452 const char *servername,
4453 union spoolss_PrinterInfo **info,
4456 if (flags & PRINTER_ENUM_LOCAL) {
4457 return enum_all_printers_info_2(mem_ctx, info, count);
4460 if (flags & PRINTER_ENUM_NAME) {
4461 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4462 return WERR_INVALID_NAME;
4465 return enum_all_printers_info_2(mem_ctx, info, count);
4468 if (flags & PRINTER_ENUM_REMOTE) {
4469 return WERR_UNKNOWN_LEVEL;
4475 /********************************************************************
4476 * handle enumeration of printers at level 4
4477 ********************************************************************/
4479 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4481 const char *servername,
4482 union spoolss_PrinterInfo **info,
4485 DEBUG(4,("enum_all_printers_info_4\n"));
4487 return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4491 /********************************************************************
4492 * handle enumeration of printers at level 5
4493 ********************************************************************/
4495 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4497 const char *servername,
4498 union spoolss_PrinterInfo **info,
4501 DEBUG(4,("enum_all_printers_info_5\n"));
4503 return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4506 /****************************************************************
4507 _spoolss_EnumPrinters
4508 ****************************************************************/
4510 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4511 struct spoolss_EnumPrinters *r)
4516 /* that's an [in out] buffer */
4518 if (!r->in.buffer && (r->in.offered != 0)) {
4519 return WERR_INVALID_PARAM;
4522 DEBUG(4,("_spoolss_EnumPrinters\n"));
4526 *r->out.info = NULL;
4530 * flags==PRINTER_ENUM_NAME
4531 * if name=="" then enumerates all printers
4532 * if name!="" then enumerate the printer
4533 * flags==PRINTER_ENUM_REMOTE
4534 * name is NULL, enumerate printers
4535 * Level 2: name!="" enumerates printers, name can't be NULL
4536 * Level 3: doesn't exist
4537 * Level 4: does a local registry lookup
4538 * Level 5: same as Level 2
4541 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4542 W_ERROR_HAVE_NO_MEMORY(name);
4544 switch (r->in.level) {
4546 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4547 r->out.info, r->out.count);
4550 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4551 r->out.info, r->out.count);
4554 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4555 r->out.info, r->out.count);
4558 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4559 r->out.info, r->out.count);
4562 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4563 r->out.info, r->out.count);
4566 return WERR_UNKNOWN_LEVEL;
4569 if (!W_ERROR_IS_OK(result)) {
4573 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4574 spoolss_EnumPrinters, NULL,
4575 *r->out.info, r->in.level,
4577 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4578 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4580 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4583 /****************************************************************
4585 ****************************************************************/
4587 WERROR _spoolss_GetPrinter(pipes_struct *p,
4588 struct spoolss_GetPrinter *r)
4590 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4591 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4592 WERROR result = WERR_OK;
4596 /* that's an [in out] buffer */
4598 if (!r->in.buffer && (r->in.offered != 0)) {
4599 return WERR_INVALID_PARAM;
4604 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4608 result = get_a_printer(Printer, &ntprinter, 2,
4609 lp_const_servicename(snum));
4610 if (!W_ERROR_IS_OK(result)) {
4614 switch (r->in.level) {
4616 result = construct_printer_info0(p->mem_ctx, ntprinter,
4617 &r->out.info->info0, snum);
4620 result = construct_printer_info1(p->mem_ctx, ntprinter,
4622 &r->out.info->info1, snum);
4625 result = construct_printer_info2(p->mem_ctx, ntprinter,
4626 &r->out.info->info2, snum);
4629 result = construct_printer_info3(p->mem_ctx, ntprinter,
4630 &r->out.info->info3, snum);
4633 result = construct_printer_info4(p->mem_ctx, ntprinter,
4634 &r->out.info->info4, snum);
4637 result = construct_printer_info5(p->mem_ctx, ntprinter,
4638 &r->out.info->info5, snum);
4641 result = construct_printer_info6(p->mem_ctx, ntprinter,
4642 &r->out.info->info6, snum);
4645 result = construct_printer_info7(p->mem_ctx, Printer,
4646 &r->out.info->info7, snum);
4649 result = construct_printer_info8(p->mem_ctx, ntprinter,
4650 &r->out.info->info8, snum);
4653 result = WERR_UNKNOWN_LEVEL;
4657 free_a_printer(&ntprinter, 2);
4659 if (!W_ERROR_IS_OK(result)) {
4660 TALLOC_FREE(r->out.info);
4664 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4665 r->out.info, r->in.level);
4666 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4668 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4671 /********************************************************************
4672 ********************************************************************/
4674 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4675 fstring *fstring_array,
4676 const char *cservername)
4678 int i, num_strings = 0;
4679 const char **array = NULL;
4681 for (i=0; fstring_array && fstring_array[i][0] != '\0'; i++) {
4683 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4684 cservername, fstring_array[i]);
4691 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4698 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4699 &array, &num_strings);
4705 /********************************************************************
4706 * fill a spoolss_DriverInfo1 struct
4707 ********************************************************************/
4709 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4710 struct spoolss_DriverInfo1 *r,
4711 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4712 const char *servername,
4713 const char *architecture)
4715 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4716 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4721 /********************************************************************
4722 * fill a spoolss_DriverInfo2 struct
4723 ********************************************************************/
4725 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4726 struct spoolss_DriverInfo2 *r,
4727 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4728 const char *servername)
4731 const char *cservername = canon_servername(servername);
4733 r->version = driver->info_3->cversion;
4735 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4736 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4737 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4738 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4740 if (strlen(driver->info_3->driverpath)) {
4741 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4742 cservername, driver->info_3->driverpath);
4744 r->driver_path = talloc_strdup(mem_ctx, "");
4746 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4748 if (strlen(driver->info_3->datafile)) {
4749 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4750 cservername, driver->info_3->datafile);
4752 r->data_file = talloc_strdup(mem_ctx, "");
4754 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4756 if (strlen(driver->info_3->configfile)) {
4757 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4758 cservername, driver->info_3->configfile);
4760 r->config_file = talloc_strdup(mem_ctx, "");
4762 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4767 /********************************************************************
4768 * fill a spoolss_DriverInfo3 struct
4769 ********************************************************************/
4771 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4772 struct spoolss_DriverInfo3 *r,
4773 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4774 const char *servername)
4776 const char *cservername = canon_servername(servername);
4778 r->version = driver->info_3->cversion;
4780 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4781 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4782 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4783 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4785 if (strlen(driver->info_3->driverpath)) {
4786 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4787 cservername, driver->info_3->driverpath);
4789 r->driver_path = talloc_strdup(mem_ctx, "");
4791 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4793 if (strlen(driver->info_3->datafile)) {
4794 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4795 cservername, driver->info_3->datafile);
4797 r->data_file = talloc_strdup(mem_ctx, "");
4799 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4801 if (strlen(driver->info_3->configfile)) {
4802 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4803 cservername, driver->info_3->configfile);
4805 r->config_file = talloc_strdup(mem_ctx, "");
4807 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4809 if (strlen(driver->info_3->helpfile)) {
4810 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4811 cservername, driver->info_3->helpfile);
4813 r->help_file = talloc_strdup(mem_ctx, "");
4815 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4817 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4818 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4819 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4820 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4822 r->dependent_files = string_array_from_driver_info(mem_ctx,
4823 driver->info_3->dependentfiles,
4828 /********************************************************************
4829 * fill a spoolss_DriverInfo4 struct
4830 ********************************************************************/
4832 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4833 struct spoolss_DriverInfo4 *r,
4834 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4835 const char *servername)
4837 const char *cservername = canon_servername(servername);
4839 r->version = driver->info_3->cversion;
4841 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4842 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4843 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4844 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4846 if (strlen(driver->info_3->driverpath)) {
4847 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4848 cservername, driver->info_3->driverpath);
4850 r->driver_path = talloc_strdup(mem_ctx, "");
4852 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4854 if (strlen(driver->info_3->datafile)) {
4855 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4856 cservername, driver->info_3->datafile);
4858 r->data_file = talloc_strdup(mem_ctx, "");
4860 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4862 if (strlen(driver->info_3->configfile)) {
4863 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4864 cservername, driver->info_3->configfile);
4866 r->config_file = talloc_strdup(mem_ctx, "");
4868 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4870 if (strlen(driver->info_3->helpfile)) {
4871 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4872 cservername, driver->info_3->helpfile);
4874 r->help_file = talloc_strdup(mem_ctx, "");
4876 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4878 r->dependent_files = string_array_from_driver_info(mem_ctx,
4879 driver->info_3->dependentfiles,
4883 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4884 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4885 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4886 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4888 r->previous_names = string_array_from_driver_info(mem_ctx,
4895 /********************************************************************
4896 * fill a spoolss_DriverInfo5 struct
4897 ********************************************************************/
4899 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4900 struct spoolss_DriverInfo5 *r,
4901 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4902 const char *servername)
4904 const char *cservername = canon_servername(servername);
4906 r->version = driver->info_3->cversion;
4908 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4909 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4910 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4911 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4913 if (strlen(driver->info_3->driverpath)) {
4914 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4915 cservername, driver->info_3->driverpath);
4917 r->driver_path = talloc_strdup(mem_ctx, "");
4919 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4921 if (strlen(driver->info_3->datafile)) {
4922 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4923 cservername, driver->info_3->datafile);
4925 r->data_file = talloc_strdup(mem_ctx, "");
4927 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4929 if (strlen(driver->info_3->configfile)) {
4930 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4931 cservername, driver->info_3->configfile);
4933 r->config_file = talloc_strdup(mem_ctx, "");
4935 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4937 r->driver_attributes = 0;
4938 r->config_version = 0;
4939 r->driver_version = 0;
4943 /********************************************************************
4944 * fill a spoolss_DriverInfo6 struct
4945 ********************************************************************/
4947 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4948 struct spoolss_DriverInfo6 *r,
4949 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4950 const char *servername)
4952 const char *cservername = canon_servername(servername);
4954 r->version = driver->info_3->cversion;
4956 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4957 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4958 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4959 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4961 if (strlen(driver->info_3->driverpath)) {
4962 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4963 cservername, driver->info_3->driverpath);
4965 r->driver_path = talloc_strdup(mem_ctx, "");
4967 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4969 if (strlen(driver->info_3->datafile)) {
4970 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4971 cservername, driver->info_3->datafile);
4973 r->data_file = talloc_strdup(mem_ctx, "");
4975 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4977 if (strlen(driver->info_3->configfile)) {
4978 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4979 cservername, driver->info_3->configfile);
4981 r->config_file = talloc_strdup(mem_ctx, "");
4983 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4985 if (strlen(driver->info_3->helpfile)) {
4986 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4987 cservername, driver->info_3->helpfile);
4989 r->help_file = talloc_strdup(mem_ctx, "");
4991 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4993 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4994 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4995 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4996 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4998 r->dependent_files = string_array_from_driver_info(mem_ctx,
4999 driver->info_3->dependentfiles,
5001 r->previous_names = string_array_from_driver_info(mem_ctx,
5006 r->driver_version = 0;
5008 r->manufacturer_name = talloc_strdup(mem_ctx, "");
5009 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5010 r->manufacturer_url = talloc_strdup(mem_ctx, "");
5011 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5012 r->hardware_id = talloc_strdup(mem_ctx, "");
5013 W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5014 r->provider = talloc_strdup(mem_ctx, "");
5015 W_ERROR_HAVE_NO_MEMORY(r->provider);
5020 /********************************************************************
5021 ********************************************************************/
5023 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5024 struct spoolss_DriverFileInfo *r,
5025 const char *cservername,
5026 const char *file_name,
5027 enum spoolss_DriverFileType file_type,
5028 uint32_t file_version)
5030 r->file_name = talloc_asprintf(mem_ctx, "\\\\%s%s",
5031 cservername, file_name);
5032 W_ERROR_HAVE_NO_MEMORY(r->file_name);
5033 r->file_type = file_type;
5034 r->file_version = file_version;
5039 /********************************************************************
5040 ********************************************************************/
5042 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5043 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5044 const char *cservername,
5045 struct spoolss_DriverFileInfo **info_p,
5048 struct spoolss_DriverFileInfo *info = NULL;
5056 if (strlen(driver->info_3->driverpath)) {
5057 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5058 struct spoolss_DriverFileInfo,
5060 W_ERROR_HAVE_NO_MEMORY(info);
5061 result = fill_spoolss_DriverFileInfo(info,
5064 driver->info_3->driverpath,
5065 SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5067 W_ERROR_NOT_OK_RETURN(result);
5071 if (strlen(driver->info_3->configfile)) {
5072 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5073 struct spoolss_DriverFileInfo,
5075 W_ERROR_HAVE_NO_MEMORY(info);
5076 result = fill_spoolss_DriverFileInfo(info,
5079 driver->info_3->configfile,
5080 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5082 W_ERROR_NOT_OK_RETURN(result);
5086 if (strlen(driver->info_3->datafile)) {
5087 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5088 struct spoolss_DriverFileInfo,
5090 W_ERROR_HAVE_NO_MEMORY(info);
5091 result = fill_spoolss_DriverFileInfo(info,
5094 driver->info_3->datafile,
5095 SPOOLSS_DRIVER_FILE_TYPE_DATA,
5097 W_ERROR_NOT_OK_RETURN(result);
5101 if (strlen(driver->info_3->helpfile)) {
5102 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5103 struct spoolss_DriverFileInfo,
5105 W_ERROR_HAVE_NO_MEMORY(info);
5106 result = fill_spoolss_DriverFileInfo(info,
5109 driver->info_3->helpfile,
5110 SPOOLSS_DRIVER_FILE_TYPE_HELP,
5112 W_ERROR_NOT_OK_RETURN(result);
5116 for (i=0; driver->info_3->dependentfiles[i][0] != '\0'; i++) {
5117 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5118 struct spoolss_DriverFileInfo,
5120 W_ERROR_HAVE_NO_MEMORY(info);
5121 result = fill_spoolss_DriverFileInfo(info,
5124 driver->info_3->dependentfiles[i],
5125 SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5127 W_ERROR_NOT_OK_RETURN(result);
5137 /********************************************************************
5138 * fill a spoolss_DriverInfo101 sttruct
5139 ********************************************************************/
5141 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5142 struct spoolss_DriverInfo101 *r,
5143 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5144 const char *servername)
5146 const char *cservername = canon_servername(servername);
5149 r->version = driver->info_3->cversion;
5151 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
5152 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5153 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
5154 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5156 result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5160 if (!W_ERROR_IS_OK(result)) {
5164 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
5165 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
5167 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
5168 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
5170 r->previous_names = string_array_from_driver_info(mem_ctx,
5174 r->driver_version = 0;
5176 r->manufacturer_name = talloc_strdup(mem_ctx, "");
5177 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5178 r->manufacturer_url = talloc_strdup(mem_ctx, "");
5179 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5180 r->hardware_id = talloc_strdup(mem_ctx, "");
5181 W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5182 r->provider = talloc_strdup(mem_ctx, "");
5183 W_ERROR_HAVE_NO_MEMORY(r->provider);
5188 /********************************************************************
5189 * construct_printer_driver_info_1
5190 ********************************************************************/
5192 static WERROR construct_printer_driver_info_1(TALLOC_CTX *mem_ctx,
5193 struct spoolss_DriverInfo1 *r,
5195 const char *servername,
5196 const char *architecture,
5199 NT_PRINTER_INFO_LEVEL *printer = NULL;
5200 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5203 ZERO_STRUCT(driver);
5205 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5206 return WERR_INVALID_PRINTER_NAME;
5208 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5209 free_a_printer(&printer, 2);
5210 return WERR_UNKNOWN_PRINTER_DRIVER;
5213 result = fill_printer_driver_info1(mem_ctx, r, &driver, servername, architecture);
5215 free_a_printer(&printer,2);
5220 /********************************************************************
5221 * construct_printer_driver_info_2
5222 * fill a printer_info_2 struct
5223 ********************************************************************/
5225 static WERROR construct_printer_driver_info_2(TALLOC_CTX *mem_ctx,
5226 struct spoolss_DriverInfo2 *r,
5228 const char *servername,
5229 const char *architecture,
5232 NT_PRINTER_INFO_LEVEL *printer = NULL;
5233 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5236 ZERO_STRUCT(printer);
5237 ZERO_STRUCT(driver);
5239 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5240 return WERR_INVALID_PRINTER_NAME;
5242 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5243 free_a_printer(&printer, 2);
5244 return WERR_UNKNOWN_PRINTER_DRIVER;
5247 result = fill_printer_driver_info2(mem_ctx, r, &driver, servername);
5249 free_a_printer(&printer,2);
5254 /********************************************************************
5255 * construct_printer_info_3
5256 * fill a printer_info_3 struct
5257 ********************************************************************/
5259 static WERROR construct_printer_driver_info_3(TALLOC_CTX *mem_ctx,
5260 struct spoolss_DriverInfo3 *r,
5262 const char *servername,
5263 const char *architecture,
5266 NT_PRINTER_INFO_LEVEL *printer = NULL;
5267 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5269 ZERO_STRUCT(driver);
5271 status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5272 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5273 if (!W_ERROR_IS_OK(status))
5274 return WERR_INVALID_PRINTER_NAME;
5276 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5277 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5282 * I put this code in during testing. Helpful when commenting out the
5283 * support for DRIVER_INFO_6 in regards to win2k. Not needed in general
5284 * as win2k always queries the driver using an infor level of 6.
5285 * I've left it in (but ifdef'd out) because I'll probably
5286 * use it in experimentation again in the future. --jerry 22/01/2002
5289 if (!W_ERROR_IS_OK(status)) {
5291 * Is this a W2k client ?
5294 /* Yes - try again with a WinNT driver. */
5296 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5297 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5301 if (!W_ERROR_IS_OK(status)) {
5302 free_a_printer(&printer,2);
5303 return WERR_UNKNOWN_PRINTER_DRIVER;
5311 status = fill_printer_driver_info3(mem_ctx, r, &driver, servername);
5313 free_a_printer(&printer,2);
5318 /********************************************************************
5319 * construct_printer_info_6
5320 * fill a printer_info_6 struct
5321 ********************************************************************/
5323 static WERROR construct_printer_driver_info_6(TALLOC_CTX *mem_ctx,
5324 struct spoolss_DriverInfo6 *r,
5326 const char *servername,
5327 const char *architecture,
5330 NT_PRINTER_INFO_LEVEL *printer = NULL;
5331 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5334 ZERO_STRUCT(driver);
5336 status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5338 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5340 if (!W_ERROR_IS_OK(status))
5341 return WERR_INVALID_PRINTER_NAME;
5343 status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5345 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5347 if (!W_ERROR_IS_OK(status))
5350 * Is this a W2k client ?
5354 free_a_printer(&printer,2);
5355 return WERR_UNKNOWN_PRINTER_DRIVER;
5358 /* Yes - try again with a WinNT driver. */
5360 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5361 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5362 if (!W_ERROR_IS_OK(status)) {
5363 free_a_printer(&printer,2);
5364 return WERR_UNKNOWN_PRINTER_DRIVER;
5368 status = fill_printer_driver_info6(mem_ctx, r, &driver, servername);
5370 free_a_printer(&printer,2);
5371 free_a_printer_driver(driver, 3);
5376 /********************************************************************
5377 * construct_printer_info_101
5378 * fill a printer_info_101 struct
5379 ********************************************************************/
5381 static WERROR construct_printer_driver_info_101(TALLOC_CTX *mem_ctx,
5382 struct spoolss_DriverInfo101 *r,
5384 const char *servername,
5385 const char *architecture,
5388 NT_PRINTER_INFO_LEVEL *printer = NULL;
5389 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5392 ZERO_STRUCT(driver);
5394 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5396 DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5397 win_errstr(result)));
5399 if (!W_ERROR_IS_OK(result)) {
5400 return WERR_INVALID_PRINTER_NAME;
5403 result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5404 architecture, version);
5406 DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5407 win_errstr(result)));
5409 if (!W_ERROR_IS_OK(result)) {
5411 * Is this a W2k client ?
5415 free_a_printer(&printer, 2);
5416 return WERR_UNKNOWN_PRINTER_DRIVER;
5419 /* Yes - try again with a WinNT driver. */
5421 result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5422 architecture, version);
5423 DEBUG(8,("construct_printer_driver_info_6: status: %s\n",
5424 win_errstr(result)));
5425 if (!W_ERROR_IS_OK(result)) {
5426 free_a_printer(&printer, 2);
5427 return WERR_UNKNOWN_PRINTER_DRIVER;
5431 result = fill_printer_driver_info101(mem_ctx, r, &driver, servername);
5433 free_a_printer(&printer, 2);
5434 free_a_printer_driver(driver, 3);
5439 /****************************************************************
5440 _spoolss_GetPrinterDriver2
5441 ****************************************************************/
5443 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5444 struct spoolss_GetPrinterDriver2 *r)
5446 Printer_entry *printer;
5449 const char *servername;
5452 /* that's an [in out] buffer */
5454 if (!r->in.buffer && (r->in.offered != 0)) {
5455 return WERR_INVALID_PARAM;
5458 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5460 if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5461 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5462 return WERR_INVALID_PRINTER_NAME;
5466 *r->out.server_major_version = 0;
5467 *r->out.server_minor_version = 0;
5469 servername = get_server_name(printer);
5471 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5475 switch (r->in.level) {
5477 result = construct_printer_driver_info_1(p->mem_ctx,
5478 &r->out.info->info1,
5482 r->in.client_major_version);
5485 result = construct_printer_driver_info_2(p->mem_ctx,
5486 &r->out.info->info2,
5490 r->in.client_major_version);
5493 result = construct_printer_driver_info_3(p->mem_ctx,
5494 &r->out.info->info3,
5498 r->in.client_major_version);
5501 result = construct_printer_driver_info_6(p->mem_ctx,
5502 &r->out.info->info6,
5506 r->in.client_major_version);
5509 result = construct_printer_driver_info_101(p->mem_ctx,
5510 &r->out.info->info101,
5514 r->in.client_major_version);
5517 result = WERR_UNKNOWN_LEVEL;
5521 if (!W_ERROR_IS_OK(result)) {
5522 TALLOC_FREE(r->out.info);
5526 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5527 r->out.info, r->in.level);
5528 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5530 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5534 /****************************************************************
5535 _spoolss_StartPagePrinter
5536 ****************************************************************/
5538 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5539 struct spoolss_StartPagePrinter *r)
5541 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5544 DEBUG(3,("_spoolss_StartPagePrinter: "
5545 "Error in startpageprinter printer handle\n"));
5549 Printer->page_started = true;
5553 /****************************************************************
5554 _spoolss_EndPagePrinter
5555 ****************************************************************/
5557 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5558 struct spoolss_EndPagePrinter *r)
5562 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5565 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5566 OUR_HANDLE(r->in.handle)));
5570 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5573 Printer->page_started = false;
5574 print_job_endpage(snum, Printer->jobid);
5579 /****************************************************************
5580 _spoolss_StartDocPrinter
5581 ****************************************************************/
5583 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5584 struct spoolss_StartDocPrinter *r)
5586 struct spoolss_DocumentInfo1 *info_1;
5588 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5591 DEBUG(2,("_spoolss_StartDocPrinter: "
5592 "Invalid handle (%s:%u:%u)\n",
5593 OUR_HANDLE(r->in.handle)));
5597 if (r->in.level != 1) {
5598 return WERR_UNKNOWN_LEVEL;
5601 info_1 = r->in.info.info1;
5604 * a nice thing with NT is it doesn't listen to what you tell it.
5605 * when asked to send _only_ RAW datas, it tries to send datas
5608 * So I add checks like in NT Server ...
5611 if (info_1->datatype) {
5612 if (strcmp(info_1->datatype, "RAW") != 0) {
5614 return WERR_INVALID_DATATYPE;
5618 /* get the share number of the printer */
5619 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5623 Printer->jobid = print_job_start(p->server_info, snum,
5624 info_1->document_name,
5625 Printer->nt_devmode);
5627 /* An error occured in print_job_start() so return an appropriate
5630 if (Printer->jobid == -1) {
5631 return map_werror_from_unix(errno);
5634 Printer->document_started = true;
5635 *r->out.job_id = Printer->jobid;
5640 /****************************************************************
5641 _spoolss_EndDocPrinter
5642 ****************************************************************/
5644 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5645 struct spoolss_EndDocPrinter *r)
5647 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5651 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5652 OUR_HANDLE(r->in.handle)));
5656 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5660 Printer->document_started = false;
5661 print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
5662 /* error codes unhandled so far ... */
5667 /****************************************************************
5668 _spoolss_WritePrinter
5669 ****************************************************************/
5671 WERROR _spoolss_WritePrinter(pipes_struct *p,
5672 struct spoolss_WritePrinter *r)
5674 uint32_t buffer_written;
5676 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5679 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5680 OUR_HANDLE(r->in.handle)));
5681 *r->out.num_written = r->in._data_size;
5685 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5688 buffer_written = (uint32_t)print_job_write(snum, Printer->jobid,
5689 (const char *)r->in.data.data,
5691 (size_t)r->in._data_size);
5692 if (buffer_written == (uint32_t)-1) {
5693 *r->out.num_written = 0;
5694 if (errno == ENOSPC)
5695 return WERR_NO_SPOOL_SPACE;
5697 return WERR_ACCESS_DENIED;
5700 *r->out.num_written = r->in._data_size;
5705 /********************************************************************
5706 * api_spoolss_getprinter
5707 * called from the spoolss dispatcher
5709 ********************************************************************/
5711 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5715 WERROR errcode = WERR_BADFUNC;
5716 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5719 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5720 OUR_HANDLE(handle)));
5724 if (!get_printer_snum(p, handle, &snum, NULL))
5728 case SPOOLSS_PRINTER_CONTROL_PAUSE:
5729 errcode = print_queue_pause(p->server_info, snum);
5731 case SPOOLSS_PRINTER_CONTROL_RESUME:
5732 case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5733 errcode = print_queue_resume(p->server_info, snum);
5735 case SPOOLSS_PRINTER_CONTROL_PURGE:
5736 errcode = print_queue_purge(p->server_info, snum);
5739 return WERR_UNKNOWN_LEVEL;
5746 /****************************************************************
5747 _spoolss_AbortPrinter
5748 * From MSDN: "Deletes printer's spool file if printer is configured
5750 ****************************************************************/
5752 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5753 struct spoolss_AbortPrinter *r)
5755 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5757 WERROR errcode = WERR_OK;
5760 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5761 OUR_HANDLE(r->in.handle)));
5765 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5768 print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5773 /********************************************************************
5774 * called by spoolss_api_setprinter
5775 * when updating a printer description
5776 ********************************************************************/
5778 static WERROR update_printer_sec(struct policy_handle *handle,
5779 pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5781 SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5785 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5787 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5788 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5789 OUR_HANDLE(handle)));
5791 result = WERR_BADFID;
5796 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5797 result = WERR_INVALID_PARAM;
5801 /* Check the user has permissions to change the security
5802 descriptor. By experimentation with two NT machines, the user
5803 requires Full Access to the printer to change security
5806 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5807 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5808 result = WERR_ACCESS_DENIED;
5812 /* NT seems to like setting the security descriptor even though
5813 nothing may have actually changed. */
5815 if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5816 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5817 result = WERR_BADFID;
5821 if (DEBUGLEVEL >= 10) {
5825 the_acl = old_secdesc_ctr->sd->dacl;
5826 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5827 PRINTERNAME(snum), the_acl->num_aces));
5829 for (i = 0; i < the_acl->num_aces; i++) {
5830 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5831 &the_acl->aces[i].trustee),
5832 the_acl->aces[i].access_mask));
5835 the_acl = secdesc_ctr->sd->dacl;
5838 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5839 PRINTERNAME(snum), the_acl->num_aces));
5841 for (i = 0; i < the_acl->num_aces; i++) {
5842 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5843 &the_acl->aces[i].trustee),
5844 the_acl->aces[i].access_mask));
5847 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5851 new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5852 if (!new_secdesc_ctr) {
5853 result = WERR_NOMEM;
5857 if (security_descriptor_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5862 result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5869 /********************************************************************
5870 Canonicalize printer info from a client
5872 ATTN: It does not matter what we set the servername to hear
5873 since we do the necessary work in get_a_printer() to set it to
5874 the correct value based on what the client sent in the
5875 _spoolss_open_printer_ex().
5876 ********************************************************************/
5878 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5880 fstring printername;
5883 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5884 "portname=%s drivername=%s comment=%s location=%s\n",
5885 info->servername, info->printername, info->sharename,
5886 info->portname, info->drivername, info->comment, info->location));
5888 /* we force some elements to "correct" values */
5889 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5890 fstrcpy(info->sharename, lp_servicename(snum));
5892 /* check to see if we allow printername != sharename */
5894 if ( lp_force_printername(snum) ) {
5895 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5896 global_myname(), info->sharename );
5899 /* make sure printername is in \\server\printername format */
5901 fstrcpy( printername, info->printername );
5903 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5904 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5908 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5909 global_myname(), p );
5912 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5913 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5920 /****************************************************************************
5921 ****************************************************************************/
5923 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5925 char *cmd = lp_addport_cmd();
5926 char *command = NULL;
5928 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5929 bool is_print_op = false;
5932 return WERR_ACCESS_DENIED;
5935 command = talloc_asprintf(ctx,
5936 "%s \"%s\" \"%s\"", cmd, portname, uri );
5942 is_print_op = user_has_privileges( token, &se_printop );
5944 DEBUG(10,("Running [%s]\n", command));
5946 /********* BEGIN SePrintOperatorPrivilege **********/
5951 ret = smbrun(command, NULL);
5956 /********* END SePrintOperatorPrivilege **********/
5958 DEBUGADD(10,("returned [%d]\n", ret));
5960 TALLOC_FREE(command);
5963 return WERR_ACCESS_DENIED;
5969 /****************************************************************************
5970 ****************************************************************************/
5972 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5974 char *cmd = lp_addprinter_cmd();
5976 char *command = NULL;
5980 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5981 bool is_print_op = false;
5982 char *remote_machine = talloc_strdup(ctx, "%m");
5984 if (!remote_machine) {
5987 remote_machine = talloc_sub_basic(ctx,
5988 current_user_info.smb_name,
5989 current_user_info.domain,
5991 if (!remote_machine) {
5995 command = talloc_asprintf(ctx,
5996 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5997 cmd, printer->info_2->printername, printer->info_2->sharename,
5998 printer->info_2->portname, printer->info_2->drivername,
5999 printer->info_2->location, printer->info_2->comment, remote_machine);
6005 is_print_op = user_has_privileges( token, &se_printop );
6007 DEBUG(10,("Running [%s]\n", command));
6009 /********* BEGIN SePrintOperatorPrivilege **********/
6014 if ( (ret = smbrun(command, &fd)) == 0 ) {
6015 /* Tell everyone we updated smb.conf. */
6016 message_send_all(smbd_messaging_context(),
6017 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6023 /********* END SePrintOperatorPrivilege **********/
6025 DEBUGADD(10,("returned [%d]\n", ret));
6027 TALLOC_FREE(command);
6028 TALLOC_FREE(remote_machine);
6036 /* reload our services immediately */
6037 reload_services(false);
6040 /* Get lines and convert them back to dos-codepage */
6041 qlines = fd_lines_load(fd, &numlines, 0, NULL);
6042 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6045 /* Set the portname to what the script says the portname should be. */
6046 /* but don't require anything to be return from the script exit a good error code */
6049 /* Set the portname to what the script says the portname should be. */
6050 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
6051 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6054 TALLOC_FREE(qlines);
6059 /********************************************************************
6060 * Called by spoolss_api_setprinter
6061 * when updating a printer description.
6062 ********************************************************************/
6064 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
6065 struct spoolss_SetPrinterInfoCtr *info_ctr,
6066 struct spoolss_DeviceMode *devmode)
6069 NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
6070 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6075 DEBUG(8,("update_printer\n"));
6080 result = WERR_BADFID;
6084 if (!get_printer_snum(p, handle, &snum, NULL)) {
6085 result = WERR_BADFID;
6089 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
6090 (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
6091 result = WERR_BADFID;
6095 DEBUGADD(8,("Converting info_2 struct\n"));
6098 * convert_printer_info converts the incoming
6099 * info from the client and overwrites the info
6100 * just read from the tdb in the pointer 'printer'.
6103 if (!convert_printer_info(info_ctr, printer)) {
6104 result = WERR_NOMEM;
6109 /* we have a valid devmode
6110 convert it and link it*/
6112 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
6113 if (!convert_devicemode(printer->info_2->printername, devmode,
6114 &printer->info_2->devmode)) {
6115 result = WERR_NOMEM;
6120 /* Do sanity check on the requested changes for Samba */
6122 if (!check_printer_ok(printer->info_2, snum)) {
6123 result = WERR_INVALID_PARAM;
6127 /* FIXME!!! If the driver has changed we really should verify that
6128 it is installed before doing much else --jerry */
6130 /* Check calling user has permission to update printer description */
6132 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6133 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6134 result = WERR_ACCESS_DENIED;
6138 /* Call addprinter hook */
6139 /* Check changes to see if this is really needed */
6141 if ( *lp_addprinter_cmd()
6142 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
6143 || !strequal(printer->info_2->comment, old_printer->info_2->comment)
6144 || !strequal(printer->info_2->portname, old_printer->info_2->portname)
6145 || !strequal(printer->info_2->location, old_printer->info_2->location)) )
6147 /* add_printer_hook() will call reload_services() */
6149 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
6151 result = WERR_ACCESS_DENIED;
6157 * When a *new* driver is bound to a printer, the drivername is used to
6158 * lookup previously saved driver initialization info, which is then
6159 * bound to the printer, simulating what happens in the Windows arch.
6161 if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
6163 if (!set_driver_init(printer, 2))
6165 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
6166 printer->info_2->drivername));
6169 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
6170 printer->info_2->drivername));
6172 notify_printer_driver(snum, printer->info_2->drivername);
6176 * flag which changes actually occured. This is a small subset of
6177 * all the possible changes. We also have to update things in the
6181 if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
6182 init_unistr2( &buffer, printer->info_2->comment, UNI_STR_TERMINATE);
6183 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
6184 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6186 notify_printer_comment(snum, printer->info_2->comment);
6189 if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
6190 init_unistr2( &buffer, printer->info_2->sharename, UNI_STR_TERMINATE);
6191 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
6192 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6194 notify_printer_sharename(snum, printer->info_2->sharename);
6197 if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
6200 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
6203 pname = printer->info_2->printername;
6206 init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
6207 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
6208 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6210 notify_printer_printername( snum, pname );
6213 if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
6214 init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
6215 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
6216 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6218 notify_printer_port(snum, printer->info_2->portname);
6221 if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
6222 init_unistr2( &buffer, printer->info_2->location, UNI_STR_TERMINATE);
6223 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
6224 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6226 notify_printer_location(snum, printer->info_2->location);
6229 /* here we need to update some more DsSpooler keys */
6230 /* uNCName, serverName, shortServerName */
6232 init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
6233 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
6234 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6235 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
6236 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6238 slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
6239 global_myname(), printer->info_2->sharename );
6240 init_unistr2( &buffer, asc_buffer, UNI_STR_TERMINATE);
6241 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
6242 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6244 /* Update printer info */
6245 result = mod_a_printer(printer, 2);
6248 free_a_printer(&printer, 2);
6249 free_a_printer(&old_printer, 2);
6255 /****************************************************************************
6256 ****************************************************************************/
6257 static WERROR publish_or_unpublish_printer(pipes_struct *p,
6258 struct policy_handle *handle,
6259 struct spoolss_SetPrinterInfo7 *info7)
6263 Printer_entry *Printer;
6265 if ( lp_security() != SEC_ADS ) {
6266 return WERR_UNKNOWN_LEVEL;
6269 Printer = find_printer_index_by_hnd(p, handle);
6271 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6276 if (!get_printer_snum(p, handle, &snum, NULL))
6279 nt_printer_publish(Printer, snum, info7->action);
6283 return WERR_UNKNOWN_LEVEL;
6287 /****************************************************************
6289 ****************************************************************/
6291 WERROR _spoolss_SetPrinter(pipes_struct *p,
6292 struct spoolss_SetPrinter *r)
6296 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6299 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6300 OUR_HANDLE(r->in.handle)));
6304 /* check the level */
6305 switch (r->in.info_ctr->level) {
6307 return control_printer(r->in.handle, r->in.command, p);
6309 result = update_printer(p, r->in.handle,
6311 r->in.devmode_ctr->devmode);
6312 if (!W_ERROR_IS_OK(result))
6314 if (r->in.secdesc_ctr->sd)
6315 result = update_printer_sec(r->in.handle, p,
6319 return update_printer_sec(r->in.handle, p,
6322 return publish_or_unpublish_printer(p, r->in.handle,
6323 r->in.info_ctr->info.info7);
6325 return WERR_UNKNOWN_LEVEL;
6329 /****************************************************************
6330 _spoolss_FindClosePrinterNotify
6331 ****************************************************************/
6333 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
6334 struct spoolss_FindClosePrinterNotify *r)
6336 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6339 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6340 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6344 if (Printer->notify.client_connected == true) {
6347 if ( Printer->printer_type == SPLHND_SERVER)
6349 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6350 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6353 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6356 Printer->notify.flags=0;
6357 Printer->notify.options=0;
6358 Printer->notify.localmachine[0]='\0';
6359 Printer->notify.printerlocal=0;
6360 TALLOC_FREE(Printer->notify.option);
6361 Printer->notify.client_connected = false;
6366 /****************************************************************
6368 ****************************************************************/
6370 WERROR _spoolss_AddJob(pipes_struct *p,
6371 struct spoolss_AddJob *r)
6373 if (!r->in.buffer && (r->in.offered != 0)) {
6374 return WERR_INVALID_PARAM;
6377 /* this is what a NT server returns for AddJob. AddJob must fail on
6378 * non-local printers */
6380 if (r->in.level != 1) {
6381 return WERR_UNKNOWN_LEVEL;
6384 return WERR_INVALID_PARAM;
6387 /****************************************************************************
6389 ****************************************************************************/
6391 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6392 struct spoolss_JobInfo1 *r,
6393 const print_queue_struct *queue,
6394 int position, int snum,
6395 const NT_PRINTER_INFO_LEVEL *ntprinter)
6399 t = gmtime(&queue->time);
6401 r->job_id = queue->job;
6403 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6404 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6405 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6406 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6407 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6408 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6409 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6410 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6411 r->data_type = talloc_strdup(mem_ctx, "RAW");
6412 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6413 r->text_status = talloc_strdup(mem_ctx, "");
6414 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6416 r->status = nt_printj_status(queue->status);
6417 r->priority = queue->priority;
6418 r->position = position;
6419 r->total_pages = queue->page_count;
6420 r->pages_printed = 0; /* ??? */
6422 init_systemtime(&r->submitted, t);
6427 /****************************************************************************
6429 ****************************************************************************/
6431 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6432 struct spoolss_JobInfo2 *r,
6433 const print_queue_struct *queue,
6434 int position, int snum,
6435 const NT_PRINTER_INFO_LEVEL *ntprinter,
6436 struct spoolss_DeviceMode *devmode)
6440 t = gmtime(&queue->time);
6442 r->job_id = queue->job;
6444 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6445 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6446 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6447 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6448 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6449 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6450 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6451 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6452 r->notify_name = talloc_strdup(mem_ctx, queue->fs_user);
6453 W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6454 r->data_type = talloc_strdup(mem_ctx, "RAW");
6455 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6456 r->print_processor = talloc_strdup(mem_ctx, "winprint");
6457 W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6458 r->parameters = talloc_strdup(mem_ctx, "");
6459 W_ERROR_HAVE_NO_MEMORY(r->parameters);
6460 r->driver_name = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6461 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6463 r->devmode = devmode;
6465 r->text_status = talloc_strdup(mem_ctx, "");
6466 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6470 r->status = nt_printj_status(queue->status);
6471 r->priority = queue->priority;
6472 r->position = position;
6475 r->total_pages = queue->page_count;
6476 r->size = queue->size;
6477 init_systemtime(&r->submitted, t);
6479 r->pages_printed = 0; /* ??? */
6484 /****************************************************************************
6485 Enumjobs at level 1.
6486 ****************************************************************************/
6488 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6489 const print_queue_struct *queue,
6490 uint32_t num_queues, int snum,
6491 const NT_PRINTER_INFO_LEVEL *ntprinter,
6492 union spoolss_JobInfo **info_p,
6495 union spoolss_JobInfo *info;
6497 WERROR result = WERR_OK;
6499 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6500 W_ERROR_HAVE_NO_MEMORY(info);
6502 *count = num_queues;
6504 for (i=0; i<*count; i++) {
6505 result = fill_job_info1(info,
6511 if (!W_ERROR_IS_OK(result)) {
6517 if (!W_ERROR_IS_OK(result)) {
6528 /****************************************************************************
6529 Enumjobs at level 2.
6530 ****************************************************************************/
6532 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6533 const print_queue_struct *queue,
6534 uint32_t num_queues, int snum,
6535 const NT_PRINTER_INFO_LEVEL *ntprinter,
6536 union spoolss_JobInfo **info_p,
6539 union spoolss_JobInfo *info;
6541 WERROR result = WERR_OK;
6543 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6544 W_ERROR_HAVE_NO_MEMORY(info);
6546 *count = num_queues;
6548 for (i=0; i<*count; i++) {
6550 struct spoolss_DeviceMode *devmode;
6552 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6554 result = WERR_NOMEM;
6558 result = fill_job_info2(info,
6565 if (!W_ERROR_IS_OK(result)) {
6571 if (!W_ERROR_IS_OK(result)) {
6582 /****************************************************************
6584 ****************************************************************/
6586 WERROR _spoolss_EnumJobs(pipes_struct *p,
6587 struct spoolss_EnumJobs *r)
6590 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6592 print_status_struct prt_status;
6593 print_queue_struct *queue = NULL;
6596 /* that's an [in out] buffer */
6598 if (!r->in.buffer && (r->in.offered != 0)) {
6599 return WERR_INVALID_PARAM;
6602 DEBUG(4,("_spoolss_EnumJobs\n"));
6606 *r->out.info = NULL;
6608 /* lookup the printer snum and tdb entry */
6610 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6614 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6615 if (!W_ERROR_IS_OK(result)) {
6619 count = print_queue_status(snum, &queue, &prt_status);
6620 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6621 count, prt_status.status, prt_status.message));
6625 free_a_printer(&ntprinter, 2);
6629 switch (r->in.level) {
6631 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6632 ntprinter, r->out.info, r->out.count);
6635 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6636 ntprinter, r->out.info, r->out.count);
6639 result = WERR_UNKNOWN_LEVEL;
6644 free_a_printer(&ntprinter, 2);
6646 if (!W_ERROR_IS_OK(result)) {
6650 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6651 spoolss_EnumJobs, NULL,
6652 *r->out.info, r->in.level,
6654 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6655 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6657 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6660 /****************************************************************
6661 _spoolss_ScheduleJob
6662 ****************************************************************/
6664 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6665 struct spoolss_ScheduleJob *r)
6670 /****************************************************************
6672 ****************************************************************/
6674 WERROR _spoolss_SetJob(pipes_struct *p,
6675 struct spoolss_SetJob *r)
6678 WERROR errcode = WERR_BADFUNC;
6680 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6684 if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6685 return WERR_INVALID_PRINTER_NAME;
6688 switch (r->in.command) {
6689 case SPOOLSS_JOB_CONTROL_CANCEL:
6690 case SPOOLSS_JOB_CONTROL_DELETE:
6691 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6695 case SPOOLSS_JOB_CONTROL_PAUSE:
6696 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6700 case SPOOLSS_JOB_CONTROL_RESTART:
6701 case SPOOLSS_JOB_CONTROL_RESUME:
6702 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6707 return WERR_UNKNOWN_LEVEL;
6713 static const struct print_architecture_table_node archi_table[]= {
6715 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
6716 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
6717 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
6718 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
6719 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
6720 {"Windows IA64", SPL_ARCH_IA64, 3 },
6721 {"Windows x64", SPL_ARCH_X64, 3 },
6725 /****************************************************************************
6726 Enumerates all printer drivers by level and architecture.
6727 ****************************************************************************/
6729 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
6730 const char *servername,
6731 const char *architecture,
6733 union spoolss_DriverInfo **info_p,
6739 fstring *list = NULL;
6740 NT_PRINTER_DRIVER_INFO_LEVEL driver;
6741 union spoolss_DriverInfo *info = NULL;
6743 WERROR result = WERR_OK;
6748 for (version=0; version<DRIVER_MAX_VERSION; version++) {
6750 ndrivers = get_ntdrivers(&list, architecture, version);
6751 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6752 ndrivers, architecture, version));
6754 if (ndrivers == -1) {
6755 result = WERR_NOMEM;
6759 if (ndrivers != 0) {
6760 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6761 union spoolss_DriverInfo,
6764 DEBUG(0,("enumprinterdrivers_level1: "
6765 "failed to enlarge driver info buffer!\n"));
6766 result = WERR_NOMEM;
6771 for (i=0; i<ndrivers; i++) {
6772 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6773 ZERO_STRUCT(driver);
6774 result = get_a_printer_driver(&driver, 3, list[i],
6775 architecture, version);
6776 if (!W_ERROR_IS_OK(result)) {
6782 result = fill_printer_driver_info1(info, &info[count+i].info1,
6783 &driver, servername,
6787 result = fill_printer_driver_info2(info, &info[count+i].info2,
6788 &driver, servername);
6791 result = fill_printer_driver_info3(info, &info[count+i].info3,
6792 &driver, servername);
6795 result = fill_printer_driver_info4(info, &info[count+i].info4,
6796 &driver, servername);
6799 result = fill_printer_driver_info5(info, &info[count+i].info5,
6800 &driver, servername);
6803 result = fill_printer_driver_info6(info, &info[count+i].info6,
6804 &driver, servername);
6807 result = WERR_UNKNOWN_LEVEL;
6811 if (!W_ERROR_IS_OK(result)) {
6812 free_a_printer_driver(driver, 3);
6815 free_a_printer_driver(driver, 3);
6825 if (!W_ERROR_IS_OK(result)) {
6836 /****************************************************************************
6837 Enumerates all printer drivers by level.
6838 ****************************************************************************/
6840 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6841 const char *servername,
6842 const char *architecture,
6844 union spoolss_DriverInfo **info_p,
6848 WERROR result = WERR_OK;
6850 if (strequal(architecture, "all")) {
6852 for (a=0; archi_table[a].long_archi != NULL; a++) {
6854 union spoolss_DriverInfo *info = NULL;
6857 result = enumprinterdrivers_level_by_architecture(mem_ctx,
6859 archi_table[a].long_archi,
6863 if (!W_ERROR_IS_OK(result)) {
6867 for (i=0; i < count; i++) {
6868 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
6869 info[i], info_p, count_p);
6876 return enumprinterdrivers_level_by_architecture(mem_ctx,
6884 /****************************************************************************
6885 Enumerates all printer drivers at level 1.
6886 ****************************************************************************/
6888 static WERROR enumprinterdrivers_level1(TALLOC_CTX *mem_ctx,
6889 const char *servername,
6890 const char *architecture,
6891 union spoolss_DriverInfo **info_p,
6894 return enumprinterdrivers_level(mem_ctx, servername, architecture, 1,
6898 /****************************************************************************
6899 Enumerates all printer drivers at level 2.
6900 ****************************************************************************/
6902 static WERROR enumprinterdrivers_level2(TALLOC_CTX *mem_ctx,
6903 const char *servername,
6904 const char *architecture,
6905 union spoolss_DriverInfo **info_p,
6908 return enumprinterdrivers_level(mem_ctx, servername, architecture, 2,
6912 /****************************************************************************
6913 Enumerates all printer drivers at level 3.
6914 ****************************************************************************/
6916 static WERROR enumprinterdrivers_level3(TALLOC_CTX *mem_ctx,
6917 const char *servername,
6918 const char *architecture,
6919 union spoolss_DriverInfo **info_p,
6922 return enumprinterdrivers_level(mem_ctx, servername, architecture, 3,
6926 /****************************************************************************
6927 Enumerates all printer drivers at level 4.
6928 ****************************************************************************/
6930 static WERROR enumprinterdrivers_level4(TALLOC_CTX *mem_ctx,
6931 const char *servername,
6932 const char *architecture,
6933 union spoolss_DriverInfo **info_p,
6936 return enumprinterdrivers_level(mem_ctx, servername, architecture, 4,
6940 /****************************************************************************
6941 Enumerates all printer drivers at level 5.
6942 ****************************************************************************/
6944 static WERROR enumprinterdrivers_level5(TALLOC_CTX *mem_ctx,
6945 const char *servername,
6946 const char *architecture,
6947 union spoolss_DriverInfo **info_p,
6950 return enumprinterdrivers_level(mem_ctx, servername, architecture, 5,
6954 /****************************************************************************
6955 Enumerates all printer drivers at level 6.
6956 ****************************************************************************/
6958 static WERROR enumprinterdrivers_level6(TALLOC_CTX *mem_ctx,
6959 const char *servername,
6960 const char *architecture,
6961 union spoolss_DriverInfo **info_p,
6964 return enumprinterdrivers_level(mem_ctx, servername, architecture, 6,
6969 /****************************************************************
6970 _spoolss_EnumPrinterDrivers
6971 ****************************************************************/
6973 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6974 struct spoolss_EnumPrinterDrivers *r)
6976 const char *cservername;
6979 /* that's an [in out] buffer */
6981 if (!r->in.buffer && (r->in.offered != 0)) {
6982 return WERR_INVALID_PARAM;
6985 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6989 *r->out.info = NULL;
6991 cservername = canon_servername(r->in.server);
6993 if (!is_myname_or_ipaddr(cservername)) {
6994 return WERR_UNKNOWN_PRINTER_DRIVER;
6997 switch (r->in.level) {
6999 result = enumprinterdrivers_level1(p->mem_ctx, cservername,
7001 r->out.info, r->out.count);
7004 result = enumprinterdrivers_level2(p->mem_ctx, cservername,
7006 r->out.info, r->out.count);
7009 result = enumprinterdrivers_level3(p->mem_ctx, cservername,
7011 r->out.info, r->out.count);
7014 result = enumprinterdrivers_level4(p->mem_ctx, cservername,
7016 r->out.info, r->out.count);
7019 result = enumprinterdrivers_level5(p->mem_ctx, cservername,
7021 r->out.info, r->out.count);
7024 result = enumprinterdrivers_level6(p->mem_ctx, cservername,
7026 r->out.info, r->out.count);
7029 return WERR_UNKNOWN_LEVEL;
7032 if (!W_ERROR_IS_OK(result)) {
7036 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7037 spoolss_EnumPrinterDrivers, NULL,
7038 *r->out.info, r->in.level,
7040 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7041 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7043 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7046 /****************************************************************************
7047 ****************************************************************************/
7049 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
7050 struct spoolss_FormInfo1 *r,
7051 const nt_forms_struct *form)
7053 r->form_name = talloc_strdup(mem_ctx, form->name);
7054 W_ERROR_HAVE_NO_MEMORY(r->form_name);
7056 r->flags = form->flag;
7057 r->size.width = form->width;
7058 r->size.height = form->length;
7059 r->area.left = form->left;
7060 r->area.top = form->top;
7061 r->area.right = form->right;
7062 r->area.bottom = form->bottom;
7067 /****************************************************************
7068 spoolss_enumforms_level1
7069 ****************************************************************/
7071 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
7072 const nt_forms_struct *builtin_forms,
7073 uint32_t num_builtin_forms,
7074 const nt_forms_struct *user_forms,
7075 uint32_t num_user_forms,
7076 union spoolss_FormInfo **info_p,
7079 union spoolss_FormInfo *info;
7080 WERROR result = WERR_OK;
7083 *count = num_builtin_forms + num_user_forms;
7085 info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
7086 W_ERROR_HAVE_NO_MEMORY(info);
7088 /* construct the list of form structures */
7089 for (i=0; i<num_builtin_forms; i++) {
7090 DEBUGADD(6,("Filling builtin form number [%d]\n",i));
7091 result = fill_form_info_1(info, &info[i].info1,
7093 if (!W_ERROR_IS_OK(result)) {
7098 for (i=0; i<num_user_forms; i++) {
7099 DEBUGADD(6,("Filling user form number [%d]\n",i));
7100 result = fill_form_info_1(info, &info[i+num_builtin_forms].info1,
7102 if (!W_ERROR_IS_OK(result)) {
7108 if (!W_ERROR_IS_OK(result)) {
7119 /****************************************************************
7121 ****************************************************************/
7123 WERROR _spoolss_EnumForms(pipes_struct *p,
7124 struct spoolss_EnumForms *r)
7127 nt_forms_struct *user_forms = NULL;
7128 nt_forms_struct *builtin_forms = NULL;
7129 uint32_t num_user_forms;
7130 uint32_t num_builtin_forms;
7134 *r->out.info = NULL;
7136 /* that's an [in out] buffer */
7138 if (!r->in.buffer && (r->in.offered != 0) ) {
7139 return WERR_INVALID_PARAM;
7142 DEBUG(4,("_spoolss_EnumForms\n"));
7143 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7144 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7146 num_builtin_forms = get_builtin_ntforms(&builtin_forms);
7147 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
7148 num_user_forms = get_ntforms(&user_forms);
7149 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
7151 if (num_user_forms + num_builtin_forms == 0) {
7152 SAFE_FREE(builtin_forms);
7153 SAFE_FREE(user_forms);
7154 return WERR_NO_MORE_ITEMS;
7157 switch (r->in.level) {
7159 result = spoolss_enumforms_level1(p->mem_ctx,
7168 result = WERR_UNKNOWN_LEVEL;
7172 SAFE_FREE(user_forms);
7173 SAFE_FREE(builtin_forms);
7175 if (!W_ERROR_IS_OK(result)) {
7179 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7180 spoolss_EnumForms, NULL,
7181 *r->out.info, r->in.level,
7183 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7184 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7186 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7189 /****************************************************************
7190 ****************************************************************/
7192 static WERROR find_form_byname(const char *name,
7193 nt_forms_struct *form)
7195 nt_forms_struct *list = NULL;
7196 int num_forms = 0, i = 0;
7198 if (get_a_builtin_ntform_by_string(name, form)) {
7202 num_forms = get_ntforms(&list);
7203 DEBUGADD(5,("Number of forms [%d]\n", num_forms));
7205 if (num_forms == 0) {
7209 /* Check if the requested name is in the list of form structures */
7210 for (i = 0; i < num_forms; i++) {
7212 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
7214 if (strequal(name, list[i].name)) {
7215 DEBUGADD(6,("Found form %s number [%d]\n", name, i));
7227 /****************************************************************
7229 ****************************************************************/
7231 WERROR _spoolss_GetForm(pipes_struct *p,
7232 struct spoolss_GetForm *r)
7235 nt_forms_struct form;
7237 /* that's an [in out] buffer */
7239 if (!r->in.buffer && (r->in.offered != 0)) {
7240 return WERR_INVALID_PARAM;
7243 DEBUG(4,("_spoolss_GetForm\n"));
7244 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7245 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7247 result = find_form_byname(r->in.form_name, &form);
7248 if (!W_ERROR_IS_OK(result)) {
7249 TALLOC_FREE(r->out.info);
7253 switch (r->in.level) {
7255 result = fill_form_info_1(p->mem_ctx,
7256 &r->out.info->info1,
7261 result = WERR_UNKNOWN_LEVEL;
7265 if (!W_ERROR_IS_OK(result)) {
7266 TALLOC_FREE(r->out.info);
7270 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
7271 r->out.info, r->in.level);
7272 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7274 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7277 /****************************************************************************
7278 ****************************************************************************/
7280 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7281 struct spoolss_PortInfo1 *r,
7284 r->port_name = talloc_strdup(mem_ctx, name);
7285 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7290 /****************************************************************************
7291 TODO: This probably needs distinguish between TCP/IP and Local ports
7293 ****************************************************************************/
7295 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7296 struct spoolss_PortInfo2 *r,
7299 r->port_name = talloc_strdup(mem_ctx, name);
7300 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7302 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7303 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7305 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7306 W_ERROR_HAVE_NO_MEMORY(r->description);
7308 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7315 /****************************************************************************
7316 wrapper around the enumer ports command
7317 ****************************************************************************/
7319 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7321 char *cmd = lp_enumports_cmd();
7322 char **qlines = NULL;
7323 char *command = NULL;
7331 /* if no hook then just fill in the default port */
7334 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7337 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7338 TALLOC_FREE(qlines);
7345 /* we have a valid enumport command */
7347 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7352 DEBUG(10,("Running [%s]\n", command));
7353 ret = smbrun(command, &fd);
7354 DEBUG(10,("Returned [%d]\n", ret));
7355 TALLOC_FREE(command);
7360 return WERR_ACCESS_DENIED;
7364 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7365 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7375 /****************************************************************************
7377 ****************************************************************************/
7379 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7380 union spoolss_PortInfo **info_p,
7383 union spoolss_PortInfo *info = NULL;
7385 WERROR result = WERR_OK;
7386 char **qlines = NULL;
7389 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7390 if (!W_ERROR_IS_OK(result)) {
7395 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7397 DEBUG(10,("Returning WERR_NOMEM\n"));
7398 result = WERR_NOMEM;
7402 for (i=0; i<numlines; i++) {
7403 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7404 result = fill_port_1(info, &info[i].info1, qlines[i]);
7405 if (!W_ERROR_IS_OK(result)) {
7410 TALLOC_FREE(qlines);
7413 if (!W_ERROR_IS_OK(result)) {
7415 TALLOC_FREE(qlines);
7427 /****************************************************************************
7429 ****************************************************************************/
7431 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7432 union spoolss_PortInfo **info_p,
7435 union spoolss_PortInfo *info = NULL;
7437 WERROR result = WERR_OK;
7438 char **qlines = NULL;
7441 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7442 if (!W_ERROR_IS_OK(result)) {
7447 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7449 DEBUG(10,("Returning WERR_NOMEM\n"));
7450 result = WERR_NOMEM;
7454 for (i=0; i<numlines; i++) {
7455 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7456 result = fill_port_2(info, &info[i].info2, qlines[i]);
7457 if (!W_ERROR_IS_OK(result)) {
7462 TALLOC_FREE(qlines);
7465 if (!W_ERROR_IS_OK(result)) {
7467 TALLOC_FREE(qlines);
7479 /****************************************************************
7481 ****************************************************************/
7483 WERROR _spoolss_EnumPorts(pipes_struct *p,
7484 struct spoolss_EnumPorts *r)
7488 /* that's an [in out] buffer */
7490 if (!r->in.buffer && (r->in.offered != 0)) {
7491 return WERR_INVALID_PARAM;
7494 DEBUG(4,("_spoolss_EnumPorts\n"));
7498 *r->out.info = NULL;
7500 switch (r->in.level) {
7502 result = enumports_level_1(p->mem_ctx, r->out.info,
7506 result = enumports_level_2(p->mem_ctx, r->out.info,
7510 return WERR_UNKNOWN_LEVEL;
7513 if (!W_ERROR_IS_OK(result)) {
7517 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7518 spoolss_EnumPorts, NULL,
7519 *r->out.info, r->in.level,
7521 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7522 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7524 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7527 /****************************************************************************
7528 ****************************************************************************/
7530 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7532 struct spoolss_SetPrinterInfoCtr *info_ctr,
7533 struct spoolss_DeviceMode *devmode,
7534 struct security_descriptor *sec_desc,
7535 struct spoolss_UserLevelCtr *user_ctr,
7536 struct policy_handle *handle)
7538 NT_PRINTER_INFO_LEVEL *printer = NULL;
7541 WERROR err = WERR_OK;
7543 if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7544 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7548 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7549 if (!convert_printer_info(info_ctr, printer)) {
7550 free_a_printer(&printer, 2);
7554 /* check to see if the printer already exists */
7556 if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7557 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7558 printer->info_2->sharename));
7559 free_a_printer(&printer, 2);
7560 return WERR_PRINTER_ALREADY_EXISTS;
7563 /* FIXME!!! smbd should check to see if the driver is installed before
7564 trying to add a printer like this --jerry */
7566 if (*lp_addprinter_cmd() ) {
7567 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7569 free_a_printer(&printer,2);
7570 return WERR_ACCESS_DENIED;
7573 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7574 "smb.conf parameter \"addprinter command\" is defined. This"
7575 "parameter must exist for this call to succeed\n",
7576 printer->info_2->sharename ));
7579 /* use our primary netbios name since get_a_printer() will convert
7580 it to what the client expects on a case by case basis */
7582 slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7583 printer->info_2->sharename);
7586 if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7587 free_a_printer(&printer,2);
7588 return WERR_ACCESS_DENIED;
7591 /* you must be a printer admin to add a new printer */
7592 if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
7593 free_a_printer(&printer,2);
7594 return WERR_ACCESS_DENIED;
7598 * Do sanity check on the requested changes for Samba.
7601 if (!check_printer_ok(printer->info_2, snum)) {
7602 free_a_printer(&printer,2);
7603 return WERR_INVALID_PARAM;
7607 * When a printer is created, the drivername bound to the printer is used
7608 * to lookup previously saved driver initialization info, which is then
7609 * bound to the new printer, simulating what happens in the Windows arch.
7614 set_driver_init(printer, 2);
7618 /* A valid devmode was included, convert and link it
7620 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7622 if (!convert_devicemode(printer->info_2->printername, devmode,
7623 &printer->info_2->devmode)) {
7628 /* write the ASCII on disk */
7629 err = mod_a_printer(printer, 2);
7630 if (!W_ERROR_IS_OK(err)) {
7631 free_a_printer(&printer,2);
7635 if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7636 /* Handle open failed - remove addition. */
7637 del_a_printer(printer->info_2->sharename);
7638 free_a_printer(&printer,2);
7639 ZERO_STRUCTP(handle);
7640 return WERR_ACCESS_DENIED;
7643 update_c_setprinter(false);
7644 free_a_printer(&printer,2);
7649 /****************************************************************
7650 _spoolss_AddPrinterEx
7651 ****************************************************************/
7653 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7654 struct spoolss_AddPrinterEx *r)
7656 switch (r->in.info_ctr->level) {
7658 /* we don't handle yet */
7659 /* but I know what to do ... */
7660 return WERR_UNKNOWN_LEVEL;
7662 return spoolss_addprinterex_level_2(p, r->in.server,
7664 r->in.devmode_ctr->devmode,
7665 r->in.secdesc_ctr->sd,
7666 r->in.userlevel_ctr,
7669 return WERR_UNKNOWN_LEVEL;
7673 /****************************************************************
7675 ****************************************************************/
7677 WERROR _spoolss_AddPrinter(pipes_struct *p,
7678 struct spoolss_AddPrinter *r)
7680 struct spoolss_AddPrinterEx a;
7681 struct spoolss_UserLevelCtr userlevel_ctr;
7683 ZERO_STRUCT(userlevel_ctr);
7685 userlevel_ctr.level = 1;
7687 a.in.server = r->in.server;
7688 a.in.info_ctr = r->in.info_ctr;
7689 a.in.devmode_ctr = r->in.devmode_ctr;
7690 a.in.secdesc_ctr = r->in.secdesc_ctr;
7691 a.in.userlevel_ctr = &userlevel_ctr;
7692 a.out.handle = r->out.handle;
7694 return _spoolss_AddPrinterEx(p, &a);
7697 /****************************************************************
7698 _spoolss_AddPrinterDriver
7699 ****************************************************************/
7701 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7702 struct spoolss_AddPrinterDriver *r)
7704 uint32_t level = r->in.info_ctr->level;
7705 struct spoolss_AddDriverInfoCtr *info = r->in.info_ctr;
7706 WERROR err = WERR_OK;
7707 NT_PRINTER_DRIVER_INFO_LEVEL driver;
7708 const char *driver_name = NULL;
7712 switch (p->hdr_req.opnum) {
7713 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7714 fn = "_spoolss_AddPrinterDriver";
7716 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7717 fn = "_spoolss_AddPrinterDriverEx";
7720 return WERR_INVALID_PARAM;
7725 if (level != 3 && level != 6) {
7726 /* Clever hack from Martin Zielinski <mz@seh.de>
7727 * to allow downgrade from level 8 (Vista).
7729 DEBUG(0,("%s: level %d not yet implemented\n", fn, level));
7730 return WERR_UNKNOWN_LEVEL;
7733 ZERO_STRUCT(driver);
7735 if (!convert_printer_driver_info(info, &driver, level)) {
7740 DEBUG(5,("Cleaning driver's information\n"));
7741 err = clean_up_driver_struct(p, driver, level);
7742 if (!W_ERROR_IS_OK(err))
7745 DEBUG(5,("Moving driver to final destination\n"));
7746 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, driver, level,
7751 if (add_a_printer_driver(driver, level)!=0) {
7752 err = WERR_ACCESS_DENIED;
7758 driver_name = driver.info_3->name ? driver.info_3->name : "";
7761 driver_name = driver.info_6->name ? driver.info_6->name : "";
7766 * I think this is where he DrvUpgradePrinter() hook would be
7767 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7768 * server. Right now, we just need to send ourselves a message
7769 * to update each printer bound to this driver. --jerry
7772 if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7773 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7778 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7779 * decide if the driver init data should be deleted. The rules are:
7780 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7781 * 2) delete init data only if there is no 2k/Xp driver
7782 * 3) always delete init data
7783 * The generalized rule is always use init data from the highest order driver.
7784 * It is necessary to follow the driver install by an initialization step to
7785 * finish off this process.
7788 version = driver.info_3->cversion;
7789 else if (level == 6)
7790 version = driver.info_6->version;
7795 * 9x printer driver - never delete init data
7798 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7803 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7804 * there is no 2k/Xp driver init data for this driver name.
7808 NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7810 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7812 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7814 if (!del_driver_init(driver_name))
7815 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7819 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7821 free_a_printer_driver(driver1,3);
7822 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7829 * 2k or Xp printer driver - always delete init data
7832 if (!del_driver_init(driver_name))
7833 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7838 DEBUG(0,("%s: invalid level=%d\n", fn, level));
7844 free_a_printer_driver(driver, level);
7848 /****************************************************************
7849 _spoolss_AddPrinterDriverEx
7850 ****************************************************************/
7852 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7853 struct spoolss_AddPrinterDriverEx *r)
7855 struct spoolss_AddPrinterDriver a;
7858 * we only support the semantics of AddPrinterDriver()
7859 * i.e. only copy files that are newer than existing ones
7862 if (r->in.flags != APD_COPY_NEW_FILES) {
7863 return WERR_ACCESS_DENIED;
7866 a.in.servername = r->in.servername;
7867 a.in.info_ctr = r->in.info_ctr;
7869 return _spoolss_AddPrinterDriver(p, &a);
7872 /****************************************************************************
7873 ****************************************************************************/
7875 struct _spoolss_paths {
7881 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7883 static const struct _spoolss_paths spoolss_paths[]= {
7884 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
7885 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
7888 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7889 const char *servername,
7890 const char *environment,
7894 const char *pservername = NULL;
7895 const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7896 const char *short_archi;
7900 /* environment may be empty */
7901 if (environment && strlen(environment)) {
7902 long_archi = environment;
7905 /* servername may be empty */
7906 if (servername && strlen(servername)) {
7907 pservername = canon_servername(servername);
7909 if (!is_myname_or_ipaddr(pservername)) {
7910 return WERR_INVALID_PARAM;
7914 if (!(short_archi = get_short_archi(long_archi))) {
7915 return WERR_INVALID_ENVIRONMENT;
7918 switch (component) {
7919 case SPOOLSS_PRTPROCS_PATH:
7920 case SPOOLSS_DRIVER_PATH:
7922 *path = talloc_asprintf(mem_ctx,
7925 spoolss_paths[component].share,
7928 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7929 SPOOLSS_DEFAULT_SERVER_PATH,
7930 spoolss_paths[component].dir,
7935 return WERR_INVALID_PARAM;
7945 /****************************************************************************
7946 ****************************************************************************/
7948 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7949 const char *servername,
7950 const char *environment,
7951 struct spoolss_DriverDirectoryInfo1 *r)
7956 werr = compose_spoolss_server_path(mem_ctx,
7959 SPOOLSS_DRIVER_PATH,
7961 if (!W_ERROR_IS_OK(werr)) {
7965 DEBUG(4,("printer driver directory: [%s]\n", path));
7967 r->directory_name = path;
7972 /****************************************************************
7973 _spoolss_GetPrinterDriverDirectory
7974 ****************************************************************/
7976 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7977 struct spoolss_GetPrinterDriverDirectory *r)
7981 /* that's an [in out] buffer */
7983 if (!r->in.buffer && (r->in.offered != 0)) {
7984 return WERR_INVALID_PARAM;
7987 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7992 /* r->in.level is ignored */
7994 werror = getprinterdriverdir_level_1(p->mem_ctx,
7997 &r->out.info->info1);
7998 if (!W_ERROR_IS_OK(werror)) {
7999 TALLOC_FREE(r->out.info);
8003 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
8004 r->out.info, r->in.level);
8005 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8007 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8010 /****************************************************************
8011 _spoolss_EnumPrinterData
8012 ****************************************************************/
8014 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
8015 struct spoolss_EnumPrinterData *r)
8017 NT_PRINTER_INFO_LEVEL *printer = NULL;
8018 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8021 struct regval_blob *val = NULL;
8022 NT_PRINTER_DATA *p_data;
8023 int i, key_index, num_values;
8026 *r->out.value_needed = 0;
8027 *r->out.type = REG_NONE;
8028 *r->out.data_needed = 0;
8030 DEBUG(5,("_spoolss_EnumPrinterData\n"));
8033 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
8034 OUR_HANDLE(r->in.handle)));
8038 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8042 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8043 if (!W_ERROR_IS_OK(result)) {
8047 p_data = printer->info_2->data;
8048 key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
8053 * The NT machine wants to know the biggest size of value and data
8055 * cf: MSDN EnumPrinterData remark section
8058 if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
8060 uint32_t biggest_valuesize = 0;
8061 uint32_t biggest_datasize = 0;
8063 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8065 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
8067 for ( i=0; i<num_values; i++ )
8069 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
8071 name_length = strlen(val->valuename);
8072 if ( strlen(val->valuename) > biggest_valuesize )
8073 biggest_valuesize = name_length;
8075 if ( val->size > biggest_datasize )
8076 biggest_datasize = val->size;
8078 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8082 /* the value is an UNICODE string but real_value_size is the length
8083 in bytes including the trailing 0 */
8085 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8086 *r->out.data_needed = biggest_datasize;
8088 DEBUG(6,("final values: [%d], [%d]\n",
8089 *r->out.value_needed, *r->out.data_needed));
8095 * the value len is wrong in NT sp3
8096 * that's the number of bytes not the number of unicode chars
8099 if (key_index != -1) {
8100 val = regval_ctr_specific_value(p_data->keys[key_index].values,
8106 /* out_value should default to "" or else NT4 has
8107 problems unmarshalling the response */
8109 if (r->in.value_offered) {
8110 *r->out.value_needed = 1;
8111 r->out.value_name = talloc_strdup(r, "");
8112 if (!r->out.value_name) {
8113 result = WERR_NOMEM;
8117 r->out.value_name = NULL;
8118 *r->out.value_needed = 0;
8121 /* the data is counted in bytes */
8123 *r->out.data_needed = r->in.data_offered;
8125 result = WERR_NO_MORE_ITEMS;
8129 * - counted in bytes in the request
8130 * - counted in UNICODE chars in the max reply
8131 * - counted in bytes in the real size
8133 * take a pause *before* coding not *during* coding
8137 if (r->in.value_offered) {
8138 r->out.value_name = talloc_strdup(r, regval_name(val));
8139 if (!r->out.value_name) {
8140 result = WERR_NOMEM;
8143 *r->out.value_needed = strlen_m(regval_name(val));
8145 r->out.value_name = NULL;
8146 *r->out.value_needed = 0;
8151 *r->out.type = regval_type(val);
8153 /* data - counted in bytes */
8155 if (r->out.data && regval_size(val)) {
8156 memcpy(r->out.data, regval_data_p(val), regval_size(val));
8159 *r->out.data_needed = regval_size(val);
8163 free_a_printer(&printer, 2);
8167 /****************************************************************
8168 _spoolss_SetPrinterData
8169 ****************************************************************/
8171 WERROR _spoolss_SetPrinterData(pipes_struct *p,
8172 struct spoolss_SetPrinterData *r)
8174 NT_PRINTER_INFO_LEVEL *printer = NULL;
8176 WERROR result = WERR_OK;
8177 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8180 DEBUG(5,("_spoolss_SetPrinterData\n"));
8183 DEBUG(2,("_spoolss_SetPrinterData: Invalid handle (%s:%u:%u).\n",
8184 OUR_HANDLE(r->in.handle)));
8188 if (Printer->printer_type == SPLHND_SERVER) {
8189 DEBUG(10,("_spoolss_SetPrinterData: "
8190 "Not implemented for server handles yet\n"));
8191 return WERR_INVALID_PARAM;
8194 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8199 * Access check : NT returns "access denied" if you make a
8200 * SetPrinterData call without the necessary privildge.
8201 * we were originally returning OK if nothing changed
8202 * which made Win2k issue **a lot** of SetPrinterData
8203 * when connecting to a printer --jerry
8206 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8207 DEBUG(3,("_spoolss_SetPrinterData: "
8208 "change denied by handle access permissions\n"));
8209 result = WERR_ACCESS_DENIED;
8213 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8214 if (!W_ERROR_IS_OK(result)) {
8218 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8219 r->in.type, &r->in.data);
8220 if (!W_ERROR_IS_OK(result)) {
8225 * When client side code sets a magic printer data key, detect it and save
8226 * the current printer data and the magic key's data (its the DEVMODE) for
8227 * future printer/driver initializations.
8229 if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8230 /* Set devmode and printer initialization info */
8231 result = save_driver_init(printer, 2, blob.data, blob.length);
8233 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8238 result = set_printer_dataex(printer, SPOOL_PRINTERDATA_KEY,
8239 r->in.value_name, r->in.type,
8240 blob.data, blob.length);
8241 if (W_ERROR_IS_OK(result)) {
8242 result = mod_a_printer(printer, 2);
8246 free_a_printer(&printer, 2);
8251 /****************************************************************
8252 _spoolss_ResetPrinter
8253 ****************************************************************/
8255 WERROR _spoolss_ResetPrinter(pipes_struct *p,
8256 struct spoolss_ResetPrinter *r)
8258 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8261 DEBUG(5,("_spoolss_ResetPrinter\n"));
8264 * All we do is to check to see if the handle and queue is valid.
8265 * This call really doesn't mean anything to us because we only
8266 * support RAW printing. --jerry
8270 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8271 OUR_HANDLE(r->in.handle)));
8275 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8279 /* blindly return success */
8283 /****************************************************************
8284 _spoolss_DeletePrinterData
8285 ****************************************************************/
8287 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
8288 struct spoolss_DeletePrinterData *r)
8290 NT_PRINTER_INFO_LEVEL *printer = NULL;
8292 WERROR status = WERR_OK;
8293 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8295 DEBUG(5,("_spoolss_DeletePrinterData\n"));
8298 DEBUG(2,("_spoolss_DeletePrinterData: Invalid handle (%s:%u:%u).\n",
8299 OUR_HANDLE(r->in.handle)));
8303 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8306 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8307 DEBUG(3, ("_spoolss_DeletePrinterData: "
8308 "printer properties change denied by handle\n"));
8309 return WERR_ACCESS_DENIED;
8312 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8313 if (!W_ERROR_IS_OK(status))
8316 if (!r->in.value_name) {
8317 free_a_printer(&printer, 2);
8321 status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY,
8324 if ( W_ERROR_IS_OK(status) )
8325 mod_a_printer( printer, 2 );
8327 free_a_printer(&printer, 2);
8332 /****************************************************************
8334 ****************************************************************/
8336 WERROR _spoolss_AddForm(pipes_struct *p,
8337 struct spoolss_AddForm *r)
8339 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8340 nt_forms_struct tmpForm;
8342 WERROR status = WERR_OK;
8343 NT_PRINTER_INFO_LEVEL *printer = NULL;
8344 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8347 nt_forms_struct *list=NULL;
8348 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8350 DEBUG(5,("_spoolss_AddForm\n"));
8353 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8354 OUR_HANDLE(r->in.handle)));
8359 /* forms can be added on printer of on the print server handle */
8361 if ( Printer->printer_type == SPLHND_PRINTER )
8363 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8366 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8367 if (!W_ERROR_IS_OK(status))
8371 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8372 and not a printer admin, then fail */
8374 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8375 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8376 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8378 p->server_info->ptok,
8379 lp_printer_admin(snum))) {
8380 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8381 return WERR_ACCESS_DENIED;
8384 /* can't add if builtin */
8386 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8387 status = WERR_FILE_EXISTS;
8391 count = get_ntforms(&list);
8393 if(!add_a_form(&list, form, &count)) {
8394 status = WERR_NOMEM;
8399 write_ntforms(&list, count);
8403 * ChangeID must always be set if this is a printer
8406 if ( Printer->printer_type == SPLHND_PRINTER )
8407 status = mod_a_printer(printer, 2);
8411 free_a_printer(&printer, 2);
8417 /****************************************************************
8419 ****************************************************************/
8421 WERROR _spoolss_DeleteForm(pipes_struct *p,
8422 struct spoolss_DeleteForm *r)
8424 const char *form_name = r->in.form_name;
8425 nt_forms_struct tmpForm;
8427 nt_forms_struct *list=NULL;
8428 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8430 WERROR status = WERR_OK;
8431 NT_PRINTER_INFO_LEVEL *printer = NULL;
8432 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8435 DEBUG(5,("_spoolss_DeleteForm\n"));
8438 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8439 OUR_HANDLE(r->in.handle)));
8443 /* forms can be deleted on printer of on the print server handle */
8445 if ( Printer->printer_type == SPLHND_PRINTER )
8447 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8450 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8451 if (!W_ERROR_IS_OK(status))
8455 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8456 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8457 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8459 p->server_info->ptok,
8460 lp_printer_admin(snum))) {
8461 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8462 return WERR_ACCESS_DENIED;
8466 /* can't delete if builtin */
8468 if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8469 status = WERR_INVALID_PARAM;
8473 count = get_ntforms(&list);
8476 ret = delete_a_form(&list, form_name, &count, &status);
8483 * ChangeID must always be set if this is a printer
8486 if ( Printer->printer_type == SPLHND_PRINTER )
8487 status = mod_a_printer(printer, 2);
8491 free_a_printer(&printer, 2);
8497 /****************************************************************
8499 ****************************************************************/
8501 WERROR _spoolss_SetForm(pipes_struct *p,
8502 struct spoolss_SetForm *r)
8504 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8505 nt_forms_struct tmpForm;
8507 WERROR status = WERR_OK;
8508 NT_PRINTER_INFO_LEVEL *printer = NULL;
8509 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8512 nt_forms_struct *list=NULL;
8513 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8515 DEBUG(5,("_spoolss_SetForm\n"));
8518 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8519 OUR_HANDLE(r->in.handle)));
8523 /* forms can be modified on printer of on the print server handle */
8525 if ( Printer->printer_type == SPLHND_PRINTER )
8527 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8530 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8531 if (!W_ERROR_IS_OK(status))
8535 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8536 and not a printer admin, then fail */
8538 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8539 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8540 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8542 p->server_info->ptok,
8543 lp_printer_admin(snum))) {
8544 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8545 return WERR_ACCESS_DENIED;
8548 /* can't set if builtin */
8549 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8550 status = WERR_INVALID_PARAM;
8554 count = get_ntforms(&list);
8555 update_a_form(&list, form, count);
8557 write_ntforms(&list, count);
8561 * ChangeID must always be set if this is a printer
8564 if ( Printer->printer_type == SPLHND_PRINTER )
8565 status = mod_a_printer(printer, 2);
8570 free_a_printer(&printer, 2);
8576 /****************************************************************************
8577 fill_print_processor1
8578 ****************************************************************************/
8580 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8581 struct spoolss_PrintProcessorInfo1 *r,
8582 const char *print_processor_name)
8584 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8585 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8590 /****************************************************************************
8591 enumprintprocessors level 1.
8592 ****************************************************************************/
8594 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8595 union spoolss_PrintProcessorInfo **info_p,
8598 union spoolss_PrintProcessorInfo *info;
8601 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8602 W_ERROR_HAVE_NO_MEMORY(info);
8606 result = fill_print_processor1(info, &info[0].info1, "winprint");
8607 if (!W_ERROR_IS_OK(result)) {
8612 if (!W_ERROR_IS_OK(result)) {
8623 /****************************************************************
8624 _spoolss_EnumPrintProcessors
8625 ****************************************************************/
8627 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8628 struct spoolss_EnumPrintProcessors *r)
8632 /* that's an [in out] buffer */
8634 if (!r->in.buffer && (r->in.offered != 0)) {
8635 return WERR_INVALID_PARAM;
8638 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8641 * Enumerate the print processors ...
8643 * Just reply with "winprint", to keep NT happy
8644 * and I can use my nice printer checker.
8649 *r->out.info = NULL;
8651 switch (r->in.level) {
8653 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8657 return WERR_UNKNOWN_LEVEL;
8660 if (!W_ERROR_IS_OK(result)) {
8664 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8665 spoolss_EnumPrintProcessors, NULL,
8666 *r->out.info, r->in.level,
8668 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8669 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8671 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8674 /****************************************************************************
8675 fill_printprocdatatype1
8676 ****************************************************************************/
8678 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8679 struct spoolss_PrintProcDataTypesInfo1 *r,
8680 const char *name_array)
8682 r->name_array = talloc_strdup(mem_ctx, name_array);
8683 W_ERROR_HAVE_NO_MEMORY(r->name_array);
8688 /****************************************************************************
8689 enumprintprocdatatypes level 1.
8690 ****************************************************************************/
8692 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8693 union spoolss_PrintProcDataTypesInfo **info_p,
8697 union spoolss_PrintProcDataTypesInfo *info;
8699 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8700 W_ERROR_HAVE_NO_MEMORY(info);
8704 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8705 if (!W_ERROR_IS_OK(result)) {
8710 if (!W_ERROR_IS_OK(result)) {
8721 /****************************************************************
8722 _spoolss_EnumPrintProcDataTypes
8723 ****************************************************************/
8725 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8726 struct spoolss_EnumPrintProcDataTypes *r)
8730 /* that's an [in out] buffer */
8732 if (!r->in.buffer && (r->in.offered != 0)) {
8733 return WERR_INVALID_PARAM;
8736 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8740 *r->out.info = NULL;
8742 switch (r->in.level) {
8744 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8748 return WERR_UNKNOWN_LEVEL;
8751 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8752 spoolss_EnumPrintProcDataTypes, NULL,
8753 *r->out.info, r->in.level,
8755 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8756 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8758 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8761 /****************************************************************************
8763 ****************************************************************************/
8765 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8766 struct spoolss_MonitorInfo1 *r,
8767 const char *monitor_name)
8769 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8770 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8775 /****************************************************************************
8777 ****************************************************************************/
8779 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8780 struct spoolss_MonitorInfo2 *r,
8781 const char *monitor_name,
8782 const char *environment,
8783 const char *dll_name)
8785 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8786 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8787 r->environment = talloc_strdup(mem_ctx, environment);
8788 W_ERROR_HAVE_NO_MEMORY(r->environment);
8789 r->dll_name = talloc_strdup(mem_ctx, dll_name);
8790 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8795 /****************************************************************************
8796 enumprintmonitors level 1.
8797 ****************************************************************************/
8799 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8800 union spoolss_MonitorInfo **info_p,
8803 union spoolss_MonitorInfo *info;
8804 WERROR result = WERR_OK;
8806 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8807 W_ERROR_HAVE_NO_MEMORY(info);
8811 result = fill_monitor_1(info, &info[0].info1,
8813 if (!W_ERROR_IS_OK(result)) {
8817 result = fill_monitor_1(info, &info[1].info1,
8819 if (!W_ERROR_IS_OK(result)) {
8824 if (!W_ERROR_IS_OK(result)) {
8835 /****************************************************************************
8836 enumprintmonitors level 2.
8837 ****************************************************************************/
8839 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8840 union spoolss_MonitorInfo **info_p,
8843 union spoolss_MonitorInfo *info;
8844 WERROR result = WERR_OK;
8846 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8847 W_ERROR_HAVE_NO_MEMORY(info);
8851 result = fill_monitor_2(info, &info[0].info2,
8853 "Windows NT X86", /* FIXME */
8855 if (!W_ERROR_IS_OK(result)) {
8859 result = fill_monitor_2(info, &info[1].info2,
8861 "Windows NT X86", /* FIXME */
8863 if (!W_ERROR_IS_OK(result)) {
8868 if (!W_ERROR_IS_OK(result)) {
8879 /****************************************************************
8880 _spoolss_EnumMonitors
8881 ****************************************************************/
8883 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8884 struct spoolss_EnumMonitors *r)
8888 /* that's an [in out] buffer */
8890 if (!r->in.buffer && (r->in.offered != 0)) {
8891 return WERR_INVALID_PARAM;
8894 DEBUG(5,("_spoolss_EnumMonitors\n"));
8897 * Enumerate the print monitors ...
8899 * Just reply with "Local Port", to keep NT happy
8900 * and I can use my nice printer checker.
8905 *r->out.info = NULL;
8907 switch (r->in.level) {
8909 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8913 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8917 return WERR_UNKNOWN_LEVEL;
8920 if (!W_ERROR_IS_OK(result)) {
8924 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8925 spoolss_EnumMonitors, NULL,
8926 *r->out.info, r->in.level,
8928 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8929 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8931 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8934 /****************************************************************************
8935 ****************************************************************************/
8937 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8938 const print_queue_struct *queue,
8939 int count, int snum,
8940 const NT_PRINTER_INFO_LEVEL *ntprinter,
8942 struct spoolss_JobInfo1 *r)
8947 for (i=0; i<count && found == false; i++) {
8948 if (queue[i].job == (int)jobid) {
8953 if (found == false) {
8954 /* NT treats not found as bad param... yet another bad choice */
8955 return WERR_INVALID_PARAM;
8958 return fill_job_info1(mem_ctx,
8966 /****************************************************************************
8967 ****************************************************************************/
8969 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8970 const print_queue_struct *queue,
8971 int count, int snum,
8972 const NT_PRINTER_INFO_LEVEL *ntprinter,
8974 struct spoolss_JobInfo2 *r)
8978 struct spoolss_DeviceMode *devmode;
8979 NT_DEVICEMODE *nt_devmode;
8982 for (i=0; i<count && found == false; i++) {
8983 if (queue[i].job == (int)jobid) {
8988 if (found == false) {
8989 /* NT treats not found as bad param... yet another bad
8991 return WERR_INVALID_PARAM;
8995 * if the print job does not have a DEVMODE associated with it,
8996 * just use the one for the printer. A NULL devicemode is not
8997 * a failure condition
9000 nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
9002 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
9003 W_ERROR_HAVE_NO_MEMORY(devmode);
9004 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
9005 if (!W_ERROR_IS_OK(result)) {
9009 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
9010 W_ERROR_HAVE_NO_MEMORY(devmode);
9013 return fill_job_info2(mem_ctx,
9022 /****************************************************************
9024 ****************************************************************/
9026 WERROR _spoolss_GetJob(pipes_struct *p,
9027 struct spoolss_GetJob *r)
9029 WERROR result = WERR_OK;
9030 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
9033 print_queue_struct *queue = NULL;
9034 print_status_struct prt_status;
9036 /* that's an [in out] buffer */
9038 if (!r->in.buffer && (r->in.offered != 0)) {
9039 return WERR_INVALID_PARAM;
9042 DEBUG(5,("_spoolss_GetJob\n"));
9046 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9050 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
9051 if (!W_ERROR_IS_OK(result)) {
9055 count = print_queue_status(snum, &queue, &prt_status);
9057 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
9058 count, prt_status.status, prt_status.message));
9060 switch (r->in.level) {
9062 result = getjob_level_1(p->mem_ctx,
9063 queue, count, snum, ntprinter,
9064 r->in.job_id, &r->out.info->info1);
9067 result = getjob_level_2(p->mem_ctx,
9068 queue, count, snum, ntprinter,
9069 r->in.job_id, &r->out.info->info2);
9072 result = WERR_UNKNOWN_LEVEL;
9077 free_a_printer(&ntprinter, 2);
9079 if (!W_ERROR_IS_OK(result)) {
9080 TALLOC_FREE(r->out.info);
9084 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
9085 r->out.info, r->in.level);
9086 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9088 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9091 /****************************************************************
9092 _spoolss_GetPrinterDataEx
9094 From MSDN documentation of GetPrinterDataEx: pass request
9095 to GetPrinterData if key is "PrinterDriverData".
9096 ****************************************************************/
9098 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
9099 struct spoolss_GetPrinterDataEx *r)
9102 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9103 struct regval_blob *val = NULL;
9104 NT_PRINTER_INFO_LEVEL *printer = NULL;
9106 WERROR result = WERR_OK;
9108 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9110 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9111 r->in.key_name, r->in.value_name));
9113 /* in case of problem, return some default values */
9116 *r->out.type = REG_NONE;
9119 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9120 OUR_HANDLE(r->in.handle)));
9121 result = WERR_BADFID;
9125 /* Is the handle to a printer or to the server? */
9127 if (Printer->printer_type == SPLHND_SERVER) {
9128 DEBUG(10,("_spoolss_GetPrinterDataEx: "
9129 "Not implemented for server handles yet\n"));
9130 result = WERR_INVALID_PARAM;
9134 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9138 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9139 if (!W_ERROR_IS_OK(result)) {
9143 /* check to see if the keyname is valid */
9144 if (!strlen(r->in.key_name)) {
9145 result = WERR_INVALID_PARAM;
9149 if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
9150 DEBUG(4,("_spoolss_GetPrinterDataEx: "
9151 "Invalid keyname [%s]\n", r->in.key_name ));
9152 result = WERR_BADFILE;
9156 /* When given a new keyname, we should just create it */
9158 val = get_printer_data(printer->info_2,
9159 r->in.key_name, r->in.value_name);
9161 result = WERR_BADFILE;
9165 *r->out.needed = regval_size(val);
9167 if (*r->out.needed > r->in.offered) {
9168 result = WERR_MORE_DATA;
9172 *r->out.type = regval_type(val);
9174 memcpy(r->out.buffer, regval_data_p(val), regval_size(val));
9178 free_a_printer(&printer, 2);
9184 /****************************************************************
9185 _spoolss_SetPrinterDataEx
9186 ****************************************************************/
9188 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
9189 struct spoolss_SetPrinterDataEx *r)
9191 NT_PRINTER_INFO_LEVEL *printer = NULL;
9193 WERROR result = WERR_OK;
9194 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9197 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9199 /* From MSDN documentation of SetPrinterDataEx: pass request to
9200 SetPrinterData if key is "PrinterDriverData" */
9203 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9204 OUR_HANDLE(r->in.handle)));
9208 if (Printer->printer_type == SPLHND_SERVER) {
9209 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9210 "Not implemented for server handles yet\n"));
9211 return WERR_INVALID_PARAM;
9214 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9219 * Access check : NT returns "access denied" if you make a
9220 * SetPrinterData call without the necessary privildge.
9221 * we were originally returning OK if nothing changed
9222 * which made Win2k issue **a lot** of SetPrinterData
9223 * when connecting to a printer --jerry
9226 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9227 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9228 "change denied by handle access permissions\n"));
9229 return WERR_ACCESS_DENIED;
9232 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9233 if (!W_ERROR_IS_OK(result)) {
9237 /* check for OID in valuename */
9239 oid_string = strchr(r->in.value_name, ',');
9245 /* save the registry data */
9247 result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
9248 r->in.type, r->in.buffer, r->in.offered);
9250 if (W_ERROR_IS_OK(result)) {
9251 /* save the OID if one was specified */
9253 char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
9254 r->in.key_name, SPOOL_OID_KEY);
9256 result = WERR_NOMEM;
9261 * I'm not checking the status here on purpose. Don't know
9262 * if this is right, but I'm returning the status from the
9263 * previous set_printer_dataex() call. I have no idea if
9264 * this is right. --jerry
9267 set_printer_dataex(printer, str, r->in.value_name,
9268 REG_SZ, (uint8_t *)oid_string,
9269 strlen(oid_string)+1);
9272 result = mod_a_printer(printer, 2);
9276 free_a_printer(&printer, 2);
9281 /****************************************************************
9282 _spoolss_DeletePrinterDataEx
9283 ****************************************************************/
9285 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
9286 struct spoolss_DeletePrinterDataEx *r)
9288 NT_PRINTER_INFO_LEVEL *printer = NULL;
9290 WERROR status = WERR_OK;
9291 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9293 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9296 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9297 "Invalid handle (%s:%u:%u).\n",
9298 OUR_HANDLE(r->in.handle)));
9302 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9305 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9306 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9307 "printer properties change denied by handle\n"));
9308 return WERR_ACCESS_DENIED;
9311 if (!r->in.value_name || !r->in.key_name) {
9315 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9316 if (!W_ERROR_IS_OK(status))
9319 status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
9321 if ( W_ERROR_IS_OK(status) )
9322 mod_a_printer( printer, 2 );
9324 free_a_printer(&printer, 2);
9329 /****************************************************************
9330 _spoolss_EnumPrinterKey
9331 ****************************************************************/
9333 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
9334 struct spoolss_EnumPrinterKey *r)
9336 fstring *keynames = NULL;
9338 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9339 NT_PRINTER_DATA *data;
9340 NT_PRINTER_INFO_LEVEL *printer = NULL;
9342 WERROR result = WERR_BADFILE;
9344 const char **array = NULL;
9347 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9350 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9351 OUR_HANDLE(r->in.handle)));
9355 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9359 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9360 if (!W_ERROR_IS_OK(result)) {
9364 /* get the list of subkey names */
9366 data = printer->info_2->data;
9368 num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
9369 if (num_keys == -1) {
9370 result = WERR_BADFILE;
9376 array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 1);
9378 result = WERR_NOMEM;
9382 for (i=0; i < num_keys; i++) {
9383 array[i] = talloc_strdup(array, keynames[i]);
9385 result = WERR_NOMEM;
9389 *r->out.needed += strlen_m_term(keynames[i]) * 2;
9392 if (r->in.offered < *r->out.needed) {
9393 result = WERR_MORE_DATA;
9399 *r->out.key_buffer = array;
9402 if (!W_ERROR_IS_OK(result)) {
9404 ZERO_STRUCTP(r->out.key_buffer);
9407 free_a_printer(&printer, 2);
9408 SAFE_FREE(keynames);
9413 /****************************************************************
9414 _spoolss_DeletePrinterKey
9415 ****************************************************************/
9417 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9418 struct spoolss_DeletePrinterKey *r)
9420 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9421 NT_PRINTER_INFO_LEVEL *printer = NULL;
9425 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9428 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9429 OUR_HANDLE(r->in.handle)));
9433 /* if keyname == NULL, return error */
9435 if ( !r->in.key_name )
9436 return WERR_INVALID_PARAM;
9438 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9441 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9442 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9443 "printer properties change denied by handle\n"));
9444 return WERR_ACCESS_DENIED;
9447 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9448 if (!W_ERROR_IS_OK(status))
9451 /* delete the key and all subneys */
9453 status = delete_all_printer_data( printer->info_2, r->in.key_name );
9455 if ( W_ERROR_IS_OK(status) )
9456 status = mod_a_printer(printer, 2);
9458 free_a_printer( &printer, 2 );
9463 /****************************************************************
9464 ****************************************************************/
9466 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9467 struct regval_blob *v,
9468 struct spoolss_PrinterEnumValues *r)
9472 r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
9473 W_ERROR_HAVE_NO_MEMORY(r->data);
9475 r->value_name = talloc_strdup(mem_ctx, regval_name(v));
9476 W_ERROR_HAVE_NO_MEMORY(r->value_name);
9478 r->type = regval_type(v);
9479 r->data_length = regval_size(v);
9481 if (r->data_length) {
9482 DATA_BLOB blob = data_blob_const(regval_data_p(v),
9484 result = pull_spoolss_PrinterData(mem_ctx, &blob,
9487 if (!W_ERROR_IS_OK(result)) {
9495 /****************************************************************
9496 _spoolss_EnumPrinterDataEx
9497 ****************************************************************/
9499 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9500 struct spoolss_EnumPrinterDataEx *r)
9503 NT_PRINTER_INFO_LEVEL *printer = NULL;
9504 struct spoolss_PrinterEnumValues *info = NULL;
9505 NT_PRINTER_DATA *p_data;
9506 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9512 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9516 *r->out.info = NULL;
9519 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9520 OUR_HANDLE(r->in.handle)));
9525 * first check for a keyname of NULL or "". Win2k seems to send
9526 * this a lot and we should send back WERR_INVALID_PARAM
9527 * no need to spend time looking up the printer in this case.
9531 if (!strlen(r->in.key_name)) {
9532 result = WERR_INVALID_PARAM;
9536 /* get the printer off of disk */
9538 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9542 ZERO_STRUCT(printer);
9543 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9544 if (!W_ERROR_IS_OK(result)) {
9548 /* now look for a match on the key name */
9550 p_data = printer->info_2->data;
9552 key_index = lookup_printerkey(p_data, r->in.key_name);
9553 if (key_index == -1) {
9554 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9556 result = WERR_INVALID_PARAM;
9560 /* allocate the memory for the array of pointers -- if necessary */
9562 count = regval_ctr_numvals(p_data->keys[key_index].values);
9564 result = WERR_OK; /* ??? */
9568 info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9569 struct spoolss_PrinterEnumValues,
9572 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9573 result = WERR_NOMEM;
9578 * loop through all params and build the array to pass
9579 * back to the client
9582 for (i=0; i < count; i++) {
9584 struct regval_blob *val;
9586 /* lookup the registry value */
9588 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9590 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9594 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9595 if (!W_ERROR_IS_OK(result)) {
9600 #if 0 /* FIXME - gd */
9601 /* housekeeping information in the reply */
9603 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9604 * the hand marshalled container size is a multiple
9605 * of 4 bytes for RPC alignment.
9609 needed += 4-(needed % 4);
9612 *r->out.count = count;
9613 *r->out.info = info;
9618 free_a_printer(&printer, 2);
9621 if (!W_ERROR_IS_OK(result)) {
9625 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9626 spoolss_EnumPrinterDataEx, NULL,
9629 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9630 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9632 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9635 /****************************************************************************
9636 ****************************************************************************/
9638 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9639 const char *servername,
9640 const char *environment,
9641 struct spoolss_PrintProcessorDirectoryInfo1 *r)
9646 werr = compose_spoolss_server_path(mem_ctx,
9649 SPOOLSS_PRTPROCS_PATH,
9651 if (!W_ERROR_IS_OK(werr)) {
9655 DEBUG(4,("print processor directory: [%s]\n", path));
9657 r->directory_name = path;
9662 /****************************************************************
9663 _spoolss_GetPrintProcessorDirectory
9664 ****************************************************************/
9666 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9667 struct spoolss_GetPrintProcessorDirectory *r)
9671 /* that's an [in out] buffer */
9673 if (!r->in.buffer && (r->in.offered != 0)) {
9674 return WERR_INVALID_PARAM;
9677 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9682 /* r->in.level is ignored */
9684 result = getprintprocessordirectory_level_1(p->mem_ctx,
9687 &r->out.info->info1);
9688 if (!W_ERROR_IS_OK(result)) {
9689 TALLOC_FREE(r->out.info);
9693 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9694 r->out.info, r->in.level);
9695 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9697 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9700 /*******************************************************************
9701 ********************************************************************/
9703 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9704 const char *dllname)
9706 enum ndr_err_code ndr_err;
9707 struct spoolss_MonitorUi ui;
9709 ui.dll_name = dllname;
9711 ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9712 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9713 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9714 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9716 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9719 /*******************************************************************
9720 Streams the monitor UI DLL name in UNICODE
9721 *******************************************************************/
9723 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9724 NT_USER_TOKEN *token, DATA_BLOB *in,
9725 DATA_BLOB *out, uint32_t *needed)
9727 const char *dllname = "tcpmonui.dll";
9729 *needed = (strlen(dllname)+1) * 2;
9731 if (out->length < *needed) {
9732 return WERR_INSUFFICIENT_BUFFER;
9735 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9742 /*******************************************************************
9743 ********************************************************************/
9745 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9746 struct spoolss_PortData1 *port1,
9747 const DATA_BLOB *buf)
9749 enum ndr_err_code ndr_err;
9750 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9751 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9752 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9753 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9755 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9758 /*******************************************************************
9759 ********************************************************************/
9761 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9762 struct spoolss_PortData2 *port2,
9763 const DATA_BLOB *buf)
9765 enum ndr_err_code ndr_err;
9766 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9767 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9768 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9769 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9771 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9774 /*******************************************************************
9775 Create a new TCP/IP port
9776 *******************************************************************/
9778 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9779 NT_USER_TOKEN *token, DATA_BLOB *in,
9780 DATA_BLOB *out, uint32_t *needed)
9782 struct spoolss_PortData1 port1;
9783 struct spoolss_PortData2 port2;
9784 char *device_uri = NULL;
9787 const char *portname;
9788 const char *hostaddress;
9790 uint32_t port_number;
9793 /* peek for spoolss_PortData version */
9795 if (!in || (in->length < (128 + 4))) {
9796 return WERR_GENERAL_FAILURE;
9799 version = IVAL(in->data, 128);
9805 if (!pull_port_data_1(mem_ctx, &port1, in)) {
9809 portname = port1.portname;
9810 hostaddress = port1.hostaddress;
9811 queue = port1.queue;
9812 protocol = port1.protocol;
9813 port_number = port1.port_number;
9819 if (!pull_port_data_2(mem_ctx, &port2, in)) {
9823 portname = port2.portname;
9824 hostaddress = port2.hostaddress;
9825 queue = port2.queue;
9826 protocol = port2.protocol;
9827 port_number = port2.port_number;
9831 DEBUG(1,("xcvtcp_addport: "
9832 "unknown version of port_data: %d\n", version));
9833 return WERR_UNKNOWN_PORT;
9836 /* create the device URI and call the add_port_hook() */
9839 case PROTOCOL_RAWTCP_TYPE:
9840 device_uri = talloc_asprintf(mem_ctx,
9841 "socket://%s:%d/", hostaddress,
9845 case PROTOCOL_LPR_TYPE:
9846 device_uri = talloc_asprintf(mem_ctx,
9847 "lpr://%s/%s", hostaddress, queue );
9851 return WERR_UNKNOWN_PORT;
9858 return add_port_hook(mem_ctx, token, portname, device_uri);
9861 /*******************************************************************
9862 *******************************************************************/
9864 struct xcv_api_table xcvtcp_cmds[] = {
9865 { "MonitorUI", xcvtcp_monitorui },
9866 { "AddPort", xcvtcp_addport},
9870 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9871 NT_USER_TOKEN *token, const char *command,
9878 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9880 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9881 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9882 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9885 return WERR_BADFUNC;
9888 /*******************************************************************
9889 *******************************************************************/
9890 #if 0 /* don't support management using the "Local Port" monitor */
9892 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9893 NT_USER_TOKEN *token, DATA_BLOB *in,
9894 DATA_BLOB *out, uint32_t *needed)
9896 const char *dllname = "localui.dll";
9898 *needed = (strlen(dllname)+1) * 2;
9900 if (out->length < *needed) {
9901 return WERR_INSUFFICIENT_BUFFER;
9904 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9911 /*******************************************************************
9912 *******************************************************************/
9914 struct xcv_api_table xcvlocal_cmds[] = {
9915 { "MonitorUI", xcvlocal_monitorui },
9919 struct xcv_api_table xcvlocal_cmds[] = {
9926 /*******************************************************************
9927 *******************************************************************/
9929 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9930 NT_USER_TOKEN *token, const char *command,
9931 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9936 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9938 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9939 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9940 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9942 return WERR_BADFUNC;
9945 /****************************************************************
9947 ****************************************************************/
9949 WERROR _spoolss_XcvData(pipes_struct *p,
9950 struct spoolss_XcvData *r)
9952 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9953 DATA_BLOB out_data = data_blob_null;
9957 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9958 OUR_HANDLE(r->in.handle)));
9962 /* Has to be a handle to the TCP/IP port monitor */
9964 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9965 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9969 /* requires administrative access to the server */
9971 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9972 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9973 return WERR_ACCESS_DENIED;
9976 /* Allocate the outgoing buffer */
9978 if (r->in.out_data_size) {
9979 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9980 if (out_data.data == NULL) {
9985 switch ( Printer->printer_type ) {
9986 case SPLHND_PORTMON_TCP:
9987 werror = process_xcvtcp_command(p->mem_ctx,
9988 p->server_info->ptok,
9989 r->in.function_name,
9990 &r->in.in_data, &out_data,
9993 case SPLHND_PORTMON_LOCAL:
9994 werror = process_xcvlocal_command(p->mem_ctx,
9995 p->server_info->ptok,
9996 r->in.function_name,
9997 &r->in.in_data, &out_data,
10001 werror = WERR_INVALID_PRINT_MONITOR;
10004 if (!W_ERROR_IS_OK(werror)) {
10008 *r->out.status_code = 0;
10010 memcpy(r->out.out_data, out_data.data, out_data.length);
10015 /****************************************************************
10016 _spoolss_AddPrintProcessor
10017 ****************************************************************/
10019 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
10020 struct spoolss_AddPrintProcessor *r)
10022 /* for now, just indicate success and ignore the add. We'll
10023 automatically set the winprint processor for printer
10024 entries later. Used to debug the LexMark Optra S 1855 PCL
10030 /****************************************************************
10032 ****************************************************************/
10034 WERROR _spoolss_AddPort(pipes_struct *p,
10035 struct spoolss_AddPort *r)
10037 /* do what w2k3 does */
10039 return WERR_NOT_SUPPORTED;
10042 /****************************************************************
10043 _spoolss_GetPrinterDriver
10044 ****************************************************************/
10046 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
10047 struct spoolss_GetPrinterDriver *r)
10049 p->rng_fault_state = true;
10050 return WERR_NOT_SUPPORTED;
10053 /****************************************************************
10054 _spoolss_ReadPrinter
10055 ****************************************************************/
10057 WERROR _spoolss_ReadPrinter(pipes_struct *p,
10058 struct spoolss_ReadPrinter *r)
10060 p->rng_fault_state = true;
10061 return WERR_NOT_SUPPORTED;
10064 /****************************************************************
10065 _spoolss_WaitForPrinterChange
10066 ****************************************************************/
10068 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
10069 struct spoolss_WaitForPrinterChange *r)
10071 p->rng_fault_state = true;
10072 return WERR_NOT_SUPPORTED;
10075 /****************************************************************
10076 _spoolss_ConfigurePort
10077 ****************************************************************/
10079 WERROR _spoolss_ConfigurePort(pipes_struct *p,
10080 struct spoolss_ConfigurePort *r)
10082 p->rng_fault_state = true;
10083 return WERR_NOT_SUPPORTED;
10086 /****************************************************************
10087 _spoolss_DeletePort
10088 ****************************************************************/
10090 WERROR _spoolss_DeletePort(pipes_struct *p,
10091 struct spoolss_DeletePort *r)
10093 p->rng_fault_state = true;
10094 return WERR_NOT_SUPPORTED;
10097 /****************************************************************
10098 _spoolss_CreatePrinterIC
10099 ****************************************************************/
10101 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
10102 struct spoolss_CreatePrinterIC *r)
10104 p->rng_fault_state = true;
10105 return WERR_NOT_SUPPORTED;
10108 /****************************************************************
10109 _spoolss_PlayGDIScriptOnPrinterIC
10110 ****************************************************************/
10112 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
10113 struct spoolss_PlayGDIScriptOnPrinterIC *r)
10115 p->rng_fault_state = true;
10116 return WERR_NOT_SUPPORTED;
10119 /****************************************************************
10120 _spoolss_DeletePrinterIC
10121 ****************************************************************/
10123 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
10124 struct spoolss_DeletePrinterIC *r)
10126 p->rng_fault_state = true;
10127 return WERR_NOT_SUPPORTED;
10130 /****************************************************************
10131 _spoolss_AddPrinterConnection
10132 ****************************************************************/
10134 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
10135 struct spoolss_AddPrinterConnection *r)
10137 p->rng_fault_state = true;
10138 return WERR_NOT_SUPPORTED;
10141 /****************************************************************
10142 _spoolss_DeletePrinterConnection
10143 ****************************************************************/
10145 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
10146 struct spoolss_DeletePrinterConnection *r)
10148 p->rng_fault_state = true;
10149 return WERR_NOT_SUPPORTED;
10152 /****************************************************************
10153 _spoolss_PrinterMessageBox
10154 ****************************************************************/
10156 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
10157 struct spoolss_PrinterMessageBox *r)
10159 p->rng_fault_state = true;
10160 return WERR_NOT_SUPPORTED;
10163 /****************************************************************
10164 _spoolss_AddMonitor
10165 ****************************************************************/
10167 WERROR _spoolss_AddMonitor(pipes_struct *p,
10168 struct spoolss_AddMonitor *r)
10170 p->rng_fault_state = true;
10171 return WERR_NOT_SUPPORTED;
10174 /****************************************************************
10175 _spoolss_DeleteMonitor
10176 ****************************************************************/
10178 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
10179 struct spoolss_DeleteMonitor *r)
10181 p->rng_fault_state = true;
10182 return WERR_NOT_SUPPORTED;
10185 /****************************************************************
10186 _spoolss_DeletePrintProcessor
10187 ****************************************************************/
10189 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
10190 struct spoolss_DeletePrintProcessor *r)
10192 p->rng_fault_state = true;
10193 return WERR_NOT_SUPPORTED;
10196 /****************************************************************
10197 _spoolss_AddPrintProvidor
10198 ****************************************************************/
10200 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
10201 struct spoolss_AddPrintProvidor *r)
10203 p->rng_fault_state = true;
10204 return WERR_NOT_SUPPORTED;
10207 /****************************************************************
10208 _spoolss_DeletePrintProvidor
10209 ****************************************************************/
10211 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
10212 struct spoolss_DeletePrintProvidor *r)
10214 p->rng_fault_state = true;
10215 return WERR_NOT_SUPPORTED;
10218 /****************************************************************
10219 _spoolss_FindFirstPrinterChangeNotification
10220 ****************************************************************/
10222 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
10223 struct spoolss_FindFirstPrinterChangeNotification *r)
10225 p->rng_fault_state = true;
10226 return WERR_NOT_SUPPORTED;
10229 /****************************************************************
10230 _spoolss_FindNextPrinterChangeNotification
10231 ****************************************************************/
10233 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
10234 struct spoolss_FindNextPrinterChangeNotification *r)
10236 p->rng_fault_state = true;
10237 return WERR_NOT_SUPPORTED;
10240 /****************************************************************
10241 _spoolss_RouterFindFirstPrinterChangeNotificationOld
10242 ****************************************************************/
10244 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
10245 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10247 p->rng_fault_state = true;
10248 return WERR_NOT_SUPPORTED;
10251 /****************************************************************
10252 _spoolss_ReplyOpenPrinter
10253 ****************************************************************/
10255 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
10256 struct spoolss_ReplyOpenPrinter *r)
10258 p->rng_fault_state = true;
10259 return WERR_NOT_SUPPORTED;
10262 /****************************************************************
10263 _spoolss_RouterReplyPrinter
10264 ****************************************************************/
10266 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
10267 struct spoolss_RouterReplyPrinter *r)
10269 p->rng_fault_state = true;
10270 return WERR_NOT_SUPPORTED;
10273 /****************************************************************
10274 _spoolss_ReplyClosePrinter
10275 ****************************************************************/
10277 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
10278 struct spoolss_ReplyClosePrinter *r)
10280 p->rng_fault_state = true;
10281 return WERR_NOT_SUPPORTED;
10284 /****************************************************************
10286 ****************************************************************/
10288 WERROR _spoolss_AddPortEx(pipes_struct *p,
10289 struct spoolss_AddPortEx *r)
10291 p->rng_fault_state = true;
10292 return WERR_NOT_SUPPORTED;
10295 /****************************************************************
10296 _spoolss_RouterFindFirstPrinterChangeNotification
10297 ****************************************************************/
10299 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
10300 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10302 p->rng_fault_state = true;
10303 return WERR_NOT_SUPPORTED;
10306 /****************************************************************
10307 _spoolss_SpoolerInit
10308 ****************************************************************/
10310 WERROR _spoolss_SpoolerInit(pipes_struct *p,
10311 struct spoolss_SpoolerInit *r)
10313 p->rng_fault_state = true;
10314 return WERR_NOT_SUPPORTED;
10317 /****************************************************************
10318 _spoolss_ResetPrinterEx
10319 ****************************************************************/
10321 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
10322 struct spoolss_ResetPrinterEx *r)
10324 p->rng_fault_state = true;
10325 return WERR_NOT_SUPPORTED;
10328 /****************************************************************
10329 _spoolss_RouterReplyPrinterEx
10330 ****************************************************************/
10332 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
10333 struct spoolss_RouterReplyPrinterEx *r)
10335 p->rng_fault_state = true;
10336 return WERR_NOT_SUPPORTED;
10339 /****************************************************************
10341 ****************************************************************/
10343 WERROR _spoolss_44(pipes_struct *p,
10344 struct spoolss_44 *r)
10346 p->rng_fault_state = true;
10347 return WERR_NOT_SUPPORTED;
10350 /****************************************************************
10352 ****************************************************************/
10354 WERROR _spoolss_47(pipes_struct *p,
10355 struct spoolss_47 *r)
10357 p->rng_fault_state = true;
10358 return WERR_NOT_SUPPORTED;
10361 /****************************************************************
10363 ****************************************************************/
10365 WERROR _spoolss_4a(pipes_struct *p,
10366 struct spoolss_4a *r)
10368 p->rng_fault_state = true;
10369 return WERR_NOT_SUPPORTED;
10372 /****************************************************************
10374 ****************************************************************/
10376 WERROR _spoolss_4b(pipes_struct *p,
10377 struct spoolss_4b *r)
10379 p->rng_fault_state = true;
10380 return WERR_NOT_SUPPORTED;
10383 /****************************************************************
10385 ****************************************************************/
10387 WERROR _spoolss_4c(pipes_struct *p,
10388 struct spoolss_4c *r)
10390 p->rng_fault_state = true;
10391 return WERR_NOT_SUPPORTED;
10394 /****************************************************************
10396 ****************************************************************/
10398 WERROR _spoolss_53(pipes_struct *p,
10399 struct spoolss_53 *r)
10401 p->rng_fault_state = true;
10402 return WERR_NOT_SUPPORTED;
10405 /****************************************************************
10407 ****************************************************************/
10409 WERROR _spoolss_55(pipes_struct *p,
10410 struct spoolss_55 *r)
10412 p->rng_fault_state = true;
10413 return WERR_NOT_SUPPORTED;
10416 /****************************************************************
10418 ****************************************************************/
10420 WERROR _spoolss_56(pipes_struct *p,
10421 struct spoolss_56 *r)
10423 p->rng_fault_state = true;
10424 return WERR_NOT_SUPPORTED;
10427 /****************************************************************
10429 ****************************************************************/
10431 WERROR _spoolss_57(pipes_struct *p,
10432 struct spoolss_57 *r)
10434 p->rng_fault_state = true;
10435 return WERR_NOT_SUPPORTED;
10438 /****************************************************************
10440 ****************************************************************/
10442 WERROR _spoolss_5a(pipes_struct *p,
10443 struct spoolss_5a *r)
10445 p->rng_fault_state = true;
10446 return WERR_NOT_SUPPORTED;
10449 /****************************************************************
10451 ****************************************************************/
10453 WERROR _spoolss_5b(pipes_struct *p,
10454 struct spoolss_5b *r)
10456 p->rng_fault_state = true;
10457 return WERR_NOT_SUPPORTED;
10460 /****************************************************************
10462 ****************************************************************/
10464 WERROR _spoolss_5c(pipes_struct *p,
10465 struct spoolss_5c *r)
10467 p->rng_fault_state = true;
10468 return WERR_NOT_SUPPORTED;
10471 /****************************************************************
10473 ****************************************************************/
10475 WERROR _spoolss_5d(pipes_struct *p,
10476 struct spoolss_5d *r)
10478 p->rng_fault_state = true;
10479 return WERR_NOT_SUPPORTED;
10482 /****************************************************************
10484 ****************************************************************/
10486 WERROR _spoolss_5e(pipes_struct *p,
10487 struct spoolss_5e *r)
10489 p->rng_fault_state = true;
10490 return WERR_NOT_SUPPORTED;
10493 /****************************************************************
10495 ****************************************************************/
10497 WERROR _spoolss_5f(pipes_struct *p,
10498 struct spoolss_5f *r)
10500 p->rng_fault_state = true;
10501 return WERR_NOT_SUPPORTED;