?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Missed one check on the memcpy for bug #7063.
[Samba/gbeck.git] / source3 / rpc_server / srv_spoolss_nt.c
blob7a4c9c92638312517ee221446acd4d04b59b2cba
1 /*
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.
11 *
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.
16 *
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.
21 *
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/>.
24 */
25
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. */
28
29 #include "includes.h"
30 #include "../librpc/gen_ndr/srv_spoolss.h"
31 #include "../librpc/gen_ndr/cli_spoolss.h"
32
33 /* macros stolen from s4 spoolss server */
34 #define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
35 ((info)?ndr_size_##fn(info, level, ic, 0):0)
36
37 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,ic,info,level,count) \
38 ((info)?ndr_size_##fn##_info(mem_ctx, ic, level, count, info):0)
39
40 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,ic,info,count) \
41 ((info)?ndr_size_##fn##_info(mem_ctx, ic, count, info):0)
42
43 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
44
45
46 extern userdom_struct current_user_info;
47
48 #undef DBGC_CLASS
49 #define DBGC_CLASS DBGC_RPC_SRV
50
51 #ifndef MAX_OPEN_PRINTER_EXS
52 #define MAX_OPEN_PRINTER_EXS 50
53 #endif
54
55 #define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
56 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
57
58 static Printer_entry *printers_list;
59
60 typedef struct _counter_printer_0 {
61 struct _counter_printer_0 *next;
62 struct _counter_printer_0 *prev;
63
64 int snum;
65 uint32_t counter;
66 } counter_printer_0;
67
68 static counter_printer_0 *counter_list;
69
70 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
71 static uint32_t smb_connections = 0;
72
73
74 /* in printing/nt_printing.c */
75
76 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
77
78 /* API table for Xcv Monitor functions */
79
80 struct xcv_api_table {
81 const char *name;
82 WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
83 };
84
85 /********************************************************************
86 * Canonicalize servername.
87 ********************************************************************/
88
89 static const char *canon_servername(const char *servername)
90 {
91 const char *pservername = servername;
92 while (*pservername == '\\') {
93 pservername++;
94 }
95 return pservername;
96 }
97
98 /* translate between internal status numbers and NT status numbers */
99 static int nt_printj_status(int v)
100 {
101 switch (v) {
102 case LPQ_QUEUED:
103 return 0;
104 case LPQ_PAUSED:
105 return JOB_STATUS_PAUSED;
106 case LPQ_SPOOLING:
107 return JOB_STATUS_SPOOLING;
108 case LPQ_PRINTING:
109 return JOB_STATUS_PRINTING;
110 case LPQ_ERROR:
111 return JOB_STATUS_ERROR;
112 case LPQ_DELETING:
113 return JOB_STATUS_DELETING;
114 case LPQ_OFFLINE:
115 return JOB_STATUS_OFFLINE;
116 case LPQ_PAPEROUT:
117 return JOB_STATUS_PAPEROUT;
118 case LPQ_PRINTED:
119 return JOB_STATUS_PRINTED;
120 case LPQ_DELETED:
121 return JOB_STATUS_DELETED;
122 case LPQ_BLOCKED:
123 return JOB_STATUS_BLOCKED_DEVQ;
124 case LPQ_USER_INTERVENTION:
125 return JOB_STATUS_USER_INTERVENTION;
126 }
127 return 0;
128 }
129
130 static int nt_printq_status(int v)
131 {
132 switch (v) {
133 case LPQ_PAUSED:
134 return PRINTER_STATUS_PAUSED;
135 case LPQ_QUEUED:
136 case LPQ_SPOOLING:
137 case LPQ_PRINTING:
138 return 0;
139 }
140 return 0;
141 }
142
143 /***************************************************************************
144 Disconnect from the client
145 ****************************************************************************/
146
147 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
148 {
149 WERROR result;
150 NTSTATUS status;
151
152 /*
153 * Tell the specific printing tdb we no longer want messages for this printer
154 * by deregistering our PID.
155 */
156
157 if (!print_notify_deregister_pid(snum))
158 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
159
160 /* weird if the test succeds !!! */
161 if (smb_connections==0) {
162 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
163 return;
164 }
165
166 status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
167 handle,
168 &result);
169 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
170 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
171 win_errstr(result)));
172
173 /* if it's the last connection, deconnect the IPC$ share */
174 if (smb_connections==1) {
175
176 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
177 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
178
179 messaging_deregister(smbd_messaging_context(),
180 MSG_PRINTER_NOTIFY2, NULL);
181
182 /* Tell the connections db we're no longer interested in
183 * printer notify messages. */
184
185 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
186 }
187
188 smb_connections--;
189 }
190
191 /****************************************************************************
192 Functions to free a printer entry datastruct.
193 ****************************************************************************/
194
195 static int printer_entry_destructor(Printer_entry *Printer)
196 {
197 if (Printer->notify.client_connected == true) {
198 int snum = -1;
199
200 if ( Printer->printer_type == SPLHND_SERVER) {
201 snum = -1;
202 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
203 } else if (Printer->printer_type == SPLHND_PRINTER) {
204 snum = print_queue_snum(Printer->sharename);
205 if (snum != -1)
206 srv_spoolss_replycloseprinter(snum,
207 &Printer->notify.client_hnd);
208 }
209 }
210
211 Printer->notify.flags=0;
212 Printer->notify.options=0;
213 Printer->notify.localmachine[0]='\0';
214 Printer->notify.printerlocal=0;
215 TALLOC_FREE(Printer->notify.option);
216 Printer->notify.client_connected = false;
217
218 free_nt_devicemode( &Printer->nt_devmode );
219 free_a_printer( &Printer->printer_info, 2 );
220
221 /* Remove from the internal list. */
222 DLIST_REMOVE(printers_list, Printer);
223 return 0;
224 }
225
226 /****************************************************************************
227 find printer index by handle
228 ****************************************************************************/
229
230 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
231 struct policy_handle *hnd)
232 {
233 Printer_entry *find_printer = NULL;
234
235 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
236 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
237 return NULL;
238 }
239
240 return find_printer;
241 }
242
243 /****************************************************************************
244 Close printer index by handle.
245 ****************************************************************************/
246
247 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
248 {
249 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
250
251 if (!Printer) {
252 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
253 OUR_HANDLE(hnd)));
254 return false;
255 }
256
257 close_policy_hnd(p, hnd);
258
259 return true;
260 }
261
262 /****************************************************************************
263 Delete a printer given a handle.
264 ****************************************************************************/
265
266 static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename)
267 {
268 char *cmd = lp_deleteprinter_cmd();
269 char *command = NULL;
270 int ret;
271 SE_PRIV se_printop = SE_PRINT_OPERATOR;
272 bool is_print_op = false;
273
274 /* can't fail if we don't try */
275
276 if ( !*cmd )
277 return WERR_OK;
278
279 command = talloc_asprintf(ctx,
280 "%s \"%s\"",
281 cmd, sharename);
282 if (!command) {
283 return WERR_NOMEM;
284 }
285 if ( token )
286 is_print_op = user_has_privileges( token, &se_printop );
287
288 DEBUG(10,("Running [%s]\n", command));
289
290 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
291
292 if ( is_print_op )
293 become_root();
294
295 if ( (ret = smbrun(command, NULL)) == 0 ) {
296 /* Tell everyone we updated smb.conf. */
297 message_send_all(smbd_messaging_context(),
298 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
299 }
300
301 if ( is_print_op )
302 unbecome_root();
303
304 /********** END SePrintOperatorPrivlege BLOCK **********/
305
306 DEBUGADD(10,("returned [%d]\n", ret));
307
308 TALLOC_FREE(command);
309
310 if (ret != 0)
311 return WERR_BADFID; /* What to return here? */
312
313 /* go ahead and re-read the services immediately */
314 become_root();
315 reload_services(false);
316 unbecome_root();
317
318 if ( lp_servicenumber( sharename ) < 0 )
319 return WERR_ACCESS_DENIED;
320
321 return WERR_OK;
322 }
323
324 /****************************************************************************
325 Delete a printer given a handle.
326 ****************************************************************************/
327
328 static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
329 {
330 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
331
332 if (!Printer) {
333 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
334 OUR_HANDLE(hnd)));
335 return WERR_BADFID;
336 }
337
338 /*
339 * It turns out that Windows allows delete printer on a handle
340 * opened by an admin user, then used on a pipe handle created
341 * by an anonymous user..... but they're working on security.... riiight !
342 * JRA.
343 */
344
345 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
346 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
347 return WERR_ACCESS_DENIED;
348 }
349
350 /* this does not need a become root since the access check has been
351 done on the handle already */
352
353 if (del_a_printer( Printer->sharename ) != 0) {
354 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
355 return WERR_BADFID;
356 }
357
358 return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
359 Printer->sharename );
360 }
361
362 /****************************************************************************
363 Return the snum of a printer corresponding to an handle.
364 ****************************************************************************/
365
366 static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
367 int *number, struct share_params **params)
368 {
369 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
370
371 if (!Printer) {
372 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
373 OUR_HANDLE(hnd)));
374 return false;
375 }
376
377 switch (Printer->printer_type) {
378 case SPLHND_PRINTER:
379 DEBUG(4,("short name:%s\n", Printer->sharename));
380 *number = print_queue_snum(Printer->sharename);
381 return (*number != -1);
382 case SPLHND_SERVER:
383 return false;
384 default:
385 return false;
386 }
387 }
388
389 /****************************************************************************
390 Set printer handle type.
391 Check if it's \\server or \\server\printer
392 ****************************************************************************/
393
394 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
395 {
396 DEBUG(3,("Setting printer type=%s\n", handlename));
397
398 if ( strlen(handlename) < 3 ) {
399 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
400 return false;
401 }
402
403 /* it's a print server */
404 if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
405 DEBUGADD(4,("Printer is a print server\n"));
406 Printer->printer_type = SPLHND_SERVER;
407 }
408 /* it's a printer (set_printer_hnd_name() will handle port monitors */
409 else {
410 DEBUGADD(4,("Printer is a printer\n"));
411 Printer->printer_type = SPLHND_PRINTER;
412 }
413
414 return true;
415 }
416
417 /****************************************************************************
418 Set printer handle name.. Accept names like \\server, \\server\printer,
419 \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port" See
420 the MSDN docs regarding OpenPrinter() for details on the XcvData() and
421 XcvDataPort() interface.
422 ****************************************************************************/
423
424 static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
425 {
426 int snum;
427 int n_services=lp_numservices();
428 char *aprinter, *printername;
429 const char *servername;
430 fstring sname;
431 bool found = false;
432 NT_PRINTER_INFO_LEVEL *printer = NULL;
433 WERROR result;
434
435 DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
436 (unsigned long)strlen(handlename)));
437
438 aprinter = CONST_DISCARD(char *, handlename);
439 if ( *handlename == '\\' ) {
440 servername = canon_servername(handlename);
441 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
442 *aprinter = '\0';
443 aprinter++;
444 }
445 } else {
446 servername = global_myname();
447 }
448
449 /* save the servername to fill in replies on this handle */
450
451 if ( !is_myname_or_ipaddr( servername ) )
452 return false;
453
454 fstrcpy( Printer->servername, servername );
455
456 if ( Printer->printer_type == SPLHND_SERVER )
457 return true;
458
459 if ( Printer->printer_type != SPLHND_PRINTER )
460 return false;
461
462 DEBUGADD(5, ("searching for [%s]\n", aprinter ));
463
464 /* check for the Port Monitor Interface */
465
466 if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
467 Printer->printer_type = SPLHND_PORTMON_TCP;
468 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
469 found = true;
470 }
471 else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
472 Printer->printer_type = SPLHND_PORTMON_LOCAL;
473 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
474 found = true;
475 }
476
477 /* Search all sharenames first as this is easier than pulling
478 the printer_info_2 off of disk. Don't use find_service() since
479 that calls out to map_username() */
480
481 /* do another loop to look for printernames */
482
483 for (snum=0; !found && snum<n_services; snum++) {
484
485 /* no point going on if this is not a printer */
486
487 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
488 continue;
489
490 fstrcpy(sname, lp_servicename(snum));
491 if ( strequal( aprinter, sname ) ) {
492 found = true;
493 break;
494 }
495
496 /* no point looking up the printer object if
497 we aren't allowing printername != sharename */
498
499 if ( lp_force_printername(snum) )
500 continue;
501
502 fstrcpy(sname, lp_servicename(snum));
503
504 printer = NULL;
505
506 /* This call doesn't fill in the location or comment from
507 * a CUPS server for efficiency with large numbers of printers.
508 * JRA.
509 */
510
511 result = get_a_printer_search( NULL, &printer, 2, sname );
512 if ( !W_ERROR_IS_OK(result) ) {
513 DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
514 sname, win_errstr(result)));
515 continue;
516 }
517
518 /* printername is always returned as \\server\printername */
519 if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
520 DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
521 printer->info_2->printername));
522 free_a_printer( &printer, 2);
523 continue;
524 }
525
526 printername++;
527
528 if ( strequal(printername, aprinter) ) {
529 free_a_printer( &printer, 2);
530 found = true;
531 break;
532 }
533
534 DEBUGADD(10, ("printername: %s\n", printername));
535
536 free_a_printer( &printer, 2);
537 }
538
539 free_a_printer( &printer, 2);
540
541 if ( !found ) {
542 DEBUGADD(4,("Printer not found\n"));
543 return false;
544 }
545
546 DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
547
548 fstrcpy(Printer->sharename, sname);
549
550 return true;
551 }
552
553 /****************************************************************************
554 Find first available printer slot. creates a printer handle for you.
555 ****************************************************************************/
556
557 static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
558 const char *name, uint32_t access_granted)
559 {
560 Printer_entry *new_printer;
561
562 DEBUG(10,("open_printer_hnd: name [%s]\n", name));
563
564 new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
565 if (new_printer == NULL) {
566 return false;
567 }
568 talloc_set_destructor(new_printer, printer_entry_destructor);
569
570 if (!create_policy_hnd(p, hnd, new_printer)) {
571 TALLOC_FREE(new_printer);
572 return false;
573 }
574
575 /* Add to the internal list. */
576 DLIST_ADD(printers_list, new_printer);
577
578 new_printer->notify.option=NULL;
579
580 if (!set_printer_hnd_printertype(new_printer, name)) {
581 close_printer_handle(p, hnd);
582 return false;
583 }
584
585 if (!set_printer_hnd_name(new_printer, name)) {
586 close_printer_handle(p, hnd);
587 return false;
588 }
589
590 new_printer->access_granted = access_granted;
591
592 DEBUG(5, ("%d printer handles active\n",
593 (int)num_pipe_handles(p->pipe_handles)));
594
595 return true;
596 }
597
598 /***************************************************************************
599 check to see if the client motify handle is monitoring the notification
600 given by (notify_type, notify_field).
601 **************************************************************************/
602
603 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
604 uint16_t notify_field)
605 {
606 return true;
607 }
608
609 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
610 uint16_t notify_field)
611 {
612 struct spoolss_NotifyOption *option = p->notify.option;
613 uint32_t i, j;
614
615 /*
616 * Flags should always be zero when the change notify
617 * is registered by the client's spooler. A user Win32 app
618 * might use the flags though instead of the NOTIFY_OPTION_INFO
619 * --jerry
620 */
621
622 if (!option) {
623 return false;
624 }
625
626 if (p->notify.flags)
627 return is_monitoring_event_flags(
628 p->notify.flags, notify_type, notify_field);
629
630 for (i = 0; i < option->count; i++) {
631
632 /* Check match for notify_type */
633
634 if (option->types[i].type != notify_type)
635 continue;
636
637 /* Check match for field */
638
639 for (j = 0; j < option->types[i].count; j++) {
640 if (option->types[i].fields[j].field == notify_field) {
641 return true;
642 }
643 }
644 }
645
646 DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
647 p->servername, p->sharename, notify_type, notify_field));
648
649 return false;
650 }
651
652 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
653 _data->data.integer[0] = _integer; \
654 _data->data.integer[1] = 0;
655
656
657 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
658 _data->data.string.string = talloc_strdup(mem_ctx, _p); \
659 if (!_data->data.string.string) {\
660 _data->data.string.size = 0; \
661 } \
662 _data->data.string.size = strlen_m_term(_p) * 2;
663
664 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
665 _data->data.devmode.devmode = _devmode;
666
667 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
668 _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
669 if (!_data->data.sd.sd) { \
670 _data->data.sd.sd_size = 0; \
671 } \
672 _data->data.sd.sd_size = _size;
673
674 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
675 struct tm *t,
676 const char **pp,
677 uint32_t *plen)
678 {
679 struct spoolss_Time st;
680 uint32_t len = 16;
681 char *p;
682
683 if (!init_systemtime(&st, t)) {
684 return;
685 }
686
687 p = talloc_array(mem_ctx, char, len);
688 if (!p) {
689 return;
690 }
691
692 /*
693 * Systemtime must be linearized as a set of UINT16's.
694 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
695 */
696
697 SSVAL(p, 0, st.year);
698 SSVAL(p, 2, st.month);
699 SSVAL(p, 4, st.day_of_week);
700 SSVAL(p, 6, st.day);
701 SSVAL(p, 8, st.hour);
702 SSVAL(p, 10, st.minute);
703 SSVAL(p, 12, st.second);
704 SSVAL(p, 14, st.millisecond);
705
706 *pp = p;
707 *plen = len;
708 }
709
710 /* Convert a notification message to a struct spoolss_Notify */
711
712 static void notify_one_value(struct spoolss_notify_msg *msg,
713 struct spoolss_Notify *data,
714 TALLOC_CTX *mem_ctx)
715 {
716 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
717 }
718
719 static void notify_string(struct spoolss_notify_msg *msg,
720 struct spoolss_Notify *data,
721 TALLOC_CTX *mem_ctx)
722 {
723 /* The length of the message includes the trailing \0 */
724
725 data->data.string.size = msg->len * 2;
726 data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
727 if (!data->data.string.string) {
728 data->data.string.size = 0;
729 return;
730 }
731 }
732
733 static void notify_system_time(struct spoolss_notify_msg *msg,
734 struct spoolss_Notify *data,
735 TALLOC_CTX *mem_ctx)
736 {
737 data->data.string.string = NULL;
738 data->data.string.size = 0;
739
740 if (msg->len != sizeof(time_t)) {
741 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
742 msg->len));
743 return;
744 }
745
746 init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
747 &data->data.string.string,
748 &data->data.string.size);
749 }
750
751 struct notify2_message_table {
752 const char *name;
753 void (*fn)(struct spoolss_notify_msg *msg,
754 struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
755 };
756
757 static struct notify2_message_table printer_notify_table[] = {
758 /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
759 /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
760 /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
761 /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
762 /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
763 /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
764 /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
765 /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
766 /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
767 /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
768 /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
769 /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
770 /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
771 /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
772 /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
773 /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
774 /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
775 /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
776 /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
777 };
778
779 static struct notify2_message_table job_notify_table[] = {
780 /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
781 /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
782 /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
783 /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
784 /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
785 /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
786 /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
787 /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
788 /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
789 /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
790 /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
791 /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
792 /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
793 /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
794 /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
795 /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
796 /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
797 /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
798 /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
799 /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
800 /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
801 /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
802 /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
803 /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
804 };
805
806
807 /***********************************************************************
808 Allocate talloc context for container object
809 **********************************************************************/
810
811 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
812 {
813 if ( !ctr )
814 return;
815
816 ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
817
818 return;
819 }
820
821 /***********************************************************************
822 release all allocated memory and zero out structure
823 **********************************************************************/
824
825 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
826 {
827 if ( !ctr )
828 return;
829
830 if ( ctr->ctx )
831 talloc_destroy(ctr->ctx);
832
833 ZERO_STRUCTP(ctr);
834
835 return;
836 }
837
838 /***********************************************************************
839 **********************************************************************/
840
841 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
842 {
843 if ( !ctr )
844 return NULL;
845
846 return ctr->ctx;
847 }
848
849 /***********************************************************************
850 **********************************************************************/
851
852 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
853 {
854 if ( !ctr || !ctr->msg_groups )
855 return NULL;
856
857 if ( idx >= ctr->num_groups )
858 return NULL;
859
860 return &ctr->msg_groups[idx];
861
862 }
863
864 /***********************************************************************
865 How many groups of change messages do we have ?
866 **********************************************************************/
867
868 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
869 {
870 if ( !ctr )
871 return 0;
872
873 return ctr->num_groups;
874 }
875
876 /***********************************************************************
877 Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
878 **********************************************************************/
879
880 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
881 {
882 SPOOLSS_NOTIFY_MSG_GROUP *groups = NULL;
883 SPOOLSS_NOTIFY_MSG_GROUP *msg_grp = NULL;
884 SPOOLSS_NOTIFY_MSG *msg_list = NULL;
885 int i, new_slot;
886
887 if ( !ctr || !msg )
888 return 0;
889
890 /* loop over all groups looking for a matching printer name */
891
892 for ( i=0; i<ctr->num_groups; i++ ) {
893 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
894 break;
895 }
896
897 /* add a new group? */
898
899 if ( i == ctr->num_groups ) {
900 ctr->num_groups++;
901
902 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
903 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
904 return 0;
905 }
906 ctr->msg_groups = groups;
907
908 /* clear the new entry and set the printer name */
909
910 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
911 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
912 }
913
914 /* add the change messages; 'i' is the correct index now regardless */
915
916 msg_grp = &ctr->msg_groups[i];
917
918 msg_grp->num_msgs++;
919
920 if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
921 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
922 return 0;
923 }
924 msg_grp->msgs = msg_list;
925
926 new_slot = msg_grp->num_msgs-1;
927 memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
928
929 /* need to allocate own copy of data */
930
931 if ( msg->len != 0 )
932 msg_grp->msgs[new_slot].notify.data = (char *)
933 TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
934
935 return ctr->num_groups;
936 }
937
938 /***********************************************************************
939 Send a change notication message on all handles which have a call
940 back registered
941 **********************************************************************/
942
943 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
944 {
945 Printer_entry *p;
946 TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
947 SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
948 SPOOLSS_NOTIFY_MSG *messages;
949 int sending_msg_count;
950
951 if ( !msg_group ) {
952 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
953 return;
954 }
955
956 messages = msg_group->msgs;
957
958 if ( !messages ) {
959 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
960 return;
961 }
962
963 DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
964
965 /* loop over all printers */
966
967 for (p = printers_list; p; p = p->next) {
968 struct spoolss_Notify *notifies;
969 uint32_t count = 0;
970 uint32_t id;
971 int i;
972
973 /* Is there notification on this handle? */
974
975 if ( !p->notify.client_connected )
976 continue;
977
978 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
979
980 /* For this printer? Print servers always receive
981 notifications. */
982
983 if ( ( p->printer_type == SPLHND_PRINTER ) &&
984 ( !strequal(msg_group->printername, p->sharename) ) )
985 continue;
986
987 DEBUG(10,("Our printer\n"));
988
989 /* allocate the max entries possible */
990
991 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
992 if (!notifies) {
993 return;
994 }
995
996 /* build the array of change notifications */
997
998 sending_msg_count = 0;
999
1000 for ( i=0; i<msg_group->num_msgs; i++ ) {
1001 SPOOLSS_NOTIFY_MSG *msg = &messages[i];
1002
1003 /* Are we monitoring this event? */
1004
1005 if (!is_monitoring_event(p, msg->type, msg->field))
1006 continue;
1007
1008 sending_msg_count++;
1009
1010
1011 DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1012 msg->type, msg->field, p->sharename));
1013
1014 /*
1015 * if the is a printer notification handle and not a job notification
1016 * type, then set the id to 0. Other wise just use what was specified
1017 * in the message.
1018 *
1019 * When registering change notification on a print server handle
1020 * we always need to send back the id (snum) matching the printer
1021 * for which the change took place. For change notify registered
1022 * on a printer handle, this does not matter and the id should be 0.
1023 *
1024 * --jerry
1025 */
1026
1027 if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1028 id = 0;
1029 else
1030 id = msg->id;
1031
1032
1033 /* Convert unix jobid to smb jobid */
1034
1035 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1036 id = sysjob_to_jobid(msg->id);
1037
1038 if (id == -1) {
1039 DEBUG(3, ("no such unix jobid %d\n", msg->id));
1040 goto done;
1041 }
1042 }
1043
1044 construct_info_data( &notifies[count], msg->type, msg->field, id );
1045
1046 switch(msg->type) {
1047 case PRINTER_NOTIFY_TYPE:
1048 if ( printer_notify_table[msg->field].fn )
1049 printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1050 break;
1051
1052 case JOB_NOTIFY_TYPE:
1053 if ( job_notify_table[msg->field].fn )
1054 job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1055 break;
1056
1057 default:
1058 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1059 goto done;
1060 }
1061
1062 count++;
1063 }
1064
1065 if ( sending_msg_count ) {
1066 NTSTATUS status;
1067 WERROR werr;
1068 union spoolss_ReplyPrinterInfo info;
1069 struct spoolss_NotifyInfo info0;
1070 uint32_t reply_result;
1071
1072 info0.version = 0x2;
1073 info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1074 info0.count = count;
1075 info0.notifies = notifies;
1076
1077 info.info0 = &info0;
1078
1079 status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1080 &p->notify.client_hnd,
1081 p->notify.change, /* color */
1082 p->notify.flags,
1083 &reply_result,
1084 0, /* reply_type, must be 0 */
1085 info,
1086 &werr);
1087 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1088 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1089 notify_cli_pipe->srv_name_slash,
1090 win_errstr(werr)));
1091 }
1092 switch (reply_result) {
1093 case 0:
1094 break;
1095 case PRINTER_NOTIFY_INFO_DISCARDED:
1096 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1097 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1098 break;
1099 default:
1100 break;
1101 }
1102 }
1103 }
1104
1105 done:
1106 DEBUG(8,("send_notify2_changes: Exit...\n"));
1107 return;
1108 }
1109
1110 /***********************************************************************
1111 **********************************************************************/
1112
1113 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1114 {
1115
1116 uint32_t tv_sec, tv_usec;
1117 size_t offset = 0;
1118
1119 /* Unpack message */
1120
1121 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1122 msg->printer);
1123
1124 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1125 &tv_sec, &tv_usec,
1126 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1127
1128 if (msg->len == 0)
1129 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1130 &msg->notify.value[0], &msg->notify.value[1]);
1131 else
1132 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1133 &msg->len, &msg->notify.data);
1134
1135 DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1136 msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1137
1138 tv->tv_sec = tv_sec;
1139 tv->tv_usec = tv_usec;
1140
1141 if (msg->len == 0)
1142 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1143 msg->notify.value[1]));
1144 else
1145 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1146
1147 return true;
1148 }
1149
1150 /********************************************************************
1151 Receive a notify2 message list
1152 ********************************************************************/
1153
1154 static void receive_notify2_message_list(struct messaging_context *msg,
1155 void *private_data,
1156 uint32_t msg_type,
1157 struct server_id server_id,
1158 DATA_BLOB *data)
1159 {
1160 size_t msg_count, i;
1161 char *buf = (char *)data->data;
1162 char *msg_ptr;
1163 size_t msg_len;
1164 SPOOLSS_NOTIFY_MSG notify;
1165 SPOOLSS_NOTIFY_MSG_CTR messages;
1166 int num_groups;
1167
1168 if (data->length < 4) {
1169 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1170 return;
1171 }
1172
1173 msg_count = IVAL(buf, 0);
1174 msg_ptr = buf + 4;
1175
1176 DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1177
1178 if (msg_count == 0) {
1179 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1180 return;
1181 }
1182
1183 /* initialize the container */
1184
1185 ZERO_STRUCT( messages );
1186 notify_msg_ctr_init( &messages );
1187
1188 /*
1189 * build message groups for each printer identified
1190 * in a change_notify msg. Remember that a PCN message
1191 * includes the handle returned for the srv_spoolss_replyopenprinter()
1192 * call. Therefore messages are grouped according to printer handle.
1193 */
1194
1195 for ( i=0; i<msg_count; i++ ) {
1196 struct timeval msg_tv;
1197
1198 if (msg_ptr + 4 - buf > data->length) {
1199 DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1200 return;
1201 }
1202
1203 msg_len = IVAL(msg_ptr,0);
1204 msg_ptr += 4;
1205
1206 if (msg_ptr + msg_len - buf > data->length) {
1207 DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1208 return;
1209 }
1210
1211 /* unpack messages */
1212
1213 ZERO_STRUCT( notify );
1214 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1215 msg_ptr += msg_len;
1216
1217 /* add to correct list in container */
1218
1219 notify_msg_ctr_addmsg( &messages, &notify );
1220
1221 /* free memory that might have been allocated by notify2_unpack_msg() */
1222
1223 if ( notify.len != 0 )
1224 SAFE_FREE( notify.notify.data );
1225 }
1226
1227 /* process each group of messages */
1228
1229 num_groups = notify_msg_ctr_numgroups( &messages );
1230 for ( i=0; i<num_groups; i++ )
1231 send_notify2_changes( &messages, i );
1232
1233
1234 /* cleanup */
1235
1236 DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1237 (uint32_t)msg_count ));
1238
1239 notify_msg_ctr_destroy( &messages );
1240
1241 return;
1242 }
1243
1244 /********************************************************************
1245 Send a message to ourself about new driver being installed
1246 so we can upgrade the information for each printer bound to this
1247 driver
1248 ********************************************************************/
1249
1250 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1251 {
1252 int len = strlen(drivername);
1253
1254 if (!len)
1255 return false;
1256
1257 DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1258 drivername));
1259
1260 messaging_send_buf(smbd_messaging_context(), procid_self(),
1261 MSG_PRINTER_DRVUPGRADE,
1262 (uint8_t *)drivername, len+1);
1263
1264 return true;
1265 }
1266
1267 /**********************************************************************
1268 callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1269 over all printers, upgrading ones as necessary
1270 **********************************************************************/
1271
1272 void do_drv_upgrade_printer(struct messaging_context *msg,
1273 void *private_data,
1274 uint32_t msg_type,
1275 struct server_id server_id,
1276 DATA_BLOB *data)
1277 {
1278 fstring drivername;
1279 int snum;
1280 int n_services = lp_numservices();
1281 size_t len;
1282
1283 len = MIN(data->length,sizeof(drivername)-1);
1284 strncpy(drivername, (const char *)data->data, len);
1285
1286 DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1287
1288 /* Iterate the printer list */
1289
1290 for (snum=0; snum<n_services; snum++)
1291 {
1292 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1293 {
1294 WERROR result;
1295 NT_PRINTER_INFO_LEVEL *printer = NULL;
1296
1297 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1298 if (!W_ERROR_IS_OK(result))
1299 continue;
1300
1301 if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1302 {
1303 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1304
1305 /* all we care about currently is the change_id */
1306
1307 result = mod_a_printer(printer, 2);
1308 if (!W_ERROR_IS_OK(result)) {
1309 DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1310 win_errstr(result)));
1311 }
1312 }
1313
1314 free_a_printer(&printer, 2);
1315 }
1316 }
1317
1318 /* all done */
1319 }
1320
1321 /********************************************************************
1322 Update the cache for all printq's with a registered client
1323 connection
1324 ********************************************************************/
1325
1326 void update_monitored_printq_cache( void )
1327 {
1328 Printer_entry *printer = printers_list;
1329 int snum;
1330
1331 /* loop through all printers and update the cache where
1332 client_connected == true */
1333 while ( printer )
1334 {
1335 if ( (printer->printer_type == SPLHND_PRINTER)
1336 && printer->notify.client_connected )
1337 {
1338 snum = print_queue_snum(printer->sharename);
1339 print_queue_status( snum, NULL, NULL );
1340 }
1341
1342 printer = printer->next;
1343 }
1344
1345 return;
1346 }
1347 /********************************************************************
1348 Send a message to ourself about new driver being installed
1349 so we can upgrade the information for each printer bound to this
1350 driver
1351 ********************************************************************/
1352
1353 static bool srv_spoolss_reset_printerdata(char* drivername)
1354 {
1355 int len = strlen(drivername);
1356
1357 if (!len)
1358 return false;
1359
1360 DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1361 drivername));
1362
1363 messaging_send_buf(smbd_messaging_context(), procid_self(),
1364 MSG_PRINTERDATA_INIT_RESET,
1365 (uint8_t *)drivername, len+1);
1366
1367 return true;
1368 }
1369
1370 /**********************************************************************
1371 callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1372 over all printers, resetting printer data as neessary
1373 **********************************************************************/
1374
1375 void reset_all_printerdata(struct messaging_context *msg,
1376 void *private_data,
1377 uint32_t msg_type,
1378 struct server_id server_id,
1379 DATA_BLOB *data)
1380 {
1381 fstring drivername;
1382 int snum;
1383 int n_services = lp_numservices();
1384 size_t len;
1385
1386 len = MIN( data->length, sizeof(drivername)-1 );
1387 strncpy( drivername, (const char *)data->data, len );
1388
1389 DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1390
1391 /* Iterate the printer list */
1392
1393 for ( snum=0; snum<n_services; snum++ )
1394 {
1395 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1396 {
1397 WERROR result;
1398 NT_PRINTER_INFO_LEVEL *printer = NULL;
1399
1400 result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1401 if ( !W_ERROR_IS_OK(result) )
1402 continue;
1403
1404 /*
1405 * if the printer is bound to the driver,
1406 * then reset to the new driver initdata
1407 */
1408
1409 if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1410 {
1411 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1412
1413 if ( !set_driver_init(printer, 2) ) {
1414 DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1415 printer->info_2->printername, printer->info_2->drivername));
1416 }
1417
1418 result = mod_a_printer( printer, 2 );
1419 if ( !W_ERROR_IS_OK(result) ) {
1420 DEBUG(3,("reset_all_printerdata: mod_a_printer() failed! (%s)\n",
1421 get_dos_error_msg(result)));
1422 }
1423 }
1424
1425 free_a_printer( &printer, 2 );
1426 }
1427 }
1428
1429 /* all done */
1430
1431 return;
1432 }
1433
1434 /****************************************************************
1435 _spoolss_OpenPrinter
1436 ****************************************************************/
1437
1438 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1439 struct spoolss_OpenPrinter *r)
1440 {
1441 struct spoolss_OpenPrinterEx e;
1442 WERROR werr;
1443
1444 ZERO_STRUCT(e.in.userlevel);
1445
1446 e.in.printername = r->in.printername;
1447 e.in.datatype = r->in.datatype;
1448 e.in.devmode_ctr = r->in.devmode_ctr;
1449 e.in.access_mask = r->in.access_mask;
1450 e.in.level = 0;
1451
1452 e.out.handle = r->out.handle;
1453
1454 werr = _spoolss_OpenPrinterEx(p, &e);
1455
1456 if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1457 /* OpenPrinterEx returns this for a bad
1458 * printer name. We must return WERR_INVALID_PRINTER_NAME
1459 * instead.
1460 */
1461 werr = WERR_INVALID_PRINTER_NAME;
1462 }
1463
1464 return werr;
1465 }
1466
1467 /********************************************************************
1468 ********************************************************************/
1469
1470 bool convert_devicemode(const char *printername,
1471 const struct spoolss_DeviceMode *devmode,
1472 NT_DEVICEMODE **pp_nt_devmode)
1473 {
1474 NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1475
1476 /*
1477 * Ensure nt_devmode is a valid pointer
1478 * as we will be overwriting it.
1479 */
1480
1481 if (nt_devmode == NULL) {
1482 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1483 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1484 return false;
1485 }
1486
1487 fstrcpy(nt_devmode->devicename, devmode->devicename);
1488 fstrcpy(nt_devmode->formname, devmode->formname);
1489
1490 nt_devmode->devicename[31] = '\0';
1491 nt_devmode->formname[31] = '\0';
1492
1493 nt_devmode->specversion = devmode->specversion;
1494 nt_devmode->driverversion = devmode->driverversion;
1495 nt_devmode->size = devmode->size;
1496 nt_devmode->fields = devmode->fields;
1497 nt_devmode->orientation = devmode->orientation;
1498 nt_devmode->papersize = devmode->papersize;
1499 nt_devmode->paperlength = devmode->paperlength;
1500 nt_devmode->paperwidth = devmode->paperwidth;
1501 nt_devmode->scale = devmode->scale;
1502 nt_devmode->copies = devmode->copies;
1503 nt_devmode->defaultsource = devmode->defaultsource;
1504 nt_devmode->printquality = devmode->printquality;
1505 nt_devmode->color = devmode->color;
1506 nt_devmode->duplex = devmode->duplex;
1507 nt_devmode->yresolution = devmode->yresolution;
1508 nt_devmode->ttoption = devmode->ttoption;
1509 nt_devmode->collate = devmode->collate;
1510
1511 nt_devmode->logpixels = devmode->logpixels;
1512 nt_devmode->bitsperpel = devmode->bitsperpel;
1513 nt_devmode->pelswidth = devmode->pelswidth;
1514 nt_devmode->pelsheight = devmode->pelsheight;
1515 nt_devmode->displayflags = devmode->displayflags;
1516 nt_devmode->displayfrequency = devmode->displayfrequency;
1517 nt_devmode->icmmethod = devmode->icmmethod;
1518 nt_devmode->icmintent = devmode->icmintent;
1519 nt_devmode->mediatype = devmode->mediatype;
1520 nt_devmode->dithertype = devmode->dithertype;
1521 nt_devmode->reserved1 = devmode->reserved1;
1522 nt_devmode->reserved2 = devmode->reserved2;
1523 nt_devmode->panningwidth = devmode->panningwidth;
1524 nt_devmode->panningheight = devmode->panningheight;
1525
1526 /*
1527 * Only change private and driverextra if the incoming devmode
1528 * has a new one. JRA.
1529 */
1530
1531 if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1532 SAFE_FREE(nt_devmode->nt_dev_private);
1533 nt_devmode->driverextra = devmode->__driverextra_length;
1534 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1535 return false;
1536 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1537 }
1538
1539 *pp_nt_devmode = nt_devmode;
1540
1541 return true;
1542 }
1543
1544 /****************************************************************
1545 _spoolss_OpenPrinterEx
1546 ****************************************************************/
1547
1548 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1549 struct spoolss_OpenPrinterEx *r)
1550 {
1551 int snum;
1552 Printer_entry *Printer=NULL;
1553
1554 if (!r->in.printername) {
1555 return WERR_INVALID_PARAM;
1556 }
1557
1558 /* some sanity check because you can open a printer or a print server */
1559 /* aka: \\server\printer or \\server */
1560
1561 DEBUGADD(3,("checking name: %s\n", r->in.printername));
1562
1563 if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1564 ZERO_STRUCTP(r->out.handle);
1565 return WERR_INVALID_PARAM;
1566 }
1567
1568 Printer = find_printer_index_by_hnd(p, r->out.handle);
1569 if ( !Printer ) {
1570 DEBUG(0,("_spoolss_OpenPrinterEx: logic error. Can't find printer "
1571 "handle we created for printer %s\n", r->in.printername));
1572 close_printer_handle(p, r->out.handle);
1573 ZERO_STRUCTP(r->out.handle);
1574 return WERR_INVALID_PARAM;
1575 }
1576
1577 /*
1578 * First case: the user is opening the print server:
1579 *
1580 * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1581 * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1582 *
1583 * Then both Win2k and WinNT clients try an OpenPrinterEx with
1584 * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1585 * or if the user is listed in the smb.conf printer admin parameter.
1586 *
1587 * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1588 * client view printer folder, but does not show the MSAPW.
1589 *
1590 * Note: this test needs code to check access rights here too. Jeremy
1591 * could you look at this?
1592 *
1593 * Second case: the user is opening a printer:
1594 * NT doesn't let us connect to a printer if the connecting user
1595 * doesn't have print permission.
1596 *
1597 * Third case: user is opening a Port Monitor
1598 * access checks same as opening a handle to the print server.
1599 */
1600
1601 switch (Printer->printer_type )
1602 {
1603 case SPLHND_SERVER:
1604 case SPLHND_PORTMON_TCP:
1605 case SPLHND_PORTMON_LOCAL:
1606 /* Printserver handles use global struct... */
1607
1608 snum = -1;
1609
1610 /* Map standard access rights to object specific access rights */
1611
1612 se_map_standard(&r->in.access_mask,
1613 &printserver_std_mapping);
1614
1615 /* Deny any object specific bits that don't apply to print
1616 servers (i.e printer and job specific bits) */
1617
1618 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1619
1620 if (r->in.access_mask &
1621 ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1622 DEBUG(3, ("access DENIED for non-printserver bits\n"));
1623 close_printer_handle(p, r->out.handle);
1624 ZERO_STRUCTP(r->out.handle);
1625 return WERR_ACCESS_DENIED;
1626 }
1627
1628 /* Allow admin access */
1629
1630 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1631 {
1632 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1633
1634 if (!lp_ms_add_printer_wizard()) {
1635 close_printer_handle(p, r->out.handle);
1636 ZERO_STRUCTP(r->out.handle);
1637 return WERR_ACCESS_DENIED;
1638 }
1639
1640 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1641 and not a printer admin, then fail */
1642
1643 if ((p->server_info->utok.uid != sec_initial_uid()) &&
1644 !user_has_privileges(p->server_info->ptok,
1645 &se_printop ) &&
1646 !token_contains_name_in_list(
1647 uidtoname(p->server_info->utok.uid),
1648 NULL, NULL,
1649 p->server_info->ptok,
1650 lp_printer_admin(snum))) {
1651 close_printer_handle(p, r->out.handle);
1652 ZERO_STRUCTP(r->out.handle);
1653 return WERR_ACCESS_DENIED;
1654 }
1655
1656 r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1657 }
1658 else
1659 {
1660 r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1661 }
1662
1663 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1664 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1665
1666 /* We fall through to return WERR_OK */
1667 break;
1668
1669 case SPLHND_PRINTER:
1670 /* NT doesn't let us connect to a printer if the connecting user
1671 doesn't have print permission. */
1672
1673 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1674 close_printer_handle(p, r->out.handle);
1675 ZERO_STRUCTP(r->out.handle);
1676 return WERR_BADFID;
1677 }
1678
1679 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1680 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1681 }
1682
1683 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1684
1685 /* map an empty access mask to the minimum access mask */
1686 if (r->in.access_mask == 0x0)
1687 r->in.access_mask = PRINTER_ACCESS_USE;
1688
1689 /*
1690 * If we are not serving the printer driver for this printer,
1691 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1692 * will keep NT clients happy --jerry
1693 */
1694
1695 if (lp_use_client_driver(snum)
1696 && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1697 {
1698 r->in.access_mask = PRINTER_ACCESS_USE;
1699 }
1700
1701 /* check smb.conf parameters and the the sec_desc */
1702
1703 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1704 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1705 ZERO_STRUCTP(r->out.handle);
1706 return WERR_ACCESS_DENIED;
1707 }
1708
1709 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1710 p->server_info->ptok, snum) ||
1711 !print_access_check(p->server_info, snum,
1712 r->in.access_mask)) {
1713 DEBUG(3, ("access DENIED for printer open\n"));
1714 close_printer_handle(p, r->out.handle);
1715 ZERO_STRUCTP(r->out.handle);
1716 return WERR_ACCESS_DENIED;
1717 }
1718
1719 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1720 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1721 close_printer_handle(p, r->out.handle);
1722 ZERO_STRUCTP(r->out.handle);
1723 return WERR_ACCESS_DENIED;
1724 }
1725
1726 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1727 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1728 else
1729 r->in.access_mask = PRINTER_ACCESS_USE;
1730
1731 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1732 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1733
1734 break;
1735
1736 default:
1737 /* sanity check to prevent programmer error */
1738 ZERO_STRUCTP(r->out.handle);
1739 return WERR_BADFID;
1740 }
1741
1742 Printer->access_granted = r->in.access_mask;
1743
1744 /*
1745 * If the client sent a devmode in the OpenPrinter() call, then
1746 * save it here in case we get a job submission on this handle
1747 */
1748
1749 if ((Printer->printer_type != SPLHND_SERVER) &&
1750 r->in.devmode_ctr.devmode) {
1751 convert_devicemode(Printer->sharename,
1752 r->in.devmode_ctr.devmode,
1753 &Printer->nt_devmode);
1754 }
1755
1756 #if 0 /* JERRY -- I'm doubtful this is really effective */
1757 /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1758 optimization in Windows 2000 clients --jerry */
1759
1760 if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1761 && (RA_WIN2K == get_remote_arch()) )
1762 {
1763 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1764 sys_usleep( 500000 );
1765 }
1766 #endif
1767
1768 return WERR_OK;
1769 }
1770
1771 /****************************************************************************
1772 ****************************************************************************/
1773
1774 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1775 NT_PRINTER_INFO_LEVEL_2 *d)
1776 {
1777 DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1778
1779 if (!r || !d) {
1780 return false;
1781 }
1782
1783 d->attributes = r->attributes;
1784 d->priority = r->priority;
1785 d->default_priority = r->defaultpriority;
1786 d->starttime = r->starttime;
1787 d->untiltime = r->untiltime;
1788 d->status = r->status;
1789 d->cjobs = r->cjobs;
1790
1791 fstrcpy(d->servername, r->servername);
1792 fstrcpy(d->printername, r->printername);
1793 fstrcpy(d->sharename, r->sharename);
1794 fstrcpy(d->portname, r->portname);
1795 fstrcpy(d->drivername, r->drivername);
1796 slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1797 fstrcpy(d->location, r->location);
1798 fstrcpy(d->sepfile, r->sepfile);
1799 fstrcpy(d->printprocessor, r->printprocessor);
1800 fstrcpy(d->datatype, r->datatype);
1801 fstrcpy(d->parameters, r->parameters);
1802
1803 return true;
1804 }
1805
1806 /****************************************************************************
1807 ****************************************************************************/
1808
1809 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1810 NT_PRINTER_INFO_LEVEL *printer)
1811 {
1812 bool ret;
1813
1814 switch (info_ctr->level) {
1815 case 2:
1816 /* allocate memory if needed. Messy because
1817 convert_printer_info is used to update an existing
1818 printer or build a new one */
1819
1820 if (!printer->info_2) {
1821 printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1822 if (!printer->info_2) {
1823 DEBUG(0,("convert_printer_info: "
1824 "talloc() failed!\n"));
1825 return false;
1826 }
1827 }
1828
1829 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1830 printer->info_2);
1831 printer->info_2->setuptime = time(NULL);
1832 return ret;
1833 }
1834
1835 return false;
1836 }
1837
1838 /****************************************************************
1839 _spoolss_ClosePrinter
1840 ****************************************************************/
1841
1842 WERROR _spoolss_ClosePrinter(pipes_struct *p,
1843 struct spoolss_ClosePrinter *r)
1844 {
1845 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1846
1847 if (Printer && Printer->document_started) {
1848 struct spoolss_EndDocPrinter e;
1849
1850 e.in.handle = r->in.handle;
1851
1852 _spoolss_EndDocPrinter(p, &e);
1853 }
1854
1855 if (!close_printer_handle(p, r->in.handle))
1856 return WERR_BADFID;
1857
1858 /* clear the returned printer handle. Observed behavior
1859 from Win2k server. Don't think this really matters.
1860 Previous code just copied the value of the closed
1861 handle. --jerry */
1862
1863 ZERO_STRUCTP(r->out.handle);
1864
1865 return WERR_OK;
1866 }
1867
1868 /****************************************************************
1869 _spoolss_DeletePrinter
1870 ****************************************************************/
1871
1872 WERROR _spoolss_DeletePrinter(pipes_struct *p,
1873 struct spoolss_DeletePrinter *r)
1874 {
1875 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1876 WERROR result;
1877
1878 if (Printer && Printer->document_started) {
1879 struct spoolss_EndDocPrinter e;
1880
1881 e.in.handle = r->in.handle;
1882
1883 _spoolss_EndDocPrinter(p, &e);
1884 }
1885
1886 result = delete_printer_handle(p, r->in.handle);
1887
1888 update_c_setprinter(false);
1889
1890 return result;
1891 }
1892
1893 /*******************************************************************
1894 * static function to lookup the version id corresponding to an
1895 * long architecture string
1896 ******************************************************************/
1897
1898 static const struct print_architecture_table_node archi_table[]= {
1899
1900 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
1901 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
1902 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
1903 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
1904 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
1905 {"Windows IA64", SPL_ARCH_IA64, 3 },
1906 {"Windows x64", SPL_ARCH_X64, 3 },
1907 {NULL, "", -1 }
1908 };
1909
1910 static int get_version_id(const char *arch)
1911 {
1912 int i;
1913
1914 for (i=0; archi_table[i].long_archi != NULL; i++)
1915 {
1916 if (strcmp(arch, archi_table[i].long_archi) == 0)
1917 return (archi_table[i].version);
1918 }
1919
1920 return -1;
1921 }
1922
1923 /****************************************************************
1924 _spoolss_DeletePrinterDriver
1925 ****************************************************************/
1926
1927 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
1928 struct spoolss_DeletePrinterDriver *r)
1929 {
1930
1931 struct spoolss_DriverInfo8 *info = NULL;
1932 struct spoolss_DriverInfo8 *info_win2k = NULL;
1933 int version;
1934 WERROR status;
1935 WERROR status_win2k = WERR_ACCESS_DENIED;
1936 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1937
1938 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1939 and not a printer admin, then fail */
1940
1941 if ( (p->server_info->utok.uid != sec_initial_uid())
1942 && !user_has_privileges(p->server_info->ptok, &se_printop )
1943 && !token_contains_name_in_list(
1944 uidtoname(p->server_info->utok.uid), NULL,
1945 NULL, p->server_info->ptok,
1946 lp_printer_admin(-1)) )
1947 {
1948 return WERR_ACCESS_DENIED;
1949 }
1950
1951 /* check that we have a valid driver name first */
1952
1953 if ((version = get_version_id(r->in.architecture)) == -1)
1954 return WERR_INVALID_ENVIRONMENT;
1955
1956 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
1957 r->in.architecture,
1958 version)))
1959 {
1960 /* try for Win2k driver if "Windows NT x86" */
1961
1962 if ( version == 2 ) {
1963 version = 3;
1964 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
1965 &info,
1966 r->in.driver,
1967 r->in.architecture,
1968 version))) {
1969 status = WERR_UNKNOWN_PRINTER_DRIVER;
1970 goto done;
1971 }
1972 }
1973 /* otherwise it was a failure */
1974 else {
1975 status = WERR_UNKNOWN_PRINTER_DRIVER;
1976 goto done;
1977 }
1978
1979 }
1980
1981 if (printer_driver_in_use(info)) {
1982 status = WERR_PRINTER_DRIVER_IN_USE;
1983 goto done;
1984 }
1985
1986 if ( version == 2 )
1987 {
1988 if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
1989 &info_win2k,
1990 r->in.driver,
1991 r->in.architecture, 3)))
1992 {
1993 /* if we get to here, we now have 2 driver info structures to remove */
1994 /* remove the Win2k driver first*/
1995
1996 status_win2k = delete_printer_driver(
1997 p, info_win2k, 3, false);
1998 free_a_printer_driver(info_win2k);
1999
2000 /* this should not have failed---if it did, report to client */
2001 if ( !W_ERROR_IS_OK(status_win2k) )
2002 {
2003 status = status_win2k;
2004 goto done;
2005 }
2006 }
2007 }
2008
2009 status = delete_printer_driver(p, info, version, false);
2010
2011 /* if at least one of the deletes succeeded return OK */
2012
2013 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2014 status = WERR_OK;
2015
2016 done:
2017 free_a_printer_driver(info);
2018
2019 return status;
2020 }
2021
2022 /****************************************************************
2023 _spoolss_DeletePrinterDriverEx
2024 ****************************************************************/
2025
2026 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2027 struct spoolss_DeletePrinterDriverEx *r)
2028 {
2029 struct spoolss_DriverInfo8 *info = NULL;
2030 struct spoolss_DriverInfo8 *info_win2k = NULL;
2031 int version;
2032 bool delete_files;
2033 WERROR status;
2034 WERROR status_win2k = WERR_ACCESS_DENIED;
2035 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2036
2037 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2038 and not a printer admin, then fail */
2039
2040 if ( (p->server_info->utok.uid != sec_initial_uid())
2041 && !user_has_privileges(p->server_info->ptok, &se_printop )
2042 && !token_contains_name_in_list(
2043 uidtoname(p->server_info->utok.uid), NULL, NULL,
2044 p->server_info->ptok, lp_printer_admin(-1)) )
2045 {
2046 return WERR_ACCESS_DENIED;
2047 }
2048
2049 /* check that we have a valid driver name first */
2050 if ((version = get_version_id(r->in.architecture)) == -1) {
2051 /* this is what NT returns */
2052 return WERR_INVALID_ENVIRONMENT;
2053 }
2054
2055 if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2056 version = r->in.version;
2057
2058 status = get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
2059 r->in.architecture, version);
2060
2061 if ( !W_ERROR_IS_OK(status) )
2062 {
2063 /*
2064 * if the client asked for a specific version,
2065 * or this is something other than Windows NT x86,
2066 * then we've failed
2067 */
2068
2069 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2070 goto done;
2071
2072 /* try for Win2k driver if "Windows NT x86" */
2073
2074 version = 3;
2075 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
2076 r->in.architecture,
2077 version))) {
2078 status = WERR_UNKNOWN_PRINTER_DRIVER;
2079 goto done;
2080 }
2081 }
2082
2083 if (printer_driver_in_use(info)) {
2084 status = WERR_PRINTER_DRIVER_IN_USE;
2085 goto done;
2086 }
2087
2088 /*
2089 * we have a couple of cases to consider.
2090 * (1) Are any files in use? If so and DPD_DELTE_ALL_FILE is set,
2091 * then the delete should fail if **any** files overlap with
2092 * other drivers
2093 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2094 * non-overlapping files
2095 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2096 * is set, the do not delete any files
2097 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2098 */
2099
2100 delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2101
2102 /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2103
2104 if (delete_files && printer_driver_files_in_use(info, info) & (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
2105 /* no idea of the correct error here */
2106 status = WERR_ACCESS_DENIED;
2107 goto done;
2108 }
2109
2110
2111 /* also check for W32X86/3 if necessary; maybe we already have? */
2112
2113 if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
2114 if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info_win2k,
2115 r->in.driver,
2116 r->in.architecture, 3)))
2117 {
2118
2119 if (delete_files && printer_driver_files_in_use(info, info_win2k) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2120 /* no idea of the correct error here */
2121 free_a_printer_driver(info_win2k);
2122 status = WERR_ACCESS_DENIED;
2123 goto done;
2124 }
2125
2126 /* if we get to here, we now have 2 driver info structures to remove */
2127 /* remove the Win2k driver first*/
2128
2129 status_win2k = delete_printer_driver(
2130 p, info_win2k, 3, delete_files);
2131 free_a_printer_driver(info_win2k);
2132
2133 /* this should not have failed---if it did, report to client */
2134
2135 if ( !W_ERROR_IS_OK(status_win2k) )
2136 goto done;
2137 }
2138 }
2139
2140 status = delete_printer_driver(p, info, version, delete_files);
2141
2142 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2143 status = WERR_OK;
2144 done:
2145 free_a_printer_driver(info);
2146
2147 return status;
2148 }
2149
2150
2151 /****************************************************************************
2152 Internal routine for removing printerdata
2153 ***************************************************************************/
2154
2155 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2156 {
2157 return delete_printer_data( printer->info_2, key, value );
2158 }
2159
2160 /****************************************************************************
2161 Internal routine for storing printerdata
2162 ***************************************************************************/
2163
2164 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2165 const char *key, const char *value,
2166 uint32_t type, uint8_t *data, int real_len)
2167 {
2168 /* the registry objects enforce uniqueness based on value name */
2169
2170 return add_printer_data( printer->info_2, key, value, type, data, real_len );
2171 }
2172
2173 /********************************************************************
2174 GetPrinterData on a printer server Handle.
2175 ********************************************************************/
2176
2177 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2178 const char *value,
2179 enum winreg_Type *type,
2180 union spoolss_PrinterData *data)
2181 {
2182 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2183
2184 if (!StrCaseCmp(value, "W3SvcInstalled")) {
2185 *type = REG_DWORD;
2186 data->value = 0x00;
2187 return WERR_OK;
2188 }
2189
2190 if (!StrCaseCmp(value, "BeepEnabled")) {
2191 *type = REG_DWORD;
2192 data->value = 0x00;
2193 return WERR_OK;
2194 }
2195
2196 if (!StrCaseCmp(value, "EventLog")) {
2197 *type = REG_DWORD;
2198 /* formally was 0x1b */
2199 data->value = 0x00;
2200 return WERR_OK;
2201 }
2202
2203 if (!StrCaseCmp(value, "NetPopup")) {
2204 *type = REG_DWORD;
2205 data->value = 0x00;
2206 return WERR_OK;
2207 }
2208
2209 if (!StrCaseCmp(value, "MajorVersion")) {
2210 *type = REG_DWORD;
2211
2212 /* Windows NT 4.0 seems to not allow uploading of drivers
2213 to a server that reports 0x3 as the MajorVersion.
2214 need to investigate more how Win2k gets around this .
2215 -- jerry */
2216
2217 if (RA_WINNT == get_remote_arch()) {
2218 data->value = 0x02;
2219 } else {
2220 data->value = 0x03;
2221 }
2222
2223 return WERR_OK;
2224 }
2225
2226 if (!StrCaseCmp(value, "MinorVersion")) {
2227 *type = REG_DWORD;
2228 data->value = 0x00;
2229 return WERR_OK;
2230 }
2231
2232 /* REG_BINARY
2233 * uint32_t size = 0x114
2234 * uint32_t major = 5
2235 * uint32_t minor = [0|1]
2236 * uint32_t build = [2195|2600]
2237 * extra unicode string = e.g. "Service Pack 3"
2238 */
2239 if (!StrCaseCmp(value, "OSVersion")) {
2240 DATA_BLOB blob;
2241 enum ndr_err_code ndr_err;
2242 struct spoolss_OSVersion os;
2243
2244 os.major = 5; /* Windows 2000 == 5.0 */
2245 os.minor = 0;
2246 os.build = 2195; /* build */
2247 os.extra_string = ""; /* leave extra string empty */
2248
2249 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2250 (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2251 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2252 return WERR_GENERAL_FAILURE;
2253 }
2254
2255 *type = REG_BINARY;
2256 data->binary = blob;
2257
2258 return WERR_OK;
2259 }
2260
2261
2262 if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2263 *type = REG_SZ;
2264
2265 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2266 W_ERROR_HAVE_NO_MEMORY(data->string);
2267
2268 return WERR_OK;
2269 }
2270
2271 if (!StrCaseCmp(value, "Architecture")) {
2272 *type = REG_SZ;
2273
2274 data->string = talloc_strdup(mem_ctx, "Windows NT x86");
2275 W_ERROR_HAVE_NO_MEMORY(data->string);
2276
2277 return WERR_OK;
2278 }
2279
2280 if (!StrCaseCmp(value, "DsPresent")) {
2281 *type = REG_DWORD;
2282
2283 /* only show the publish check box if we are a
2284 member of a AD domain */
2285
2286 if (lp_security() == SEC_ADS) {
2287 data->value = 0x01;
2288 } else {
2289 data->value = 0x00;
2290 }
2291 return WERR_OK;
2292 }
2293
2294 if (!StrCaseCmp(value, "DNSMachineName")) {
2295 const char *hostname = get_mydnsfullname();
2296
2297 if (!hostname) {
2298 return WERR_BADFILE;
2299 }
2300
2301 *type = REG_SZ;
2302 data->string = talloc_strdup(mem_ctx, hostname);
2303 W_ERROR_HAVE_NO_MEMORY(data->string);
2304
2305 return WERR_OK;
2306 }
2307
2308 *type = REG_NONE;
2309
2310 return WERR_INVALID_PARAM;
2311 }
2312
2313 /****************************************************************
2314 _spoolss_GetPrinterData
2315 ****************************************************************/
2316
2317 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2318 struct spoolss_GetPrinterData *r)
2319 {
2320 struct spoolss_GetPrinterDataEx r2;
2321
2322 r2.in.handle = r->in.handle;
2323 r2.in.key_name = "PrinterDriverData";
2324 r2.in.value_name = r->in.value_name;
2325 r2.in.offered = r->in.offered;
2326 r2.out.type = r->out.type;
2327 r2.out.data = r->out.data;
2328 r2.out.needed = r->out.needed;
2329
2330 return _spoolss_GetPrinterDataEx(p, &r2);
2331 }
2332
2333 /*********************************************************
2334 Connect to the client machine.
2335 **********************************************************/
2336
2337 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2338 struct sockaddr_storage *client_ss, const char *remote_machine)
2339 {
2340 NTSTATUS ret;
2341 struct cli_state *the_cli;
2342 struct sockaddr_storage rm_addr;
2343 char addr[INET6_ADDRSTRLEN];
2344
2345 if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2346 DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
2347 remote_machine));
2348 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2349 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2350 return false;
2351 }
2352 print_sockaddr(addr, sizeof(addr), &rm_addr);
2353 } else {
2354 rm_addr = *client_ss;
2355 print_sockaddr(addr, sizeof(addr), &rm_addr);
2356 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2357 addr));
2358 }
2359
2360 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2361 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
2362 addr));
2363 return false;
2364 }
2365
2366 /* setup the connection */
2367 ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2368 &rm_addr, 0, "IPC$", "IPC",
2369 "", /* username */
2370 "", /* domain */
2371 "", /* password */
2372 0, lp_client_signing(), NULL );
2373
2374 if ( !NT_STATUS_IS_OK( ret ) ) {
2375 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2376 remote_machine ));
2377 return false;
2378 }
2379
2380 if ( the_cli->protocol != PROTOCOL_NT1 ) {
2381 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2382 cli_shutdown(the_cli);
2383 return false;
2384 }
2385
2386 /*
2387 * Ok - we have an anonymous connection to the IPC$ share.
2388 * Now start the NT Domain stuff :-).
2389 */
2390
2391 ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2392 if (!NT_STATUS_IS_OK(ret)) {
2393 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2394 remote_machine, nt_errstr(ret)));
2395 cli_shutdown(the_cli);
2396 return false;
2397 }
2398
2399 return true;
2400 }
2401
2402 /***************************************************************************
2403 Connect to the client.
2404 ****************************************************************************/
2405
2406 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2407 uint32_t localprinter, uint32_t type,
2408 struct policy_handle *handle,
2409 struct sockaddr_storage *client_ss)
2410 {
2411 WERROR result;
2412 NTSTATUS status;
2413
2414 /*
2415 * If it's the first connection, contact the client
2416 * and connect to the IPC$ share anonymously
2417 */
2418 if (smb_connections==0) {
2419 fstring unix_printer;
2420
2421 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2422
2423 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2424 return false;
2425
2426 messaging_register(smbd_messaging_context(), NULL,
2427 MSG_PRINTER_NOTIFY2,
2428 receive_notify2_message_list);
2429 /* Tell the connections db we're now interested in printer
2430 * notify messages. */
2431 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2432 }
2433
2434 /*
2435 * Tell the specific printing tdb we want messages for this printer
2436 * by registering our PID.
2437 */
2438
2439 if (!print_notify_register_pid(snum))
2440 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2441
2442 smb_connections++;
2443
2444 status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2445 printer,
2446 localprinter,
2447 type,
2448 0,
2449 NULL,
2450 handle,
2451 &result);
2452 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2453 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2454 win_errstr(result)));
2455
2456 return (W_ERROR_IS_OK(result));
2457 }
2458
2459 /****************************************************************
2460 ****************************************************************/
2461
2462 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2463 const struct spoolss_NotifyOption *r)
2464 {
2465 struct spoolss_NotifyOption *option;
2466 uint32_t i,k;
2467
2468 if (!r) {
2469 return NULL;
2470 }
2471
2472 option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2473 if (!option) {
2474 return NULL;
2475 }
2476
2477 *option = *r;
2478
2479 if (!option->count) {
2480 return option;
2481 }
2482
2483 option->types = talloc_zero_array(option,
2484 struct spoolss_NotifyOptionType, option->count);
2485 if (!option->types) {
2486 talloc_free(option);
2487 return NULL;
2488 }
2489
2490 for (i=0; i < option->count; i++) {
2491 option->types[i] = r->types[i];
2492
2493 if (option->types[i].count) {
2494 option->types[i].fields = talloc_zero_array(option,
2495 union spoolss_Field, option->types[i].count);
2496 if (!option->types[i].fields) {
2497 talloc_free(option);
2498 return NULL;
2499 }
2500 for (k=0; k<option->types[i].count; k++) {
2501 option->types[i].fields[k] =
2502 r->types[i].fields[k];
2503 }
2504 }
2505 }
2506
2507 return option;
2508 }
2509
2510 /****************************************************************
2511 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2512 *
2513 * before replying OK: status=0 a rpc call is made to the workstation
2514 * asking ReplyOpenPrinter
2515 *
2516 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2517 * called from api_spoolss_rffpcnex
2518 ****************************************************************/
2519
2520 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2521 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2522 {
2523 int snum = -1;
2524 struct spoolss_NotifyOption *option = r->in.notify_options;
2525 struct sockaddr_storage client_ss;
2526
2527 /* store the notify value in the printer struct */
2528
2529 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2530
2531 if (!Printer) {
2532 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2533 "Invalid handle (%s:%u:%u).\n",
2534 OUR_HANDLE(r->in.handle)));
2535 return WERR_BADFID;
2536 }
2537
2538 Printer->notify.flags = r->in.flags;
2539 Printer->notify.options = r->in.options;
2540 Printer->notify.printerlocal = r->in.printer_local;
2541
2542 TALLOC_FREE(Printer->notify.option);
2543 Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2544
2545 fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2546
2547 /* Connect to the client machine and send a ReplyOpenPrinter */
2548
2549 if ( Printer->printer_type == SPLHND_SERVER)
2550 snum = -1;
2551 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2552 !get_printer_snum(p, r->in.handle, &snum, NULL) )
2553 return WERR_BADFID;
2554
2555 DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2556 "client_address is %s\n", p->client_address));
2557
2558 if (!interpret_string_addr(&client_ss, p->client_address,
2559 AI_NUMERICHOST)) {
2560 return WERR_SERVER_UNAVAILABLE;
2561 }
2562
2563 if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2564 Printer->notify.printerlocal, 1,
2565 &Printer->notify.client_hnd, &client_ss))
2566 return WERR_SERVER_UNAVAILABLE;
2567
2568 Printer->notify.client_connected = true;
2569
2570 return WERR_OK;
2571 }
2572
2573 /*******************************************************************
2574 * fill a notify_info_data with the servername
2575 ********************************************************************/
2576
2577 void spoolss_notify_server_name(int snum,
2578 struct spoolss_Notify *data,
2579 print_queue_struct *queue,
2580 NT_PRINTER_INFO_LEVEL *printer,
2581 TALLOC_CTX *mem_ctx)
2582 {
2583 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2584 }
2585
2586 /*******************************************************************
2587 * fill a notify_info_data with the printername (not including the servername).
2588 ********************************************************************/
2589
2590 void spoolss_notify_printer_name(int snum,
2591 struct spoolss_Notify *data,
2592 print_queue_struct *queue,
2593 NT_PRINTER_INFO_LEVEL *printer,
2594 TALLOC_CTX *mem_ctx)
2595 {
2596 /* the notify name should not contain the \\server\ part */
2597 char *p = strrchr(printer->info_2->printername, '\\');
2598
2599 if (!p) {
2600 p = printer->info_2->printername;
2601 } else {
2602 p++;
2603 }
2604
2605 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2606 }
2607
2608 /*******************************************************************
2609 * fill a notify_info_data with the servicename
2610 ********************************************************************/
2611
2612 void spoolss_notify_share_name(int snum,
2613 struct spoolss_Notify *data,
2614 print_queue_struct *queue,
2615 NT_PRINTER_INFO_LEVEL *printer,
2616 TALLOC_CTX *mem_ctx)
2617 {
2618 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2619 }
2620
2621 /*******************************************************************
2622 * fill a notify_info_data with the port name
2623 ********************************************************************/
2624
2625 void spoolss_notify_port_name(int snum,
2626 struct spoolss_Notify *data,
2627 print_queue_struct *queue,
2628 NT_PRINTER_INFO_LEVEL *printer,
2629 TALLOC_CTX *mem_ctx)
2630 {
2631 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2632 }
2633
2634 /*******************************************************************
2635 * fill a notify_info_data with the printername
2636 * but it doesn't exist, have to see what to do
2637 ********************************************************************/
2638
2639 void spoolss_notify_driver_name(int snum,
2640 struct spoolss_Notify *data,
2641 print_queue_struct *queue,
2642 NT_PRINTER_INFO_LEVEL *printer,
2643 TALLOC_CTX *mem_ctx)
2644 {
2645 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2646 }
2647
2648 /*******************************************************************
2649 * fill a notify_info_data with the comment
2650 ********************************************************************/
2651
2652 void spoolss_notify_comment(int snum,
2653 struct spoolss_Notify *data,
2654 print_queue_struct *queue,
2655 NT_PRINTER_INFO_LEVEL *printer,
2656 TALLOC_CTX *mem_ctx)
2657 {
2658 char *p;
2659
2660 if (*printer->info_2->comment == '\0') {
2661 p = lp_comment(snum);
2662 } else {
2663 p = printer->info_2->comment;
2664 }
2665
2666 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2667 }
2668
2669 /*******************************************************************
2670 * fill a notify_info_data with the comment
2671 * location = "Room 1, floor 2, building 3"
2672 ********************************************************************/
2673
2674 void spoolss_notify_location(int snum,
2675 struct spoolss_Notify *data,
2676 print_queue_struct *queue,
2677 NT_PRINTER_INFO_LEVEL *printer,
2678 TALLOC_CTX *mem_ctx)
2679 {
2680 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2681 }
2682
2683 /*******************************************************************
2684 * fill a notify_info_data with the device mode
2685 * jfm:xxxx don't to it for know but that's a real problem !!!
2686 ********************************************************************/
2687
2688 static void spoolss_notify_devmode(int snum,
2689 struct spoolss_Notify *data,
2690 print_queue_struct *queue,
2691 NT_PRINTER_INFO_LEVEL *printer,
2692 TALLOC_CTX *mem_ctx)
2693 {
2694 /* for a dummy implementation we have to zero the fields */
2695 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2696 }
2697
2698 /*******************************************************************
2699 * fill a notify_info_data with the separator file name
2700 ********************************************************************/
2701
2702 void spoolss_notify_sepfile(int snum,
2703 struct spoolss_Notify *data,
2704 print_queue_struct *queue,
2705 NT_PRINTER_INFO_LEVEL *printer,
2706 TALLOC_CTX *mem_ctx)
2707 {
2708 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2709 }
2710
2711 /*******************************************************************
2712 * fill a notify_info_data with the print processor
2713 * jfm:xxxx return always winprint to indicate we don't do anything to it
2714 ********************************************************************/
2715
2716 void spoolss_notify_print_processor(int snum,
2717 struct spoolss_Notify *data,
2718 print_queue_struct *queue,
2719 NT_PRINTER_INFO_LEVEL *printer,
2720 TALLOC_CTX *mem_ctx)
2721 {
2722 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2723 }
2724
2725 /*******************************************************************
2726 * fill a notify_info_data with the print processor options
2727 * jfm:xxxx send an empty string
2728 ********************************************************************/
2729
2730 void spoolss_notify_parameters(int snum,
2731 struct spoolss_Notify *data,
2732 print_queue_struct *queue,
2733 NT_PRINTER_INFO_LEVEL *printer,
2734 TALLOC_CTX *mem_ctx)
2735 {
2736 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2737 }
2738
2739 /*******************************************************************
2740 * fill a notify_info_data with the data type
2741 * jfm:xxxx always send RAW as data type
2742 ********************************************************************/
2743
2744 void spoolss_notify_datatype(int snum,
2745 struct spoolss_Notify *data,
2746 print_queue_struct *queue,
2747 NT_PRINTER_INFO_LEVEL *printer,
2748 TALLOC_CTX *mem_ctx)
2749 {
2750 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
2751 }
2752
2753 /*******************************************************************
2754 * fill a notify_info_data with the security descriptor
2755 * jfm:xxxx send an null pointer to say no security desc
2756 * have to implement security before !
2757 ********************************************************************/
2758
2759 static void spoolss_notify_security_desc(int snum,
2760 struct spoolss_Notify *data,
2761 print_queue_struct *queue,
2762 NT_PRINTER_INFO_LEVEL *printer,
2763 TALLOC_CTX *mem_ctx)
2764 {
2765 SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
2766 printer->info_2->secdesc_buf->sd_size,
2767 printer->info_2->secdesc_buf->sd);
2768 }
2769
2770 /*******************************************************************
2771 * fill a notify_info_data with the attributes
2772 * jfm:xxxx a samba printer is always shared
2773 ********************************************************************/
2774
2775 void spoolss_notify_attributes(int snum,
2776 struct spoolss_Notify *data,
2777 print_queue_struct *queue,
2778 NT_PRINTER_INFO_LEVEL *printer,
2779 TALLOC_CTX *mem_ctx)
2780 {
2781 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
2782 }
2783
2784 /*******************************************************************
2785 * fill a notify_info_data with the priority
2786 ********************************************************************/
2787
2788 static void spoolss_notify_priority(int snum,
2789 struct spoolss_Notify *data,
2790 print_queue_struct *queue,
2791 NT_PRINTER_INFO_LEVEL *printer,
2792 TALLOC_CTX *mem_ctx)
2793 {
2794 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
2795 }
2796
2797 /*******************************************************************
2798 * fill a notify_info_data with the default priority
2799 ********************************************************************/
2800
2801 static void spoolss_notify_default_priority(int snum,
2802 struct spoolss_Notify *data,
2803 print_queue_struct *queue,
2804 NT_PRINTER_INFO_LEVEL *printer,
2805 TALLOC_CTX *mem_ctx)
2806 {
2807 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
2808 }
2809
2810 /*******************************************************************
2811 * fill a notify_info_data with the start time
2812 ********************************************************************/
2813
2814 static void spoolss_notify_start_time(int snum,
2815 struct spoolss_Notify *data,
2816 print_queue_struct *queue,
2817 NT_PRINTER_INFO_LEVEL *printer,
2818 TALLOC_CTX *mem_ctx)
2819 {
2820 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
2821 }
2822
2823 /*******************************************************************
2824 * fill a notify_info_data with the until time
2825 ********************************************************************/
2826
2827 static void spoolss_notify_until_time(int snum,
2828 struct spoolss_Notify *data,
2829 print_queue_struct *queue,
2830 NT_PRINTER_INFO_LEVEL *printer,
2831 TALLOC_CTX *mem_ctx)
2832 {
2833 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
2834 }
2835
2836 /*******************************************************************
2837 * fill a notify_info_data with the status
2838 ********************************************************************/
2839
2840 static void spoolss_notify_status(int snum,
2841 struct spoolss_Notify *data,
2842 print_queue_struct *queue,
2843 NT_PRINTER_INFO_LEVEL *printer,
2844 TALLOC_CTX *mem_ctx)
2845 {
2846 print_status_struct status;
2847
2848 print_queue_length(snum, &status);
2849 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
2850 }
2851
2852 /*******************************************************************
2853 * fill a notify_info_data with the number of jobs queued
2854 ********************************************************************/
2855
2856 void spoolss_notify_cjobs(int snum,
2857 struct spoolss_Notify *data,
2858 print_queue_struct *queue,
2859 NT_PRINTER_INFO_LEVEL *printer,
2860 TALLOC_CTX *mem_ctx)
2861 {
2862 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
2863 }
2864
2865 /*******************************************************************
2866 * fill a notify_info_data with the average ppm
2867 ********************************************************************/
2868
2869 static void spoolss_notify_average_ppm(int snum,
2870 struct spoolss_Notify *data,
2871 print_queue_struct *queue,
2872 NT_PRINTER_INFO_LEVEL *printer,
2873 TALLOC_CTX *mem_ctx)
2874 {
2875 /* always respond 8 pages per minutes */
2876 /* a little hard ! */
2877 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
2878 }
2879
2880 /*******************************************************************
2881 * fill a notify_info_data with username
2882 ********************************************************************/
2883
2884 static void spoolss_notify_username(int snum,
2885 struct spoolss_Notify *data,
2886 print_queue_struct *queue,
2887 NT_PRINTER_INFO_LEVEL *printer,
2888 TALLOC_CTX *mem_ctx)
2889 {
2890 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
2891 }
2892
2893 /*******************************************************************
2894 * fill a notify_info_data with job status
2895 ********************************************************************/
2896
2897 static void spoolss_notify_job_status(int snum,
2898 struct spoolss_Notify *data,
2899 print_queue_struct *queue,
2900 NT_PRINTER_INFO_LEVEL *printer,
2901 TALLOC_CTX *mem_ctx)
2902 {
2903 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
2904 }
2905
2906 /*******************************************************************
2907 * fill a notify_info_data with job name
2908 ********************************************************************/
2909
2910 static void spoolss_notify_job_name(int snum,
2911 struct spoolss_Notify *data,
2912 print_queue_struct *queue,
2913 NT_PRINTER_INFO_LEVEL *printer,
2914 TALLOC_CTX *mem_ctx)
2915 {
2916 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
2917 }
2918
2919 /*******************************************************************
2920 * fill a notify_info_data with job status
2921 ********************************************************************/
2922
2923 static void spoolss_notify_job_status_string(int snum,
2924 struct spoolss_Notify *data,
2925 print_queue_struct *queue,
2926 NT_PRINTER_INFO_LEVEL *printer,
2927 TALLOC_CTX *mem_ctx)
2928 {
2929 /*
2930 * Now we're returning job status codes we just return a "" here. JRA.
2931 */
2932
2933 const char *p = "";
2934
2935 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
2936 p = "unknown";
2937
2938 switch (queue->status) {
2939 case LPQ_QUEUED:
2940 p = "Queued";
2941 break;
2942 case LPQ_PAUSED:
2943 p = ""; /* NT provides the paused string */
2944 break;
2945 case LPQ_SPOOLING:
2946 p = "Spooling";
2947 break;
2948 case LPQ_PRINTING:
2949 p = "Printing";
2950 break;
2951 }
2952 #endif /* NO LONGER NEEDED. */
2953
2954 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2955 }
2956
2957 /*******************************************************************
2958 * fill a notify_info_data with job time
2959 ********************************************************************/
2960
2961 static void spoolss_notify_job_time(int snum,
2962 struct spoolss_Notify *data,
2963 print_queue_struct *queue,
2964 NT_PRINTER_INFO_LEVEL *printer,
2965 TALLOC_CTX *mem_ctx)
2966 {
2967 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
2968 }
2969
2970 /*******************************************************************
2971 * fill a notify_info_data with job size
2972 ********************************************************************/
2973
2974 static void spoolss_notify_job_size(int snum,
2975 struct spoolss_Notify *data,
2976 print_queue_struct *queue,
2977 NT_PRINTER_INFO_LEVEL *printer,
2978 TALLOC_CTX *mem_ctx)
2979 {
2980 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
2981 }
2982
2983 /*******************************************************************
2984 * fill a notify_info_data with page info
2985 ********************************************************************/
2986 static void spoolss_notify_total_pages(int snum,
2987 struct spoolss_Notify *data,
2988 print_queue_struct *queue,
2989 NT_PRINTER_INFO_LEVEL *printer,
2990 TALLOC_CTX *mem_ctx)
2991 {
2992 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
2993 }
2994
2995 /*******************************************************************
2996 * fill a notify_info_data with pages printed info.
2997 ********************************************************************/
2998 static void spoolss_notify_pages_printed(int snum,
2999 struct spoolss_Notify *data,
3000 print_queue_struct *queue,
3001 NT_PRINTER_INFO_LEVEL *printer,
3002 TALLOC_CTX *mem_ctx)
3003 {
3004 /* Add code when back-end tracks this */
3005 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3006 }
3007
3008 /*******************************************************************
3009 Fill a notify_info_data with job position.
3010 ********************************************************************/
3011
3012 static void spoolss_notify_job_position(int snum,
3013 struct spoolss_Notify *data,
3014 print_queue_struct *queue,
3015 NT_PRINTER_INFO_LEVEL *printer,
3016 TALLOC_CTX *mem_ctx)
3017 {
3018 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3019 }
3020
3021 /*******************************************************************
3022 Fill a notify_info_data with submitted time.
3023 ********************************************************************/
3024
3025 static void spoolss_notify_submitted_time(int snum,
3026 struct spoolss_Notify *data,
3027 print_queue_struct *queue,
3028 NT_PRINTER_INFO_LEVEL *printer,
3029 TALLOC_CTX *mem_ctx)
3030 {
3031 data->data.string.string = NULL;
3032 data->data.string.size = 0;
3033
3034 init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3035 &data->data.string.string,
3036 &data->data.string.size);
3037
3038 }
3039
3040 struct s_notify_info_data_table
3041 {
3042 enum spoolss_NotifyType type;
3043 uint16_t field;
3044 const char *name;
3045 enum spoolss_NotifyTable variable_type;
3046 void (*fn) (int snum, struct spoolss_Notify *data,
3047 print_queue_struct *queue,
3048 NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3049 };
3050
3051 /* A table describing the various print notification constants and
3052 whether the notification data is a pointer to a variable sized
3053 buffer, a one value uint32_t or a two value uint32_t. */
3054
3055 static const struct s_notify_info_data_table notify_info_data_table[] =
3056 {
3057 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3058 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3059 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_share_name },
3060 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3061 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3062 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING, spoolss_notify_comment },
3063 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING, spoolss_notify_location },
3064 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3065 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING, spoolss_notify_sepfile },
3066 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3067 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3068 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3069 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, spoolss_notify_security_desc },
3070 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD, spoolss_notify_attributes },
3071 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3072 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_default_priority },
3073 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3074 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3075 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_status },
3076 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, NULL },
3077 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD, spoolss_notify_cjobs },
3078 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD, spoolss_notify_average_ppm },
3079 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, NULL },
3080 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3081 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, NULL },
3082 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3083 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINTER_NAME, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3084 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_MACHINE_NAME, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3085 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PORT_NAME, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3086 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3087 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_NOTIFY_NAME, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3088 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DATATYPE, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3089 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINT_PROCESSOR, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3090 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PARAMETERS, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3091 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DRIVER_NAME, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3092 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DEVMODE, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3093 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_job_status },
3094 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS_STRING, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, spoolss_notify_job_status_string },
3095 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, NULL },
3096 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING, spoolss_notify_job_name },
3097 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRIORITY, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3098 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_POSITION, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD, spoolss_notify_job_position },
3099 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME, spoolss_notify_submitted_time },
3100 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_START_TIME, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3101 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_UNTIL_TIME, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3102 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TIME, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_job_time },
3103 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_PAGES, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, spoolss_notify_total_pages },
3104 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PAGES_PRINTED, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, spoolss_notify_pages_printed },
3105 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_BYTES, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, spoolss_notify_job_size },
3106 };
3107
3108 /*******************************************************************
3109 Return the variable_type of info_data structure.
3110 ********************************************************************/
3111
3112 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3113 uint16_t field)
3114 {
3115 int i=0;
3116
3117 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3118 if ( (notify_info_data_table[i].type == type) &&
3119 (notify_info_data_table[i].field == field) ) {
3120 return notify_info_data_table[i].variable_type;
3121 }
3122 }
3123
3124 DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3125
3126 return 0;
3127 }
3128
3129 /****************************************************************************
3130 ****************************************************************************/
3131
3132 static bool search_notify(enum spoolss_NotifyType type,
3133 uint16_t field,
3134 int *value)
3135 {
3136 int i;
3137
3138 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3139 if (notify_info_data_table[i].type == type &&
3140 notify_info_data_table[i].field == field &&
3141 notify_info_data_table[i].fn != NULL) {
3142 *value = i;
3143 return true;
3144 }
3145 }
3146
3147 return false;
3148 }
3149
3150 /****************************************************************************
3151 ****************************************************************************/
3152
3153 void construct_info_data(struct spoolss_Notify *info_data,
3154 enum spoolss_NotifyType type,
3155 uint16_t field,
3156 int id)
3157 {
3158 info_data->type = type;
3159 info_data->field.field = field;
3160 info_data->variable_type = variable_type_of_notify_info_data(type, field);
3161 info_data->job_id = id;
3162 }
3163
3164 /*******************************************************************
3165 *
3166 * fill a notify_info struct with info asked
3167 *
3168 ********************************************************************/
3169
3170 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3171 struct spoolss_NotifyInfo *info,
3172 int snum,
3173 const struct spoolss_NotifyOptionType *option_type,
3174 uint32_t id,
3175 TALLOC_CTX *mem_ctx)
3176 {
3177 int field_num,j;
3178 enum spoolss_NotifyType type;
3179 uint16_t field;
3180
3181 struct spoolss_Notify *current_data;
3182 NT_PRINTER_INFO_LEVEL *printer = NULL;
3183 print_queue_struct *queue=NULL;
3184
3185 type = option_type->type;
3186
3187 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3188 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3189 option_type->count, lp_servicename(snum)));
3190
3191 if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3192 return false;
3193
3194 for(field_num=0; field_num < option_type->count; field_num++) {
3195 field = option_type->fields[field_num].field;
3196
3197 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3198
3199 if (!search_notify(type, field, &j) )
3200 continue;
3201
3202 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3203 struct spoolss_Notify,
3204 info->count + 1);
3205 if (info->notifies == NULL) {
3206 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3207 free_a_printer(&printer, 2);
3208 return false;
3209 }
3210
3211 current_data = &info->notifies[info->count];
3212
3213 construct_info_data(current_data, type, field, id);
3214
3215 DEBUG(10,("construct_notify_printer_info: calling [%s] snum=%d printername=[%s])\n",
3216 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3217
3218 notify_info_data_table[j].fn(snum, current_data, queue,
3219 printer, mem_ctx);
3220
3221 info->count++;
3222 }
3223
3224 free_a_printer(&printer, 2);
3225 return true;
3226 }
3227
3228 /*******************************************************************
3229 *
3230 * fill a notify_info struct with info asked
3231 *
3232 ********************************************************************/
3233
3234 static bool construct_notify_jobs_info(print_queue_struct *queue,
3235 struct spoolss_NotifyInfo *info,
3236 NT_PRINTER_INFO_LEVEL *printer,
3237 int snum,
3238 const struct spoolss_NotifyOptionType *option_type,
3239 uint32_t id,
3240 TALLOC_CTX *mem_ctx)
3241 {
3242 int field_num,j;
3243 enum spoolss_NotifyType type;
3244 uint16_t field;
3245 struct spoolss_Notify *current_data;
3246
3247 DEBUG(4,("construct_notify_jobs_info\n"));
3248
3249 type = option_type->type;
3250
3251 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3252 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3253 option_type->count));
3254
3255 for(field_num=0; field_num<option_type->count; field_num++) {
3256 field = option_type->fields[field_num].field;
3257
3258 if (!search_notify(type, field, &j) )
3259 continue;
3260
3261 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3262 struct spoolss_Notify,
3263 info->count + 1);
3264 if (info->notifies == NULL) {
3265 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3266 return false;
3267 }
3268
3269 current_data=&(info->notifies[info->count]);
3270
3271 construct_info_data(current_data, type, field, id);
3272 notify_info_data_table[j].fn(snum, current_data, queue,
3273 printer, mem_ctx);
3274 info->count++;
3275 }
3276
3277 return true;
3278 }
3279
3280 /*
3281 * JFM: The enumeration is not that simple, it's even non obvious.
3282 *
3283 * let's take an example: I want to monitor the PRINTER SERVER for
3284 * the printer's name and the number of jobs currently queued.
3285 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3286 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3287 *
3288 * I have 3 printers on the back of my server.
3289 *
3290 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3291 * structures.
3292 * Number Data Id
3293 * 1 printer 1 name 1
3294 * 2 printer 1 cjob 1
3295 * 3 printer 2 name 2
3296 * 4 printer 2 cjob 2
3297 * 5 printer 3 name 3
3298 * 6 printer 3 name 3
3299 *
3300 * that's the print server case, the printer case is even worse.
3301 */
3302
3303 /*******************************************************************
3304 *
3305 * enumerate all printers on the printserver
3306 * fill a notify_info struct with info asked
3307 *
3308 ********************************************************************/
3309
3310 static WERROR printserver_notify_info(pipes_struct *p,
3311 struct policy_handle *hnd,
3312 struct spoolss_NotifyInfo *info,
3313 TALLOC_CTX *mem_ctx)
3314 {
3315 int snum;
3316 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3317 int n_services=lp_numservices();
3318 int i;
3319 struct spoolss_NotifyOption *option;
3320 struct spoolss_NotifyOptionType option_type;
3321
3322 DEBUG(4,("printserver_notify_info\n"));
3323
3324 if (!Printer)
3325 return WERR_BADFID;
3326
3327 option = Printer->notify.option;
3328
3329 info->version = 2;
3330 info->notifies = NULL;
3331 info->count = 0;
3332
3333 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3334 sending a ffpcn() request first */
3335
3336 if ( !option )
3337 return WERR_BADFID;
3338
3339 for (i=0; i<option->count; i++) {
3340 option_type = option->types[i];
3341
3342 if (option_type.type != PRINTER_NOTIFY_TYPE)
3343 continue;
3344
3345 for (snum=0; snum<n_services; snum++)
3346 {
3347 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3348 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3349 }
3350 }
3351
3352 #if 0
3353 /*
3354 * Debugging information, don't delete.
3355 */
3356
3357 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3358 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3359 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3360
3361 for (i=0; i<info->count; i++) {
3362 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3363 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3364 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3365 }
3366 #endif
3367
3368 return WERR_OK;
3369 }
3370
3371 /*******************************************************************
3372 *
3373 * fill a notify_info struct with info asked
3374 *
3375 ********************************************************************/
3376
3377 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3378 struct spoolss_NotifyInfo *info,
3379 TALLOC_CTX *mem_ctx)
3380 {
3381 int snum;
3382 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3383 int i;
3384 uint32_t id;
3385 struct spoolss_NotifyOption *option;
3386 struct spoolss_NotifyOptionType option_type;
3387 int count,j;
3388 print_queue_struct *queue=NULL;
3389 print_status_struct status;
3390
3391 DEBUG(4,("printer_notify_info\n"));
3392
3393 if (!Printer)
3394 return WERR_BADFID;
3395
3396 option = Printer->notify.option;
3397 id = 0x0;
3398
3399 info->version = 2;
3400 info->notifies = NULL;
3401 info->count = 0;
3402
3403 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3404 sending a ffpcn() request first */
3405
3406 if ( !option )
3407 return WERR_BADFID;
3408
3409 get_printer_snum(p, hnd, &snum, NULL);
3410
3411 for (i=0; i<option->count; i++) {
3412 option_type = option->types[i];
3413
3414 switch (option_type.type) {
3415 case PRINTER_NOTIFY_TYPE:
3416 if(construct_notify_printer_info(Printer, info, snum,
3417 &option_type, id,
3418 mem_ctx))
3419 id--;
3420 break;
3421
3422 case JOB_NOTIFY_TYPE: {
3423 NT_PRINTER_INFO_LEVEL *printer = NULL;
3424
3425 count = print_queue_status(snum, &queue, &status);
3426
3427 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3428 goto done;
3429
3430 for (j=0; j<count; j++) {
3431 construct_notify_jobs_info(&queue[j], info,
3432 printer, snum,
3433 &option_type,
3434 queue[j].job,
3435 mem_ctx);
3436 }
3437
3438 free_a_printer(&printer, 2);
3439
3440 done:
3441 SAFE_FREE(queue);
3442 break;
3443 }
3444 }
3445 }
3446
3447 /*
3448 * Debugging information, don't delete.
3449 */
3450 /*
3451 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3452 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3453 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3454
3455 for (i=0; i<info->count; i++) {
3456 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3457 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3458 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3459 }
3460 */
3461 return WERR_OK;
3462 }
3463
3464 /****************************************************************
3465 _spoolss_RouterRefreshPrinterChangeNotify
3466 ****************************************************************/
3467
3468 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3469 struct spoolss_RouterRefreshPrinterChangeNotify *r)
3470 {
3471 struct spoolss_NotifyInfo *info;
3472
3473 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3474 WERROR result = WERR_BADFID;
3475
3476 /* we always have a spoolss_NotifyInfo struct */
3477 info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3478 if (!info) {
3479 result = WERR_NOMEM;
3480 goto done;
3481 }
3482
3483 *r->out.info = info;
3484
3485 if (!Printer) {
3486 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3487 "Invalid handle (%s:%u:%u).\n",
3488 OUR_HANDLE(r->in.handle)));
3489 goto done;
3490 }
3491
3492 DEBUG(4,("Printer type %x\n",Printer->printer_type));
3493
3494 /*
3495 * We are now using the change value, and
3496 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3497 * I don't have a global notification system, I'm sending back all the
3498 * informations even when _NOTHING_ has changed.
3499 */
3500
3501 /* We need to keep track of the change value to send back in
3502 RRPCN replies otherwise our updates are ignored. */
3503
3504 Printer->notify.fnpcn = true;
3505
3506 if (Printer->notify.client_connected) {
3507 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3508 "Saving change value in request [%x]\n",
3509 r->in.change_low));
3510 Printer->notify.change = r->in.change_low;
3511 }
3512
3513 /* just ignore the spoolss_NotifyOption */
3514
3515 switch (Printer->printer_type) {
3516 case SPLHND_SERVER:
3517 result = printserver_notify_info(p, r->in.handle,
3518 info, p->mem_ctx);
3519 break;
3520
3521 case SPLHND_PRINTER:
3522 result = printer_notify_info(p, r->in.handle,
3523 info, p->mem_ctx);
3524 break;
3525 }
3526
3527 Printer->notify.fnpcn = false;
3528
3529 done:
3530 return result;
3531 }
3532
3533 /********************************************************************
3534 * construct_printer_info_0
3535 * fill a printer_info_0 struct
3536 ********************************************************************/
3537
3538 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3539 const NT_PRINTER_INFO_LEVEL *ntprinter,
3540 struct spoolss_PrinterInfo0 *r,
3541 int snum)
3542 {
3543 int count;
3544 counter_printer_0 *session_counter;
3545 time_t setuptime;
3546 print_status_struct status;
3547
3548 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3549 W_ERROR_HAVE_NO_MEMORY(r->printername);
3550
3551 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3552 W_ERROR_HAVE_NO_MEMORY(r->servername);
3553
3554 count = print_queue_length(snum, &status);
3555
3556 /* check if we already have a counter for this printer */
3557 for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3558 if (session_counter->snum == snum)
3559 break;
3560 }
3561
3562 /* it's the first time, add it to the list */
3563 if (session_counter == NULL) {
3564 session_counter = SMB_MALLOC_P(counter_printer_0);
3565 W_ERROR_HAVE_NO_MEMORY(session_counter);
3566 ZERO_STRUCTP(session_counter);
3567 session_counter->snum = snum;
3568 session_counter->counter = 0;
3569 DLIST_ADD(counter_list, session_counter);
3570 }
3571
3572 /* increment it */
3573 session_counter->counter++;
3574
3575 r->cjobs = count;
3576 r->total_jobs = 0;
3577 r->total_bytes = 0;
3578
3579 setuptime = (time_t)ntprinter->info_2->setuptime;
3580
3581 init_systemtime(&r->time, gmtime(&setuptime));
3582
3583 /* JFM:
3584 * the global_counter should be stored in a TDB as it's common to all the clients
3585 * and should be zeroed on samba startup
3586 */
3587 r->global_counter = session_counter->counter;
3588 r->total_pages = 0;
3589 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3590 r->version = 0x0005; /* NT 5 */
3591 r->free_build = 0x0893; /* build 2195 */
3592 r->spooling = 0;
3593 r->max_spooling = 0;
3594 r->session_counter = session_counter->counter;
3595 r->num_error_out_of_paper = 0x0;
3596 r->num_error_not_ready = 0x0; /* number of print failure */
3597 r->job_error = 0x0;
3598 r->number_of_processors = 0x1;
3599 r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3600 r->high_part_total_bytes = 0x0;
3601 r->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3602 r->last_error = WERR_OK;
3603 r->status = nt_printq_status(status.status);
3604 r->enumerate_network_printers = 0x0;
3605 r->c_setprinter = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3606 r->processor_architecture = 0x0;
3607 r->processor_level = 0x6; /* 6 ???*/
3608 r->ref_ic = 0;
3609 r->reserved2 = 0;
3610 r->reserved3 = 0;
3611
3612 return WERR_OK;
3613 }
3614
3615 /****************************************************************************
3616 Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure. Both pointers
3617 should be valid upon entry
3618 ****************************************************************************/
3619
3620 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3621 struct spoolss_DeviceMode *r,
3622 const NT_DEVICEMODE *ntdevmode)
3623 {
3624 if (!r || !ntdevmode) {
3625 return WERR_INVALID_PARAM;
3626 }
3627
3628 r->devicename = talloc_strdup(mem_ctx, ntdevmode->devicename);
3629 W_ERROR_HAVE_NO_MEMORY(r->devicename);
3630
3631 r->specversion = ntdevmode->specversion;
3632 r->driverversion = ntdevmode->driverversion;
3633 r->size = ntdevmode->size;
3634 r->__driverextra_length = ntdevmode->driverextra;
3635 r->fields = ntdevmode->fields;
3636
3637 r->orientation = ntdevmode->orientation;
3638 r->papersize = ntdevmode->papersize;
3639 r->paperlength = ntdevmode->paperlength;
3640 r->paperwidth = ntdevmode->paperwidth;
3641 r->scale = ntdevmode->scale;
3642 r->copies = ntdevmode->copies;
3643 r->defaultsource = ntdevmode->defaultsource;
3644 r->printquality = ntdevmode->printquality;
3645 r->color = ntdevmode->color;
3646 r->duplex = ntdevmode->duplex;
3647 r->yresolution = ntdevmode->yresolution;
3648 r->ttoption = ntdevmode->ttoption;
3649 r->collate = ntdevmode->collate;
3650
3651 r->formname = talloc_strdup(mem_ctx, ntdevmode->formname);
3652 W_ERROR_HAVE_NO_MEMORY(r->formname);
3653
3654 /* all 0 below are values that have not been set in the old parsing/copy
3655 * function, maybe they should... - gd */
3656
3657 r->logpixels = 0;
3658 r->bitsperpel = 0;
3659 r->pelswidth = 0;
3660 r->pelsheight = 0;
3661 r->displayflags = 0;
3662 r->displayfrequency = 0;
3663 r->icmmethod = ntdevmode->icmmethod;
3664 r->icmintent = ntdevmode->icmintent;
3665 r->mediatype = ntdevmode->mediatype;
3666 r->dithertype = ntdevmode->dithertype;
3667 r->reserved1 = 0;
3668 r->reserved2 = 0;
3669 r->panningwidth = 0;
3670 r->panningheight = 0;
3671
3672 if (ntdevmode->nt_dev_private != NULL) {
3673 r->driverextra_data = data_blob_talloc(mem_ctx,
3674 ntdevmode->nt_dev_private,
3675 ntdevmode->driverextra);
3676 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3677 }
3678
3679 return WERR_OK;
3680 }
3681
3682
3683 /****************************************************************************
3684 Create a spoolss_DeviceMode struct. Returns talloced memory.
3685 ****************************************************************************/
3686
3687 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3688 const char *servicename)
3689 {
3690 WERROR result;
3691 NT_PRINTER_INFO_LEVEL *printer = NULL;
3692 struct spoolss_DeviceMode *devmode = NULL;
3693
3694 DEBUG(7,("construct_dev_mode\n"));
3695
3696 DEBUGADD(8,("getting printer characteristics\n"));
3697
3698 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3699 return NULL;
3700
3701 if (!printer->info_2->devmode) {
3702 DEBUG(5, ("BONG! There was no device mode!\n"));
3703 goto done;
3704 }
3705
3706 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3707 if (!devmode) {
3708 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3709 goto done;
3710 }
3711
3712 DEBUGADD(8,("loading DEVICEMODE\n"));
3713
3714 result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3715 if (!W_ERROR_IS_OK(result)) {
3716 TALLOC_FREE(devmode);
3717 }
3718
3719 done:
3720 free_a_printer(&printer,2);
3721
3722 return devmode;
3723 }
3724
3725 /********************************************************************
3726 * construct_printer_info1
3727 * fill a spoolss_PrinterInfo1 struct
3728 ********************************************************************/
3729
3730 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3731 const NT_PRINTER_INFO_LEVEL *ntprinter,
3732 uint32_t flags,
3733 struct spoolss_PrinterInfo1 *r,
3734 int snum)
3735 {
3736 r->flags = flags;
3737
3738 r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
3739 ntprinter->info_2->printername,
3740 ntprinter->info_2->drivername,
3741 ntprinter->info_2->location);
3742 W_ERROR_HAVE_NO_MEMORY(r->description);
3743
3744 if (*ntprinter->info_2->comment == '\0') {
3745 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
3746 } else {
3747 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
3748 }
3749 W_ERROR_HAVE_NO_MEMORY(r->comment);
3750
3751 r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3752 W_ERROR_HAVE_NO_MEMORY(r->name);
3753
3754 return WERR_OK;
3755 }
3756
3757 /********************************************************************
3758 * construct_printer_info2
3759 * fill a spoolss_PrinterInfo2 struct
3760 ********************************************************************/
3761
3762 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3763 const NT_PRINTER_INFO_LEVEL *ntprinter,
3764 struct spoolss_PrinterInfo2 *r,
3765 int snum)
3766 {
3767 int count;
3768
3769 print_status_struct status;
3770
3771 count = print_queue_length(snum, &status);
3772
3773 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3774 W_ERROR_HAVE_NO_MEMORY(r->servername);
3775 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3776 W_ERROR_HAVE_NO_MEMORY(r->printername);
3777 r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
3778 W_ERROR_HAVE_NO_MEMORY(r->sharename);
3779 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
3780 W_ERROR_HAVE_NO_MEMORY(r->portname);
3781 r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
3782 W_ERROR_HAVE_NO_MEMORY(r->drivername);
3783
3784 if (*ntprinter->info_2->comment == '\0') {
3785 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
3786 } else {
3787 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
3788 }
3789 W_ERROR_HAVE_NO_MEMORY(r->comment);
3790
3791 r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
3792 W_ERROR_HAVE_NO_MEMORY(r->location);
3793 r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
3794 W_ERROR_HAVE_NO_MEMORY(r->sepfile);
3795 r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
3796 W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
3797 r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
3798 W_ERROR_HAVE_NO_MEMORY(r->datatype);
3799 r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
3800 W_ERROR_HAVE_NO_MEMORY(r->parameters);
3801
3802 r->attributes = ntprinter->info_2->attributes;
3803
3804 r->priority = ntprinter->info_2->priority;
3805 r->defaultpriority = ntprinter->info_2->default_priority;
3806 r->starttime = ntprinter->info_2->starttime;
3807 r->untiltime = ntprinter->info_2->untiltime;
3808 r->status = nt_printq_status(status.status);
3809 r->cjobs = count;
3810 r->averageppm = ntprinter->info_2->averageppm;
3811
3812 r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
3813 if (!r->devmode) {
3814 DEBUG(8,("Returning NULL Devicemode!\n"));
3815 }
3816
3817 r->secdesc = NULL;
3818
3819 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3820 /* don't use talloc_steal() here unless you do a deep steal of all
3821 the SEC_DESC members */
3822
3823 r->secdesc = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
3824 }
3825
3826 return WERR_OK;
3827 }
3828
3829 /********************************************************************
3830 * construct_printer_info3
3831 * fill a spoolss_PrinterInfo3 struct
3832 ********************************************************************/
3833
3834 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3835 const NT_PRINTER_INFO_LEVEL *ntprinter,
3836 struct spoolss_PrinterInfo3 *r,
3837 int snum)
3838 {
3839 /* These are the components of the SD we are returning. */
3840
3841 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3842 /* don't use talloc_steal() here unless you do a deep steal of all
3843 the SEC_DESC members */
3844
3845 r->secdesc = dup_sec_desc(mem_ctx,
3846 ntprinter->info_2->secdesc_buf->sd);
3847 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3848 }
3849
3850 return WERR_OK;
3851 }
3852
3853 /********************************************************************
3854 * construct_printer_info4
3855 * fill a spoolss_PrinterInfo4 struct
3856 ********************************************************************/
3857
3858 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
3859 const NT_PRINTER_INFO_LEVEL *ntprinter,
3860 struct spoolss_PrinterInfo4 *r,
3861 int snum)
3862 {
3863 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3864 W_ERROR_HAVE_NO_MEMORY(r->printername);
3865 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3866 W_ERROR_HAVE_NO_MEMORY(r->servername);
3867
3868 r->attributes = ntprinter->info_2->attributes;
3869
3870 return WERR_OK;
3871 }
3872
3873 /********************************************************************
3874 * construct_printer_info5
3875 * fill a spoolss_PrinterInfo5 struct
3876 ********************************************************************/
3877
3878 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
3879 const NT_PRINTER_INFO_LEVEL *ntprinter,
3880 struct spoolss_PrinterInfo5 *r,
3881 int snum)
3882 {
3883 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3884 W_ERROR_HAVE_NO_MEMORY(r->printername);
3885 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
3886 W_ERROR_HAVE_NO_MEMORY(r->portname);
3887
3888 r->attributes = ntprinter->info_2->attributes;
3889
3890 /* these two are not used by NT+ according to MSDN */
3891
3892 r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
3893 r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
3894
3895 return WERR_OK;
3896 }
3897
3898 /********************************************************************
3899 * construct_printer_info_6
3900 * fill a spoolss_PrinterInfo6 struct
3901 ********************************************************************/
3902
3903 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
3904 const NT_PRINTER_INFO_LEVEL *ntprinter,
3905 struct spoolss_PrinterInfo6 *r,
3906 int snum)
3907 {
3908 int count;
3909 print_status_struct status;
3910
3911 count = print_queue_length(snum, &status);
3912
3913 r->status = nt_printq_status(status.status);
3914
3915 return WERR_OK;
3916 }
3917
3918 /********************************************************************
3919 * construct_printer_info7
3920 * fill a spoolss_PrinterInfo7 struct
3921 ********************************************************************/
3922
3923 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
3924 Printer_entry *print_hnd,
3925 struct spoolss_PrinterInfo7 *r,
3926 int snum)
3927 {
3928 struct GUID guid;
3929
3930 if (is_printer_published(print_hnd, snum, &guid)) {
3931 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
3932 r->action = DSPRINT_PUBLISH;
3933 } else {
3934 r->guid = talloc_strdup(mem_ctx, "");
3935 r->action = DSPRINT_UNPUBLISH;
3936 }
3937 W_ERROR_HAVE_NO_MEMORY(r->guid);
3938
3939 return WERR_OK;
3940 }
3941
3942 /********************************************************************
3943 * construct_printer_info8
3944 * fill a spoolss_PrinterInfo8 struct
3945 ********************************************************************/
3946
3947 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
3948 const NT_PRINTER_INFO_LEVEL *ntprinter,
3949 struct spoolss_DeviceModeInfo *r,
3950 int snum)
3951 {
3952 struct spoolss_DeviceMode *devmode;
3953 WERROR result;
3954
3955 if (!ntprinter->info_2->devmode) {
3956 r->devmode = NULL;
3957 return WERR_OK;
3958 }
3959
3960 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3961 W_ERROR_HAVE_NO_MEMORY(devmode);
3962
3963 result = convert_nt_devicemode(mem_ctx, devmode, ntprinter->info_2->devmode);
3964 if (!W_ERROR_IS_OK(result)) {
3965 TALLOC_FREE(devmode);
3966 return result;
3967 }
3968
3969 r->devmode = devmode;
3970
3971 return WERR_OK;
3972 }
3973
3974
3975 /********************************************************************
3976 ********************************************************************/
3977
3978 static bool snum_is_shared_printer(int snum)
3979 {
3980 return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
3981 }
3982
3983 /********************************************************************
3984 Spoolss_enumprinters.
3985 ********************************************************************/
3986
3987 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
3988 uint32_t level,
3989 uint32_t flags,
3990 union spoolss_PrinterInfo **info_p,
3991 uint32_t *count_p)
3992 {
3993 int snum;
3994 int n_services = lp_numservices();
3995 union spoolss_PrinterInfo *info = NULL;
3996 uint32_t count = 0;
3997 WERROR result = WERR_OK;
3998
3999 *count_p = 0;
4000 *info_p = NULL;
4001
4002 for (snum = 0; snum < n_services; snum++) {
4003
4004 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4005
4006 if (!snum_is_shared_printer(snum)) {
4007 continue;
4008 }
4009
4010 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4011 lp_servicename(snum), snum));
4012
4013 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4014 union spoolss_PrinterInfo,
4015 count + 1);
4016 if (!info) {
4017 result = WERR_NOMEM;
4018 goto out;
4019 }
4020
4021 result = get_a_printer(NULL, &ntprinter, 2,
4022 lp_const_servicename(snum));
4023 if (!W_ERROR_IS_OK(result)) {
4024 goto out;
4025 }
4026
4027 switch (level) {
4028 case 0:
4029 result = construct_printer_info0(info, ntprinter,
4030 &info[count].info0, snum);
4031 break;
4032 case 1:
4033 result = construct_printer_info1(info, ntprinter, flags,
4034 &info[count].info1, snum);
4035 break;
4036 case 2:
4037 result = construct_printer_info2(info, ntprinter,
4038 &info[count].info2, snum);
4039 break;
4040 case 4:
4041 result = construct_printer_info4(info, ntprinter,
4042 &info[count].info4, snum);
4043 break;
4044 case 5:
4045 result = construct_printer_info5(info, ntprinter,
4046 &info[count].info5, snum);
4047 break;
4048
4049 default:
4050 result = WERR_UNKNOWN_LEVEL;
4051 free_a_printer(&ntprinter, 2);
4052 goto out;
4053 }
4054
4055 free_a_printer(&ntprinter, 2);
4056 if (!W_ERROR_IS_OK(result)) {
4057 goto out;
4058 }
4059
4060 count++;
4061 }
4062
4063 *count_p = count;
4064 *info_p = info;
4065
4066 out:
4067 if (!W_ERROR_IS_OK(result)) {
4068 TALLOC_FREE(info);
4069 return result;
4070 }
4071
4072 *info_p = info;
4073
4074 return WERR_OK;
4075 }
4076
4077 /********************************************************************
4078 * handle enumeration of printers at level 0
4079 ********************************************************************/
4080
4081 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4082 uint32_t flags,
4083 const char *servername,
4084 union spoolss_PrinterInfo **info,
4085 uint32_t *count)
4086 {
4087 DEBUG(4,("enum_all_printers_info_0\n"));
4088
4089 return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4090 }
4091
4092
4093 /********************************************************************
4094 ********************************************************************/
4095
4096 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4097 uint32_t flags,
4098 union spoolss_PrinterInfo **info,
4099 uint32_t *count)
4100 {
4101 DEBUG(4,("enum_all_printers_info_1\n"));
4102
4103 return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4104 }
4105
4106 /********************************************************************
4107 enum_all_printers_info_1_local.
4108 *********************************************************************/
4109
4110 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4111 union spoolss_PrinterInfo **info,
4112 uint32_t *count)
4113 {
4114 DEBUG(4,("enum_all_printers_info_1_local\n"));
4115
4116 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4117 }
4118
4119 /********************************************************************
4120 enum_all_printers_info_1_name.
4121 *********************************************************************/
4122
4123 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4124 const char *name,
4125 union spoolss_PrinterInfo **info,
4126 uint32_t *count)
4127 {
4128 const char *s = name;
4129
4130 DEBUG(4,("enum_all_printers_info_1_name\n"));
4131
4132 if ((name[0] == '\\') && (name[1] == '\\')) {
4133 s = name + 2;
4134 }
4135
4136 if (!is_myname_or_ipaddr(s)) {
4137 return WERR_INVALID_NAME;
4138 }
4139
4140 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4141 }
4142
4143 /********************************************************************
4144 enum_all_printers_info_1_network.
4145 *********************************************************************/
4146
4147 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4148 const char *name,
4149 union spoolss_PrinterInfo **info,
4150 uint32_t *count)
4151 {
4152 const char *s = name;
4153
4154 DEBUG(4,("enum_all_printers_info_1_network\n"));
4155
4156 /* If we respond to a enum_printers level 1 on our name with flags
4157 set to PRINTER_ENUM_REMOTE with a list of printers then these
4158 printers incorrectly appear in the APW browse list.
4159 Specifically the printers for the server appear at the workgroup
4160 level where all the other servers in the domain are
4161 listed. Windows responds to this call with a
4162 WERR_CAN_NOT_COMPLETE so we should do the same. */
4163
4164 if (name[0] == '\\' && name[1] == '\\') {
4165 s = name + 2;
4166 }
4167
4168 if (is_myname_or_ipaddr(s)) {
4169 return WERR_CAN_NOT_COMPLETE;
4170 }
4171
4172 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4173 }
4174
4175 /********************************************************************
4176 * api_spoolss_enumprinters
4177 *
4178 * called from api_spoolss_enumprinters (see this to understand)
4179 ********************************************************************/
4180
4181 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4182 union spoolss_PrinterInfo **info,
4183 uint32_t *count)
4184 {
4185 DEBUG(4,("enum_all_printers_info_2\n"));
4186
4187 return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4188 }
4189
4190 /********************************************************************
4191 * handle enumeration of printers at level 1
4192 ********************************************************************/
4193
4194 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4195 uint32_t flags,
4196 const char *name,
4197 union spoolss_PrinterInfo **info,
4198 uint32_t *count)
4199 {
4200 /* Not all the flags are equals */
4201
4202 if (flags & PRINTER_ENUM_LOCAL) {
4203 return enum_all_printers_info_1_local(mem_ctx, info, count);
4204 }
4205
4206 if (flags & PRINTER_ENUM_NAME) {
4207 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4208 }
4209
4210 if (flags & PRINTER_ENUM_NETWORK) {
4211 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4212 }
4213
4214 return WERR_OK; /* NT4sp5 does that */
4215 }
4216
4217 /********************************************************************
4218 * handle enumeration of printers at level 2
4219 ********************************************************************/
4220
4221 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4222 uint32_t flags,
4223 const char *servername,
4224 union spoolss_PrinterInfo **info,
4225 uint32_t *count)
4226 {
4227 if (flags & PRINTER_ENUM_LOCAL) {
4228 return enum_all_printers_info_2(mem_ctx, info, count);
4229 }
4230
4231 if (flags & PRINTER_ENUM_NAME) {
4232 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4233 return WERR_INVALID_NAME;
4234 }
4235
4236 return enum_all_printers_info_2(mem_ctx, info, count);
4237 }
4238
4239 if (flags & PRINTER_ENUM_REMOTE) {
4240 return WERR_UNKNOWN_LEVEL;
4241 }
4242
4243 return WERR_OK;
4244 }
4245
4246 /********************************************************************
4247 * handle enumeration of printers at level 4
4248 ********************************************************************/
4249
4250 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4251 uint32_t flags,
4252 const char *servername,
4253 union spoolss_PrinterInfo **info,
4254 uint32_t *count)
4255 {
4256 DEBUG(4,("enum_all_printers_info_4\n"));
4257
4258 return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4259 }
4260
4261
4262 /********************************************************************
4263 * handle enumeration of printers at level 5
4264 ********************************************************************/
4265
4266 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4267 uint32_t flags,
4268 const char *servername,
4269 union spoolss_PrinterInfo **info,
4270 uint32_t *count)
4271 {
4272 DEBUG(4,("enum_all_printers_info_5\n"));
4273
4274 return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4275 }
4276
4277 /****************************************************************
4278 _spoolss_EnumPrinters
4279 ****************************************************************/
4280
4281 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4282 struct spoolss_EnumPrinters *r)
4283 {
4284 const char *name;
4285 WERROR result;
4286
4287 /* that's an [in out] buffer */
4288
4289 if (!r->in.buffer && (r->in.offered != 0)) {
4290 return WERR_INVALID_PARAM;
4291 }
4292
4293 DEBUG(4,("_spoolss_EnumPrinters\n"));
4294
4295 *r->out.needed = 0;
4296 *r->out.count = 0;
4297 *r->out.info = NULL;
4298
4299 /*
4300 * Level 1:
4301 * flags==PRINTER_ENUM_NAME
4302 * if name=="" then enumerates all printers
4303 * if name!="" then enumerate the printer
4304 * flags==PRINTER_ENUM_REMOTE
4305 * name is NULL, enumerate printers
4306 * Level 2: name!="" enumerates printers, name can't be NULL
4307 * Level 3: doesn't exist
4308 * Level 4: does a local registry lookup
4309 * Level 5: same as Level 2
4310 */
4311
4312 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4313 W_ERROR_HAVE_NO_MEMORY(name);
4314
4315 switch (r->in.level) {
4316 case 0:
4317 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4318 r->out.info, r->out.count);
4319 break;
4320 case 1:
4321 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4322 r->out.info, r->out.count);
4323 break;
4324 case 2:
4325 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4326 r->out.info, r->out.count);
4327 break;
4328 case 4:
4329 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4330 r->out.info, r->out.count);
4331 break;
4332 case 5:
4333 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4334 r->out.info, r->out.count);
4335 break;
4336 default:
4337 return WERR_UNKNOWN_LEVEL;
4338 }
4339
4340 if (!W_ERROR_IS_OK(result)) {
4341 return result;
4342 }
4343
4344 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4345 spoolss_EnumPrinters, NULL,
4346 *r->out.info, r->in.level,
4347 *r->out.count);
4348 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4349 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4350
4351 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4352 }
4353
4354 /****************************************************************
4355 _spoolss_GetPrinter
4356 ****************************************************************/
4357
4358 WERROR _spoolss_GetPrinter(pipes_struct *p,
4359 struct spoolss_GetPrinter *r)
4360 {
4361 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4362 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4363 WERROR result = WERR_OK;
4364
4365 int snum;
4366
4367 /* that's an [in out] buffer */
4368
4369 if (!r->in.buffer && (r->in.offered != 0)) {
4370 return WERR_INVALID_PARAM;
4371 }
4372
4373 *r->out.needed = 0;
4374
4375 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4376 return WERR_BADFID;
4377 }
4378
4379 result = get_a_printer(Printer, &ntprinter, 2,
4380 lp_const_servicename(snum));
4381 if (!W_ERROR_IS_OK(result)) {
4382 return result;
4383 }
4384
4385 switch (r->in.level) {
4386 case 0:
4387 result = construct_printer_info0(p->mem_ctx, ntprinter,
4388 &r->out.info->info0, snum);
4389 break;
4390 case 1:
4391 result = construct_printer_info1(p->mem_ctx, ntprinter,
4392 PRINTER_ENUM_ICON8,
4393 &r->out.info->info1, snum);
4394 break;
4395 case 2:
4396 result = construct_printer_info2(p->mem_ctx, ntprinter,
4397 &r->out.info->info2, snum);
4398 break;
4399 case 3:
4400 result = construct_printer_info3(p->mem_ctx, ntprinter,
4401 &r->out.info->info3, snum);
4402 break;
4403 case 4:
4404 result = construct_printer_info4(p->mem_ctx, ntprinter,
4405 &r->out.info->info4, snum);
4406 break;
4407 case 5:
4408 result = construct_printer_info5(p->mem_ctx, ntprinter,
4409 &r->out.info->info5, snum);
4410 break;
4411 case 6:
4412 result = construct_printer_info6(p->mem_ctx, ntprinter,
4413 &r->out.info->info6, snum);
4414 break;
4415 case 7:
4416 result = construct_printer_info7(p->mem_ctx, Printer,
4417 &r->out.info->info7, snum);
4418 break;
4419 case 8:
4420 result = construct_printer_info8(p->mem_ctx, ntprinter,
4421 &r->out.info->info8, snum);
4422 break;
4423 default:
4424 result = WERR_UNKNOWN_LEVEL;
4425 break;
4426 }
4427
4428 free_a_printer(&ntprinter, 2);
4429
4430 if (!W_ERROR_IS_OK(result)) {
4431 TALLOC_FREE(r->out.info);
4432 return result;
4433 }
4434
4435 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4436 r->out.info, r->in.level);
4437 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4438
4439 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4440 }
4441
4442 /********************************************************************
4443 ********************************************************************/
4444
4445 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4446 const char **string_array,
4447 const char *cservername)
4448 {
4449 int i, num_strings = 0;
4450 const char **array = NULL;
4451
4452 if (!string_array) {
4453 return NULL;
4454 }
4455
4456 for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4457
4458 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4459 cservername, string_array[i]);
4460 if (!str) {
4461 TALLOC_FREE(array);
4462 return NULL;
4463 }
4464
4465
4466 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4467 TALLOC_FREE(array);
4468 return NULL;
4469 }
4470 }
4471
4472 if (i > 0) {
4473 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4474 &array, &num_strings);
4475 }
4476
4477 return array;
4478 }
4479
4480 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4481 do { \
4482 if (in && strlen(in)) { \
4483 out = talloc_strdup(mem_ctx, in); \
4484 W_ERROR_HAVE_NO_MEMORY(out); \
4485 } else { \
4486 out = NULL; \
4487 } \
4488 } while (0);
4489
4490 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, in, out) \
4491 do { \
4492 if (in && strlen(in)) { \
4493 out = talloc_asprintf(mem_ctx, "\\\\%s%s", server, in); \
4494 } else { \
4495 out = talloc_strdup(mem_ctx, ""); \
4496 } \
4497 W_ERROR_HAVE_NO_MEMORY(out); \
4498 } while (0);
4499
4500 /********************************************************************
4501 * fill a spoolss_DriverInfo1 struct
4502 ********************************************************************/
4503
4504 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4505 struct spoolss_DriverInfo1 *r,
4506 const struct spoolss_DriverInfo8 *driver,
4507 const char *servername)
4508 {
4509 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4510 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4511
4512 return WERR_OK;
4513 }
4514
4515 /********************************************************************
4516 * fill a spoolss_DriverInfo2 struct
4517 ********************************************************************/
4518
4519 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4520 struct spoolss_DriverInfo2 *r,
4521 const struct spoolss_DriverInfo8 *driver,
4522 const char *servername)
4523
4524 {
4525 const char *cservername = canon_servername(servername);
4526
4527 r->version = driver->version;
4528
4529 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4530 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4531 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4532 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4533
4534 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4535 driver->driver_path,
4536 r->driver_path);
4537
4538 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4539 driver->data_file,
4540 r->data_file);
4541
4542 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4543 driver->config_file,
4544 r->config_file);
4545
4546 return WERR_OK;
4547 }
4548
4549 /********************************************************************
4550 * fill a spoolss_DriverInfo3 struct
4551 ********************************************************************/
4552
4553 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4554 struct spoolss_DriverInfo3 *r,
4555 const struct spoolss_DriverInfo8 *driver,
4556 const char *servername)
4557 {
4558 const char *cservername = canon_servername(servername);
4559
4560 r->version = driver->version;
4561
4562 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4563 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4564 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4565 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4566
4567 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4568 driver->driver_path,
4569 r->driver_path);
4570
4571 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4572 driver->data_file,
4573 r->data_file);
4574
4575 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4576 driver->config_file,
4577 r->config_file);
4578
4579 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4580 driver->help_file,
4581 r->help_file);
4582
4583 FILL_DRIVER_STRING(mem_ctx,
4584 driver->monitor_name,
4585 r->monitor_name);
4586
4587 FILL_DRIVER_STRING(mem_ctx,
4588 driver->default_datatype,
4589 r->default_datatype);
4590
4591 r->dependent_files = string_array_from_driver_info(mem_ctx,
4592 driver->dependent_files,
4593 cservername);
4594 return WERR_OK;
4595 }
4596
4597 /********************************************************************
4598 * fill a spoolss_DriverInfo4 struct
4599 ********************************************************************/
4600
4601 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4602 struct spoolss_DriverInfo4 *r,
4603 const struct spoolss_DriverInfo8 *driver,
4604 const char *servername)
4605 {
4606 const char *cservername = canon_servername(servername);
4607
4608 r->version = driver->version;
4609
4610 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4611 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4612 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4613 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4614
4615 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4616 driver->driver_path,
4617 r->driver_path);
4618
4619 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4620 driver->data_file,
4621 r->data_file);
4622
4623 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4624 driver->config_file,
4625 r->config_file);
4626
4627 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4628 driver->help_file,
4629 r->help_file);
4630
4631 r->dependent_files = string_array_from_driver_info(mem_ctx,
4632 driver->dependent_files,
4633 cservername);
4634
4635 FILL_DRIVER_STRING(mem_ctx,
4636 driver->monitor_name,
4637 r->monitor_name);
4638
4639 FILL_DRIVER_STRING(mem_ctx,
4640 driver->default_datatype,
4641 r->default_datatype);
4642
4643 r->previous_names = string_array_from_driver_info(mem_ctx,
4644 driver->previous_names,
4645 cservername);
4646
4647 return WERR_OK;
4648 }
4649
4650 /********************************************************************
4651 * fill a spoolss_DriverInfo5 struct
4652 ********************************************************************/
4653
4654 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4655 struct spoolss_DriverInfo5 *r,
4656 const struct spoolss_DriverInfo8 *driver,
4657 const char *servername)
4658 {
4659 const char *cservername = canon_servername(servername);
4660
4661 r->version = driver->version;
4662
4663 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4664 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4665 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4666 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4667
4668 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4669 driver->driver_path,
4670 r->driver_path);
4671
4672 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4673 driver->data_file,
4674 r->data_file);
4675
4676 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4677 driver->config_file,
4678 r->config_file);
4679
4680 r->driver_attributes = 0;
4681 r->config_version = 0;
4682 r->driver_version = 0;
4683
4684 return WERR_OK;
4685 }
4686 /********************************************************************
4687 * fill a spoolss_DriverInfo6 struct
4688 ********************************************************************/
4689
4690 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4691 struct spoolss_DriverInfo6 *r,
4692 const struct spoolss_DriverInfo8 *driver,
4693 const char *servername)
4694 {
4695 const char *cservername = canon_servername(servername);
4696
4697 r->version = driver->version;
4698
4699 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4700 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4701 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4702 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4703
4704 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4705 driver->driver_path,
4706 r->driver_path);
4707
4708 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4709 driver->data_file,
4710 r->data_file);
4711
4712 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4713 driver->config_file,
4714 r->config_file);
4715
4716 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4717 driver->help_file,
4718 r->help_file);
4719
4720 FILL_DRIVER_STRING(mem_ctx,
4721 driver->monitor_name,
4722 r->monitor_name);
4723
4724 FILL_DRIVER_STRING(mem_ctx,
4725 driver->default_datatype,
4726 r->default_datatype);
4727
4728 r->dependent_files = string_array_from_driver_info(mem_ctx,
4729 driver->dependent_files,
4730 cservername);
4731 r->previous_names = string_array_from_driver_info(mem_ctx,
4732 driver->previous_names,
4733 cservername);
4734
4735 r->driver_date = driver->driver_date;
4736 r->driver_version = driver->driver_version;
4737
4738 FILL_DRIVER_STRING(mem_ctx,
4739 driver->manufacturer_name,
4740 r->manufacturer_name);
4741 FILL_DRIVER_STRING(mem_ctx,
4742 driver->manufacturer_url,
4743 r->manufacturer_url);
4744 FILL_DRIVER_STRING(mem_ctx,
4745 driver->hardware_id,
4746 r->hardware_id);
4747 FILL_DRIVER_STRING(mem_ctx,
4748 driver->provider,
4749 r->provider);
4750
4751 return WERR_OK;
4752 }
4753
4754 /********************************************************************
4755 * fill a spoolss_DriverInfo8 struct
4756 ********************************************************************/
4757
4758 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
4759 struct spoolss_DriverInfo8 *r,
4760 const struct spoolss_DriverInfo8 *driver,
4761 const char *servername)
4762 {
4763 const char *cservername = canon_servername(servername);
4764
4765 r->version = driver->version;
4766
4767 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4768 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4769 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4770 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4771
4772 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4773 driver->driver_path,
4774 r->driver_path);
4775
4776 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4777 driver->data_file,
4778 r->data_file);
4779
4780 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4781 driver->config_file,
4782 r->config_file);
4783
4784 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4785 driver->help_file,
4786 r->help_file);
4787
4788 FILL_DRIVER_STRING(mem_ctx,
4789 driver->monitor_name,
4790 r->monitor_name);
4791
4792 FILL_DRIVER_STRING(mem_ctx,
4793 driver->default_datatype,
4794 r->default_datatype);
4795
4796 r->dependent_files = string_array_from_driver_info(mem_ctx,
4797 driver->dependent_files,
4798 cservername);
4799 r->previous_names = string_array_from_driver_info(mem_ctx,
4800 driver->previous_names,
4801 cservername);
4802
4803 r->driver_date = driver->driver_date;
4804 r->driver_version = driver->driver_version;
4805
4806 FILL_DRIVER_STRING(mem_ctx,
4807 driver->manufacturer_name,
4808 r->manufacturer_name);
4809 FILL_DRIVER_STRING(mem_ctx,
4810 driver->manufacturer_url,
4811 r->manufacturer_url);
4812 FILL_DRIVER_STRING(mem_ctx,
4813 driver->hardware_id,
4814 r->hardware_id);
4815 FILL_DRIVER_STRING(mem_ctx,
4816 driver->provider,
4817 r->provider);
4818
4819 FILL_DRIVER_STRING(mem_ctx,
4820 driver->print_processor,
4821 r->print_processor);
4822 FILL_DRIVER_STRING(mem_ctx,
4823 driver->vendor_setup,
4824 r->vendor_setup);
4825
4826 r->color_profiles = string_array_from_driver_info(mem_ctx,
4827 driver->color_profiles,
4828 cservername);
4829
4830 FILL_DRIVER_STRING(mem_ctx,
4831 driver->inf_path,
4832 r->inf_path);
4833
4834 r->printer_driver_attributes = driver->printer_driver_attributes;
4835
4836 r->core_driver_dependencies = string_array_from_driver_info(mem_ctx,
4837 driver->core_driver_dependencies,
4838 cservername);
4839
4840 r->min_inbox_driver_ver_date = driver->min_inbox_driver_ver_date;
4841 r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
4842
4843 return WERR_OK;
4844 }
4845 /********************************************************************
4846 ********************************************************************/
4847
4848 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
4849 struct spoolss_DriverFileInfo *r,
4850 const char *cservername,
4851 const char *file_name,
4852 enum spoolss_DriverFileType file_type,
4853 uint32_t file_version)
4854 {
4855 r->file_name = talloc_asprintf(mem_ctx, "\\\\%s%s",
4856 cservername, file_name);
4857 W_ERROR_HAVE_NO_MEMORY(r->file_name);
4858 r->file_type = file_type;
4859 r->file_version = file_version;
4860
4861 return WERR_OK;
4862 }
4863
4864 /********************************************************************
4865 ********************************************************************/
4866
4867 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
4868 const struct spoolss_DriverInfo8 *driver,
4869 const char *cservername,
4870 struct spoolss_DriverFileInfo **info_p,
4871 uint32_t *count_p)
4872 {
4873 struct spoolss_DriverFileInfo *info = NULL;
4874 uint32_t count = 0;
4875 WERROR result;
4876 uint32_t i;
4877
4878 *info_p = NULL;
4879 *count_p = 0;
4880
4881 if (strlen(driver->driver_path)) {
4882 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4883 struct spoolss_DriverFileInfo,
4884 count + 1);
4885 W_ERROR_HAVE_NO_MEMORY(info);
4886 result = fill_spoolss_DriverFileInfo(info,
4887 &info[count],
4888 cservername,
4889 driver->driver_path,
4890 SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
4891 0);
4892 W_ERROR_NOT_OK_RETURN(result);
4893 count++;
4894 }
4895
4896 if (strlen(driver->config_file)) {
4897 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4898 struct spoolss_DriverFileInfo,
4899 count + 1);
4900 W_ERROR_HAVE_NO_MEMORY(info);
4901 result = fill_spoolss_DriverFileInfo(info,
4902 &info[count],
4903 cservername,
4904 driver->config_file,
4905 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
4906 0);
4907 W_ERROR_NOT_OK_RETURN(result);
4908 count++;
4909 }
4910
4911 if (strlen(driver->data_file)) {
4912 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4913 struct spoolss_DriverFileInfo,
4914 count + 1);
4915 W_ERROR_HAVE_NO_MEMORY(info);
4916 result = fill_spoolss_DriverFileInfo(info,
4917 &info[count],
4918 cservername,
4919 driver->data_file,
4920 SPOOLSS_DRIVER_FILE_TYPE_DATA,
4921 0);
4922 W_ERROR_NOT_OK_RETURN(result);
4923 count++;
4924 }
4925
4926 if (strlen(driver->help_file)) {
4927 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4928 struct spoolss_DriverFileInfo,
4929 count + 1);
4930 W_ERROR_HAVE_NO_MEMORY(info);
4931 result = fill_spoolss_DriverFileInfo(info,
4932 &info[count],
4933 cservername,
4934 driver->help_file,
4935 SPOOLSS_DRIVER_FILE_TYPE_HELP,
4936 0);
4937 W_ERROR_NOT_OK_RETURN(result);
4938 count++;
4939 }
4940
4941 for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
4942 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4943 struct spoolss_DriverFileInfo,
4944 count + 1);
4945 W_ERROR_HAVE_NO_MEMORY(info);
4946 result = fill_spoolss_DriverFileInfo(info,
4947 &info[count],
4948 cservername,
4949 driver->dependent_files[i],
4950 SPOOLSS_DRIVER_FILE_TYPE_OTHER,
4951 0);
4952 W_ERROR_NOT_OK_RETURN(result);
4953 count++;
4954 }
4955
4956 *info_p = info;
4957 *count_p = count;
4958
4959 return WERR_OK;
4960 }
4961
4962 /********************************************************************
4963 * fill a spoolss_DriverInfo101 sttruct
4964 ********************************************************************/
4965
4966 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
4967 struct spoolss_DriverInfo101 *r,
4968 const struct spoolss_DriverInfo8 *driver,
4969 const char *servername)
4970 {
4971 const char *cservername = canon_servername(servername);
4972 WERROR result;
4973
4974 r->version = driver->version;
4975
4976 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4977 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4978 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4979 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4980
4981 result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
4982 cservername,
4983 &r->file_info,
4984 &r->file_count);
4985 if (!W_ERROR_IS_OK(result)) {
4986 return result;
4987 }
4988
4989 FILL_DRIVER_STRING(mem_ctx,
4990 driver->monitor_name,
4991 r->monitor_name);
4992
4993 FILL_DRIVER_STRING(mem_ctx,
4994 driver->default_datatype,
4995 r->default_datatype);
4996
4997 r->previous_names = string_array_from_driver_info(mem_ctx,
4998 driver->previous_names,
4999 cservername);
5000 r->driver_date = driver->driver_date;
5001 r->driver_version = driver->driver_version;
5002
5003 FILL_DRIVER_STRING(mem_ctx,
5004 driver->manufacturer_name,
5005 r->manufacturer_name);
5006 FILL_DRIVER_STRING(mem_ctx,
5007 driver->manufacturer_url,
5008 r->manufacturer_url);
5009 FILL_DRIVER_STRING(mem_ctx,
5010 driver->hardware_id,
5011 r->hardware_id);
5012 FILL_DRIVER_STRING(mem_ctx,
5013 driver->provider,
5014 r->provider);
5015
5016 return WERR_OK;
5017 }
5018
5019 /********************************************************************
5020 ********************************************************************/
5021
5022 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
5023 uint32_t level,
5024 union spoolss_DriverInfo *r,
5025 int snum,
5026 const char *servername,
5027 const char *architecture,
5028 uint32_t version)
5029 {
5030 NT_PRINTER_INFO_LEVEL *printer = NULL;
5031 struct spoolss_DriverInfo8 *driver;
5032 WERROR result;
5033
5034 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5035
5036 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5037 win_errstr(result)));
5038
5039 if (!W_ERROR_IS_OK(result)) {
5040 return WERR_INVALID_PRINTER_NAME;
5041 }
5042
5043 result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
5044 architecture, version);
5045
5046 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5047 win_errstr(result)));
5048
5049 if (!W_ERROR_IS_OK(result)) {
5050 /*
5051 * Is this a W2k client ?
5052 */
5053
5054 if (version < 3) {
5055 free_a_printer(&printer, 2);
5056 return WERR_UNKNOWN_PRINTER_DRIVER;
5057 }
5058
5059 /* Yes - try again with a WinNT driver. */
5060 version = 2;
5061 result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
5062 architecture, version);
5063 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5064 win_errstr(result)));
5065 if (!W_ERROR_IS_OK(result)) {
5066 free_a_printer(&printer, 2);
5067 return WERR_UNKNOWN_PRINTER_DRIVER;
5068 }
5069 }
5070
5071 switch (level) {
5072 case 1:
5073 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5074 break;
5075 case 2:
5076 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5077 break;
5078 case 3:
5079 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5080 break;
5081 case 4:
5082 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5083 break;
5084 case 5:
5085 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5086 break;
5087 case 6:
5088 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5089 break;
5090 case 8:
5091 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5092 break;
5093 case 101:
5094 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5095 break;
5096 default:
5097 result = WERR_UNKNOWN_LEVEL;
5098 break;
5099 }
5100
5101 free_a_printer(&printer, 2);
5102 free_a_printer_driver(driver);
5103
5104 return result;
5105 }
5106
5107 /****************************************************************
5108 _spoolss_GetPrinterDriver2
5109 ****************************************************************/
5110
5111 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5112 struct spoolss_GetPrinterDriver2 *r)
5113 {
5114 Printer_entry *printer;
5115 WERROR result;
5116
5117 const char *servername;
5118 int snum;
5119
5120 /* that's an [in out] buffer */
5121
5122 if (!r->in.buffer && (r->in.offered != 0)) {
5123 return WERR_INVALID_PARAM;
5124 }
5125
5126 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5127
5128 if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5129 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5130 return WERR_INVALID_PRINTER_NAME;
5131 }
5132
5133 *r->out.needed = 0;
5134 *r->out.server_major_version = 0;
5135 *r->out.server_minor_version = 0;
5136
5137 servername = get_server_name(printer);
5138
5139 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5140 return WERR_BADFID;
5141 }
5142
5143 result = construct_printer_driver_info_level(p->mem_ctx, r->in.level,
5144 r->out.info, snum,
5145 servername,
5146 r->in.architecture,
5147 r->in.client_major_version);
5148 if (!W_ERROR_IS_OK(result)) {
5149 TALLOC_FREE(r->out.info);
5150 return result;
5151 }
5152
5153 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5154 r->out.info, r->in.level);
5155 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5156
5157 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5158 }
5159
5160
5161 /****************************************************************
5162 _spoolss_StartPagePrinter
5163 ****************************************************************/
5164
5165 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5166 struct spoolss_StartPagePrinter *r)
5167 {
5168 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5169
5170 if (!Printer) {
5171 DEBUG(3,("_spoolss_StartPagePrinter: "
5172 "Error in startpageprinter printer handle\n"));
5173 return WERR_BADFID;
5174 }
5175
5176 Printer->page_started = true;
5177 return WERR_OK;
5178 }
5179
5180 /****************************************************************
5181 _spoolss_EndPagePrinter
5182 ****************************************************************/
5183
5184 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5185 struct spoolss_EndPagePrinter *r)
5186 {
5187 int snum;
5188
5189 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5190
5191 if (!Printer) {
5192 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5193 OUR_HANDLE(r->in.handle)));
5194 return WERR_BADFID;
5195 }
5196
5197 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5198 return WERR_BADFID;
5199
5200 Printer->page_started = false;
5201 print_job_endpage(snum, Printer->jobid);
5202
5203 return WERR_OK;
5204 }
5205
5206 /****************************************************************
5207 _spoolss_StartDocPrinter
5208 ****************************************************************/
5209
5210 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5211 struct spoolss_StartDocPrinter *r)
5212 {
5213 struct spoolss_DocumentInfo1 *info_1;
5214 int snum;
5215 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5216
5217 if (!Printer) {
5218 DEBUG(2,("_spoolss_StartDocPrinter: "
5219 "Invalid handle (%s:%u:%u)\n",
5220 OUR_HANDLE(r->in.handle)));
5221 return WERR_BADFID;
5222 }
5223
5224 if (r->in.level != 1) {
5225 return WERR_UNKNOWN_LEVEL;
5226 }
5227
5228 info_1 = r->in.info.info1;
5229
5230 /*
5231 * a nice thing with NT is it doesn't listen to what you tell it.
5232 * when asked to send _only_ RAW datas, it tries to send datas
5233 * in EMF format.
5234 *
5235 * So I add checks like in NT Server ...
5236 */
5237
5238 if (info_1->datatype) {
5239 if (strcmp(info_1->datatype, "RAW") != 0) {
5240 *r->out.job_id = 0;
5241 return WERR_INVALID_DATATYPE;
5242 }
5243 }
5244
5245 /* get the share number of the printer */
5246 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5247 return WERR_BADFID;
5248 }
5249
5250 Printer->jobid = print_job_start(p->server_info, snum,
5251 info_1->document_name,
5252 Printer->nt_devmode);
5253
5254 /* An error occured in print_job_start() so return an appropriate
5255 NT error code. */
5256
5257 if (Printer->jobid == -1) {
5258 return map_werror_from_unix(errno);
5259 }
5260
5261 Printer->document_started = true;
5262 *r->out.job_id = Printer->jobid;
5263
5264 return WERR_OK;
5265 }
5266
5267 /****************************************************************
5268 _spoolss_EndDocPrinter
5269 ****************************************************************/
5270
5271 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5272 struct spoolss_EndDocPrinter *r)
5273 {
5274 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5275 int snum;
5276
5277 if (!Printer) {
5278 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5279 OUR_HANDLE(r->in.handle)));
5280 return WERR_BADFID;
5281 }
5282
5283 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5284 return WERR_BADFID;
5285 }
5286
5287 Printer->document_started = false;
5288 print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
5289 /* error codes unhandled so far ... */
5290
5291 return WERR_OK;
5292 }
5293
5294 /****************************************************************
5295 _spoolss_WritePrinter
5296 ****************************************************************/
5297
5298 WERROR _spoolss_WritePrinter(pipes_struct *p,
5299 struct spoolss_WritePrinter *r)
5300 {
5301 uint32_t buffer_written;
5302 int snum;
5303 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5304
5305 if (!Printer) {
5306 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5307 OUR_HANDLE(r->in.handle)));
5308 *r->out.num_written = r->in._data_size;
5309 return WERR_BADFID;
5310 }
5311
5312 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5313 return WERR_BADFID;
5314
5315 buffer_written = (uint32_t)print_job_write(snum, Printer->jobid,
5316 (const char *)r->in.data.data,
5317 (SMB_OFF_T)-1,
5318 (size_t)r->in._data_size);
5319 if (buffer_written == (uint32_t)-1) {
5320 *r->out.num_written = 0;
5321 if (errno == ENOSPC)
5322 return WERR_NO_SPOOL_SPACE;
5323 else
5324 return WERR_ACCESS_DENIED;
5325 }
5326
5327 *r->out.num_written = r->in._data_size;
5328
5329 return WERR_OK;
5330 }
5331
5332 /********************************************************************
5333 * api_spoolss_getprinter
5334 * called from the spoolss dispatcher
5335 *
5336 ********************************************************************/
5337
5338 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5339 pipes_struct *p)
5340 {
5341 int snum;
5342 WERROR errcode = WERR_BADFUNC;
5343 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5344
5345 if (!Printer) {
5346 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5347 OUR_HANDLE(handle)));
5348 return WERR_BADFID;
5349 }
5350
5351 if (!get_printer_snum(p, handle, &snum, NULL))
5352 return WERR_BADFID;
5353
5354 switch (command) {
5355 case SPOOLSS_PRINTER_CONTROL_PAUSE:
5356 errcode = print_queue_pause(p->server_info, snum);
5357 break;
5358 case SPOOLSS_PRINTER_CONTROL_RESUME:
5359 case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5360 errcode = print_queue_resume(p->server_info, snum);
5361 break;
5362 case SPOOLSS_PRINTER_CONTROL_PURGE:
5363 errcode = print_queue_purge(p->server_info, snum);
5364 break;
5365 default:
5366 return WERR_UNKNOWN_LEVEL;
5367 }
5368
5369 return errcode;
5370 }
5371
5372
5373 /****************************************************************
5374 _spoolss_AbortPrinter
5375 * From MSDN: "Deletes printer's spool file if printer is configured
5376 * for spooling"
5377 ****************************************************************/
5378
5379 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5380 struct spoolss_AbortPrinter *r)
5381 {
5382 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5383 int snum;
5384 WERROR errcode = WERR_OK;
5385
5386 if (!Printer) {
5387 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5388 OUR_HANDLE(r->in.handle)));
5389 return WERR_BADFID;
5390 }
5391
5392 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5393 return WERR_BADFID;
5394
5395 print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5396
5397 return errcode;
5398 }
5399
5400 /********************************************************************
5401 * called by spoolss_api_setprinter
5402 * when updating a printer description
5403 ********************************************************************/
5404
5405 static WERROR update_printer_sec(struct policy_handle *handle,
5406 pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5407 {
5408 SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5409 WERROR result;
5410 int snum;
5411
5412 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5413
5414 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5415 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5416 OUR_HANDLE(handle)));
5417
5418 result = WERR_BADFID;
5419 goto done;
5420 }
5421
5422 if (!secdesc_ctr) {
5423 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5424 result = WERR_INVALID_PARAM;
5425 goto done;
5426 }
5427
5428 /* Check the user has permissions to change the security
5429 descriptor. By experimentation with two NT machines, the user
5430 requires Full Access to the printer to change security
5431 information. */
5432
5433 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5434 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5435 result = WERR_ACCESS_DENIED;
5436 goto done;
5437 }
5438
5439 /* NT seems to like setting the security descriptor even though
5440 nothing may have actually changed. */
5441
5442 if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5443 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5444 result = WERR_BADFID;
5445 goto done;
5446 }
5447
5448 if (DEBUGLEVEL >= 10) {
5449 SEC_ACL *the_acl;
5450 int i;
5451
5452 the_acl = old_secdesc_ctr->sd->dacl;
5453 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5454 PRINTERNAME(snum), the_acl->num_aces));
5455
5456 for (i = 0; i < the_acl->num_aces; i++) {
5457 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5458 &the_acl->aces[i].trustee),
5459 the_acl->aces[i].access_mask));
5460 }
5461
5462 the_acl = secdesc_ctr->sd->dacl;
5463
5464 if (the_acl) {
5465 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5466 PRINTERNAME(snum), the_acl->num_aces));
5467
5468 for (i = 0; i < the_acl->num_aces; i++) {
5469 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5470 &the_acl->aces[i].trustee),
5471 the_acl->aces[i].access_mask));
5472 }
5473 } else {
5474 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5475 }
5476 }
5477
5478 new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5479 if (!new_secdesc_ctr) {
5480 result = WERR_NOMEM;
5481 goto done;
5482 }
5483
5484 if (security_descriptor_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5485 result = WERR_OK;
5486 goto done;
5487 }
5488
5489 result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5490
5491 done:
5492
5493 return result;
5494 }
5495
5496 /********************************************************************
5497 Canonicalize printer info from a client
5498
5499 ATTN: It does not matter what we set the servername to hear
5500 since we do the necessary work in get_a_printer() to set it to
5501 the correct value based on what the client sent in the
5502 _spoolss_open_printer_ex().
5503 ********************************************************************/
5504
5505 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5506 {
5507 fstring printername;
5508 const char *p;
5509
5510 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5511 "portname=%s drivername=%s comment=%s location=%s\n",
5512 info->servername, info->printername, info->sharename,
5513 info->portname, info->drivername, info->comment, info->location));
5514
5515 /* we force some elements to "correct" values */
5516 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5517 fstrcpy(info->sharename, lp_servicename(snum));
5518
5519 /* check to see if we allow printername != sharename */
5520
5521 if ( lp_force_printername(snum) ) {
5522 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5523 global_myname(), info->sharename );
5524 } else {
5525
5526 /* make sure printername is in \\server\printername format */
5527
5528 fstrcpy( printername, info->printername );
5529 p = printername;
5530 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5531 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5532 p++;
5533 }
5534
5535 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5536 global_myname(), p );
5537 }
5538
5539 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5540 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5541
5542
5543
5544 return true;
5545 }
5546
5547 /****************************************************************************
5548 ****************************************************************************/
5549
5550 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5551 {
5552 char *cmd = lp_addport_cmd();
5553 char *command = NULL;
5554 int ret;
5555 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5556 bool is_print_op = false;
5557
5558 if ( !*cmd ) {
5559 return WERR_ACCESS_DENIED;
5560 }
5561
5562 command = talloc_asprintf(ctx,
5563 "%s \"%s\" \"%s\"", cmd, portname, uri );
5564 if (!command) {
5565 return WERR_NOMEM;
5566 }
5567
5568 if ( token )
5569 is_print_op = user_has_privileges( token, &se_printop );
5570
5571 DEBUG(10,("Running [%s]\n", command));
5572
5573 /********* BEGIN SePrintOperatorPrivilege **********/
5574
5575 if ( is_print_op )
5576 become_root();
5577
5578 ret = smbrun(command, NULL);
5579
5580 if ( is_print_op )
5581 unbecome_root();
5582
5583 /********* END SePrintOperatorPrivilege **********/
5584
5585 DEBUGADD(10,("returned [%d]\n", ret));
5586
5587 TALLOC_FREE(command);
5588
5589 if ( ret != 0 ) {
5590 return WERR_ACCESS_DENIED;
5591 }
5592
5593 return WERR_OK;
5594 }
5595
5596 /****************************************************************************
5597 ****************************************************************************/
5598
5599 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5600 {
5601 char *cmd = lp_addprinter_cmd();
5602 char **qlines;
5603 char *command = NULL;
5604 int numlines;
5605 int ret;
5606 int fd;
5607 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5608 bool is_print_op = false;
5609 char *remote_machine = talloc_strdup(ctx, "%m");
5610
5611 if (!remote_machine) {
5612 return false;
5613 }
5614 remote_machine = talloc_sub_basic(ctx,
5615 current_user_info.smb_name,
5616 current_user_info.domain,
5617 remote_machine);
5618 if (!remote_machine) {
5619 return false;
5620 }
5621
5622 command = talloc_asprintf(ctx,
5623 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5624 cmd, printer->info_2->printername, printer->info_2->sharename,
5625 printer->info_2->portname, printer->info_2->drivername,
5626 printer->info_2->location, printer->info_2->comment, remote_machine);
5627 if (!command) {
5628 return false;
5629 }
5630
5631 if ( token )
5632 is_print_op = user_has_privileges( token, &se_printop );
5633
5634 DEBUG(10,("Running [%s]\n", command));
5635
5636 /********* BEGIN SePrintOperatorPrivilege **********/
5637
5638 if ( is_print_op )
5639 become_root();
5640
5641 if ( (ret = smbrun(command, &fd)) == 0 ) {
5642 /* Tell everyone we updated smb.conf. */
5643 message_send_all(smbd_messaging_context(),
5644 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
5645 }
5646
5647 if ( is_print_op )
5648 unbecome_root();
5649
5650 /********* END SePrintOperatorPrivilege **********/
5651
5652 DEBUGADD(10,("returned [%d]\n", ret));
5653
5654 TALLOC_FREE(command);
5655 TALLOC_FREE(remote_machine);
5656
5657 if ( ret != 0 ) {
5658 if (fd != -1)
5659 close(fd);
5660 return false;
5661 }
5662
5663 /* reload our services immediately */
5664 become_root();
5665 reload_services(false);
5666 unbecome_root();
5667
5668 numlines = 0;
5669 /* Get lines and convert them back to dos-codepage */
5670 qlines = fd_lines_load(fd, &numlines, 0, NULL);
5671 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5672 close(fd);
5673
5674 /* Set the portname to what the script says the portname should be. */
5675 /* but don't require anything to be return from the script exit a good error code */
5676
5677 if (numlines) {
5678 /* Set the portname to what the script says the portname should be. */
5679 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
5680 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
5681 }
5682
5683 TALLOC_FREE(qlines);
5684 return true;
5685 }
5686
5687
5688 /********************************************************************
5689 * Called by spoolss_api_setprinter
5690 * when updating a printer description.
5691 ********************************************************************/
5692
5693 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
5694 struct spoolss_SetPrinterInfoCtr *info_ctr,
5695 struct spoolss_DeviceMode *devmode)
5696 {
5697 int snum;
5698 NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
5699 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5700 WERROR result;
5701 DATA_BLOB buffer;
5702 fstring asc_buffer;
5703
5704 DEBUG(8,("update_printer\n"));
5705
5706 result = WERR_OK;
5707
5708 if (!Printer) {
5709 result = WERR_BADFID;
5710 goto done;
5711 }
5712
5713 if (!get_printer_snum(p, handle, &snum, NULL)) {
5714 result = WERR_BADFID;
5715 goto done;
5716 }
5717
5718 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
5719 (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
5720 result = WERR_BADFID;
5721 goto done;
5722 }
5723
5724 DEBUGADD(8,("Converting info_2 struct\n"));
5725
5726 /*
5727 * convert_printer_info converts the incoming
5728 * info from the client and overwrites the info
5729 * just read from the tdb in the pointer 'printer'.
5730 */
5731
5732 if (!convert_printer_info(info_ctr, printer)) {
5733 result = WERR_NOMEM;
5734 goto done;
5735 }
5736
5737 if (devmode) {
5738 /* we have a valid devmode
5739 convert it and link it*/
5740
5741 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5742 if (!convert_devicemode(printer->info_2->printername, devmode,
5743 &printer->info_2->devmode)) {
5744 result = WERR_NOMEM;
5745 goto done;
5746 }
5747 }
5748
5749 /* Do sanity check on the requested changes for Samba */
5750
5751 if (!check_printer_ok(printer->info_2, snum)) {
5752 result = WERR_INVALID_PARAM;
5753 goto done;
5754 }
5755
5756 /* FIXME!!! If the driver has changed we really should verify that
5757 it is installed before doing much else --jerry */
5758
5759 /* Check calling user has permission to update printer description */
5760
5761 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
5762 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5763 result = WERR_ACCESS_DENIED;
5764 goto done;
5765 }
5766
5767 /* Call addprinter hook */
5768 /* Check changes to see if this is really needed */
5769
5770 if ( *lp_addprinter_cmd()
5771 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
5772 || !strequal(printer->info_2->comment, old_printer->info_2->comment)
5773 || !strequal(printer->info_2->portname, old_printer->info_2->portname)
5774 || !strequal(printer->info_2->location, old_printer->info_2->location)) )
5775 {
5776 /* add_printer_hook() will call reload_services() */
5777
5778 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
5779 printer) ) {
5780 result = WERR_ACCESS_DENIED;
5781 goto done;
5782 }
5783 }
5784
5785 /*
5786 * When a *new* driver is bound to a printer, the drivername is used to
5787 * lookup previously saved driver initialization info, which is then
5788 * bound to the printer, simulating what happens in the Windows arch.
5789 */
5790 if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
5791 {
5792 if (!set_driver_init(printer, 2))
5793 {
5794 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
5795 printer->info_2->drivername));
5796 }
5797
5798 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
5799 printer->info_2->drivername));
5800
5801 notify_printer_driver(snum, printer->info_2->drivername);
5802 }
5803
5804 /*
5805 * flag which changes actually occured. This is a small subset of
5806 * all the possible changes. We also have to update things in the
5807 * DsSpooler key.
5808 */
5809
5810 if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
5811 push_reg_sz(talloc_tos(), &buffer, printer->info_2->comment);
5812 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
5813 REG_SZ, buffer.data, buffer.length);
5814
5815 notify_printer_comment(snum, printer->info_2->comment);
5816 }
5817
5818 if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
5819 push_reg_sz(talloc_tos(), &buffer, printer->info_2->sharename);
5820 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
5821 REG_SZ, buffer.data, buffer.length);
5822
5823 notify_printer_sharename(snum, printer->info_2->sharename);
5824 }
5825
5826 if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
5827 char *pname;
5828
5829 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
5830 pname++;
5831 else
5832 pname = printer->info_2->printername;
5833
5834
5835 push_reg_sz(talloc_tos(), &buffer, pname);
5836 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
5837 REG_SZ, buffer.data, buffer.length);
5838
5839 notify_printer_printername( snum, pname );
5840 }
5841
5842 if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
5843 push_reg_sz(talloc_tos(), &buffer, printer->info_2->portname);
5844 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
5845 REG_SZ, buffer.data, buffer.length);
5846
5847 notify_printer_port(snum, printer->info_2->portname);
5848 }
5849
5850 if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
5851 push_reg_sz(talloc_tos(), &buffer, printer->info_2->location);
5852 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
5853 REG_SZ, buffer.data, buffer.length);
5854
5855 notify_printer_location(snum, printer->info_2->location);
5856 }
5857
5858 /* here we need to update some more DsSpooler keys */
5859 /* uNCName, serverName, shortServerName */
5860
5861 push_reg_sz(talloc_tos(), &buffer, global_myname());
5862 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
5863 REG_SZ, buffer.data, buffer.length);
5864 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
5865 REG_SZ, buffer.data, buffer.length);
5866
5867 slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
5868 global_myname(), printer->info_2->sharename );
5869 push_reg_sz(talloc_tos(), &buffer, asc_buffer);
5870 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
5871 REG_SZ, buffer.data, buffer.length);
5872
5873 /* Update printer info */
5874 result = mod_a_printer(printer, 2);
5875
5876 done:
5877 free_a_printer(&printer, 2);
5878 free_a_printer(&old_printer, 2);
5879
5880
5881 return result;
5882 }
5883
5884 /****************************************************************************
5885 ****************************************************************************/
5886 static WERROR publish_or_unpublish_printer(pipes_struct *p,
5887 struct policy_handle *handle,
5888 struct spoolss_SetPrinterInfo7 *info7)
5889 {
5890 #ifdef HAVE_ADS
5891 int snum;
5892 Printer_entry *Printer;
5893
5894 if ( lp_security() != SEC_ADS ) {
5895 return WERR_UNKNOWN_LEVEL;
5896 }
5897
5898 Printer = find_printer_index_by_hnd(p, handle);
5899
5900 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
5901
5902 if (!Printer)
5903 return WERR_BADFID;
5904
5905 if (!get_printer_snum(p, handle, &snum, NULL))
5906 return WERR_BADFID;
5907
5908 nt_printer_publish(Printer, snum, info7->action);
5909
5910 return WERR_OK;
5911 #else
5912 return WERR_UNKNOWN_LEVEL;
5913 #endif
5914 }
5915
5916 /****************************************************************
5917 _spoolss_SetPrinter
5918 ****************************************************************/
5919
5920 WERROR _spoolss_SetPrinter(pipes_struct *p,
5921 struct spoolss_SetPrinter *r)
5922 {
5923 WERROR result;
5924
5925 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5926
5927 if (!Printer) {
5928 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
5929 OUR_HANDLE(r->in.handle)));
5930 return WERR_BADFID;
5931 }
5932
5933 /* check the level */
5934 switch (r->in.info_ctr->level) {
5935 case 0:
5936 return control_printer(r->in.handle, r->in.command, p);
5937 case 2:
5938 result = update_printer(p, r->in.handle,
5939 r->in.info_ctr,
5940 r->in.devmode_ctr->devmode);
5941 if (!W_ERROR_IS_OK(result))
5942 return result;
5943 if (r->in.secdesc_ctr->sd)
5944 result = update_printer_sec(r->in.handle, p,
5945 r->in.secdesc_ctr);
5946 return result;
5947 case 3:
5948 return update_printer_sec(r->in.handle, p,
5949 r->in.secdesc_ctr);
5950 case 7:
5951 return publish_or_unpublish_printer(p, r->in.handle,
5952 r->in.info_ctr->info.info7);
5953 default:
5954 return WERR_UNKNOWN_LEVEL;
5955 }
5956 }
5957
5958 /****************************************************************
5959 _spoolss_FindClosePrinterNotify
5960 ****************************************************************/
5961
5962 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
5963 struct spoolss_FindClosePrinterNotify *r)
5964 {
5965 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5966
5967 if (!Printer) {
5968 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
5969 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
5970 return WERR_BADFID;
5971 }
5972
5973 if (Printer->notify.client_connected == true) {
5974 int snum = -1;
5975
5976 if ( Printer->printer_type == SPLHND_SERVER)
5977 snum = -1;
5978 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
5979 !get_printer_snum(p, r->in.handle, &snum, NULL) )
5980 return WERR_BADFID;
5981
5982 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
5983 }
5984
5985 Printer->notify.flags=0;
5986 Printer->notify.options=0;
5987 Printer->notify.localmachine[0]='\0';
5988 Printer->notify.printerlocal=0;
5989 TALLOC_FREE(Printer->notify.option);
5990 Printer->notify.client_connected = false;
5991
5992 return WERR_OK;
5993 }
5994
5995 /****************************************************************
5996 _spoolss_AddJob
5997 ****************************************************************/
5998
5999 WERROR _spoolss_AddJob(pipes_struct *p,
6000 struct spoolss_AddJob *r)
6001 {
6002 if (!r->in.buffer && (r->in.offered != 0)) {
6003 return WERR_INVALID_PARAM;
6004 }
6005
6006 /* this is what a NT server returns for AddJob. AddJob must fail on
6007 * non-local printers */
6008
6009 if (r->in.level != 1) {
6010 return WERR_UNKNOWN_LEVEL;
6011 }
6012
6013 return WERR_INVALID_PARAM;
6014 }
6015
6016 /****************************************************************************
6017 fill_job_info1
6018 ****************************************************************************/
6019
6020 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6021 struct spoolss_JobInfo1 *r,
6022 const print_queue_struct *queue,
6023 int position, int snum,
6024 const NT_PRINTER_INFO_LEVEL *ntprinter)
6025 {
6026 struct tm *t;
6027
6028 t = gmtime(&queue->time);
6029
6030 r->job_id = queue->job;
6031
6032 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6033 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6034 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6035 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6036 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6037 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6038 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6039 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6040 r->data_type = talloc_strdup(mem_ctx, "RAW");
6041 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6042 r->text_status = talloc_strdup(mem_ctx, "");
6043 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6044
6045 r->status = nt_printj_status(queue->status);
6046 r->priority = queue->priority;
6047 r->position = position;
6048 r->total_pages = queue->page_count;
6049 r->pages_printed = 0; /* ??? */
6050
6051 init_systemtime(&r->submitted, t);
6052
6053 return WERR_OK;
6054 }
6055
6056 /****************************************************************************
6057 fill_job_info2
6058 ****************************************************************************/
6059
6060 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6061 struct spoolss_JobInfo2 *r,
6062 const print_queue_struct *queue,
6063 int position, int snum,
6064 const NT_PRINTER_INFO_LEVEL *ntprinter,
6065 struct spoolss_DeviceMode *devmode)
6066 {
6067 struct tm *t;
6068
6069 t = gmtime(&queue->time);
6070
6071 r->job_id = queue->job;
6072
6073 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6074 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6075 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6076 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6077 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6078 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6079 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6080 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6081 r->notify_name = talloc_strdup(mem_ctx, queue->fs_user);
6082 W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6083 r->data_type = talloc_strdup(mem_ctx, "RAW");
6084 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6085 r->print_processor = talloc_strdup(mem_ctx, "winprint");
6086 W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6087 r->parameters = talloc_strdup(mem_ctx, "");
6088 W_ERROR_HAVE_NO_MEMORY(r->parameters);
6089 r->driver_name = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6090 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6091
6092 r->devmode = devmode;
6093
6094 r->text_status = talloc_strdup(mem_ctx, "");
6095 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6096
6097 r->secdesc = NULL;
6098
6099 r->status = nt_printj_status(queue->status);
6100 r->priority = queue->priority;
6101 r->position = position;
6102 r->start_time = 0;
6103 r->until_time = 0;
6104 r->total_pages = queue->page_count;
6105 r->size = queue->size;
6106 init_systemtime(&r->submitted, t);
6107 r->time = 0;
6108 r->pages_printed = 0; /* ??? */
6109
6110 return WERR_OK;
6111 }
6112
6113 /****************************************************************************
6114 Enumjobs at level 1.
6115 ****************************************************************************/
6116
6117 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6118 const print_queue_struct *queue,
6119 uint32_t num_queues, int snum,
6120 const NT_PRINTER_INFO_LEVEL *ntprinter,
6121 union spoolss_JobInfo **info_p,
6122 uint32_t *count)
6123 {
6124 union spoolss_JobInfo *info;
6125 int i;
6126 WERROR result = WERR_OK;
6127
6128 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6129 W_ERROR_HAVE_NO_MEMORY(info);
6130
6131 *count = num_queues;
6132
6133 for (i=0; i<*count; i++) {
6134 result = fill_job_info1(info,
6135 &info[i].info1,
6136 &queue[i],
6137 i,
6138 snum,
6139 ntprinter);
6140 if (!W_ERROR_IS_OK(result)) {
6141 goto out;
6142 }
6143 }
6144
6145 out:
6146 if (!W_ERROR_IS_OK(result)) {
6147 TALLOC_FREE(info);
6148 *count = 0;
6149 return result;
6150 }
6151
6152 *info_p = info;
6153
6154 return WERR_OK;
6155 }
6156
6157 /****************************************************************************
6158 Enumjobs at level 2.
6159 ****************************************************************************/
6160
6161 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6162 const print_queue_struct *queue,
6163 uint32_t num_queues, int snum,
6164 const NT_PRINTER_INFO_LEVEL *ntprinter,
6165 union spoolss_JobInfo **info_p,
6166 uint32_t *count)
6167 {
6168 union spoolss_JobInfo *info;
6169 int i;
6170 WERROR result = WERR_OK;
6171
6172 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6173 W_ERROR_HAVE_NO_MEMORY(info);
6174
6175 *count = num_queues;
6176
6177 for (i=0; i<*count; i++) {
6178
6179 struct spoolss_DeviceMode *devmode;
6180
6181 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6182 if (!devmode) {
6183 result = WERR_NOMEM;
6184 goto out;
6185 }
6186
6187 result = fill_job_info2(info,
6188 &info[i].info2,
6189 &queue[i],
6190 i,
6191 snum,
6192 ntprinter,
6193 devmode);
6194 if (!W_ERROR_IS_OK(result)) {
6195 goto out;
6196 }
6197 }
6198
6199 out:
6200 if (!W_ERROR_IS_OK(result)) {
6201 TALLOC_FREE(info);
6202 *count = 0;
6203 return result;
6204 }
6205
6206 *info_p = info;
6207
6208 return WERR_OK;
6209 }
6210
6211 /****************************************************************
6212 _spoolss_EnumJobs
6213 ****************************************************************/
6214
6215 WERROR _spoolss_EnumJobs(pipes_struct *p,
6216 struct spoolss_EnumJobs *r)
6217 {
6218 WERROR result;
6219 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6220 int snum;
6221 print_status_struct prt_status;
6222 print_queue_struct *queue = NULL;
6223 uint32_t count;
6224
6225 /* that's an [in out] buffer */
6226
6227 if (!r->in.buffer && (r->in.offered != 0)) {
6228 return WERR_INVALID_PARAM;
6229 }
6230
6231 DEBUG(4,("_spoolss_EnumJobs\n"));
6232
6233 *r->out.needed = 0;
6234 *r->out.count = 0;
6235 *r->out.info = NULL;
6236
6237 /* lookup the printer snum and tdb entry */
6238
6239 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6240 return WERR_BADFID;
6241 }
6242
6243 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6244 if (!W_ERROR_IS_OK(result)) {
6245 return result;
6246 }
6247
6248 count = print_queue_status(snum, &queue, &prt_status);
6249 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6250 count, prt_status.status, prt_status.message));
6251
6252 if (count == 0) {
6253 SAFE_FREE(queue);
6254 free_a_printer(&ntprinter, 2);
6255 return WERR_OK;
6256 }
6257
6258 switch (r->in.level) {
6259 case 1:
6260 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6261 ntprinter, r->out.info, r->out.count);
6262 break;
6263 case 2:
6264 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6265 ntprinter, r->out.info, r->out.count);
6266 break;
6267 default:
6268 result = WERR_UNKNOWN_LEVEL;
6269 break;
6270 }
6271
6272 SAFE_FREE(queue);
6273 free_a_printer(&ntprinter, 2);
6274
6275 if (!W_ERROR_IS_OK(result)) {
6276 return result;
6277 }
6278
6279 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6280 spoolss_EnumJobs, NULL,
6281 *r->out.info, r->in.level,
6282 *r->out.count);
6283 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6284 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6285
6286 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6287 }
6288
6289 /****************************************************************
6290 _spoolss_ScheduleJob
6291 ****************************************************************/
6292
6293 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6294 struct spoolss_ScheduleJob *r)
6295 {
6296 return WERR_OK;
6297 }
6298
6299 /****************************************************************
6300 _spoolss_SetJob
6301 ****************************************************************/
6302
6303 WERROR _spoolss_SetJob(pipes_struct *p,
6304 struct spoolss_SetJob *r)
6305 {
6306 int snum;
6307 WERROR errcode = WERR_BADFUNC;
6308
6309 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6310 return WERR_BADFID;
6311 }
6312
6313 if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6314 return WERR_INVALID_PRINTER_NAME;
6315 }
6316
6317 switch (r->in.command) {
6318 case SPOOLSS_JOB_CONTROL_CANCEL:
6319 case SPOOLSS_JOB_CONTROL_DELETE:
6320 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6321 errcode = WERR_OK;
6322 }
6323 break;
6324 case SPOOLSS_JOB_CONTROL_PAUSE:
6325 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6326 errcode = WERR_OK;
6327 }
6328 break;
6329 case SPOOLSS_JOB_CONTROL_RESTART:
6330 case SPOOLSS_JOB_CONTROL_RESUME:
6331 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6332 errcode = WERR_OK;
6333 }
6334 break;
6335 default:
6336 return WERR_UNKNOWN_LEVEL;
6337 }
6338
6339 return errcode;
6340 }
6341
6342 /****************************************************************************
6343 Enumerates all printer drivers by level and architecture.
6344 ****************************************************************************/
6345
6346 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
6347 const char *servername,
6348 const char *architecture,
6349 uint32_t level,
6350 union spoolss_DriverInfo **info_p,
6351 uint32_t *count_p)
6352 {
6353 int i;
6354 int ndrivers;
6355 uint32_t version;
6356 fstring *list = NULL;
6357 struct spoolss_DriverInfo8 *driver;
6358 union spoolss_DriverInfo *info = NULL;
6359 uint32_t count = 0;
6360 WERROR result = WERR_OK;
6361
6362 *count_p = 0;
6363 *info_p = NULL;
6364
6365 for (version=0; version<DRIVER_MAX_VERSION; version++) {
6366 list = NULL;
6367 ndrivers = get_ntdrivers(&list, architecture, version);
6368 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6369 ndrivers, architecture, version));
6370
6371 if (ndrivers == -1) {
6372 result = WERR_NOMEM;
6373 goto out;
6374 }
6375
6376 if (ndrivers != 0) {
6377 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6378 union spoolss_DriverInfo,
6379 count + ndrivers);
6380 if (!info) {
6381 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
6382 "failed to enlarge driver info buffer!\n"));
6383 result = WERR_NOMEM;
6384 goto out;
6385 }
6386 }
6387
6388 for (i=0; i<ndrivers; i++) {
6389 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6390 ZERO_STRUCT(driver);
6391 result = get_a_printer_driver(mem_ctx, &driver, list[i],
6392 architecture, version);
6393 if (!W_ERROR_IS_OK(result)) {
6394 goto out;
6395 }
6396
6397 switch (level) {
6398 case 1:
6399 result = fill_printer_driver_info1(info, &info[count+i].info1,
6400 driver, servername);
6401 break;
6402 case 2:
6403 result = fill_printer_driver_info2(info, &info[count+i].info2,
6404 driver, servername);
6405 break;
6406 case 3:
6407 result = fill_printer_driver_info3(info, &info[count+i].info3,
6408 driver, servername);
6409 break;
6410 case 4:
6411 result = fill_printer_driver_info4(info, &info[count+i].info4,
6412 driver, servername);
6413 break;
6414 case 5:
6415 result = fill_printer_driver_info5(info, &info[count+i].info5,
6416 driver, servername);
6417 break;
6418 case 6:
6419 result = fill_printer_driver_info6(info, &info[count+i].info6,
6420 driver, servername);
6421 break;
6422 case 8:
6423 result = fill_printer_driver_info8(info, &info[count+i].info8,
6424 driver, servername);
6425 break;
6426 default:
6427 result = WERR_UNKNOWN_LEVEL;
6428 break;
6429 }
6430
6431 free_a_printer_driver(driver);
6432
6433 if (!W_ERROR_IS_OK(result)) {
6434 goto out;
6435 }
6436 }
6437
6438 count += ndrivers;
6439 SAFE_FREE(list);
6440 }
6441
6442 out:
6443 SAFE_FREE(list);
6444
6445 if (!W_ERROR_IS_OK(result)) {
6446 TALLOC_FREE(info);
6447 return result;
6448 }
6449
6450 *info_p = info;
6451 *count_p = count;
6452
6453 return WERR_OK;
6454 }
6455
6456 /****************************************************************************
6457 Enumerates all printer drivers by level.
6458 ****************************************************************************/
6459
6460 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6461 const char *servername,
6462 const char *architecture,
6463 uint32_t level,
6464 union spoolss_DriverInfo **info_p,
6465 uint32_t *count_p)
6466 {
6467 uint32_t a,i;
6468 WERROR result = WERR_OK;
6469
6470 if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
6471
6472 for (a=0; archi_table[a].long_archi != NULL; a++) {
6473
6474 union spoolss_DriverInfo *info = NULL;
6475 uint32_t count = 0;
6476
6477 result = enumprinterdrivers_level_by_architecture(mem_ctx,
6478 servername,
6479 archi_table[a].long_archi,
6480 level,
6481 &info,
6482 &count);
6483 if (!W_ERROR_IS_OK(result)) {
6484 continue;
6485 }
6486
6487 for (i=0; i < count; i++) {
6488 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
6489 info[i], info_p, count_p);
6490 }
6491 }
6492
6493 return result;
6494 }
6495
6496 return enumprinterdrivers_level_by_architecture(mem_ctx,
6497 servername,
6498 architecture,
6499 level,
6500 info_p,
6501 count_p);
6502 }
6503
6504 /****************************************************************
6505 _spoolss_EnumPrinterDrivers
6506 ****************************************************************/
6507
6508 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6509 struct spoolss_EnumPrinterDrivers *r)
6510 {
6511 const char *cservername;
6512 WERROR result;
6513
6514 /* that's an [in out] buffer */
6515
6516 if (!r->in.buffer && (r->in.offered != 0)) {
6517 return WERR_INVALID_PARAM;
6518 }
6519
6520 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6521
6522 *r->out.needed = 0;
6523 *r->out.count = 0;
6524 *r->out.info = NULL;
6525
6526 cservername = canon_servername(r->in.server);
6527
6528 if (!is_myname_or_ipaddr(cservername)) {
6529 return WERR_UNKNOWN_PRINTER_DRIVER;
6530 }
6531
6532 result = enumprinterdrivers_level(p->mem_ctx, cservername,
6533 r->in.environment,
6534 r->in.level,
6535 r->out.info,
6536 r->out.count);
6537 if (!W_ERROR_IS_OK(result)) {
6538 return result;
6539 }
6540
6541 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6542 spoolss_EnumPrinterDrivers, NULL,
6543 *r->out.info, r->in.level,
6544 *r->out.count);
6545 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6546 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6547
6548 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6549 }
6550
6551 /****************************************************************************
6552 ****************************************************************************/
6553
6554 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
6555 struct spoolss_FormInfo1 *r,
6556 const nt_forms_struct *form)
6557 {
6558 r->form_name = talloc_strdup(mem_ctx, form->name);
6559 W_ERROR_HAVE_NO_MEMORY(r->form_name);
6560
6561 r->flags = form->flag;
6562 r->size.width = form->width;
6563 r->size.height = form->length;
6564 r->area.left = form->left;
6565 r->area.top = form->top;
6566 r->area.right = form->right;
6567 r->area.bottom = form->bottom;
6568
6569 return WERR_OK;
6570 }
6571
6572 /****************************************************************
6573 spoolss_enumforms_level1
6574 ****************************************************************/
6575
6576 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
6577 const nt_forms_struct *builtin_forms,
6578 uint32_t num_builtin_forms,
6579 const nt_forms_struct *user_forms,
6580 uint32_t num_user_forms,
6581 union spoolss_FormInfo **info_p,
6582 uint32_t *count)
6583 {
6584 union spoolss_FormInfo *info;
6585 WERROR result = WERR_OK;
6586 int i;
6587
6588 *count = num_builtin_forms + num_user_forms;
6589
6590 info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
6591 W_ERROR_HAVE_NO_MEMORY(info);
6592
6593 /* construct the list of form structures */
6594 for (i=0; i<num_builtin_forms; i++) {
6595 DEBUGADD(6,("Filling builtin form number [%d]\n",i));
6596 result = fill_form_info_1(info, &info[i].info1,
6597 &builtin_forms[i]);
6598 if (!W_ERROR_IS_OK(result)) {
6599 goto out;
6600 }
6601 }
6602
6603 for (i=0; i<num_user_forms; i++) {
6604 DEBUGADD(6,("Filling user form number [%d]\n",i));
6605 result = fill_form_info_1(info, &info[i+num_builtin_forms].info1,
6606 &user_forms[i]);
6607 if (!W_ERROR_IS_OK(result)) {
6608 goto out;
6609 }
6610 }
6611
6612 out:
6613 if (!W_ERROR_IS_OK(result)) {
6614 TALLOC_FREE(info);
6615 *count = 0;
6616 return result;
6617 }
6618
6619 *info_p = info;
6620
6621 return WERR_OK;
6622 }
6623
6624 /****************************************************************
6625 _spoolss_EnumForms
6626 ****************************************************************/
6627
6628 WERROR _spoolss_EnumForms(pipes_struct *p,
6629 struct spoolss_EnumForms *r)
6630 {
6631 WERROR result;
6632 nt_forms_struct *user_forms = NULL;
6633 nt_forms_struct *builtin_forms = NULL;
6634 uint32_t num_user_forms;
6635 uint32_t num_builtin_forms;
6636
6637 *r->out.count = 0;
6638 *r->out.needed = 0;
6639 *r->out.info = NULL;
6640
6641 /* that's an [in out] buffer */
6642
6643 if (!r->in.buffer && (r->in.offered != 0) ) {
6644 return WERR_INVALID_PARAM;
6645 }
6646
6647 DEBUG(4,("_spoolss_EnumForms\n"));
6648 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6649 DEBUGADD(5,("Info level [%d]\n", r->in.level));
6650
6651 num_builtin_forms = get_builtin_ntforms(&builtin_forms);
6652 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
6653 num_user_forms = get_ntforms(&user_forms);
6654 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
6655
6656 if (num_user_forms + num_builtin_forms == 0) {
6657 SAFE_FREE(builtin_forms);
6658 SAFE_FREE(user_forms);
6659 return WERR_NO_MORE_ITEMS;
6660 }
6661
6662 switch (r->in.level) {
6663 case 1:
6664 result = spoolss_enumforms_level1(p->mem_ctx,
6665 builtin_forms,
6666 num_builtin_forms,
6667 user_forms,
6668 num_user_forms,
6669 r->out.info,
6670 r->out.count);
6671 break;
6672 default:
6673 result = WERR_UNKNOWN_LEVEL;
6674 break;
6675 }
6676
6677 SAFE_FREE(user_forms);
6678 SAFE_FREE(builtin_forms);
6679
6680 if (!W_ERROR_IS_OK(result)) {
6681 return result;
6682 }
6683
6684 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6685 spoolss_EnumForms, NULL,
6686 *r->out.info, r->in.level,
6687 *r->out.count);
6688 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6689 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6690
6691 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6692 }
6693
6694 /****************************************************************
6695 ****************************************************************/
6696
6697 static WERROR find_form_byname(const char *name,
6698 nt_forms_struct *form)
6699 {
6700 nt_forms_struct *list = NULL;
6701 int num_forms = 0, i = 0;
6702
6703 if (get_a_builtin_ntform_by_string(name, form)) {
6704 return WERR_OK;
6705 }
6706
6707 num_forms = get_ntforms(&list);
6708 DEBUGADD(5,("Number of forms [%d]\n", num_forms));
6709
6710 if (num_forms == 0) {
6711 return WERR_BADFID;
6712 }
6713
6714 /* Check if the requested name is in the list of form structures */
6715 for (i = 0; i < num_forms; i++) {
6716
6717 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
6718
6719 if (strequal(name, list[i].name)) {
6720 DEBUGADD(6,("Found form %s number [%d]\n", name, i));
6721 *form = list[i];
6722 SAFE_FREE(list);
6723 return WERR_OK;
6724 }
6725 }
6726
6727 SAFE_FREE(list);
6728
6729 return WERR_BADFID;
6730 }
6731
6732 /****************************************************************
6733 _spoolss_GetForm
6734 ****************************************************************/
6735
6736 WERROR _spoolss_GetForm(pipes_struct *p,
6737 struct spoolss_GetForm *r)
6738 {
6739 WERROR result;
6740 nt_forms_struct form;
6741
6742 /* that's an [in out] buffer */
6743
6744 if (!r->in.buffer && (r->in.offered != 0)) {
6745 return WERR_INVALID_PARAM;
6746 }
6747
6748 DEBUG(4,("_spoolss_GetForm\n"));
6749 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6750 DEBUGADD(5,("Info level [%d]\n", r->in.level));
6751
6752 result = find_form_byname(r->in.form_name, &form);
6753 if (!W_ERROR_IS_OK(result)) {
6754 TALLOC_FREE(r->out.info);
6755 return result;
6756 }
6757
6758 switch (r->in.level) {
6759 case 1:
6760 result = fill_form_info_1(p->mem_ctx,
6761 &r->out.info->info1,
6762 &form);
6763 break;
6764
6765 default:
6766 result = WERR_UNKNOWN_LEVEL;
6767 break;
6768 }
6769
6770 if (!W_ERROR_IS_OK(result)) {
6771 TALLOC_FREE(r->out.info);
6772 return result;
6773 }
6774
6775 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
6776 r->out.info, r->in.level);
6777 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
6778
6779 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6780 }
6781
6782 /****************************************************************************
6783 ****************************************************************************/
6784
6785 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
6786 struct spoolss_PortInfo1 *r,
6787 const char *name)
6788 {
6789 r->port_name = talloc_strdup(mem_ctx, name);
6790 W_ERROR_HAVE_NO_MEMORY(r->port_name);
6791
6792 return WERR_OK;
6793 }
6794
6795 /****************************************************************************
6796 TODO: This probably needs distinguish between TCP/IP and Local ports
6797 somehow.
6798 ****************************************************************************/
6799
6800 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
6801 struct spoolss_PortInfo2 *r,
6802 const char *name)
6803 {
6804 r->port_name = talloc_strdup(mem_ctx, name);
6805 W_ERROR_HAVE_NO_MEMORY(r->port_name);
6806
6807 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
6808 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
6809
6810 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
6811 W_ERROR_HAVE_NO_MEMORY(r->description);
6812
6813 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
6814 r->reserved = 0;
6815
6816 return WERR_OK;
6817 }
6818
6819
6820 /****************************************************************************
6821 wrapper around the enumer ports command
6822 ****************************************************************************/
6823
6824 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
6825 {
6826 char *cmd = lp_enumports_cmd();
6827 char **qlines = NULL;
6828 char *command = NULL;
6829 int numlines;
6830 int ret;
6831 int fd;
6832
6833 *count = 0;
6834 *lines = NULL;
6835
6836 /* if no hook then just fill in the default port */
6837
6838 if ( !*cmd ) {
6839 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
6840 return WERR_NOMEM;
6841 }
6842 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
6843 TALLOC_FREE(qlines);
6844 return WERR_NOMEM;
6845 }
6846 qlines[1] = NULL;
6847 numlines = 1;
6848 }
6849 else {
6850 /* we have a valid enumport command */
6851
6852 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
6853 if (!command) {
6854 return WERR_NOMEM;
6855 }
6856
6857 DEBUG(10,("Running [%s]\n", command));
6858 ret = smbrun(command, &fd);
6859 DEBUG(10,("Returned [%d]\n", ret));
6860 TALLOC_FREE(command);
6861 if (ret != 0) {
6862 if (fd != -1) {
6863 close(fd);
6864 }
6865 return WERR_ACCESS_DENIED;
6866 }
6867
6868 numlines = 0;
6869 qlines = fd_lines_load(fd, &numlines, 0, NULL);
6870 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6871 close(fd);
6872 }
6873
6874 *count = numlines;
6875 *lines = qlines;
6876
6877 return WERR_OK;
6878 }
6879
6880 /****************************************************************************
6881 enumports level 1.
6882 ****************************************************************************/
6883
6884 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
6885 union spoolss_PortInfo **info_p,
6886 uint32_t *count)
6887 {
6888 union spoolss_PortInfo *info = NULL;
6889 int i=0;
6890 WERROR result = WERR_OK;
6891 char **qlines = NULL;
6892 int numlines = 0;
6893
6894 result = enumports_hook(talloc_tos(), &numlines, &qlines );
6895 if (!W_ERROR_IS_OK(result)) {
6896 goto out;
6897 }
6898
6899 if (numlines) {
6900 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
6901 if (!info) {
6902 DEBUG(10,("Returning WERR_NOMEM\n"));
6903 result = WERR_NOMEM;
6904 goto out;
6905 }
6906
6907 for (i=0; i<numlines; i++) {
6908 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
6909 result = fill_port_1(info, &info[i].info1, qlines[i]);
6910 if (!W_ERROR_IS_OK(result)) {
6911 goto out;
6912 }
6913 }
6914 }
6915 TALLOC_FREE(qlines);
6916
6917 out:
6918 if (!W_ERROR_IS_OK(result)) {
6919 TALLOC_FREE(info);
6920 TALLOC_FREE(qlines);
6921 *count = 0;
6922 *info_p = NULL;
6923 return result;
6924 }
6925
6926 *info_p = info;
6927 *count = numlines;
6928
6929 return WERR_OK;
6930 }
6931
6932 /****************************************************************************
6933 enumports level 2.
6934 ****************************************************************************/
6935
6936 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
6937 union spoolss_PortInfo **info_p,
6938 uint32_t *count)
6939 {
6940 union spoolss_PortInfo *info = NULL;
6941 int i=0;
6942 WERROR result = WERR_OK;
6943 char **qlines = NULL;
6944 int numlines = 0;
6945
6946 result = enumports_hook(talloc_tos(), &numlines, &qlines );
6947 if (!W_ERROR_IS_OK(result)) {
6948 goto out;
6949 }
6950
6951 if (numlines) {
6952 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
6953 if (!info) {
6954 DEBUG(10,("Returning WERR_NOMEM\n"));
6955 result = WERR_NOMEM;
6956 goto out;
6957 }
6958
6959 for (i=0; i<numlines; i++) {
6960 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
6961 result = fill_port_2(info, &info[i].info2, qlines[i]);
6962 if (!W_ERROR_IS_OK(result)) {
6963 goto out;
6964 }
6965 }
6966 }
6967 TALLOC_FREE(qlines);
6968
6969 out:
6970 if (!W_ERROR_IS_OK(result)) {
6971 TALLOC_FREE(info);
6972 TALLOC_FREE(qlines);
6973 *count = 0;
6974 *info_p = NULL;
6975 return result;
6976 }
6977
6978 *info_p = info;
6979 *count = numlines;
6980
6981 return WERR_OK;
6982 }
6983
6984 /****************************************************************
6985 _spoolss_EnumPorts
6986 ****************************************************************/
6987
6988 WERROR _spoolss_EnumPorts(pipes_struct *p,
6989 struct spoolss_EnumPorts *r)
6990 {
6991 WERROR result;
6992
6993 /* that's an [in out] buffer */
6994
6995 if (!r->in.buffer && (r->in.offered != 0)) {
6996 return WERR_INVALID_PARAM;
6997 }
6998
6999 DEBUG(4,("_spoolss_EnumPorts\n"));
7000
7001 *r->out.count = 0;
7002 *r->out.needed = 0;
7003 *r->out.info = NULL;
7004
7005 switch (r->in.level) {
7006 case 1:
7007 result = enumports_level_1(p->mem_ctx, r->out.info,
7008 r->out.count);
7009 break;
7010 case 2:
7011 result = enumports_level_2(p->mem_ctx, r->out.info,
7012 r->out.count);
7013 break;
7014 default:
7015 return WERR_UNKNOWN_LEVEL;
7016 }
7017
7018 if (!W_ERROR_IS_OK(result)) {
7019 return result;
7020 }
7021
7022 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7023 spoolss_EnumPorts, NULL,
7024 *r->out.info, r->in.level,
7025 *r->out.count);
7026 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7027 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7028
7029 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7030 }
7031
7032 /****************************************************************************
7033 ****************************************************************************/
7034
7035 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7036 const char *server,
7037 struct spoolss_SetPrinterInfoCtr *info_ctr,
7038 struct spoolss_DeviceMode *devmode,
7039 struct security_descriptor *sec_desc,
7040 struct spoolss_UserLevelCtr *user_ctr,
7041 struct policy_handle *handle)
7042 {
7043 NT_PRINTER_INFO_LEVEL *printer = NULL;
7044 fstring name;
7045 int snum;
7046 WERROR err = WERR_OK;
7047
7048 if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7049 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7050 return WERR_NOMEM;
7051 }
7052
7053 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7054 if (!convert_printer_info(info_ctr, printer)) {
7055 free_a_printer(&printer, 2);
7056 return WERR_NOMEM;
7057 }
7058
7059 /* check to see if the printer already exists */
7060
7061 if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7062 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7063 printer->info_2->sharename));
7064 free_a_printer(&printer, 2);
7065 return WERR_PRINTER_ALREADY_EXISTS;
7066 }
7067
7068 /* FIXME!!! smbd should check to see if the driver is installed before
7069 trying to add a printer like this --jerry */
7070
7071 if (*lp_addprinter_cmd() ) {
7072 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7073 printer) ) {
7074 free_a_printer(&printer,2);
7075 return WERR_ACCESS_DENIED;
7076 }
7077 } else {
7078 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7079 "smb.conf parameter \"addprinter command\" is defined. This"
7080 "parameter must exist for this call to succeed\n",
7081 printer->info_2->sharename ));
7082 }
7083
7084 /* use our primary netbios name since get_a_printer() will convert
7085 it to what the client expects on a case by case basis */
7086
7087 slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7088 printer->info_2->sharename);
7089
7090
7091 if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7092 free_a_printer(&printer,2);
7093 return WERR_ACCESS_DENIED;
7094 }
7095
7096 /* you must be a printer admin to add a new printer */
7097 if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
7098 free_a_printer(&printer,2);
7099 return WERR_ACCESS_DENIED;
7100 }
7101
7102 /*
7103 * Do sanity check on the requested changes for Samba.
7104 */
7105
7106 if (!check_printer_ok(printer->info_2, snum)) {
7107 free_a_printer(&printer,2);
7108 return WERR_INVALID_PARAM;
7109 }
7110
7111 /*
7112 * When a printer is created, the drivername bound to the printer is used
7113 * to lookup previously saved driver initialization info, which is then
7114 * bound to the new printer, simulating what happens in the Windows arch.
7115 */
7116
7117 if (!devmode)
7118 {
7119 set_driver_init(printer, 2);
7120 }
7121 else
7122 {
7123 /* A valid devmode was included, convert and link it
7124 */
7125 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7126
7127 if (!convert_devicemode(printer->info_2->printername, devmode,
7128 &printer->info_2->devmode)) {
7129 return WERR_NOMEM;
7130 }
7131 }
7132
7133 /* write the ASCII on disk */
7134 err = mod_a_printer(printer, 2);
7135 if (!W_ERROR_IS_OK(err)) {
7136 free_a_printer(&printer,2);
7137 return err;
7138 }
7139
7140 if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7141 /* Handle open failed - remove addition. */
7142 del_a_printer(printer->info_2->sharename);
7143 free_a_printer(&printer,2);
7144 ZERO_STRUCTP(handle);
7145 return WERR_ACCESS_DENIED;
7146 }
7147
7148 update_c_setprinter(false);
7149 free_a_printer(&printer,2);
7150
7151 return WERR_OK;
7152 }
7153
7154 /****************************************************************
7155 _spoolss_AddPrinterEx
7156 ****************************************************************/
7157
7158 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7159 struct spoolss_AddPrinterEx *r)
7160 {
7161 switch (r->in.info_ctr->level) {
7162 case 1:
7163 /* we don't handle yet */
7164 /* but I know what to do ... */
7165 return WERR_UNKNOWN_LEVEL;
7166 case 2:
7167 return spoolss_addprinterex_level_2(p, r->in.server,
7168 r->in.info_ctr,
7169 r->in.devmode_ctr->devmode,
7170 r->in.secdesc_ctr->sd,
7171 r->in.userlevel_ctr,
7172 r->out.handle);
7173 default:
7174 return WERR_UNKNOWN_LEVEL;
7175 }
7176 }
7177
7178 /****************************************************************
7179 _spoolss_AddPrinter
7180 ****************************************************************/
7181
7182 WERROR _spoolss_AddPrinter(pipes_struct *p,
7183 struct spoolss_AddPrinter *r)
7184 {
7185 struct spoolss_AddPrinterEx a;
7186 struct spoolss_UserLevelCtr userlevel_ctr;
7187
7188 ZERO_STRUCT(userlevel_ctr);
7189
7190 userlevel_ctr.level = 1;
7191
7192 a.in.server = r->in.server;
7193 a.in.info_ctr = r->in.info_ctr;
7194 a.in.devmode_ctr = r->in.devmode_ctr;
7195 a.in.secdesc_ctr = r->in.secdesc_ctr;
7196 a.in.userlevel_ctr = &userlevel_ctr;
7197 a.out.handle = r->out.handle;
7198
7199 return _spoolss_AddPrinterEx(p, &a);
7200 }
7201
7202 /****************************************************************
7203 _spoolss_AddPrinterDriver
7204 ****************************************************************/
7205
7206 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7207 struct spoolss_AddPrinterDriver *r)
7208 {
7209 WERROR err = WERR_OK;
7210 char *driver_name = NULL;
7211 uint32_t version;
7212 const char *fn;
7213
7214 switch (p->hdr_req.opnum) {
7215 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7216 fn = "_spoolss_AddPrinterDriver";
7217 break;
7218 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7219 fn = "_spoolss_AddPrinterDriverEx";
7220 break;
7221 default:
7222 return WERR_INVALID_PARAM;
7223 }
7224
7225
7226 /* FIXME */
7227 if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
7228 /* Clever hack from Martin Zielinski <mz@seh.de>
7229 * to allow downgrade from level 8 (Vista).
7230 */
7231 DEBUG(0,("%s: level %d not yet implemented\n", fn,
7232 r->in.info_ctr->level));
7233 return WERR_UNKNOWN_LEVEL;
7234 }
7235
7236 DEBUG(5,("Cleaning driver's information\n"));
7237 err = clean_up_driver_struct(p, r->in.info_ctr);
7238 if (!W_ERROR_IS_OK(err))
7239 goto done;
7240
7241 DEBUG(5,("Moving driver to final destination\n"));
7242 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, r->in.info_ctr,
7243 &err)) ) {
7244 goto done;
7245 }
7246
7247 if (add_a_printer_driver(p->mem_ctx, r->in.info_ctr, &driver_name, &version)!=0) {
7248 err = WERR_ACCESS_DENIED;
7249 goto done;
7250 }
7251
7252 /*
7253 * I think this is where he DrvUpgradePrinter() hook would be
7254 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7255 * server. Right now, we just need to send ourselves a message
7256 * to update each printer bound to this driver. --jerry
7257 */
7258
7259 if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7260 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7261 fn, driver_name));
7262 }
7263
7264 /*
7265 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7266 * decide if the driver init data should be deleted. The rules are:
7267 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7268 * 2) delete init data only if there is no 2k/Xp driver
7269 * 3) always delete init data
7270 * The generalized rule is always use init data from the highest order driver.
7271 * It is necessary to follow the driver install by an initialization step to
7272 * finish off this process.
7273 */
7274
7275 switch (version) {
7276 /*
7277 * 9x printer driver - never delete init data
7278 */
7279 case 0:
7280 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7281 fn, driver_name));
7282 break;
7283
7284 /*
7285 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7286 * there is no 2k/Xp driver init data for this driver name.
7287 */
7288 case 2:
7289 {
7290 struct spoolss_DriverInfo8 *driver1;
7291
7292 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &driver1, driver_name, "Windows NT x86", 3))) {
7293 /*
7294 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7295 */
7296 if (!del_driver_init(driver_name))
7297 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7298 fn, driver_name));
7299 } else {
7300 /*
7301 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7302 */
7303 free_a_printer_driver(driver1);
7304 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7305 fn, driver_name));
7306 }
7307 }
7308 break;
7309
7310 /*
7311 * 2k or Xp printer driver - always delete init data
7312 */
7313 case 3:
7314 if (!del_driver_init(driver_name))
7315 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7316 fn, driver_name));
7317 break;
7318
7319 default:
7320 DEBUG(0,("%s: invalid level=%d\n", fn,
7321 r->in.info_ctr->level));
7322 break;
7323 }
7324
7325
7326 done:
7327 return err;
7328 }
7329
7330 /****************************************************************
7331 _spoolss_AddPrinterDriverEx
7332 ****************************************************************/
7333
7334 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7335 struct spoolss_AddPrinterDriverEx *r)
7336 {
7337 struct spoolss_AddPrinterDriver a;
7338
7339 /*
7340 * we only support the semantics of AddPrinterDriver()
7341 * i.e. only copy files that are newer than existing ones
7342 */
7343
7344 if (r->in.flags != APD_COPY_NEW_FILES) {
7345 return WERR_ACCESS_DENIED;
7346 }
7347
7348 a.in.servername = r->in.servername;
7349 a.in.info_ctr = r->in.info_ctr;
7350
7351 return _spoolss_AddPrinterDriver(p, &a);
7352 }
7353
7354 /****************************************************************************
7355 ****************************************************************************/
7356
7357 struct _spoolss_paths {
7358 int type;
7359 const char *share;
7360 const char *dir;
7361 };
7362
7363 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7364
7365 static const struct _spoolss_paths spoolss_paths[]= {
7366 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
7367 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
7368 };
7369
7370 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7371 const char *servername,
7372 const char *environment,
7373 int component,
7374 char **path)
7375 {
7376 const char *pservername = NULL;
7377 const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7378 const char *short_archi;
7379
7380 *path = NULL;
7381
7382 /* environment may be empty */
7383 if (environment && strlen(environment)) {
7384 long_archi = environment;
7385 }
7386
7387 /* servername may be empty */
7388 if (servername && strlen(servername)) {
7389 pservername = canon_servername(servername);
7390
7391 if (!is_myname_or_ipaddr(pservername)) {
7392 return WERR_INVALID_PARAM;
7393 }
7394 }
7395
7396 if (!(short_archi = get_short_archi(long_archi))) {
7397 return WERR_INVALID_ENVIRONMENT;
7398 }
7399
7400 switch (component) {
7401 case SPOOLSS_PRTPROCS_PATH:
7402 case SPOOLSS_DRIVER_PATH:
7403 if (pservername) {
7404 *path = talloc_asprintf(mem_ctx,
7405 "\\\\%s\\%s\\%s",
7406 pservername,
7407 spoolss_paths[component].share,
7408 short_archi);
7409 } else {
7410 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7411 SPOOLSS_DEFAULT_SERVER_PATH,
7412 spoolss_paths[component].dir,
7413 short_archi);
7414 }
7415 break;
7416 default:
7417 return WERR_INVALID_PARAM;
7418 }
7419
7420 if (!*path) {
7421 return WERR_NOMEM;
7422 }
7423
7424 return WERR_OK;
7425 }
7426
7427 /****************************************************************************
7428 ****************************************************************************/
7429
7430 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7431 const char *servername,
7432 const char *environment,
7433 struct spoolss_DriverDirectoryInfo1 *r)
7434 {
7435 WERROR werr;
7436 char *path = NULL;
7437
7438 werr = compose_spoolss_server_path(mem_ctx,
7439 servername,
7440 environment,
7441 SPOOLSS_DRIVER_PATH,
7442 &path);
7443 if (!W_ERROR_IS_OK(werr)) {
7444 return werr;
7445 }
7446
7447 DEBUG(4,("printer driver directory: [%s]\n", path));
7448
7449 r->directory_name = path;
7450
7451 return WERR_OK;
7452 }
7453
7454 /****************************************************************
7455 _spoolss_GetPrinterDriverDirectory
7456 ****************************************************************/
7457
7458 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7459 struct spoolss_GetPrinterDriverDirectory *r)
7460 {
7461 WERROR werror;
7462
7463 /* that's an [in out] buffer */
7464
7465 if (!r->in.buffer && (r->in.offered != 0)) {
7466 return WERR_INVALID_PARAM;
7467 }
7468
7469 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7470 r->in.level));
7471
7472 *r->out.needed = 0;
7473
7474 /* r->in.level is ignored */
7475
7476 werror = getprinterdriverdir_level_1(p->mem_ctx,
7477 r->in.server,
7478 r->in.environment,
7479 &r->out.info->info1);
7480 if (!W_ERROR_IS_OK(werror)) {
7481 TALLOC_FREE(r->out.info);
7482 return werror;
7483 }
7484
7485 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
7486 r->out.info, r->in.level);
7487 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7488
7489 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7490 }
7491
7492 /****************************************************************
7493 _spoolss_EnumPrinterData
7494 ****************************************************************/
7495
7496 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
7497 struct spoolss_EnumPrinterData *r)
7498 {
7499 NT_PRINTER_INFO_LEVEL *printer = NULL;
7500 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7501 int snum;
7502 WERROR result;
7503 struct regval_blob *val = NULL;
7504 NT_PRINTER_DATA *p_data;
7505 int i, key_index, num_values;
7506 int name_length;
7507
7508 *r->out.value_needed = 0;
7509 *r->out.type = REG_NONE;
7510 *r->out.data_needed = 0;
7511
7512 DEBUG(5,("_spoolss_EnumPrinterData\n"));
7513
7514 if (!Printer) {
7515 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
7516 OUR_HANDLE(r->in.handle)));
7517 return WERR_BADFID;
7518 }
7519
7520 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7521 return WERR_BADFID;
7522 }
7523
7524 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7525 if (!W_ERROR_IS_OK(result)) {
7526 return result;
7527 }
7528
7529 p_data = printer->info_2->data;
7530 key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
7531
7532 result = WERR_OK;
7533
7534 /*
7535 * The NT machine wants to know the biggest size of value and data
7536 *
7537 * cf: MSDN EnumPrinterData remark section
7538 */
7539
7540 if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
7541
7542 uint32_t biggest_valuesize = 0;
7543 uint32_t biggest_datasize = 0;
7544
7545 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7546
7547 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
7548
7549 for ( i=0; i<num_values; i++ )
7550 {
7551 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
7552
7553 name_length = strlen(val->valuename);
7554 if ( strlen(val->valuename) > biggest_valuesize )
7555 biggest_valuesize = name_length;
7556
7557 if ( val->size > biggest_datasize )
7558 biggest_datasize = val->size;
7559
7560 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
7561 biggest_datasize));
7562 }
7563
7564 /* the value is an UNICODE string but real_value_size is the length
7565 in bytes including the trailing 0 */
7566
7567 *r->out.value_needed = 2 * (1 + biggest_valuesize);
7568 *r->out.data_needed = biggest_datasize;
7569
7570 DEBUG(6,("final values: [%d], [%d]\n",
7571 *r->out.value_needed, *r->out.data_needed));
7572
7573 goto done;
7574 }
7575
7576 /*
7577 * the value len is wrong in NT sp3
7578 * that's the number of bytes not the number of unicode chars
7579 */
7580
7581 if (key_index != -1) {
7582 val = regval_ctr_specific_value(p_data->keys[key_index].values,
7583 r->in.enum_index);
7584 }
7585
7586 if (!val) {
7587
7588 /* out_value should default to "" or else NT4 has
7589 problems unmarshalling the response */
7590
7591 if (r->in.value_offered) {
7592 *r->out.value_needed = 1;
7593 r->out.value_name = talloc_strdup(r, "");
7594 if (!r->out.value_name) {
7595 result = WERR_NOMEM;
7596 goto done;
7597 }
7598 } else {
7599 r->out.value_name = NULL;
7600 *r->out.value_needed = 0;
7601 }
7602
7603 /* the data is counted in bytes */
7604
7605 *r->out.data_needed = r->in.data_offered;
7606
7607 result = WERR_NO_MORE_ITEMS;
7608 } else {
7609 /*
7610 * the value is:
7611 * - counted in bytes in the request
7612 * - counted in UNICODE chars in the max reply
7613 * - counted in bytes in the real size
7614 *
7615 * take a pause *before* coding not *during* coding
7616 */
7617
7618 /* name */
7619 if (r->in.value_offered) {
7620 r->out.value_name = talloc_strdup(r, regval_name(val));
7621 if (!r->out.value_name) {
7622 result = WERR_NOMEM;
7623 goto done;
7624 }
7625 *r->out.value_needed = strlen_m(regval_name(val));
7626 } else {
7627 r->out.value_name = NULL;
7628 *r->out.value_needed = 0;
7629 }
7630
7631 /* type */
7632
7633 *r->out.type = regval_type(val);
7634
7635 /* data - counted in bytes */
7636
7637 /*
7638 * See the section "Dynamically Typed Query Parameters"
7639 * in MS-RPRN.
7640 */
7641
7642 if (r->out.data && regval_data_p(val) &&
7643 regval_size(val) && r->in.data_offered) {
7644 memcpy(r->out.data, regval_data_p(val),
7645 MIN(regval_size(val),r->in.data_offered));
7646 }
7647
7648 *r->out.data_needed = regval_size(val);
7649 }
7650
7651 done:
7652 free_a_printer(&printer, 2);
7653 return result;
7654 }
7655
7656 /****************************************************************
7657 _spoolss_SetPrinterData
7658 ****************************************************************/
7659
7660 WERROR _spoolss_SetPrinterData(pipes_struct *p,
7661 struct spoolss_SetPrinterData *r)
7662 {
7663 struct spoolss_SetPrinterDataEx r2;
7664
7665 r2.in.handle = r->in.handle;
7666 r2.in.key_name = "PrinterDriverData";
7667 r2.in.value_name = r->in.value_name;
7668 r2.in.type = r->in.type;
7669 r2.in.data = r->in.data;
7670 r2.in._offered = r->in._offered;
7671
7672 return _spoolss_SetPrinterDataEx(p, &r2);
7673 }
7674
7675 /****************************************************************
7676 _spoolss_ResetPrinter
7677 ****************************************************************/
7678
7679 WERROR _spoolss_ResetPrinter(pipes_struct *p,
7680 struct spoolss_ResetPrinter *r)
7681 {
7682 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7683 int snum;
7684
7685 DEBUG(5,("_spoolss_ResetPrinter\n"));
7686
7687 /*
7688 * All we do is to check to see if the handle and queue is valid.
7689 * This call really doesn't mean anything to us because we only
7690 * support RAW printing. --jerry
7691 */
7692
7693 if (!Printer) {
7694 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
7695 OUR_HANDLE(r->in.handle)));
7696 return WERR_BADFID;
7697 }
7698
7699 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7700 return WERR_BADFID;
7701
7702
7703 /* blindly return success */
7704 return WERR_OK;
7705 }
7706
7707 /****************************************************************
7708 _spoolss_DeletePrinterData
7709 ****************************************************************/
7710
7711 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
7712 struct spoolss_DeletePrinterData *r)
7713 {
7714 struct spoolss_DeletePrinterDataEx r2;
7715
7716 r2.in.handle = r->in.handle;
7717 r2.in.key_name = "PrinterDriverData";
7718 r2.in.value_name = r->in.value_name;
7719
7720 return _spoolss_DeletePrinterDataEx(p, &r2);
7721 }
7722
7723 /****************************************************************
7724 _spoolss_AddForm
7725 ****************************************************************/
7726
7727 WERROR _spoolss_AddForm(pipes_struct *p,
7728 struct spoolss_AddForm *r)
7729 {
7730 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
7731 nt_forms_struct tmpForm;
7732 int snum = -1;
7733 WERROR status = WERR_OK;
7734 NT_PRINTER_INFO_LEVEL *printer = NULL;
7735 SE_PRIV se_printop = SE_PRINT_OPERATOR;
7736
7737 int count=0;
7738 nt_forms_struct *list=NULL;
7739 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7740
7741 DEBUG(5,("_spoolss_AddForm\n"));
7742
7743 if (!Printer) {
7744 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
7745 OUR_HANDLE(r->in.handle)));
7746 return WERR_BADFID;
7747 }
7748
7749
7750 /* forms can be added on printer of on the print server handle */
7751
7752 if ( Printer->printer_type == SPLHND_PRINTER )
7753 {
7754 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7755 return WERR_BADFID;
7756
7757 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7758 if (!W_ERROR_IS_OK(status))
7759 goto done;
7760 }
7761
7762 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
7763 and not a printer admin, then fail */
7764
7765 if ((p->server_info->utok.uid != sec_initial_uid()) &&
7766 !user_has_privileges(p->server_info->ptok, &se_printop) &&
7767 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7768 NULL, NULL,
7769 p->server_info->ptok,
7770 lp_printer_admin(snum))) {
7771 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
7772 return WERR_ACCESS_DENIED;
7773 }
7774
7775 /* can't add if builtin */
7776
7777 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
7778 status = WERR_FILE_EXISTS;
7779 goto done;
7780 }
7781
7782 count = get_ntforms(&list);
7783
7784 if(!add_a_form(&list, form, &count)) {
7785 status = WERR_NOMEM;
7786 goto done;
7787 }
7788
7789 become_root();
7790 write_ntforms(&list, count);
7791 unbecome_root();
7792
7793 /*
7794 * ChangeID must always be set if this is a printer
7795 */
7796
7797 if ( Printer->printer_type == SPLHND_PRINTER )
7798 status = mod_a_printer(printer, 2);
7799
7800 done:
7801 if ( printer )
7802 free_a_printer(&printer, 2);
7803 SAFE_FREE(list);
7804
7805 return status;
7806 }
7807
7808 /****************************************************************
7809 _spoolss_DeleteForm
7810 ****************************************************************/
7811
7812 WERROR _spoolss_DeleteForm(pipes_struct *p,
7813 struct spoolss_DeleteForm *r)
7814 {
7815 const char *form_name = r->in.form_name;
7816 nt_forms_struct tmpForm;
7817 int count=0;
7818 nt_forms_struct *list=NULL;
7819 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7820 int snum = -1;
7821 WERROR status = WERR_OK;
7822 NT_PRINTER_INFO_LEVEL *printer = NULL;
7823 SE_PRIV se_printop = SE_PRINT_OPERATOR;
7824 bool ret = false;
7825
7826 DEBUG(5,("_spoolss_DeleteForm\n"));
7827
7828 if (!Printer) {
7829 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
7830 OUR_HANDLE(r->in.handle)));
7831 return WERR_BADFID;
7832 }
7833
7834 /* forms can be deleted on printer of on the print server handle */
7835
7836 if ( Printer->printer_type == SPLHND_PRINTER )
7837 {
7838 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7839 return WERR_BADFID;
7840
7841 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7842 if (!W_ERROR_IS_OK(status))
7843 goto done;
7844 }
7845
7846 if ((p->server_info->utok.uid != sec_initial_uid()) &&
7847 !user_has_privileges(p->server_info->ptok, &se_printop) &&
7848 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7849 NULL, NULL,
7850 p->server_info->ptok,
7851 lp_printer_admin(snum))) {
7852 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
7853 return WERR_ACCESS_DENIED;
7854 }
7855
7856
7857 /* can't delete if builtin */
7858
7859 if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
7860 status = WERR_INVALID_PARAM;
7861 goto done;
7862 }
7863
7864 count = get_ntforms(&list);
7865
7866 become_root();
7867 ret = delete_a_form(&list, form_name, &count, &status);
7868 unbecome_root();
7869 if (ret == false) {
7870 goto done;
7871 }
7872
7873 /*
7874 * ChangeID must always be set if this is a printer
7875 */
7876
7877 if ( Printer->printer_type == SPLHND_PRINTER )
7878 status = mod_a_printer(printer, 2);
7879
7880 done:
7881 if ( printer )
7882 free_a_printer(&printer, 2);
7883 SAFE_FREE(list);
7884
7885 return status;
7886 }
7887
7888 /****************************************************************
7889 _spoolss_SetForm
7890 ****************************************************************/
7891
7892 WERROR _spoolss_SetForm(pipes_struct *p,
7893 struct spoolss_SetForm *r)
7894 {
7895 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
7896 nt_forms_struct tmpForm;
7897 int snum = -1;
7898 WERROR status = WERR_OK;
7899 NT_PRINTER_INFO_LEVEL *printer = NULL;
7900 SE_PRIV se_printop = SE_PRINT_OPERATOR;
7901
7902 int count=0;
7903 nt_forms_struct *list=NULL;
7904 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7905
7906 DEBUG(5,("_spoolss_SetForm\n"));
7907
7908 if (!Printer) {
7909 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
7910 OUR_HANDLE(r->in.handle)));
7911 return WERR_BADFID;
7912 }
7913
7914 /* forms can be modified on printer of on the print server handle */
7915
7916 if ( Printer->printer_type == SPLHND_PRINTER )
7917 {
7918 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7919 return WERR_BADFID;
7920
7921 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7922 if (!W_ERROR_IS_OK(status))
7923 goto done;
7924 }
7925
7926 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
7927 and not a printer admin, then fail */
7928
7929 if ((p->server_info->utok.uid != sec_initial_uid()) &&
7930 !user_has_privileges(p->server_info->ptok, &se_printop) &&
7931 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7932 NULL, NULL,
7933 p->server_info->ptok,
7934 lp_printer_admin(snum))) {
7935 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
7936 return WERR_ACCESS_DENIED;
7937 }
7938
7939 /* can't set if builtin */
7940 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
7941 status = WERR_INVALID_PARAM;
7942 goto done;
7943 }
7944
7945 count = get_ntforms(&list);
7946 update_a_form(&list, form, count);
7947 become_root();
7948 write_ntforms(&list, count);
7949 unbecome_root();
7950
7951 /*
7952 * ChangeID must always be set if this is a printer
7953 */
7954
7955 if ( Printer->printer_type == SPLHND_PRINTER )
7956 status = mod_a_printer(printer, 2);
7957
7958
7959 done:
7960 if ( printer )
7961 free_a_printer(&printer, 2);
7962 SAFE_FREE(list);
7963
7964 return status;
7965 }
7966
7967 /****************************************************************************
7968 fill_print_processor1
7969 ****************************************************************************/
7970
7971 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
7972 struct spoolss_PrintProcessorInfo1 *r,
7973 const char *print_processor_name)
7974 {
7975 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
7976 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
7977
7978 return WERR_OK;
7979 }
7980
7981 /****************************************************************************
7982 enumprintprocessors level 1.
7983 ****************************************************************************/
7984
7985 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
7986 union spoolss_PrintProcessorInfo **info_p,
7987 uint32_t *count)
7988 {
7989 union spoolss_PrintProcessorInfo *info;
7990 WERROR result;
7991
7992 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
7993 W_ERROR_HAVE_NO_MEMORY(info);
7994
7995 *count = 1;
7996
7997 result = fill_print_processor1(info, &info[0].info1, "winprint");
7998 if (!W_ERROR_IS_OK(result)) {
7999 goto out;
8000 }
8001
8002 out:
8003 if (!W_ERROR_IS_OK(result)) {
8004 TALLOC_FREE(info);
8005 *count = 0;
8006 return result;
8007 }
8008
8009 *info_p = info;
8010
8011 return WERR_OK;
8012 }
8013
8014 /****************************************************************
8015 _spoolss_EnumPrintProcessors
8016 ****************************************************************/
8017
8018 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8019 struct spoolss_EnumPrintProcessors *r)
8020 {
8021 WERROR result;
8022
8023 /* that's an [in out] buffer */
8024
8025 if (!r->in.buffer && (r->in.offered != 0)) {
8026 return WERR_INVALID_PARAM;
8027 }
8028
8029 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8030
8031 /*
8032 * Enumerate the print processors ...
8033 *
8034 * Just reply with "winprint", to keep NT happy
8035 * and I can use my nice printer checker.
8036 */
8037
8038 *r->out.count = 0;
8039 *r->out.needed = 0;
8040 *r->out.info = NULL;
8041
8042 switch (r->in.level) {
8043 case 1:
8044 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8045 r->out.count);
8046 break;
8047 default:
8048 return WERR_UNKNOWN_LEVEL;
8049 }
8050
8051 if (!W_ERROR_IS_OK(result)) {
8052 return result;
8053 }
8054
8055 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8056 spoolss_EnumPrintProcessors, NULL,
8057 *r->out.info, r->in.level,
8058 *r->out.count);
8059 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8060 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8061
8062 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8063 }
8064
8065 /****************************************************************************
8066 fill_printprocdatatype1
8067 ****************************************************************************/
8068
8069 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8070 struct spoolss_PrintProcDataTypesInfo1 *r,
8071 const char *name_array)
8072 {
8073 r->name_array = talloc_strdup(mem_ctx, name_array);
8074 W_ERROR_HAVE_NO_MEMORY(r->name_array);
8075
8076 return WERR_OK;
8077 }
8078
8079 /****************************************************************************
8080 enumprintprocdatatypes level 1.
8081 ****************************************************************************/
8082
8083 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8084 union spoolss_PrintProcDataTypesInfo **info_p,
8085 uint32_t *count)
8086 {
8087 WERROR result;
8088 union spoolss_PrintProcDataTypesInfo *info;
8089
8090 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8091 W_ERROR_HAVE_NO_MEMORY(info);
8092
8093 *count = 1;
8094
8095 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8096 if (!W_ERROR_IS_OK(result)) {
8097 goto out;
8098 }
8099
8100 out:
8101 if (!W_ERROR_IS_OK(result)) {
8102 TALLOC_FREE(info);
8103 *count = 0;
8104 return result;
8105 }
8106
8107 *info_p = info;
8108
8109 return WERR_OK;
8110 }
8111
8112 /****************************************************************
8113 _spoolss_EnumPrintProcDataTypes
8114 ****************************************************************/
8115
8116 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8117 struct spoolss_EnumPrintProcDataTypes *r)
8118 {
8119 WERROR result;
8120
8121 /* that's an [in out] buffer */
8122
8123 if (!r->in.buffer && (r->in.offered != 0)) {
8124 return WERR_INVALID_PARAM;
8125 }
8126
8127 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8128
8129 *r->out.count = 0;
8130 *r->out.needed = 0;
8131 *r->out.info = NULL;
8132
8133 switch (r->in.level) {
8134 case 1:
8135 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8136 r->out.count);
8137 break;
8138 default:
8139 return WERR_UNKNOWN_LEVEL;
8140 }
8141
8142 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8143 spoolss_EnumPrintProcDataTypes, NULL,
8144 *r->out.info, r->in.level,
8145 *r->out.count);
8146 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8147 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8148
8149 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8150 }
8151
8152 /****************************************************************************
8153 fill_monitor_1
8154 ****************************************************************************/
8155
8156 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8157 struct spoolss_MonitorInfo1 *r,
8158 const char *monitor_name)
8159 {
8160 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8161 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8162
8163 return WERR_OK;
8164 }
8165
8166 /****************************************************************************
8167 fill_monitor_2
8168 ****************************************************************************/
8169
8170 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8171 struct spoolss_MonitorInfo2 *r,
8172 const char *monitor_name,
8173 const char *environment,
8174 const char *dll_name)
8175 {
8176 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8177 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8178 r->environment = talloc_strdup(mem_ctx, environment);
8179 W_ERROR_HAVE_NO_MEMORY(r->environment);
8180 r->dll_name = talloc_strdup(mem_ctx, dll_name);
8181 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8182
8183 return WERR_OK;
8184 }
8185
8186 /****************************************************************************
8187 enumprintmonitors level 1.
8188 ****************************************************************************/
8189
8190 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8191 union spoolss_MonitorInfo **info_p,
8192 uint32_t *count)
8193 {
8194 union spoolss_MonitorInfo *info;
8195 WERROR result = WERR_OK;
8196
8197 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8198 W_ERROR_HAVE_NO_MEMORY(info);
8199
8200 *count = 2;
8201
8202 result = fill_monitor_1(info, &info[0].info1,
8203 SPL_LOCAL_PORT);
8204 if (!W_ERROR_IS_OK(result)) {
8205 goto out;
8206 }
8207
8208 result = fill_monitor_1(info, &info[1].info1,
8209 SPL_TCPIP_PORT);
8210 if (!W_ERROR_IS_OK(result)) {
8211 goto out;
8212 }
8213
8214 out:
8215 if (!W_ERROR_IS_OK(result)) {
8216 TALLOC_FREE(info);
8217 *count = 0;
8218 return result;
8219 }
8220
8221 *info_p = info;
8222
8223 return WERR_OK;
8224 }
8225
8226 /****************************************************************************
8227 enumprintmonitors level 2.
8228 ****************************************************************************/
8229
8230 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8231 union spoolss_MonitorInfo **info_p,
8232 uint32_t *count)
8233 {
8234 union spoolss_MonitorInfo *info;
8235 WERROR result = WERR_OK;
8236
8237 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8238 W_ERROR_HAVE_NO_MEMORY(info);
8239
8240 *count = 2;
8241
8242 result = fill_monitor_2(info, &info[0].info2,
8243 SPL_LOCAL_PORT,
8244 "Windows NT X86", /* FIXME */
8245 "localmon.dll");
8246 if (!W_ERROR_IS_OK(result)) {
8247 goto out;
8248 }
8249
8250 result = fill_monitor_2(info, &info[1].info2,
8251 SPL_TCPIP_PORT,
8252 "Windows NT X86", /* FIXME */
8253 "tcpmon.dll");
8254 if (!W_ERROR_IS_OK(result)) {
8255 goto out;
8256 }
8257
8258 out:
8259 if (!W_ERROR_IS_OK(result)) {
8260 TALLOC_FREE(info);
8261 *count = 0;
8262 return result;
8263 }
8264
8265 *info_p = info;
8266
8267 return WERR_OK;
8268 }
8269
8270 /****************************************************************
8271 _spoolss_EnumMonitors
8272 ****************************************************************/
8273
8274 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8275 struct spoolss_EnumMonitors *r)
8276 {
8277 WERROR result;
8278
8279 /* that's an [in out] buffer */
8280
8281 if (!r->in.buffer && (r->in.offered != 0)) {
8282 return WERR_INVALID_PARAM;
8283 }
8284
8285 DEBUG(5,("_spoolss_EnumMonitors\n"));
8286
8287 /*
8288 * Enumerate the print monitors ...
8289 *
8290 * Just reply with "Local Port", to keep NT happy
8291 * and I can use my nice printer checker.
8292 */
8293
8294 *r->out.count = 0;
8295 *r->out.needed = 0;
8296 *r->out.info = NULL;
8297
8298 switch (r->in.level) {
8299 case 1:
8300 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8301 r->out.count);
8302 break;
8303 case 2:
8304 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8305 r->out.count);
8306 break;
8307 default:
8308 return WERR_UNKNOWN_LEVEL;
8309 }
8310
8311 if (!W_ERROR_IS_OK(result)) {
8312 return result;
8313 }
8314
8315 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8316 spoolss_EnumMonitors, NULL,
8317 *r->out.info, r->in.level,
8318 *r->out.count);
8319 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8320 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8321
8322 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8323 }
8324
8325 /****************************************************************************
8326 ****************************************************************************/
8327
8328 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8329 const print_queue_struct *queue,
8330 int count, int snum,
8331 const NT_PRINTER_INFO_LEVEL *ntprinter,
8332 uint32_t jobid,
8333 struct spoolss_JobInfo1 *r)
8334 {
8335 int i = 0;
8336 bool found = false;
8337
8338 for (i=0; i<count && found == false; i++) {
8339 if (queue[i].job == (int)jobid) {
8340 found = true;
8341 }
8342 }
8343
8344 if (found == false) {
8345 /* NT treats not found as bad param... yet another bad choice */
8346 return WERR_INVALID_PARAM;
8347 }
8348
8349 return fill_job_info1(mem_ctx,
8350 r,
8351 &queue[i-1],
8352 i,
8353 snum,
8354 ntprinter);
8355 }
8356
8357 /****************************************************************************
8358 ****************************************************************************/
8359
8360 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8361 const print_queue_struct *queue,
8362 int count, int snum,
8363 const NT_PRINTER_INFO_LEVEL *ntprinter,
8364 uint32_t jobid,
8365 struct spoolss_JobInfo2 *r)
8366 {
8367 int i = 0;
8368 bool found = false;
8369 struct spoolss_DeviceMode *devmode;
8370 NT_DEVICEMODE *nt_devmode;
8371 WERROR result;
8372
8373 for (i=0; i<count && found == false; i++) {
8374 if (queue[i].job == (int)jobid) {
8375 found = true;
8376 }
8377 }
8378
8379 if (found == false) {
8380 /* NT treats not found as bad param... yet another bad
8381 choice */
8382 return WERR_INVALID_PARAM;
8383 }
8384
8385 /*
8386 * if the print job does not have a DEVMODE associated with it,
8387 * just use the one for the printer. A NULL devicemode is not
8388 * a failure condition
8389 */
8390
8391 nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8392 if (nt_devmode) {
8393 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
8394 W_ERROR_HAVE_NO_MEMORY(devmode);
8395 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
8396 if (!W_ERROR_IS_OK(result)) {
8397 return result;
8398 }
8399 } else {
8400 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
8401 W_ERROR_HAVE_NO_MEMORY(devmode);
8402 }
8403
8404 return fill_job_info2(mem_ctx,
8405 r,
8406 &queue[i-1],
8407 i,
8408 snum,
8409 ntprinter,
8410 devmode);
8411 }
8412
8413 /****************************************************************
8414 _spoolss_GetJob
8415 ****************************************************************/
8416
8417 WERROR _spoolss_GetJob(pipes_struct *p,
8418 struct spoolss_GetJob *r)
8419 {
8420 WERROR result = WERR_OK;
8421 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
8422 int snum;
8423 int count;
8424 print_queue_struct *queue = NULL;
8425 print_status_struct prt_status;
8426
8427 /* that's an [in out] buffer */
8428
8429 if (!r->in.buffer && (r->in.offered != 0)) {
8430 return WERR_INVALID_PARAM;
8431 }
8432
8433 DEBUG(5,("_spoolss_GetJob\n"));
8434
8435 *r->out.needed = 0;
8436
8437 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8438 return WERR_BADFID;
8439 }
8440
8441 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
8442 if (!W_ERROR_IS_OK(result)) {
8443 return result;
8444 }
8445
8446 count = print_queue_status(snum, &queue, &prt_status);
8447
8448 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8449 count, prt_status.status, prt_status.message));
8450
8451 switch (r->in.level) {
8452 case 1:
8453 result = getjob_level_1(p->mem_ctx,
8454 queue, count, snum, ntprinter,
8455 r->in.job_id, &r->out.info->info1);
8456 break;
8457 case 2:
8458 result = getjob_level_2(p->mem_ctx,
8459 queue, count, snum, ntprinter,
8460 r->in.job_id, &r->out.info->info2);
8461 break;
8462 default:
8463 result = WERR_UNKNOWN_LEVEL;
8464 break;
8465 }
8466
8467 SAFE_FREE(queue);
8468 free_a_printer(&ntprinter, 2);
8469
8470 if (!W_ERROR_IS_OK(result)) {
8471 TALLOC_FREE(r->out.info);
8472 return result;
8473 }
8474
8475 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
8476 r->out.info, r->in.level);
8477 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8478
8479 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8480 }
8481
8482 /****************************************************************
8483 _spoolss_GetPrinterDataEx
8484 ****************************************************************/
8485
8486 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
8487 struct spoolss_GetPrinterDataEx *r)
8488 {
8489
8490 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8491 struct regval_blob *val = NULL;
8492 NT_PRINTER_INFO_LEVEL *printer = NULL;
8493 int snum = 0;
8494 WERROR result = WERR_OK;
8495 DATA_BLOB blob;
8496
8497 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8498
8499 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8500 r->in.key_name, r->in.value_name));
8501
8502 /* in case of problem, return some default values */
8503
8504 *r->out.needed = 0;
8505 *r->out.type = REG_NONE;
8506
8507 if (!Printer) {
8508 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8509 OUR_HANDLE(r->in.handle)));
8510 result = WERR_BADFID;
8511 goto done;
8512 }
8513
8514 /* Is the handle to a printer or to the server? */
8515
8516 if (Printer->printer_type == SPLHND_SERVER) {
8517
8518 result = getprinterdata_printer_server(p->mem_ctx,
8519 r->in.value_name,
8520 r->out.type,
8521 r->out.data);
8522 goto done;
8523 }
8524
8525 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8526 result = WERR_BADFID;
8527 goto done;
8528 }
8529
8530 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8531 if (!W_ERROR_IS_OK(result)) {
8532 goto done;
8533 }
8534
8535 /* check to see if the keyname is valid */
8536 if (!strlen(r->in.key_name)) {
8537 result = WERR_INVALID_PARAM;
8538 goto done;
8539 }
8540
8541 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
8542
8543 if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
8544 strequal(r->in.value_name, "ChangeId")) {
8545 *r->out.type = REG_DWORD;
8546 *r->out.needed = 4;
8547 r->out.data->value = printer->info_2->changeid;
8548 result = WERR_OK;
8549 goto done;
8550 }
8551
8552 if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
8553 DEBUG(4,("_spoolss_GetPrinterDataEx: "
8554 "Invalid keyname [%s]\n", r->in.key_name ));
8555 result = WERR_BADFILE;
8556 goto done;
8557 }
8558
8559 val = get_printer_data(printer->info_2,
8560 r->in.key_name, r->in.value_name);
8561 if (!val) {
8562 result = WERR_BADFILE;
8563 goto done;
8564 }
8565
8566 *r->out.needed = regval_size(val);
8567 *r->out.type = regval_type(val);
8568
8569 blob = data_blob_const(regval_data_p(val), regval_size(val));
8570
8571 result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
8572 r->out.data,
8573 *r->out.type);
8574
8575 done:
8576 if (printer) {
8577 free_a_printer(&printer, 2);
8578 }
8579
8580 if (!W_ERROR_IS_OK(result)) {
8581 return result;
8582 }
8583
8584 *r->out.needed = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
8585 *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
8586 r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
8587
8588 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
8589 }
8590
8591 /****************************************************************
8592 _spoolss_SetPrinterDataEx
8593 ****************************************************************/
8594
8595 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
8596 struct spoolss_SetPrinterDataEx *r)
8597 {
8598 NT_PRINTER_INFO_LEVEL *printer = NULL;
8599 int snum = 0;
8600 WERROR result = WERR_OK;
8601 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8602 char *oid_string;
8603 DATA_BLOB blob;
8604
8605 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
8606
8607 /* From MSDN documentation of SetPrinterDataEx: pass request to
8608 SetPrinterData if key is "PrinterDriverData" */
8609
8610 if (!Printer) {
8611 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8612 OUR_HANDLE(r->in.handle)));
8613 return WERR_BADFID;
8614 }
8615
8616 if (Printer->printer_type == SPLHND_SERVER) {
8617 DEBUG(10,("_spoolss_SetPrinterDataEx: "
8618 "Not implemented for server handles yet\n"));
8619 return WERR_INVALID_PARAM;
8620 }
8621
8622 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8623 return WERR_BADFID;
8624 }
8625
8626 /*
8627 * Access check : NT returns "access denied" if you make a
8628 * SetPrinterData call without the necessary privildge.
8629 * we were originally returning OK if nothing changed
8630 * which made Win2k issue **a lot** of SetPrinterData
8631 * when connecting to a printer --jerry
8632 */
8633
8634 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8635 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
8636 "change denied by handle access permissions\n"));
8637 return WERR_ACCESS_DENIED;
8638 }
8639
8640 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8641 if (!W_ERROR_IS_OK(result)) {
8642 return result;
8643 }
8644
8645 /* check for OID in valuename */
8646
8647 oid_string = strchr(r->in.value_name, ',');
8648 if (oid_string) {
8649 *oid_string = '\0';
8650 oid_string++;
8651 }
8652
8653 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8654 r->in.type, &r->in.data);
8655 if (!W_ERROR_IS_OK(result)) {
8656 goto done;
8657 }
8658
8659 /*
8660 * When client side code sets a magic printer data key, detect it and save
8661 * the current printer data and the magic key's data (its the DEVMODE) for
8662 * future printer/driver initializations.
8663 */
8664 if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8665 /* Set devmode and printer initialization info */
8666 result = save_driver_init(printer, 2, blob.data, blob.length);
8667
8668 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8669
8670 goto done;
8671 }
8672
8673 /* save the registry data */
8674
8675 result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
8676 r->in.type, blob.data, blob.length);
8677
8678 if (W_ERROR_IS_OK(result)) {
8679 /* save the OID if one was specified */
8680 if (oid_string) {
8681 char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
8682 r->in.key_name, SPOOL_OID_KEY);
8683 if (!str) {
8684 result = WERR_NOMEM;
8685 goto done;
8686 }
8687
8688 /*
8689 * I'm not checking the status here on purpose. Don't know
8690 * if this is right, but I'm returning the status from the
8691 * previous set_printer_dataex() call. I have no idea if
8692 * this is right. --jerry
8693 */
8694
8695 set_printer_dataex(printer, str, r->in.value_name,
8696 REG_SZ, (uint8_t *)oid_string,
8697 strlen(oid_string)+1);
8698 }
8699
8700 result = mod_a_printer(printer, 2);
8701 }
8702
8703 done:
8704 free_a_printer(&printer, 2);
8705
8706 return result;
8707 }
8708
8709 /****************************************************************
8710 _spoolss_DeletePrinterDataEx
8711 ****************************************************************/
8712
8713 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
8714 struct spoolss_DeletePrinterDataEx *r)
8715 {
8716 NT_PRINTER_INFO_LEVEL *printer = NULL;
8717 int snum=0;
8718 WERROR status = WERR_OK;
8719 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8720
8721 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
8722
8723 if (!Printer) {
8724 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
8725 "Invalid handle (%s:%u:%u).\n",
8726 OUR_HANDLE(r->in.handle)));
8727 return WERR_BADFID;
8728 }
8729
8730 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8731 return WERR_BADFID;
8732
8733 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8734 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
8735 "printer properties change denied by handle\n"));
8736 return WERR_ACCESS_DENIED;
8737 }
8738
8739 if (!r->in.value_name || !r->in.key_name) {
8740 return WERR_NOMEM;
8741 }
8742
8743 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8744 if (!W_ERROR_IS_OK(status))
8745 return status;
8746
8747 status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
8748
8749 if ( W_ERROR_IS_OK(status) )
8750 mod_a_printer( printer, 2 );
8751
8752 free_a_printer(&printer, 2);
8753
8754 return status;
8755 }
8756
8757 /****************************************************************
8758 _spoolss_EnumPrinterKey
8759 ****************************************************************/
8760
8761 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
8762 struct spoolss_EnumPrinterKey *r)
8763 {
8764 fstring *keynames = NULL;
8765 int num_keys;
8766 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8767 NT_PRINTER_DATA *data;
8768 NT_PRINTER_INFO_LEVEL *printer = NULL;
8769 int snum = 0;
8770 WERROR result = WERR_BADFILE;
8771 int i;
8772 const char **array = NULL;
8773 DATA_BLOB blob;
8774
8775 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
8776
8777 if (!Printer) {
8778 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
8779 OUR_HANDLE(r->in.handle)));
8780 return WERR_BADFID;
8781 }
8782
8783 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8784 return WERR_BADFID;
8785 }
8786
8787 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8788 if (!W_ERROR_IS_OK(result)) {
8789 return result;
8790 }
8791
8792 /* get the list of subkey names */
8793
8794 data = printer->info_2->data;
8795
8796 num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
8797 if (num_keys == -1) {
8798 result = WERR_BADFILE;
8799 goto done;
8800 }
8801
8802 array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 2);
8803 if (!array) {
8804 result = WERR_NOMEM;
8805 goto done;
8806 }
8807
8808 if (!num_keys) {
8809 array[0] = talloc_strdup(array, "");
8810 if (!array[0]) {
8811 result = WERR_NOMEM;
8812 goto done;
8813 }
8814 }
8815
8816 for (i=0; i < num_keys; i++) {
8817
8818 DEBUG(10,("_spoolss_EnumPrinterKey: adding keyname: %s\n",
8819 keynames[i]));
8820
8821 array[i] = talloc_strdup(array, keynames[i]);
8822 if (!array[i]) {
8823 result = WERR_NOMEM;
8824 goto done;
8825 }
8826 }
8827
8828 if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
8829 result = WERR_NOMEM;
8830 goto done;
8831 }
8832
8833 *r->out._ndr_size = r->in.offered / 2;
8834 *r->out.needed = blob.length;
8835
8836 if (r->in.offered < *r->out.needed) {
8837 result = WERR_MORE_DATA;
8838 } else {
8839 result = WERR_OK;
8840 r->out.key_buffer->string_array = array;
8841 }
8842
8843 done:
8844 if (!W_ERROR_IS_OK(result)) {
8845 TALLOC_FREE(array);
8846 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
8847 *r->out.needed = 0;
8848 }
8849 }
8850
8851 free_a_printer(&printer, 2);
8852 SAFE_FREE(keynames);
8853
8854 return result;
8855 }
8856
8857 /****************************************************************
8858 _spoolss_DeletePrinterKey
8859 ****************************************************************/
8860
8861 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
8862 struct spoolss_DeletePrinterKey *r)
8863 {
8864 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8865 NT_PRINTER_INFO_LEVEL *printer = NULL;
8866 int snum=0;
8867 WERROR status;
8868
8869 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
8870
8871 if (!Printer) {
8872 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
8873 OUR_HANDLE(r->in.handle)));
8874 return WERR_BADFID;
8875 }
8876
8877 /* if keyname == NULL, return error */
8878
8879 if ( !r->in.key_name )
8880 return WERR_INVALID_PARAM;
8881
8882 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8883 return WERR_BADFID;
8884
8885 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8886 DEBUG(3, ("_spoolss_DeletePrinterKey: "
8887 "printer properties change denied by handle\n"));
8888 return WERR_ACCESS_DENIED;
8889 }
8890
8891 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8892 if (!W_ERROR_IS_OK(status))
8893 return status;
8894
8895 /* delete the key and all subneys */
8896
8897 status = delete_all_printer_data( printer->info_2, r->in.key_name );
8898
8899 if ( W_ERROR_IS_OK(status) )
8900 status = mod_a_printer(printer, 2);
8901
8902 free_a_printer( &printer, 2 );
8903
8904 return status;
8905 }
8906
8907 /****************************************************************
8908 ****************************************************************/
8909
8910 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
8911 struct regval_blob *v,
8912 struct spoolss_PrinterEnumValues *r)
8913 {
8914 WERROR result;
8915
8916 r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
8917 W_ERROR_HAVE_NO_MEMORY(r->data);
8918
8919 r->value_name = talloc_strdup(mem_ctx, regval_name(v));
8920 W_ERROR_HAVE_NO_MEMORY(r->value_name);
8921
8922 r->type = regval_type(v);
8923 r->data_length = regval_size(v);
8924
8925 if (r->data_length) {
8926 DATA_BLOB blob = data_blob_const(regval_data_p(v),
8927 regval_size(v));
8928 result = pull_spoolss_PrinterData(mem_ctx, &blob,
8929 r->data,
8930 r->type);
8931 if (!W_ERROR_IS_OK(result)) {
8932 return result;
8933 }
8934 }
8935
8936 return WERR_OK;
8937 }
8938
8939 /****************************************************************
8940 _spoolss_EnumPrinterDataEx
8941 ****************************************************************/
8942
8943 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
8944 struct spoolss_EnumPrinterDataEx *r)
8945 {
8946 uint32_t count = 0;
8947 NT_PRINTER_INFO_LEVEL *printer = NULL;
8948 struct spoolss_PrinterEnumValues *info = NULL;
8949 NT_PRINTER_DATA *p_data;
8950 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8951 int snum;
8952 WERROR result;
8953 int key_index;
8954 int i;
8955
8956 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
8957
8958 *r->out.count = 0;
8959 *r->out.needed = 0;
8960 *r->out.info = NULL;
8961
8962 if (!Printer) {
8963 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
8964 OUR_HANDLE(r->in.handle)));
8965 return WERR_BADFID;
8966 }
8967
8968 /*
8969 * first check for a keyname of NULL or "". Win2k seems to send
8970 * this a lot and we should send back WERR_INVALID_PARAM
8971 * no need to spend time looking up the printer in this case.
8972 * --jerry
8973 */
8974
8975 if (!strlen(r->in.key_name)) {
8976 result = WERR_INVALID_PARAM;
8977 goto done;
8978 }
8979
8980 /* get the printer off of disk */
8981
8982 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8983 return WERR_BADFID;
8984 }
8985
8986 ZERO_STRUCT(printer);
8987 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8988 if (!W_ERROR_IS_OK(result)) {
8989 return result;
8990 }
8991
8992 /* now look for a match on the key name */
8993
8994 p_data = printer->info_2->data;
8995
8996 key_index = lookup_printerkey(p_data, r->in.key_name);
8997 if (key_index == -1) {
8998 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
8999 r->in.key_name));
9000 result = WERR_INVALID_PARAM;
9001 goto done;
9002 }
9003
9004 /* allocate the memory for the array of pointers -- if necessary */
9005
9006 count = regval_ctr_numvals(p_data->keys[key_index].values);
9007 if (!count) {
9008 result = WERR_OK; /* ??? */
9009 goto done;
9010 }
9011
9012 info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9013 struct spoolss_PrinterEnumValues,
9014 count);
9015 if (!info) {
9016 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9017 result = WERR_NOMEM;
9018 goto done;
9019 }
9020
9021 /*
9022 * loop through all params and build the array to pass
9023 * back to the client
9024 */
9025
9026 for (i=0; i < count; i++) {
9027
9028 struct regval_blob *val;
9029
9030 /* lookup the registry value */
9031
9032 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9033
9034 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9035
9036 /* copy the data */
9037
9038 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9039 if (!W_ERROR_IS_OK(result)) {
9040 goto done;
9041 }
9042 }
9043
9044 #if 0 /* FIXME - gd */
9045 /* housekeeping information in the reply */
9046
9047 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9048 * the hand marshalled container size is a multiple
9049 * of 4 bytes for RPC alignment.
9050 */
9051
9052 if (needed % 4) {
9053 needed += 4-(needed % 4);
9054 }
9055 #endif
9056 *r->out.count = count;
9057 *r->out.info = info;
9058
9059 done:
9060
9061 if (printer) {
9062 free_a_printer(&printer, 2);
9063 }
9064
9065 if (!W_ERROR_IS_OK(result)) {
9066 return result;
9067 }
9068
9069 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9070 spoolss_EnumPrinterDataEx, NULL,
9071 *r->out.info,
9072 *r->out.count);
9073 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9074 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9075
9076 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9077 }
9078
9079 /****************************************************************************
9080 ****************************************************************************/
9081
9082 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9083 const char *servername,
9084 const char *environment,
9085 struct spoolss_PrintProcessorDirectoryInfo1 *r)
9086 {
9087 WERROR werr;
9088 char *path = NULL;
9089
9090 werr = compose_spoolss_server_path(mem_ctx,
9091 servername,
9092 environment,
9093 SPOOLSS_PRTPROCS_PATH,
9094 &path);
9095 if (!W_ERROR_IS_OK(werr)) {
9096 return werr;
9097 }
9098
9099 DEBUG(4,("print processor directory: [%s]\n", path));
9100
9101 r->directory_name = path;
9102
9103 return WERR_OK;
9104 }
9105
9106 /****************************************************************
9107 _spoolss_GetPrintProcessorDirectory
9108 ****************************************************************/
9109
9110 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9111 struct spoolss_GetPrintProcessorDirectory *r)
9112 {
9113 WERROR result;
9114
9115 /* that's an [in out] buffer */
9116
9117 if (!r->in.buffer && (r->in.offered != 0)) {
9118 return WERR_INVALID_PARAM;
9119 }
9120
9121 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9122 r->in.level));
9123
9124 *r->out.needed = 0;
9125
9126 /* r->in.level is ignored */
9127
9128 /* We always should reply with a local print processor directory so that
9129 * users are not forced to have a [prnproc$] share on the Samba spoolss
9130 * server - Guenther */
9131
9132 result = getprintprocessordirectory_level_1(p->mem_ctx,
9133 NULL, /* r->in.server */
9134 r->in.environment,
9135 &r->out.info->info1);
9136 if (!W_ERROR_IS_OK(result)) {
9137 TALLOC_FREE(r->out.info);
9138 return result;
9139 }
9140
9141 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9142 r->out.info, r->in.level);
9143 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9144
9145 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9146 }
9147
9148 /*******************************************************************
9149 ********************************************************************/
9150
9151 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9152 const char *dllname)
9153 {
9154 enum ndr_err_code ndr_err;
9155 struct spoolss_MonitorUi ui;
9156
9157 ui.dll_name = dllname;
9158
9159 ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9160 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9161 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9162 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9163 }
9164 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9165 }
9166
9167 /*******************************************************************
9168 Streams the monitor UI DLL name in UNICODE
9169 *******************************************************************/
9170
9171 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9172 NT_USER_TOKEN *token, DATA_BLOB *in,
9173 DATA_BLOB *out, uint32_t *needed)
9174 {
9175 const char *dllname = "tcpmonui.dll";
9176
9177 *needed = (strlen(dllname)+1) * 2;
9178
9179 if (out->length < *needed) {
9180 return WERR_INSUFFICIENT_BUFFER;
9181 }
9182
9183 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9184 return WERR_NOMEM;
9185 }
9186
9187 return WERR_OK;
9188 }
9189
9190 /*******************************************************************
9191 ********************************************************************/
9192
9193 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9194 struct spoolss_PortData1 *port1,
9195 const DATA_BLOB *buf)
9196 {
9197 enum ndr_err_code ndr_err;
9198 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9199 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9200 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9201 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9202 }
9203 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9204 }
9205
9206 /*******************************************************************
9207 ********************************************************************/
9208
9209 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9210 struct spoolss_PortData2 *port2,
9211 const DATA_BLOB *buf)
9212 {
9213 enum ndr_err_code ndr_err;
9214 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9215 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9216 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9217 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9218 }
9219 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9220 }
9221
9222 /*******************************************************************
9223 Create a new TCP/IP port
9224 *******************************************************************/
9225
9226 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9227 NT_USER_TOKEN *token, DATA_BLOB *in,
9228 DATA_BLOB *out, uint32_t *needed)
9229 {
9230 struct spoolss_PortData1 port1;
9231 struct spoolss_PortData2 port2;
9232 char *device_uri = NULL;
9233 uint32_t version;
9234
9235 const char *portname;
9236 const char *hostaddress;
9237 const char *queue;
9238 uint32_t port_number;
9239 uint32_t protocol;
9240
9241 /* peek for spoolss_PortData version */
9242
9243 if (!in || (in->length < (128 + 4))) {
9244 return WERR_GENERAL_FAILURE;
9245 }
9246
9247 version = IVAL(in->data, 128);
9248
9249 switch (version) {
9250 case 1:
9251 ZERO_STRUCT(port1);
9252
9253 if (!pull_port_data_1(mem_ctx, &port1, in)) {
9254 return WERR_NOMEM;
9255 }
9256
9257 portname = port1.portname;
9258 hostaddress = port1.hostaddress;
9259 queue = port1.queue;
9260 protocol = port1.protocol;
9261 port_number = port1.port_number;
9262
9263 break;
9264 case 2:
9265 ZERO_STRUCT(port2);
9266
9267 if (!pull_port_data_2(mem_ctx, &port2, in)) {
9268 return WERR_NOMEM;
9269 }
9270
9271 portname = port2.portname;
9272 hostaddress = port2.hostaddress;
9273 queue = port2.queue;
9274 protocol = port2.protocol;
9275 port_number = port2.port_number;
9276
9277 break;
9278 default:
9279 DEBUG(1,("xcvtcp_addport: "
9280 "unknown version of port_data: %d\n", version));
9281 return WERR_UNKNOWN_PORT;
9282 }
9283
9284 /* create the device URI and call the add_port_hook() */
9285
9286 switch (protocol) {
9287 case PROTOCOL_RAWTCP_TYPE:
9288 device_uri = talloc_asprintf(mem_ctx,
9289 "socket://%s:%d/", hostaddress,
9290 port_number);
9291 break;
9292
9293 case PROTOCOL_LPR_TYPE:
9294 device_uri = talloc_asprintf(mem_ctx,
9295 "lpr://%s/%s", hostaddress, queue );
9296 break;
9297
9298 default:
9299 return WERR_UNKNOWN_PORT;
9300 }
9301
9302 if (!device_uri) {
9303 return WERR_NOMEM;
9304 }
9305
9306 return add_port_hook(mem_ctx, token, portname, device_uri);
9307 }
9308
9309 /*******************************************************************
9310 *******************************************************************/
9311
9312 struct xcv_api_table xcvtcp_cmds[] = {
9313 { "MonitorUI", xcvtcp_monitorui },
9314 { "AddPort", xcvtcp_addport},
9315 { NULL, NULL }
9316 };
9317
9318 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9319 NT_USER_TOKEN *token, const char *command,
9320 DATA_BLOB *inbuf,
9321 DATA_BLOB *outbuf,
9322 uint32_t *needed )
9323 {
9324 int i;
9325
9326 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9327
9328 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9329 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9330 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9331 }
9332
9333 return WERR_BADFUNC;
9334 }
9335
9336 /*******************************************************************
9337 *******************************************************************/
9338 #if 0 /* don't support management using the "Local Port" monitor */
9339
9340 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9341 NT_USER_TOKEN *token, DATA_BLOB *in,
9342 DATA_BLOB *out, uint32_t *needed)
9343 {
9344 const char *dllname = "localui.dll";
9345
9346 *needed = (strlen(dllname)+1) * 2;
9347
9348 if (out->length < *needed) {
9349 return WERR_INSUFFICIENT_BUFFER;
9350 }
9351
9352 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9353 return WERR_NOMEM;
9354 }
9355
9356 return WERR_OK;
9357 }
9358
9359 /*******************************************************************
9360 *******************************************************************/
9361
9362 struct xcv_api_table xcvlocal_cmds[] = {
9363 { "MonitorUI", xcvlocal_monitorui },
9364 { NULL, NULL }
9365 };
9366 #else
9367 struct xcv_api_table xcvlocal_cmds[] = {
9368 { NULL, NULL }
9369 };
9370 #endif
9371
9372
9373
9374 /*******************************************************************
9375 *******************************************************************/
9376
9377 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9378 NT_USER_TOKEN *token, const char *command,
9379 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9380 uint32_t *needed)
9381 {
9382 int i;
9383
9384 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9385
9386 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9387 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9388 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9389 }
9390 return WERR_BADFUNC;
9391 }
9392
9393 /****************************************************************
9394 _spoolss_XcvData
9395 ****************************************************************/
9396
9397 WERROR _spoolss_XcvData(pipes_struct *p,
9398 struct spoolss_XcvData *r)
9399 {
9400 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9401 DATA_BLOB out_data = data_blob_null;
9402 WERROR werror;
9403
9404 if (!Printer) {
9405 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9406 OUR_HANDLE(r->in.handle)));
9407 return WERR_BADFID;
9408 }
9409
9410 /* Has to be a handle to the TCP/IP port monitor */
9411
9412 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9413 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9414 return WERR_BADFID;
9415 }
9416
9417 /* requires administrative access to the server */
9418
9419 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9420 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9421 return WERR_ACCESS_DENIED;
9422 }
9423
9424 /* Allocate the outgoing buffer */
9425
9426 if (r->in.out_data_size) {
9427 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9428 if (out_data.data == NULL) {
9429 return WERR_NOMEM;
9430 }
9431 }
9432
9433 switch ( Printer->printer_type ) {
9434 case SPLHND_PORTMON_TCP:
9435 werror = process_xcvtcp_command(p->mem_ctx,
9436 p->server_info->ptok,
9437 r->in.function_name,
9438 &r->in.in_data, &out_data,
9439 r->out.needed);
9440 break;
9441 case SPLHND_PORTMON_LOCAL:
9442 werror = process_xcvlocal_command(p->mem_ctx,
9443 p->server_info->ptok,
9444 r->in.function_name,
9445 &r->in.in_data, &out_data,
9446 r->out.needed);
9447 break;
9448 default:
9449 werror = WERR_INVALID_PRINT_MONITOR;
9450 }
9451
9452 if (!W_ERROR_IS_OK(werror)) {
9453 return werror;
9454 }
9455
9456 *r->out.status_code = 0;
9457
9458 if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
9459 memcpy(r->out.out_data, out_data.data,
9460 MIN(r->in.out_data_size, out_data.length));
9461 }
9462
9463 return WERR_OK;
9464 }
9465
9466 /****************************************************************
9467 _spoolss_AddPrintProcessor
9468 ****************************************************************/
9469
9470 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
9471 struct spoolss_AddPrintProcessor *r)
9472 {
9473 /* for now, just indicate success and ignore the add. We'll
9474 automatically set the winprint processor for printer
9475 entries later. Used to debug the LexMark Optra S 1855 PCL
9476 driver --jerry */
9477
9478 return WERR_OK;
9479 }
9480
9481 /****************************************************************
9482 _spoolss_AddPort
9483 ****************************************************************/
9484
9485 WERROR _spoolss_AddPort(pipes_struct *p,
9486 struct spoolss_AddPort *r)
9487 {
9488 /* do what w2k3 does */
9489
9490 return WERR_NOT_SUPPORTED;
9491 }
9492
9493 /****************************************************************
9494 _spoolss_GetPrinterDriver
9495 ****************************************************************/
9496
9497 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
9498 struct spoolss_GetPrinterDriver *r)
9499 {
9500 p->rng_fault_state = true;
9501 return WERR_NOT_SUPPORTED;
9502 }
9503
9504 /****************************************************************
9505 _spoolss_ReadPrinter
9506 ****************************************************************/
9507
9508 WERROR _spoolss_ReadPrinter(pipes_struct *p,
9509 struct spoolss_ReadPrinter *r)
9510 {
9511 p->rng_fault_state = true;
9512 return WERR_NOT_SUPPORTED;
9513 }
9514
9515 /****************************************************************
9516 _spoolss_WaitForPrinterChange
9517 ****************************************************************/
9518
9519 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
9520 struct spoolss_WaitForPrinterChange *r)
9521 {
9522 p->rng_fault_state = true;
9523 return WERR_NOT_SUPPORTED;
9524 }
9525
9526 /****************************************************************
9527 _spoolss_ConfigurePort
9528 ****************************************************************/
9529
9530 WERROR _spoolss_ConfigurePort(pipes_struct *p,
9531 struct spoolss_ConfigurePort *r)
9532 {
9533 p->rng_fault_state = true;
9534 return WERR_NOT_SUPPORTED;
9535 }
9536
9537 /****************************************************************
9538 _spoolss_DeletePort
9539 ****************************************************************/
9540
9541 WERROR _spoolss_DeletePort(pipes_struct *p,
9542 struct spoolss_DeletePort *r)
9543 {
9544 p->rng_fault_state = true;
9545 return WERR_NOT_SUPPORTED;
9546 }
9547
9548 /****************************************************************
9549 _spoolss_CreatePrinterIC
9550 ****************************************************************/
9551
9552 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
9553 struct spoolss_CreatePrinterIC *r)
9554 {
9555 p->rng_fault_state = true;
9556 return WERR_NOT_SUPPORTED;
9557 }
9558
9559 /****************************************************************
9560 _spoolss_PlayGDIScriptOnPrinterIC
9561 ****************************************************************/
9562
9563 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
9564 struct spoolss_PlayGDIScriptOnPrinterIC *r)
9565 {
9566 p->rng_fault_state = true;
9567 return WERR_NOT_SUPPORTED;
9568 }
9569
9570 /****************************************************************
9571 _spoolss_DeletePrinterIC
9572 ****************************************************************/
9573
9574 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
9575 struct spoolss_DeletePrinterIC *r)
9576 {
9577 p->rng_fault_state = true;
9578 return WERR_NOT_SUPPORTED;
9579 }
9580
9581 /****************************************************************
9582 _spoolss_AddPrinterConnection
9583 ****************************************************************/
9584
9585 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
9586 struct spoolss_AddPrinterConnection *r)
9587 {
9588 p->rng_fault_state = true;
9589 return WERR_NOT_SUPPORTED;
9590 }
9591
9592 /****************************************************************
9593 _spoolss_DeletePrinterConnection
9594 ****************************************************************/
9595
9596 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
9597 struct spoolss_DeletePrinterConnection *r)
9598 {
9599 p->rng_fault_state = true;
9600 return WERR_NOT_SUPPORTED;
9601 }
9602
9603 /****************************************************************
9604 _spoolss_PrinterMessageBox
9605 ****************************************************************/
9606
9607 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
9608 struct spoolss_PrinterMessageBox *r)
9609 {
9610 p->rng_fault_state = true;
9611 return WERR_NOT_SUPPORTED;
9612 }
9613
9614 /****************************************************************
9615 _spoolss_AddMonitor
9616 ****************************************************************/
9617
9618 WERROR _spoolss_AddMonitor(pipes_struct *p,
9619 struct spoolss_AddMonitor *r)
9620 {
9621 p->rng_fault_state = true;
9622 return WERR_NOT_SUPPORTED;
9623 }
9624
9625 /****************************************************************
9626 _spoolss_DeleteMonitor
9627 ****************************************************************/
9628
9629 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
9630 struct spoolss_DeleteMonitor *r)
9631 {
9632 p->rng_fault_state = true;
9633 return WERR_NOT_SUPPORTED;
9634 }
9635
9636 /****************************************************************
9637 _spoolss_DeletePrintProcessor
9638 ****************************************************************/
9639
9640 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
9641 struct spoolss_DeletePrintProcessor *r)
9642 {
9643 p->rng_fault_state = true;
9644 return WERR_NOT_SUPPORTED;
9645 }
9646
9647 /****************************************************************
9648 _spoolss_AddPrintProvidor
9649 ****************************************************************/
9650
9651 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
9652 struct spoolss_AddPrintProvidor *r)
9653 {
9654 p->rng_fault_state = true;
9655 return WERR_NOT_SUPPORTED;
9656 }
9657
9658 /****************************************************************
9659 _spoolss_DeletePrintProvidor
9660 ****************************************************************/
9661
9662 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
9663 struct spoolss_DeletePrintProvidor *r)
9664 {
9665 p->rng_fault_state = true;
9666 return WERR_NOT_SUPPORTED;
9667 }
9668
9669 /****************************************************************
9670 _spoolss_FindFirstPrinterChangeNotification
9671 ****************************************************************/
9672
9673 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
9674 struct spoolss_FindFirstPrinterChangeNotification *r)
9675 {
9676 p->rng_fault_state = true;
9677 return WERR_NOT_SUPPORTED;
9678 }
9679
9680 /****************************************************************
9681 _spoolss_FindNextPrinterChangeNotification
9682 ****************************************************************/
9683
9684 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
9685 struct spoolss_FindNextPrinterChangeNotification *r)
9686 {
9687 p->rng_fault_state = true;
9688 return WERR_NOT_SUPPORTED;
9689 }
9690
9691 /****************************************************************
9692 _spoolss_RouterFindFirstPrinterChangeNotificationOld
9693 ****************************************************************/
9694
9695 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
9696 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
9697 {
9698 p->rng_fault_state = true;
9699 return WERR_NOT_SUPPORTED;
9700 }
9701
9702 /****************************************************************
9703 _spoolss_ReplyOpenPrinter
9704 ****************************************************************/
9705
9706 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
9707 struct spoolss_ReplyOpenPrinter *r)
9708 {
9709 p->rng_fault_state = true;
9710 return WERR_NOT_SUPPORTED;
9711 }
9712
9713 /****************************************************************
9714 _spoolss_RouterReplyPrinter
9715 ****************************************************************/
9716
9717 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
9718 struct spoolss_RouterReplyPrinter *r)
9719 {
9720 p->rng_fault_state = true;
9721 return WERR_NOT_SUPPORTED;
9722 }
9723
9724 /****************************************************************
9725 _spoolss_ReplyClosePrinter
9726 ****************************************************************/
9727
9728 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
9729 struct spoolss_ReplyClosePrinter *r)
9730 {
9731 p->rng_fault_state = true;
9732 return WERR_NOT_SUPPORTED;
9733 }
9734
9735 /****************************************************************
9736 _spoolss_AddPortEx
9737 ****************************************************************/
9738
9739 WERROR _spoolss_AddPortEx(pipes_struct *p,
9740 struct spoolss_AddPortEx *r)
9741 {
9742 p->rng_fault_state = true;
9743 return WERR_NOT_SUPPORTED;
9744 }
9745
9746 /****************************************************************
9747 _spoolss_RouterFindFirstPrinterChangeNotification
9748 ****************************************************************/
9749
9750 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
9751 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
9752 {
9753 p->rng_fault_state = true;
9754 return WERR_NOT_SUPPORTED;
9755 }
9756
9757 /****************************************************************
9758 _spoolss_SpoolerInit
9759 ****************************************************************/
9760
9761 WERROR _spoolss_SpoolerInit(pipes_struct *p,
9762 struct spoolss_SpoolerInit *r)
9763 {
9764 p->rng_fault_state = true;
9765 return WERR_NOT_SUPPORTED;
9766 }
9767
9768 /****************************************************************
9769 _spoolss_ResetPrinterEx
9770 ****************************************************************/
9771
9772 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
9773 struct spoolss_ResetPrinterEx *r)
9774 {
9775 p->rng_fault_state = true;
9776 return WERR_NOT_SUPPORTED;
9777 }
9778
9779 /****************************************************************
9780 _spoolss_RouterReplyPrinterEx
9781 ****************************************************************/
9782
9783 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
9784 struct spoolss_RouterReplyPrinterEx *r)
9785 {
9786 p->rng_fault_state = true;
9787 return WERR_NOT_SUPPORTED;
9788 }
9789
9790 /****************************************************************
9791 _spoolss_44
9792 ****************************************************************/
9793
9794 WERROR _spoolss_44(pipes_struct *p,
9795 struct spoolss_44 *r)
9796 {
9797 p->rng_fault_state = true;
9798 return WERR_NOT_SUPPORTED;
9799 }
9800
9801 /****************************************************************
9802 _spoolss_47
9803 ****************************************************************/
9804
9805 WERROR _spoolss_47(pipes_struct *p,
9806 struct spoolss_47 *r)
9807 {
9808 p->rng_fault_state = true;
9809 return WERR_NOT_SUPPORTED;
9810 }
9811
9812 /****************************************************************
9813 _spoolss_4a
9814 ****************************************************************/
9815
9816 WERROR _spoolss_4a(pipes_struct *p,
9817 struct spoolss_4a *r)
9818 {
9819 p->rng_fault_state = true;
9820 return WERR_NOT_SUPPORTED;
9821 }
9822
9823 /****************************************************************
9824 _spoolss_4b
9825 ****************************************************************/
9826
9827 WERROR _spoolss_4b(pipes_struct *p,
9828 struct spoolss_4b *r)
9829 {
9830 p->rng_fault_state = true;
9831 return WERR_NOT_SUPPORTED;
9832 }
9833
9834 /****************************************************************
9835 _spoolss_4c
9836 ****************************************************************/
9837
9838 WERROR _spoolss_4c(pipes_struct *p,
9839 struct spoolss_4c *r)
9840 {
9841 p->rng_fault_state = true;
9842 return WERR_NOT_SUPPORTED;
9843 }
9844
9845 /****************************************************************
9846 _spoolss_53
9847 ****************************************************************/
9848
9849 WERROR _spoolss_53(pipes_struct *p,
9850 struct spoolss_53 *r)
9851 {
9852 p->rng_fault_state = true;
9853 return WERR_NOT_SUPPORTED;
9854 }
9855
9856 /****************************************************************
9857 _spoolss_55
9858 ****************************************************************/
9859
9860 WERROR _spoolss_55(pipes_struct *p,
9861 struct spoolss_55 *r)
9862 {
9863 p->rng_fault_state = true;
9864 return WERR_NOT_SUPPORTED;
9865 }
9866
9867 /****************************************************************
9868 _spoolss_56
9869 ****************************************************************/
9870
9871 WERROR _spoolss_56(pipes_struct *p,
9872 struct spoolss_56 *r)
9873 {
9874 p->rng_fault_state = true;
9875 return WERR_NOT_SUPPORTED;
9876 }
9877
9878 /****************************************************************
9879 _spoolss_57
9880 ****************************************************************/
9881
9882 WERROR _spoolss_57(pipes_struct *p,
9883 struct spoolss_57 *r)
9884 {
9885 p->rng_fault_state = true;
9886 return WERR_NOT_SUPPORTED;
9887 }
9888
9889 /****************************************************************
9890 _spoolss_5a
9891 ****************************************************************/
9892
9893 WERROR _spoolss_5a(pipes_struct *p,
9894 struct spoolss_5a *r)
9895 {
9896 p->rng_fault_state = true;
9897 return WERR_NOT_SUPPORTED;
9898 }
9899
9900 /****************************************************************
9901 _spoolss_5b
9902 ****************************************************************/
9903
9904 WERROR _spoolss_5b(pipes_struct *p,
9905 struct spoolss_5b *r)
9906 {
9907 p->rng_fault_state = true;
9908 return WERR_NOT_SUPPORTED;
9909 }
9910
9911 /****************************************************************
9912 _spoolss_5c
9913 ****************************************************************/
9914
9915 WERROR _spoolss_5c(pipes_struct *p,
9916 struct spoolss_5c *r)
9917 {
9918 p->rng_fault_state = true;
9919 return WERR_NOT_SUPPORTED;
9920 }
9921
9922 /****************************************************************
9923 _spoolss_5d
9924 ****************************************************************/
9925
9926 WERROR _spoolss_5d(pipes_struct *p,
9927 struct spoolss_5d *r)
9928 {
9929 p->rng_fault_state = true;
9930 return WERR_NOT_SUPPORTED;
9931 }
9932
9933 /****************************************************************
9934 _spoolss_5e
9935 ****************************************************************/
9936
9937 WERROR _spoolss_5e(pipes_struct *p,
9938 struct spoolss_5e *r)
9939 {
9940 p->rng_fault_state = true;
9941 return WERR_NOT_SUPPORTED;
9942 }
9943
9944 /****************************************************************
9945 _spoolss_5f
9946 ****************************************************************/
9947
9948 WERROR _spoolss_5f(pipes_struct *p,
9949 struct spoolss_5f *r)
9950 {
9951 p->rng_fault_state = true;
9952 return WERR_NOT_SUPPORTED;
9953 }
9954
9955 /****************************************************************
9956 _spoolss_60
9957 ****************************************************************/
9958
9959 WERROR _spoolss_60(pipes_struct *p,
9960 struct spoolss_60 *r)
9961 {
9962 p->rng_fault_state = true;
9963 return WERR_NOT_SUPPORTED;
9964 }
9965
9966 /****************************************************************
9967 _spoolss_61
9968 ****************************************************************/
9969
9970 WERROR _spoolss_61(pipes_struct *p,
9971 struct spoolss_61 *r)
9972 {
9973 p->rng_fault_state = true;
9974 return WERR_NOT_SUPPORTED;
9975 }
9976
9977 /****************************************************************
9978 _spoolss_62
9979 ****************************************************************/
9980
9981 WERROR _spoolss_62(pipes_struct *p,
9982 struct spoolss_62 *r)
9983 {
9984 p->rng_fault_state = true;
9985 return WERR_NOT_SUPPORTED;
9986 }
9987
9988 /****************************************************************
9989 _spoolss_63
9990 ****************************************************************/
9991
9992 WERROR _spoolss_63(pipes_struct *p,
9993 struct spoolss_63 *r)
9994 {
9995 p->rng_fault_state = true;
9996 return WERR_NOT_SUPPORTED;
9997 }
9998
9999 /****************************************************************
10000 _spoolss_64
10001 ****************************************************************/
10002
10003 WERROR _spoolss_64(pipes_struct *p,
10004 struct spoolss_64 *r)
10005 {
10006 p->rng_fault_state = true;
10007 return WERR_NOT_SUPPORTED;
10008 }
10009
10010 /****************************************************************
10011 _spoolss_65
10012 ****************************************************************/
10013
10014 WERROR _spoolss_65(pipes_struct *p,
10015 struct spoolss_65 *r)
10016 {
10017 p->rng_fault_state = true;
10018 return WERR_NOT_SUPPORTED;
10019 }
10020
10021 /****************************************************************
10022 _spoolss_GetCorePrinterDrivers
10023 ****************************************************************/
10024
10025 WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p,
10026 struct spoolss_GetCorePrinterDrivers *r)
10027 {
10028 p->rng_fault_state = true;
10029 return WERR_NOT_SUPPORTED;
10030 }
10031
10032 /****************************************************************
10033 _spoolss_67
10034 ****************************************************************/
10035
10036 WERROR _spoolss_67(pipes_struct *p,
10037 struct spoolss_67 *r)
10038 {
10039 p->rng_fault_state = true;
10040 return WERR_NOT_SUPPORTED;
10041 }
10042
10043 /****************************************************************
10044 _spoolss_GetPrinterDriverPackagePath
10045 ****************************************************************/
10046
10047 WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p,
10048 struct spoolss_GetPrinterDriverPackagePath *r)
10049 {
10050 p->rng_fault_state = true;
10051 return WERR_NOT_SUPPORTED;
10052 }
10053
10054 /****************************************************************
10055 _spoolss_69
10056 ****************************************************************/
10057
10058 WERROR _spoolss_69(pipes_struct *p,
10059 struct spoolss_69 *r)
10060 {
10061 p->rng_fault_state = true;
10062 return WERR_NOT_SUPPORTED;
10063 }
10064
10065 /****************************************************************
10066 _spoolss_6a
10067 ****************************************************************/
10068
10069 WERROR _spoolss_6a(pipes_struct *p,
10070 struct spoolss_6a *r)
10071 {
10072 p->rng_fault_state = true;
10073 return WERR_NOT_SUPPORTED;
10074 }
10075
10076 /****************************************************************
10077 _spoolss_6b
10078 ****************************************************************/
10079
10080 WERROR _spoolss_6b(pipes_struct *p,
10081 struct spoolss_6b *r)
10082 {
10083 p->rng_fault_state = true;
10084 return WERR_NOT_SUPPORTED;
10085 }
10086
10087 /****************************************************************
10088 _spoolss_6c
10089 ****************************************************************/
10090
10091 WERROR _spoolss_6c(pipes_struct *p,
10092 struct spoolss_6c *r)
10093 {
10094 p->rng_fault_state = true;
10095 return WERR_NOT_SUPPORTED;
10096 }
10097
10098 /****************************************************************
10099 _spoolss_6d
10100 ****************************************************************/
10101
10102 WERROR _spoolss_6d(pipes_struct *p,
10103 struct spoolss_6d *r)
10104 {
10105 p->rng_fault_state = true;
10106 return WERR_NOT_SUPPORTED;
10107 }
WIP