?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-registry: only include registry headers when really needed.
[Samba.git] / source3 / rpc_server / srv_spoolss_nt.c
blob823b051e92e7f61a8812cc14922635f20eae57d9
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-2010.
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 #include "librpc/gen_ndr/messaging.h"
33 #include "registry.h"
34
35 /* macros stolen from s4 spoolss server */
36 #define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
37 ((info)?ndr_size_##fn(info, level, ic, 0):0)
38
39 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,ic,info,level,count) \
40 ((info)?ndr_size_##fn##_info(mem_ctx, ic, level, count, info):0)
41
42 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,ic,info,count) \
43 ((info)?ndr_size_##fn##_info(mem_ctx, ic, count, info):0)
44
45 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
46
47
48 extern userdom_struct current_user_info;
49
50 #undef DBGC_CLASS
51 #define DBGC_CLASS DBGC_RPC_SRV
52
53 #ifndef MAX_OPEN_PRINTER_EXS
54 #define MAX_OPEN_PRINTER_EXS 50
55 #endif
56
57 #define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
58 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
59
60 static Printer_entry *printers_list;
61
62 typedef struct _counter_printer_0 {
63 struct _counter_printer_0 *next;
64 struct _counter_printer_0 *prev;
65
66 int snum;
67 uint32_t counter;
68 } counter_printer_0;
69
70 static counter_printer_0 *counter_list;
71
72 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
73 static uint32_t smb_connections = 0;
74
75
76 /* in printing/nt_printing.c */
77
78 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
79
80 /* API table for Xcv Monitor functions */
81
82 struct xcv_api_table {
83 const char *name;
84 WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
85 };
86
87 /********************************************************************
88 * Canonicalize servername.
89 ********************************************************************/
90
91 static const char *canon_servername(const char *servername)
92 {
93 const char *pservername = servername;
94 while (*pservername == '\\') {
95 pservername++;
96 }
97 return pservername;
98 }
99
100 /* translate between internal status numbers and NT status numbers */
101 static int nt_printj_status(int v)
102 {
103 switch (v) {
104 case LPQ_QUEUED:
105 return 0;
106 case LPQ_PAUSED:
107 return JOB_STATUS_PAUSED;
108 case LPQ_SPOOLING:
109 return JOB_STATUS_SPOOLING;
110 case LPQ_PRINTING:
111 return JOB_STATUS_PRINTING;
112 case LPQ_ERROR:
113 return JOB_STATUS_ERROR;
114 case LPQ_DELETING:
115 return JOB_STATUS_DELETING;
116 case LPQ_OFFLINE:
117 return JOB_STATUS_OFFLINE;
118 case LPQ_PAPEROUT:
119 return JOB_STATUS_PAPEROUT;
120 case LPQ_PRINTED:
121 return JOB_STATUS_PRINTED;
122 case LPQ_DELETED:
123 return JOB_STATUS_DELETED;
124 case LPQ_BLOCKED:
125 return JOB_STATUS_BLOCKED_DEVQ;
126 case LPQ_USER_INTERVENTION:
127 return JOB_STATUS_USER_INTERVENTION;
128 }
129 return 0;
130 }
131
132 static int nt_printq_status(int v)
133 {
134 switch (v) {
135 case LPQ_PAUSED:
136 return PRINTER_STATUS_PAUSED;
137 case LPQ_QUEUED:
138 case LPQ_SPOOLING:
139 case LPQ_PRINTING:
140 return 0;
141 }
142 return 0;
143 }
144
145 /***************************************************************************
146 Disconnect from the client
147 ****************************************************************************/
148
149 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
150 {
151 WERROR result;
152 NTSTATUS status;
153
154 /*
155 * Tell the specific printing tdb we no longer want messages for this printer
156 * by deregistering our PID.
157 */
158
159 if (!print_notify_deregister_pid(snum))
160 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
161
162 /* weird if the test succeds !!! */
163 if (smb_connections==0) {
164 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
165 return;
166 }
167
168 status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
169 handle,
170 &result);
171 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
172 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
173 win_errstr(result)));
174
175 /* if it's the last connection, deconnect the IPC$ share */
176 if (smb_connections==1) {
177
178 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
179 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
180
181 messaging_deregister(smbd_messaging_context(),
182 MSG_PRINTER_NOTIFY2, NULL);
183
184 /* Tell the connections db we're no longer interested in
185 * printer notify messages. */
186
187 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
188 }
189
190 smb_connections--;
191 }
192
193 /****************************************************************************
194 Functions to free a printer entry datastruct.
195 ****************************************************************************/
196
197 static int printer_entry_destructor(Printer_entry *Printer)
198 {
199 if (Printer->notify.client_connected == true) {
200 int snum = -1;
201
202 if ( Printer->printer_type == SPLHND_SERVER) {
203 snum = -1;
204 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
205 } else if (Printer->printer_type == SPLHND_PRINTER) {
206 snum = print_queue_snum(Printer->sharename);
207 if (snum != -1)
208 srv_spoolss_replycloseprinter(snum,
209 &Printer->notify.client_hnd);
210 }
211 }
212
213 Printer->notify.flags=0;
214 Printer->notify.options=0;
215 Printer->notify.localmachine[0]='\0';
216 Printer->notify.printerlocal=0;
217 TALLOC_FREE(Printer->notify.option);
218 Printer->notify.client_connected = false;
219
220 free_nt_devicemode( &Printer->nt_devmode );
221 free_a_printer( &Printer->printer_info, 2 );
222
223 /* Remove from the internal list. */
224 DLIST_REMOVE(printers_list, Printer);
225 return 0;
226 }
227
228 /****************************************************************************
229 find printer index by handle
230 ****************************************************************************/
231
232 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
233 struct policy_handle *hnd)
234 {
235 Printer_entry *find_printer = NULL;
236
237 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
238 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
239 return NULL;
240 }
241
242 return find_printer;
243 }
244
245 /****************************************************************************
246 Close printer index by handle.
247 ****************************************************************************/
248
249 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
250 {
251 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
252
253 if (!Printer) {
254 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
255 OUR_HANDLE(hnd)));
256 return false;
257 }
258
259 close_policy_hnd(p, hnd);
260
261 return true;
262 }
263
264 /****************************************************************************
265 Delete a printer given a handle.
266 ****************************************************************************/
267
268 static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename)
269 {
270 char *cmd = lp_deleteprinter_cmd();
271 char *command = NULL;
272 int ret;
273 SE_PRIV se_printop = SE_PRINT_OPERATOR;
274 bool is_print_op = false;
275
276 /* can't fail if we don't try */
277
278 if ( !*cmd )
279 return WERR_OK;
280
281 command = talloc_asprintf(ctx,
282 "%s \"%s\"",
283 cmd, sharename);
284 if (!command) {
285 return WERR_NOMEM;
286 }
287 if ( token )
288 is_print_op = user_has_privileges( token, &se_printop );
289
290 DEBUG(10,("Running [%s]\n", command));
291
292 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
293
294 if ( is_print_op )
295 become_root();
296
297 if ( (ret = smbrun(command, NULL)) == 0 ) {
298 /* Tell everyone we updated smb.conf. */
299 message_send_all(smbd_messaging_context(),
300 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
301 }
302
303 if ( is_print_op )
304 unbecome_root();
305
306 /********** END SePrintOperatorPrivlege BLOCK **********/
307
308 DEBUGADD(10,("returned [%d]\n", ret));
309
310 TALLOC_FREE(command);
311
312 if (ret != 0)
313 return WERR_BADFID; /* What to return here? */
314
315 /* go ahead and re-read the services immediately */
316 become_root();
317 reload_services(false);
318 unbecome_root();
319
320 if ( lp_servicenumber( sharename ) > 0 )
321 return WERR_ACCESS_DENIED;
322
323 return WERR_OK;
324 }
325
326 /****************************************************************************
327 Delete a printer given a handle.
328 ****************************************************************************/
329
330 static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
331 {
332 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
333
334 if (!Printer) {
335 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
336 OUR_HANDLE(hnd)));
337 return WERR_BADFID;
338 }
339
340 /*
341 * It turns out that Windows allows delete printer on a handle
342 * opened by an admin user, then used on a pipe handle created
343 * by an anonymous user..... but they're working on security.... riiight !
344 * JRA.
345 */
346
347 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
348 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
349 return WERR_ACCESS_DENIED;
350 }
351
352 /* this does not need a become root since the access check has been
353 done on the handle already */
354
355 if (del_a_printer( Printer->sharename ) != 0) {
356 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
357 return WERR_BADFID;
358 }
359
360 return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
361 Printer->sharename );
362 }
363
364 /****************************************************************************
365 Return the snum of a printer corresponding to an handle.
366 ****************************************************************************/
367
368 static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
369 int *number, struct share_params **params)
370 {
371 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
372
373 if (!Printer) {
374 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
375 OUR_HANDLE(hnd)));
376 return false;
377 }
378
379 switch (Printer->printer_type) {
380 case SPLHND_PRINTER:
381 DEBUG(4,("short name:%s\n", Printer->sharename));
382 *number = print_queue_snum(Printer->sharename);
383 return (*number != -1);
384 case SPLHND_SERVER:
385 return false;
386 default:
387 return false;
388 }
389 }
390
391 /****************************************************************************
392 Set printer handle type.
393 Check if it's \\server or \\server\printer
394 ****************************************************************************/
395
396 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
397 {
398 DEBUG(3,("Setting printer type=%s\n", handlename));
399
400 if ( strlen(handlename) < 3 ) {
401 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
402 return false;
403 }
404
405 /* it's a print server */
406 if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
407 DEBUGADD(4,("Printer is a print server\n"));
408 Printer->printer_type = SPLHND_SERVER;
409 }
410 /* it's a printer (set_printer_hnd_name() will handle port monitors */
411 else {
412 DEBUGADD(4,("Printer is a printer\n"));
413 Printer->printer_type = SPLHND_PRINTER;
414 }
415
416 return true;
417 }
418
419 /****************************************************************************
420 Set printer handle name.. Accept names like \\server, \\server\printer,
421 \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port" See
422 the MSDN docs regarding OpenPrinter() for details on the XcvData() and
423 XcvDataPort() interface.
424 ****************************************************************************/
425
426 static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
427 {
428 int snum;
429 int n_services=lp_numservices();
430 char *aprinter, *printername;
431 const char *servername;
432 fstring sname;
433 bool found = false;
434 NT_PRINTER_INFO_LEVEL *printer = NULL;
435 WERROR result;
436
437 DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
438 (unsigned long)strlen(handlename)));
439
440 aprinter = CONST_DISCARD(char *, handlename);
441 if ( *handlename == '\\' ) {
442 servername = canon_servername(handlename);
443 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
444 *aprinter = '\0';
445 aprinter++;
446 }
447 } else {
448 servername = global_myname();
449 }
450
451 /* save the servername to fill in replies on this handle */
452
453 if ( !is_myname_or_ipaddr( servername ) )
454 return false;
455
456 fstrcpy( Printer->servername, servername );
457
458 if ( Printer->printer_type == SPLHND_SERVER )
459 return true;
460
461 if ( Printer->printer_type != SPLHND_PRINTER )
462 return false;
463
464 DEBUGADD(5, ("searching for [%s]\n", aprinter ));
465
466 /* check for the Port Monitor Interface */
467
468 if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
469 Printer->printer_type = SPLHND_PORTMON_TCP;
470 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
471 found = true;
472 }
473 else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
474 Printer->printer_type = SPLHND_PORTMON_LOCAL;
475 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
476 found = true;
477 }
478
479 /* Search all sharenames first as this is easier than pulling
480 the printer_info_2 off of disk. Don't use find_service() since
481 that calls out to map_username() */
482
483 /* do another loop to look for printernames */
484
485 for (snum=0; !found && snum<n_services; snum++) {
486
487 /* no point going on if this is not a printer */
488
489 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
490 continue;
491
492 fstrcpy(sname, lp_servicename(snum));
493 if ( strequal( aprinter, sname ) ) {
494 found = true;
495 break;
496 }
497
498 /* no point looking up the printer object if
499 we aren't allowing printername != sharename */
500
501 if ( lp_force_printername(snum) )
502 continue;
503
504 fstrcpy(sname, lp_servicename(snum));
505
506 printer = NULL;
507
508 /* This call doesn't fill in the location or comment from
509 * a CUPS server for efficiency with large numbers of printers.
510 * JRA.
511 */
512
513 result = get_a_printer_search( NULL, &printer, 2, sname );
514 if ( !W_ERROR_IS_OK(result) ) {
515 DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
516 sname, win_errstr(result)));
517 continue;
518 }
519
520 /* printername is always returned as \\server\printername */
521 if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
522 DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
523 printer->info_2->printername));
524 free_a_printer( &printer, 2);
525 continue;
526 }
527
528 printername++;
529
530 if ( strequal(printername, aprinter) ) {
531 free_a_printer( &printer, 2);
532 found = true;
533 break;
534 }
535
536 DEBUGADD(10, ("printername: %s\n", printername));
537
538 free_a_printer( &printer, 2);
539 }
540
541 free_a_printer( &printer, 2);
542
543 if ( !found ) {
544 DEBUGADD(4,("Printer not found\n"));
545 return false;
546 }
547
548 DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
549
550 fstrcpy(Printer->sharename, sname);
551
552 return true;
553 }
554
555 /****************************************************************************
556 Find first available printer slot. creates a printer handle for you.
557 ****************************************************************************/
558
559 static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
560 const char *name, uint32_t access_granted)
561 {
562 Printer_entry *new_printer;
563
564 DEBUG(10,("open_printer_hnd: name [%s]\n", name));
565
566 new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
567 if (new_printer == NULL) {
568 return false;
569 }
570 talloc_set_destructor(new_printer, printer_entry_destructor);
571
572 if (!create_policy_hnd(p, hnd, new_printer)) {
573 TALLOC_FREE(new_printer);
574 return false;
575 }
576
577 /* Add to the internal list. */
578 DLIST_ADD(printers_list, new_printer);
579
580 new_printer->notify.option=NULL;
581
582 if (!set_printer_hnd_printertype(new_printer, name)) {
583 close_printer_handle(p, hnd);
584 return false;
585 }
586
587 if (!set_printer_hnd_name(new_printer, name)) {
588 close_printer_handle(p, hnd);
589 return false;
590 }
591
592 new_printer->access_granted = access_granted;
593
594 DEBUG(5, ("%d printer handles active\n",
595 (int)num_pipe_handles(p->pipe_handles)));
596
597 return true;
598 }
599
600 /***************************************************************************
601 check to see if the client motify handle is monitoring the notification
602 given by (notify_type, notify_field).
603 **************************************************************************/
604
605 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
606 uint16_t notify_field)
607 {
608 return true;
609 }
610
611 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
612 uint16_t notify_field)
613 {
614 struct spoolss_NotifyOption *option = p->notify.option;
615 uint32_t i, j;
616
617 /*
618 * Flags should always be zero when the change notify
619 * is registered by the client's spooler. A user Win32 app
620 * might use the flags though instead of the NOTIFY_OPTION_INFO
621 * --jerry
622 */
623
624 if (!option) {
625 return false;
626 }
627
628 if (p->notify.flags)
629 return is_monitoring_event_flags(
630 p->notify.flags, notify_type, notify_field);
631
632 for (i = 0; i < option->count; i++) {
633
634 /* Check match for notify_type */
635
636 if (option->types[i].type != notify_type)
637 continue;
638
639 /* Check match for field */
640
641 for (j = 0; j < option->types[i].count; j++) {
642 if (option->types[i].fields[j].field == notify_field) {
643 return true;
644 }
645 }
646 }
647
648 DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
649 p->servername, p->sharename, notify_type, notify_field));
650
651 return false;
652 }
653
654 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
655 _data->data.integer[0] = _integer; \
656 _data->data.integer[1] = 0;
657
658
659 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
660 _data->data.string.string = talloc_strdup(mem_ctx, _p); \
661 if (!_data->data.string.string) {\
662 _data->data.string.size = 0; \
663 } \
664 _data->data.string.size = strlen_m_term(_p) * 2;
665
666 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
667 _data->data.devmode.devmode = _devmode;
668
669 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
670 _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
671 if (!_data->data.sd.sd) { \
672 _data->data.sd.sd_size = 0; \
673 } \
674 _data->data.sd.sd_size = _size;
675
676 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
677 struct tm *t,
678 const char **pp,
679 uint32_t *plen)
680 {
681 struct spoolss_Time st;
682 uint32_t len = 16;
683 char *p;
684
685 if (!init_systemtime(&st, t)) {
686 return;
687 }
688
689 p = talloc_array(mem_ctx, char, len);
690 if (!p) {
691 return;
692 }
693
694 /*
695 * Systemtime must be linearized as a set of UINT16's.
696 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
697 */
698
699 SSVAL(p, 0, st.year);
700 SSVAL(p, 2, st.month);
701 SSVAL(p, 4, st.day_of_week);
702 SSVAL(p, 6, st.day);
703 SSVAL(p, 8, st.hour);
704 SSVAL(p, 10, st.minute);
705 SSVAL(p, 12, st.second);
706 SSVAL(p, 14, st.millisecond);
707
708 *pp = p;
709 *plen = len;
710 }
711
712 /* Convert a notification message to a struct spoolss_Notify */
713
714 static void notify_one_value(struct spoolss_notify_msg *msg,
715 struct spoolss_Notify *data,
716 TALLOC_CTX *mem_ctx)
717 {
718 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
719 }
720
721 static void notify_string(struct spoolss_notify_msg *msg,
722 struct spoolss_Notify *data,
723 TALLOC_CTX *mem_ctx)
724 {
725 /* The length of the message includes the trailing \0 */
726
727 data->data.string.size = msg->len * 2;
728 data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
729 if (!data->data.string.string) {
730 data->data.string.size = 0;
731 return;
732 }
733 }
734
735 static void notify_system_time(struct spoolss_notify_msg *msg,
736 struct spoolss_Notify *data,
737 TALLOC_CTX *mem_ctx)
738 {
739 data->data.string.string = NULL;
740 data->data.string.size = 0;
741
742 if (msg->len != sizeof(time_t)) {
743 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
744 msg->len));
745 return;
746 }
747
748 init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
749 &data->data.string.string,
750 &data->data.string.size);
751 }
752
753 struct notify2_message_table {
754 const char *name;
755 void (*fn)(struct spoolss_notify_msg *msg,
756 struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
757 };
758
759 static struct notify2_message_table printer_notify_table[] = {
760 /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
761 /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
762 /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
763 /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
764 /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
765 /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
766 /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
767 /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
768 /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
769 /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
770 /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
771 /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
772 /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
773 /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
774 /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
775 /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
776 /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
777 /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
778 /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
779 };
780
781 static struct notify2_message_table job_notify_table[] = {
782 /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
783 /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
784 /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
785 /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
786 /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
787 /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
788 /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
789 /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
790 /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
791 /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
792 /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
793 /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
794 /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
795 /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
796 /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
797 /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
798 /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
799 /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
800 /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
801 /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
802 /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
803 /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
804 /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
805 /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
806 };
807
808
809 /***********************************************************************
810 Allocate talloc context for container object
811 **********************************************************************/
812
813 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
814 {
815 if ( !ctr )
816 return;
817
818 ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
819
820 return;
821 }
822
823 /***********************************************************************
824 release all allocated memory and zero out structure
825 **********************************************************************/
826
827 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
828 {
829 if ( !ctr )
830 return;
831
832 if ( ctr->ctx )
833 talloc_destroy(ctr->ctx);
834
835 ZERO_STRUCTP(ctr);
836
837 return;
838 }
839
840 /***********************************************************************
841 **********************************************************************/
842
843 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
844 {
845 if ( !ctr )
846 return NULL;
847
848 return ctr->ctx;
849 }
850
851 /***********************************************************************
852 **********************************************************************/
853
854 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
855 {
856 if ( !ctr || !ctr->msg_groups )
857 return NULL;
858
859 if ( idx >= ctr->num_groups )
860 return NULL;
861
862 return &ctr->msg_groups[idx];
863
864 }
865
866 /***********************************************************************
867 How many groups of change messages do we have ?
868 **********************************************************************/
869
870 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
871 {
872 if ( !ctr )
873 return 0;
874
875 return ctr->num_groups;
876 }
877
878 /***********************************************************************
879 Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
880 **********************************************************************/
881
882 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
883 {
884 SPOOLSS_NOTIFY_MSG_GROUP *groups = NULL;
885 SPOOLSS_NOTIFY_MSG_GROUP *msg_grp = NULL;
886 SPOOLSS_NOTIFY_MSG *msg_list = NULL;
887 int i, new_slot;
888
889 if ( !ctr || !msg )
890 return 0;
891
892 /* loop over all groups looking for a matching printer name */
893
894 for ( i=0; i<ctr->num_groups; i++ ) {
895 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
896 break;
897 }
898
899 /* add a new group? */
900
901 if ( i == ctr->num_groups ) {
902 ctr->num_groups++;
903
904 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
905 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
906 return 0;
907 }
908 ctr->msg_groups = groups;
909
910 /* clear the new entry and set the printer name */
911
912 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
913 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
914 }
915
916 /* add the change messages; 'i' is the correct index now regardless */
917
918 msg_grp = &ctr->msg_groups[i];
919
920 msg_grp->num_msgs++;
921
922 if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
923 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
924 return 0;
925 }
926 msg_grp->msgs = msg_list;
927
928 new_slot = msg_grp->num_msgs-1;
929 memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
930
931 /* need to allocate own copy of data */
932
933 if ( msg->len != 0 )
934 msg_grp->msgs[new_slot].notify.data = (char *)
935 TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
936
937 return ctr->num_groups;
938 }
939
940 void construct_info_data(struct spoolss_Notify *info_data,
941 enum spoolss_NotifyType type,
942 uint16_t field,
943 int id);
944
945 /***********************************************************************
946 Send a change notication message on all handles which have a call
947 back registered
948 **********************************************************************/
949
950 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
951 {
952 Printer_entry *p;
953 TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
954 SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
955 SPOOLSS_NOTIFY_MSG *messages;
956 int sending_msg_count;
957
958 if ( !msg_group ) {
959 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
960 return;
961 }
962
963 messages = msg_group->msgs;
964
965 if ( !messages ) {
966 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
967 return;
968 }
969
970 DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
971
972 /* loop over all printers */
973
974 for (p = printers_list; p; p = p->next) {
975 struct spoolss_Notify *notifies;
976 uint32_t count = 0;
977 uint32_t id;
978 int i;
979
980 /* Is there notification on this handle? */
981
982 if ( !p->notify.client_connected )
983 continue;
984
985 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
986
987 /* For this printer? Print servers always receive
988 notifications. */
989
990 if ( ( p->printer_type == SPLHND_PRINTER ) &&
991 ( !strequal(msg_group->printername, p->sharename) ) )
992 continue;
993
994 DEBUG(10,("Our printer\n"));
995
996 /* allocate the max entries possible */
997
998 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
999 if (!notifies) {
1000 return;
1001 }
1002
1003 /* build the array of change notifications */
1004
1005 sending_msg_count = 0;
1006
1007 for ( i=0; i<msg_group->num_msgs; i++ ) {
1008 SPOOLSS_NOTIFY_MSG *msg = &messages[i];
1009
1010 /* Are we monitoring this event? */
1011
1012 if (!is_monitoring_event(p, msg->type, msg->field))
1013 continue;
1014
1015 sending_msg_count++;
1016
1017
1018 DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1019 msg->type, msg->field, p->sharename));
1020
1021 /*
1022 * if the is a printer notification handle and not a job notification
1023 * type, then set the id to 0. Other wise just use what was specified
1024 * in the message.
1025 *
1026 * When registering change notification on a print server handle
1027 * we always need to send back the id (snum) matching the printer
1028 * for which the change took place. For change notify registered
1029 * on a printer handle, this does not matter and the id should be 0.
1030 *
1031 * --jerry
1032 */
1033
1034 if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1035 id = 0;
1036 else
1037 id = msg->id;
1038
1039
1040 /* Convert unix jobid to smb jobid */
1041
1042 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1043 id = sysjob_to_jobid(msg->id);
1044
1045 if (id == -1) {
1046 DEBUG(3, ("no such unix jobid %d\n", msg->id));
1047 goto done;
1048 }
1049 }
1050
1051 construct_info_data( &notifies[count], msg->type, msg->field, id );
1052
1053 switch(msg->type) {
1054 case PRINTER_NOTIFY_TYPE:
1055 if ( printer_notify_table[msg->field].fn )
1056 printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1057 break;
1058
1059 case JOB_NOTIFY_TYPE:
1060 if ( job_notify_table[msg->field].fn )
1061 job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1062 break;
1063
1064 default:
1065 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1066 goto done;
1067 }
1068
1069 count++;
1070 }
1071
1072 if ( sending_msg_count ) {
1073 NTSTATUS status;
1074 WERROR werr;
1075 union spoolss_ReplyPrinterInfo info;
1076 struct spoolss_NotifyInfo info0;
1077 uint32_t reply_result;
1078
1079 info0.version = 0x2;
1080 info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1081 info0.count = count;
1082 info0.notifies = notifies;
1083
1084 info.info0 = &info0;
1085
1086 status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1087 &p->notify.client_hnd,
1088 p->notify.change, /* color */
1089 p->notify.flags,
1090 &reply_result,
1091 0, /* reply_type, must be 0 */
1092 info,
1093 &werr);
1094 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1095 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1096 notify_cli_pipe->srv_name_slash,
1097 win_errstr(werr)));
1098 }
1099 switch (reply_result) {
1100 case 0:
1101 break;
1102 case PRINTER_NOTIFY_INFO_DISCARDED:
1103 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1104 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1105 break;
1106 default:
1107 break;
1108 }
1109 }
1110 }
1111
1112 done:
1113 DEBUG(8,("send_notify2_changes: Exit...\n"));
1114 return;
1115 }
1116
1117 /***********************************************************************
1118 **********************************************************************/
1119
1120 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1121 {
1122
1123 uint32_t tv_sec, tv_usec;
1124 size_t offset = 0;
1125
1126 /* Unpack message */
1127
1128 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1129 msg->printer);
1130
1131 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1132 &tv_sec, &tv_usec,
1133 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1134
1135 if (msg->len == 0)
1136 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1137 &msg->notify.value[0], &msg->notify.value[1]);
1138 else
1139 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1140 &msg->len, &msg->notify.data);
1141
1142 DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1143 msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1144
1145 tv->tv_sec = tv_sec;
1146 tv->tv_usec = tv_usec;
1147
1148 if (msg->len == 0)
1149 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1150 msg->notify.value[1]));
1151 else
1152 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1153
1154 return true;
1155 }
1156
1157 /********************************************************************
1158 Receive a notify2 message list
1159 ********************************************************************/
1160
1161 static void receive_notify2_message_list(struct messaging_context *msg,
1162 void *private_data,
1163 uint32_t msg_type,
1164 struct server_id server_id,
1165 DATA_BLOB *data)
1166 {
1167 size_t msg_count, i;
1168 char *buf = (char *)data->data;
1169 char *msg_ptr;
1170 size_t msg_len;
1171 SPOOLSS_NOTIFY_MSG notify;
1172 SPOOLSS_NOTIFY_MSG_CTR messages;
1173 int num_groups;
1174
1175 if (data->length < 4) {
1176 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1177 return;
1178 }
1179
1180 msg_count = IVAL(buf, 0);
1181 msg_ptr = buf + 4;
1182
1183 DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1184
1185 if (msg_count == 0) {
1186 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1187 return;
1188 }
1189
1190 /* initialize the container */
1191
1192 ZERO_STRUCT( messages );
1193 notify_msg_ctr_init( &messages );
1194
1195 /*
1196 * build message groups for each printer identified
1197 * in a change_notify msg. Remember that a PCN message
1198 * includes the handle returned for the srv_spoolss_replyopenprinter()
1199 * call. Therefore messages are grouped according to printer handle.
1200 */
1201
1202 for ( i=0; i<msg_count; i++ ) {
1203 struct timeval msg_tv;
1204
1205 if (msg_ptr + 4 - buf > data->length) {
1206 DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1207 return;
1208 }
1209
1210 msg_len = IVAL(msg_ptr,0);
1211 msg_ptr += 4;
1212
1213 if (msg_ptr + msg_len - buf > data->length) {
1214 DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1215 return;
1216 }
1217
1218 /* unpack messages */
1219
1220 ZERO_STRUCT( notify );
1221 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1222 msg_ptr += msg_len;
1223
1224 /* add to correct list in container */
1225
1226 notify_msg_ctr_addmsg( &messages, &notify );
1227
1228 /* free memory that might have been allocated by notify2_unpack_msg() */
1229
1230 if ( notify.len != 0 )
1231 SAFE_FREE( notify.notify.data );
1232 }
1233
1234 /* process each group of messages */
1235
1236 num_groups = notify_msg_ctr_numgroups( &messages );
1237 for ( i=0; i<num_groups; i++ )
1238 send_notify2_changes( &messages, i );
1239
1240
1241 /* cleanup */
1242
1243 DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1244 (uint32_t)msg_count ));
1245
1246 notify_msg_ctr_destroy( &messages );
1247
1248 return;
1249 }
1250
1251 /********************************************************************
1252 Send a message to ourself about new driver being installed
1253 so we can upgrade the information for each printer bound to this
1254 driver
1255 ********************************************************************/
1256
1257 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1258 {
1259 int len = strlen(drivername);
1260
1261 if (!len)
1262 return false;
1263
1264 DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1265 drivername));
1266
1267 messaging_send_buf(smbd_messaging_context(), procid_self(),
1268 MSG_PRINTER_DRVUPGRADE,
1269 (uint8_t *)drivername, len+1);
1270
1271 return true;
1272 }
1273
1274 /**********************************************************************
1275 callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1276 over all printers, upgrading ones as necessary
1277 **********************************************************************/
1278
1279 void do_drv_upgrade_printer(struct messaging_context *msg,
1280 void *private_data,
1281 uint32_t msg_type,
1282 struct server_id server_id,
1283 DATA_BLOB *data)
1284 {
1285 fstring drivername;
1286 int snum;
1287 int n_services = lp_numservices();
1288 size_t len;
1289
1290 len = MIN(data->length,sizeof(drivername)-1);
1291 strncpy(drivername, (const char *)data->data, len);
1292
1293 DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1294
1295 /* Iterate the printer list */
1296
1297 for (snum=0; snum<n_services; snum++)
1298 {
1299 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1300 {
1301 WERROR result;
1302 NT_PRINTER_INFO_LEVEL *printer = NULL;
1303
1304 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1305 if (!W_ERROR_IS_OK(result))
1306 continue;
1307
1308 if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1309 {
1310 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1311
1312 /* all we care about currently is the change_id */
1313
1314 result = mod_a_printer(printer, 2);
1315 if (!W_ERROR_IS_OK(result)) {
1316 DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1317 win_errstr(result)));
1318 }
1319 }
1320
1321 free_a_printer(&printer, 2);
1322 }
1323 }
1324
1325 /* all done */
1326 }
1327
1328 /********************************************************************
1329 Update the cache for all printq's with a registered client
1330 connection
1331 ********************************************************************/
1332
1333 void update_monitored_printq_cache( void )
1334 {
1335 Printer_entry *printer = printers_list;
1336 int snum;
1337
1338 /* loop through all printers and update the cache where
1339 client_connected == true */
1340 while ( printer )
1341 {
1342 if ( (printer->printer_type == SPLHND_PRINTER)
1343 && printer->notify.client_connected )
1344 {
1345 snum = print_queue_snum(printer->sharename);
1346 print_queue_status( snum, NULL, NULL );
1347 }
1348
1349 printer = printer->next;
1350 }
1351
1352 return;
1353 }
1354 /********************************************************************
1355 Send a message to ourself about new driver being installed
1356 so we can upgrade the information for each printer bound to this
1357 driver
1358 ********************************************************************/
1359
1360 static bool srv_spoolss_reset_printerdata(char* drivername)
1361 {
1362 int len = strlen(drivername);
1363
1364 if (!len)
1365 return false;
1366
1367 DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1368 drivername));
1369
1370 messaging_send_buf(smbd_messaging_context(), procid_self(),
1371 MSG_PRINTERDATA_INIT_RESET,
1372 (uint8_t *)drivername, len+1);
1373
1374 return true;
1375 }
1376
1377 /**********************************************************************
1378 callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1379 over all printers, resetting printer data as neessary
1380 **********************************************************************/
1381
1382 void reset_all_printerdata(struct messaging_context *msg,
1383 void *private_data,
1384 uint32_t msg_type,
1385 struct server_id server_id,
1386 DATA_BLOB *data)
1387 {
1388 fstring drivername;
1389 int snum;
1390 int n_services = lp_numservices();
1391 size_t len;
1392
1393 len = MIN( data->length, sizeof(drivername)-1 );
1394 strncpy( drivername, (const char *)data->data, len );
1395
1396 DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1397
1398 /* Iterate the printer list */
1399
1400 for ( snum=0; snum<n_services; snum++ )
1401 {
1402 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1403 {
1404 WERROR result;
1405 NT_PRINTER_INFO_LEVEL *printer = NULL;
1406
1407 result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1408 if ( !W_ERROR_IS_OK(result) )
1409 continue;
1410
1411 /*
1412 * if the printer is bound to the driver,
1413 * then reset to the new driver initdata
1414 */
1415
1416 if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1417 {
1418 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1419
1420 if ( !set_driver_init(printer, 2) ) {
1421 DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1422 printer->info_2->printername, printer->info_2->drivername));
1423 }
1424
1425 result = mod_a_printer( printer, 2 );
1426 if ( !W_ERROR_IS_OK(result) ) {
1427 DEBUG(3,("reset_all_printerdata: mod_a_printer() failed! (%s)\n",
1428 get_dos_error_msg(result)));
1429 }
1430 }
1431
1432 free_a_printer( &printer, 2 );
1433 }
1434 }
1435
1436 /* all done */
1437
1438 return;
1439 }
1440
1441 /****************************************************************
1442 _spoolss_OpenPrinter
1443 ****************************************************************/
1444
1445 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1446 struct spoolss_OpenPrinter *r)
1447 {
1448 struct spoolss_OpenPrinterEx e;
1449 WERROR werr;
1450
1451 ZERO_STRUCT(e.in.userlevel);
1452
1453 e.in.printername = r->in.printername;
1454 e.in.datatype = r->in.datatype;
1455 e.in.devmode_ctr = r->in.devmode_ctr;
1456 e.in.access_mask = r->in.access_mask;
1457 e.in.level = 0;
1458
1459 e.out.handle = r->out.handle;
1460
1461 werr = _spoolss_OpenPrinterEx(p, &e);
1462
1463 if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1464 /* OpenPrinterEx returns this for a bad
1465 * printer name. We must return WERR_INVALID_PRINTER_NAME
1466 * instead.
1467 */
1468 werr = WERR_INVALID_PRINTER_NAME;
1469 }
1470
1471 return werr;
1472 }
1473
1474 /********************************************************************
1475 ********************************************************************/
1476
1477 bool convert_devicemode(const char *printername,
1478 const struct spoolss_DeviceMode *devmode,
1479 NT_DEVICEMODE **pp_nt_devmode)
1480 {
1481 NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1482
1483 /*
1484 * Ensure nt_devmode is a valid pointer
1485 * as we will be overwriting it.
1486 */
1487
1488 if (nt_devmode == NULL) {
1489 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1490 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1491 return false;
1492 }
1493
1494 fstrcpy(nt_devmode->devicename, devmode->devicename);
1495 fstrcpy(nt_devmode->formname, devmode->formname);
1496
1497 nt_devmode->devicename[31] = '\0';
1498 nt_devmode->formname[31] = '\0';
1499
1500 nt_devmode->specversion = devmode->specversion;
1501 nt_devmode->driverversion = devmode->driverversion;
1502 nt_devmode->size = devmode->size;
1503 nt_devmode->fields = devmode->fields;
1504 nt_devmode->orientation = devmode->orientation;
1505 nt_devmode->papersize = devmode->papersize;
1506 nt_devmode->paperlength = devmode->paperlength;
1507 nt_devmode->paperwidth = devmode->paperwidth;
1508 nt_devmode->scale = devmode->scale;
1509 nt_devmode->copies = devmode->copies;
1510 nt_devmode->defaultsource = devmode->defaultsource;
1511 nt_devmode->printquality = devmode->printquality;
1512 nt_devmode->color = devmode->color;
1513 nt_devmode->duplex = devmode->duplex;
1514 nt_devmode->yresolution = devmode->yresolution;
1515 nt_devmode->ttoption = devmode->ttoption;
1516 nt_devmode->collate = devmode->collate;
1517
1518 nt_devmode->logpixels = devmode->logpixels;
1519 nt_devmode->bitsperpel = devmode->bitsperpel;
1520 nt_devmode->pelswidth = devmode->pelswidth;
1521 nt_devmode->pelsheight = devmode->pelsheight;
1522 nt_devmode->displayflags = devmode->displayflags;
1523 nt_devmode->displayfrequency = devmode->displayfrequency;
1524 nt_devmode->icmmethod = devmode->icmmethod;
1525 nt_devmode->icmintent = devmode->icmintent;
1526 nt_devmode->mediatype = devmode->mediatype;
1527 nt_devmode->dithertype = devmode->dithertype;
1528 nt_devmode->reserved1 = devmode->reserved1;
1529 nt_devmode->reserved2 = devmode->reserved2;
1530 nt_devmode->panningwidth = devmode->panningwidth;
1531 nt_devmode->panningheight = devmode->panningheight;
1532
1533 /*
1534 * Only change private and driverextra if the incoming devmode
1535 * has a new one. JRA.
1536 */
1537
1538 if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1539 SAFE_FREE(nt_devmode->nt_dev_private);
1540 nt_devmode->driverextra = devmode->__driverextra_length;
1541 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1542 return false;
1543 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1544 }
1545
1546 *pp_nt_devmode = nt_devmode;
1547
1548 return true;
1549 }
1550
1551 /****************************************************************
1552 _spoolss_OpenPrinterEx
1553 ****************************************************************/
1554
1555 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1556 struct spoolss_OpenPrinterEx *r)
1557 {
1558 int snum;
1559 Printer_entry *Printer=NULL;
1560
1561 if (!r->in.printername) {
1562 return WERR_INVALID_PARAM;
1563 }
1564
1565 /* some sanity check because you can open a printer or a print server */
1566 /* aka: \\server\printer or \\server */
1567
1568 DEBUGADD(3,("checking name: %s\n", r->in.printername));
1569
1570 if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1571 ZERO_STRUCTP(r->out.handle);
1572 return WERR_INVALID_PARAM;
1573 }
1574
1575 Printer = find_printer_index_by_hnd(p, r->out.handle);
1576 if ( !Printer ) {
1577 DEBUG(0,("_spoolss_OpenPrinterEx: logic error. Can't find printer "
1578 "handle we created for printer %s\n", r->in.printername));
1579 close_printer_handle(p, r->out.handle);
1580 ZERO_STRUCTP(r->out.handle);
1581 return WERR_INVALID_PARAM;
1582 }
1583
1584 /*
1585 * First case: the user is opening the print server:
1586 *
1587 * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1588 * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1589 *
1590 * Then both Win2k and WinNT clients try an OpenPrinterEx with
1591 * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1592 * or if the user is listed in the smb.conf printer admin parameter.
1593 *
1594 * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1595 * client view printer folder, but does not show the MSAPW.
1596 *
1597 * Note: this test needs code to check access rights here too. Jeremy
1598 * could you look at this?
1599 *
1600 * Second case: the user is opening a printer:
1601 * NT doesn't let us connect to a printer if the connecting user
1602 * doesn't have print permission.
1603 *
1604 * Third case: user is opening a Port Monitor
1605 * access checks same as opening a handle to the print server.
1606 */
1607
1608 switch (Printer->printer_type )
1609 {
1610 case SPLHND_SERVER:
1611 case SPLHND_PORTMON_TCP:
1612 case SPLHND_PORTMON_LOCAL:
1613 /* Printserver handles use global struct... */
1614
1615 snum = -1;
1616
1617 /* Map standard access rights to object specific access rights */
1618
1619 se_map_standard(&r->in.access_mask,
1620 &printserver_std_mapping);
1621
1622 /* Deny any object specific bits that don't apply to print
1623 servers (i.e printer and job specific bits) */
1624
1625 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1626
1627 if (r->in.access_mask &
1628 ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1629 DEBUG(3, ("access DENIED for non-printserver bits\n"));
1630 close_printer_handle(p, r->out.handle);
1631 ZERO_STRUCTP(r->out.handle);
1632 return WERR_ACCESS_DENIED;
1633 }
1634
1635 /* Allow admin access */
1636
1637 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1638 {
1639 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1640
1641 if (!lp_ms_add_printer_wizard()) {
1642 close_printer_handle(p, r->out.handle);
1643 ZERO_STRUCTP(r->out.handle);
1644 return WERR_ACCESS_DENIED;
1645 }
1646
1647 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1648 and not a printer admin, then fail */
1649
1650 if ((p->server_info->utok.uid != sec_initial_uid()) &&
1651 !user_has_privileges(p->server_info->ptok,
1652 &se_printop ) &&
1653 !token_contains_name_in_list(
1654 uidtoname(p->server_info->utok.uid),
1655 NULL, NULL,
1656 p->server_info->ptok,
1657 lp_printer_admin(snum))) {
1658 close_printer_handle(p, r->out.handle);
1659 ZERO_STRUCTP(r->out.handle);
1660 return WERR_ACCESS_DENIED;
1661 }
1662
1663 r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1664 }
1665 else
1666 {
1667 r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1668 }
1669
1670 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1671 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1672
1673 /* We fall through to return WERR_OK */
1674 break;
1675
1676 case SPLHND_PRINTER:
1677 /* NT doesn't let us connect to a printer if the connecting user
1678 doesn't have print permission. */
1679
1680 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1681 close_printer_handle(p, r->out.handle);
1682 ZERO_STRUCTP(r->out.handle);
1683 return WERR_BADFID;
1684 }
1685
1686 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1687 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1688 }
1689
1690 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1691
1692 /* map an empty access mask to the minimum access mask */
1693 if (r->in.access_mask == 0x0)
1694 r->in.access_mask = PRINTER_ACCESS_USE;
1695
1696 /*
1697 * If we are not serving the printer driver for this printer,
1698 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1699 * will keep NT clients happy --jerry
1700 */
1701
1702 if (lp_use_client_driver(snum)
1703 && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1704 {
1705 r->in.access_mask = PRINTER_ACCESS_USE;
1706 }
1707
1708 /* check smb.conf parameters and the the sec_desc */
1709
1710 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1711 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1712 ZERO_STRUCTP(r->out.handle);
1713 return WERR_ACCESS_DENIED;
1714 }
1715
1716 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1717 p->server_info->ptok, snum) ||
1718 !print_access_check(p->server_info, snum,
1719 r->in.access_mask)) {
1720 DEBUG(3, ("access DENIED for printer open\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 & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1727 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1728 close_printer_handle(p, r->out.handle);
1729 ZERO_STRUCTP(r->out.handle);
1730 return WERR_ACCESS_DENIED;
1731 }
1732
1733 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1734 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1735 else
1736 r->in.access_mask = PRINTER_ACCESS_USE;
1737
1738 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1739 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1740
1741 break;
1742
1743 default:
1744 /* sanity check to prevent programmer error */
1745 ZERO_STRUCTP(r->out.handle);
1746 return WERR_BADFID;
1747 }
1748
1749 Printer->access_granted = r->in.access_mask;
1750
1751 /*
1752 * If the client sent a devmode in the OpenPrinter() call, then
1753 * save it here in case we get a job submission on this handle
1754 */
1755
1756 if ((Printer->printer_type != SPLHND_SERVER) &&
1757 r->in.devmode_ctr.devmode) {
1758 convert_devicemode(Printer->sharename,
1759 r->in.devmode_ctr.devmode,
1760 &Printer->nt_devmode);
1761 }
1762
1763 #if 0 /* JERRY -- I'm doubtful this is really effective */
1764 /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1765 optimization in Windows 2000 clients --jerry */
1766
1767 if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1768 && (RA_WIN2K == get_remote_arch()) )
1769 {
1770 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1771 sys_usleep( 500000 );
1772 }
1773 #endif
1774
1775 return WERR_OK;
1776 }
1777
1778 /****************************************************************************
1779 ****************************************************************************/
1780
1781 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1782 NT_PRINTER_INFO_LEVEL_2 *d)
1783 {
1784 DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1785
1786 if (!r || !d) {
1787 return false;
1788 }
1789
1790 d->attributes = r->attributes;
1791 d->priority = r->priority;
1792 d->default_priority = r->defaultpriority;
1793 d->starttime = r->starttime;
1794 d->untiltime = r->untiltime;
1795 d->status = r->status;
1796 d->cjobs = r->cjobs;
1797
1798 fstrcpy(d->servername, r->servername);
1799 fstrcpy(d->printername, r->printername);
1800 fstrcpy(d->sharename, r->sharename);
1801 fstrcpy(d->portname, r->portname);
1802 fstrcpy(d->drivername, r->drivername);
1803 slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1804 fstrcpy(d->location, r->location);
1805 fstrcpy(d->sepfile, r->sepfile);
1806 fstrcpy(d->printprocessor, r->printprocessor);
1807 fstrcpy(d->datatype, r->datatype);
1808 fstrcpy(d->parameters, r->parameters);
1809
1810 return true;
1811 }
1812
1813 /****************************************************************************
1814 ****************************************************************************/
1815
1816 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1817 NT_PRINTER_INFO_LEVEL *printer)
1818 {
1819 bool ret;
1820
1821 switch (info_ctr->level) {
1822 case 2:
1823 /* allocate memory if needed. Messy because
1824 convert_printer_info is used to update an existing
1825 printer or build a new one */
1826
1827 if (!printer->info_2) {
1828 printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1829 if (!printer->info_2) {
1830 DEBUG(0,("convert_printer_info: "
1831 "talloc() failed!\n"));
1832 return false;
1833 }
1834 }
1835
1836 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1837 printer->info_2);
1838 printer->info_2->setuptime = time(NULL);
1839 return ret;
1840 }
1841
1842 return false;
1843 }
1844
1845 /****************************************************************
1846 _spoolss_ClosePrinter
1847 ****************************************************************/
1848
1849 WERROR _spoolss_ClosePrinter(pipes_struct *p,
1850 struct spoolss_ClosePrinter *r)
1851 {
1852 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1853
1854 if (Printer && Printer->document_started) {
1855 struct spoolss_EndDocPrinter e;
1856
1857 e.in.handle = r->in.handle;
1858
1859 _spoolss_EndDocPrinter(p, &e);
1860 }
1861
1862 if (!close_printer_handle(p, r->in.handle))
1863 return WERR_BADFID;
1864
1865 /* clear the returned printer handle. Observed behavior
1866 from Win2k server. Don't think this really matters.
1867 Previous code just copied the value of the closed
1868 handle. --jerry */
1869
1870 ZERO_STRUCTP(r->out.handle);
1871
1872 return WERR_OK;
1873 }
1874
1875 /****************************************************************
1876 _spoolss_DeletePrinter
1877 ****************************************************************/
1878
1879 WERROR _spoolss_DeletePrinter(pipes_struct *p,
1880 struct spoolss_DeletePrinter *r)
1881 {
1882 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1883 WERROR result;
1884
1885 if (Printer && Printer->document_started) {
1886 struct spoolss_EndDocPrinter e;
1887
1888 e.in.handle = r->in.handle;
1889
1890 _spoolss_EndDocPrinter(p, &e);
1891 }
1892
1893 result = delete_printer_handle(p, r->in.handle);
1894
1895 update_c_setprinter(false);
1896
1897 return result;
1898 }
1899
1900 /*******************************************************************
1901 * static function to lookup the version id corresponding to an
1902 * long architecture string
1903 ******************************************************************/
1904
1905 static const struct print_architecture_table_node archi_table[]= {
1906
1907 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
1908 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
1909 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
1910 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
1911 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
1912 {"Windows IA64", SPL_ARCH_IA64, 3 },
1913 {"Windows x64", SPL_ARCH_X64, 3 },
1914 {NULL, "", -1 }
1915 };
1916
1917 static int get_version_id(const char *arch)
1918 {
1919 int i;
1920
1921 for (i=0; archi_table[i].long_archi != NULL; i++)
1922 {
1923 if (strcmp(arch, archi_table[i].long_archi) == 0)
1924 return (archi_table[i].version);
1925 }
1926
1927 return -1;
1928 }
1929
1930 /****************************************************************
1931 _spoolss_DeletePrinterDriver
1932 ****************************************************************/
1933
1934 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
1935 struct spoolss_DeletePrinterDriver *r)
1936 {
1937
1938 struct spoolss_DriverInfo8 *info = NULL;
1939 struct spoolss_DriverInfo8 *info_win2k = NULL;
1940 int version;
1941 WERROR status;
1942 WERROR status_win2k = WERR_ACCESS_DENIED;
1943 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1944
1945 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1946 and not a printer admin, then fail */
1947
1948 if ( (p->server_info->utok.uid != sec_initial_uid())
1949 && !user_has_privileges(p->server_info->ptok, &se_printop )
1950 && !token_contains_name_in_list(
1951 uidtoname(p->server_info->utok.uid), NULL,
1952 NULL, p->server_info->ptok,
1953 lp_printer_admin(-1)) )
1954 {
1955 return WERR_ACCESS_DENIED;
1956 }
1957
1958 /* check that we have a valid driver name first */
1959
1960 if ((version = get_version_id(r->in.architecture)) == -1)
1961 return WERR_INVALID_ENVIRONMENT;
1962
1963 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
1964 r->in.architecture,
1965 version)))
1966 {
1967 /* try for Win2k driver if "Windows NT x86" */
1968
1969 if ( version == 2 ) {
1970 version = 3;
1971 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
1972 &info,
1973 r->in.driver,
1974 r->in.architecture,
1975 version))) {
1976 status = WERR_UNKNOWN_PRINTER_DRIVER;
1977 goto done;
1978 }
1979 }
1980 /* otherwise it was a failure */
1981 else {
1982 status = WERR_UNKNOWN_PRINTER_DRIVER;
1983 goto done;
1984 }
1985
1986 }
1987
1988 if (printer_driver_in_use(info)) {
1989 status = WERR_PRINTER_DRIVER_IN_USE;
1990 goto done;
1991 }
1992
1993 if ( version == 2 )
1994 {
1995 if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
1996 &info_win2k,
1997 r->in.driver,
1998 r->in.architecture, 3)))
1999 {
2000 /* if we get to here, we now have 2 driver info structures to remove */
2001 /* remove the Win2k driver first*/
2002
2003 status_win2k = delete_printer_driver(
2004 p, info_win2k, 3, false);
2005 free_a_printer_driver(info_win2k);
2006
2007 /* this should not have failed---if it did, report to client */
2008 if ( !W_ERROR_IS_OK(status_win2k) )
2009 {
2010 status = status_win2k;
2011 goto done;
2012 }
2013 }
2014 }
2015
2016 status = delete_printer_driver(p, info, version, false);
2017
2018 /* if at least one of the deletes succeeded return OK */
2019
2020 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2021 status = WERR_OK;
2022
2023 done:
2024 free_a_printer_driver(info);
2025
2026 return status;
2027 }
2028
2029 /****************************************************************
2030 _spoolss_DeletePrinterDriverEx
2031 ****************************************************************/
2032
2033 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2034 struct spoolss_DeletePrinterDriverEx *r)
2035 {
2036 struct spoolss_DriverInfo8 *info = NULL;
2037 struct spoolss_DriverInfo8 *info_win2k = NULL;
2038 int version;
2039 bool delete_files;
2040 WERROR status;
2041 WERROR status_win2k = WERR_ACCESS_DENIED;
2042 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2043
2044 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2045 and not a printer admin, then fail */
2046
2047 if ( (p->server_info->utok.uid != sec_initial_uid())
2048 && !user_has_privileges(p->server_info->ptok, &se_printop )
2049 && !token_contains_name_in_list(
2050 uidtoname(p->server_info->utok.uid), NULL, NULL,
2051 p->server_info->ptok, lp_printer_admin(-1)) )
2052 {
2053 return WERR_ACCESS_DENIED;
2054 }
2055
2056 /* check that we have a valid driver name first */
2057 if ((version = get_version_id(r->in.architecture)) == -1) {
2058 /* this is what NT returns */
2059 return WERR_INVALID_ENVIRONMENT;
2060 }
2061
2062 if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2063 version = r->in.version;
2064
2065 status = get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
2066 r->in.architecture, version);
2067
2068 if ( !W_ERROR_IS_OK(status) )
2069 {
2070 /*
2071 * if the client asked for a specific version,
2072 * or this is something other than Windows NT x86,
2073 * then we've failed
2074 */
2075
2076 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2077 goto done;
2078
2079 /* try for Win2k driver if "Windows NT x86" */
2080
2081 version = 3;
2082 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
2083 r->in.architecture,
2084 version))) {
2085 status = WERR_UNKNOWN_PRINTER_DRIVER;
2086 goto done;
2087 }
2088 }
2089
2090 if (printer_driver_in_use(info)) {
2091 status = WERR_PRINTER_DRIVER_IN_USE;
2092 goto done;
2093 }
2094
2095 /*
2096 * we have a couple of cases to consider.
2097 * (1) Are any files in use? If so and DPD_DELTE_ALL_FILE is set,
2098 * then the delete should fail if **any** files overlap with
2099 * other drivers
2100 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2101 * non-overlapping files
2102 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2103 * is set, the do not delete any files
2104 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2105 */
2106
2107 delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2108
2109 /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2110
2111 if (delete_files && printer_driver_files_in_use(info, info) & (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
2112 /* no idea of the correct error here */
2113 status = WERR_ACCESS_DENIED;
2114 goto done;
2115 }
2116
2117
2118 /* also check for W32X86/3 if necessary; maybe we already have? */
2119
2120 if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
2121 if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info_win2k,
2122 r->in.driver,
2123 r->in.architecture, 3)))
2124 {
2125
2126 if (delete_files && printer_driver_files_in_use(info, info_win2k) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2127 /* no idea of the correct error here */
2128 free_a_printer_driver(info_win2k);
2129 status = WERR_ACCESS_DENIED;
2130 goto done;
2131 }
2132
2133 /* if we get to here, we now have 2 driver info structures to remove */
2134 /* remove the Win2k driver first*/
2135
2136 status_win2k = delete_printer_driver(
2137 p, info_win2k, 3, delete_files);
2138 free_a_printer_driver(info_win2k);
2139
2140 /* this should not have failed---if it did, report to client */
2141
2142 if ( !W_ERROR_IS_OK(status_win2k) )
2143 goto done;
2144 }
2145 }
2146
2147 status = delete_printer_driver(p, info, version, delete_files);
2148
2149 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2150 status = WERR_OK;
2151 done:
2152 free_a_printer_driver(info);
2153
2154 return status;
2155 }
2156
2157
2158 /****************************************************************************
2159 Internal routine for removing printerdata
2160 ***************************************************************************/
2161
2162 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2163 {
2164 return delete_printer_data( printer->info_2, key, value );
2165 }
2166
2167 /****************************************************************************
2168 Internal routine for storing printerdata
2169 ***************************************************************************/
2170
2171 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2172 const char *key, const char *value,
2173 uint32_t type, uint8_t *data, int real_len)
2174 {
2175 /* the registry objects enforce uniqueness based on value name */
2176
2177 return add_printer_data( printer->info_2, key, value, type, data, real_len );
2178 }
2179
2180 /********************************************************************
2181 GetPrinterData on a printer server Handle.
2182 ********************************************************************/
2183
2184 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2185 const char *value,
2186 enum winreg_Type *type,
2187 union spoolss_PrinterData *data)
2188 {
2189 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2190
2191 if (!StrCaseCmp(value, "W3SvcInstalled")) {
2192 *type = REG_DWORD;
2193 data->value = 0x00;
2194 return WERR_OK;
2195 }
2196
2197 if (!StrCaseCmp(value, "BeepEnabled")) {
2198 *type = REG_DWORD;
2199 data->value = 0x00;
2200 return WERR_OK;
2201 }
2202
2203 if (!StrCaseCmp(value, "EventLog")) {
2204 *type = REG_DWORD;
2205 /* formally was 0x1b */
2206 data->value = 0x00;
2207 return WERR_OK;
2208 }
2209
2210 if (!StrCaseCmp(value, "NetPopup")) {
2211 *type = REG_DWORD;
2212 data->value = 0x00;
2213 return WERR_OK;
2214 }
2215
2216 if (!StrCaseCmp(value, "MajorVersion")) {
2217 *type = REG_DWORD;
2218
2219 /* Windows NT 4.0 seems to not allow uploading of drivers
2220 to a server that reports 0x3 as the MajorVersion.
2221 need to investigate more how Win2k gets around this .
2222 -- jerry */
2223
2224 if (RA_WINNT == get_remote_arch()) {
2225 data->value = 0x02;
2226 } else {
2227 data->value = 0x03;
2228 }
2229
2230 return WERR_OK;
2231 }
2232
2233 if (!StrCaseCmp(value, "MinorVersion")) {
2234 *type = REG_DWORD;
2235 data->value = 0x00;
2236 return WERR_OK;
2237 }
2238
2239 /* REG_BINARY
2240 * uint32_t size = 0x114
2241 * uint32_t major = 5
2242 * uint32_t minor = [0|1]
2243 * uint32_t build = [2195|2600]
2244 * extra unicode string = e.g. "Service Pack 3"
2245 */
2246 if (!StrCaseCmp(value, "OSVersion")) {
2247 DATA_BLOB blob;
2248 enum ndr_err_code ndr_err;
2249 struct spoolss_OSVersion os;
2250
2251 os.major = 5; /* Windows 2000 == 5.0 */
2252 os.minor = 0;
2253 os.build = 2195; /* build */
2254 os.extra_string = ""; /* leave extra string empty */
2255
2256 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2257 (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2258 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2259 return WERR_GENERAL_FAILURE;
2260 }
2261
2262 *type = REG_BINARY;
2263 data->binary = blob;
2264
2265 return WERR_OK;
2266 }
2267
2268
2269 if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2270 *type = REG_SZ;
2271
2272 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2273 W_ERROR_HAVE_NO_MEMORY(data->string);
2274
2275 return WERR_OK;
2276 }
2277
2278 if (!StrCaseCmp(value, "Architecture")) {
2279 *type = REG_SZ;
2280 data->string = talloc_strdup(mem_ctx,
2281 lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", SPOOLSS_ARCHITECTURE_NT_X86));
2282 W_ERROR_HAVE_NO_MEMORY(data->string);
2283
2284 return WERR_OK;
2285 }
2286
2287 if (!StrCaseCmp(value, "DsPresent")) {
2288 *type = REG_DWORD;
2289
2290 /* only show the publish check box if we are a
2291 member of a AD domain */
2292
2293 if (lp_security() == SEC_ADS) {
2294 data->value = 0x01;
2295 } else {
2296 data->value = 0x00;
2297 }
2298 return WERR_OK;
2299 }
2300
2301 if (!StrCaseCmp(value, "DNSMachineName")) {
2302 const char *hostname = get_mydnsfullname();
2303
2304 if (!hostname) {
2305 return WERR_BADFILE;
2306 }
2307
2308 *type = REG_SZ;
2309 data->string = talloc_strdup(mem_ctx, hostname);
2310 W_ERROR_HAVE_NO_MEMORY(data->string);
2311
2312 return WERR_OK;
2313 }
2314
2315 *type = REG_NONE;
2316
2317 return WERR_INVALID_PARAM;
2318 }
2319
2320 /****************************************************************
2321 _spoolss_GetPrinterData
2322 ****************************************************************/
2323
2324 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2325 struct spoolss_GetPrinterData *r)
2326 {
2327 struct spoolss_GetPrinterDataEx r2;
2328
2329 r2.in.handle = r->in.handle;
2330 r2.in.key_name = "PrinterDriverData";
2331 r2.in.value_name = r->in.value_name;
2332 r2.in.offered = r->in.offered;
2333 r2.out.type = r->out.type;
2334 r2.out.data = r->out.data;
2335 r2.out.needed = r->out.needed;
2336
2337 return _spoolss_GetPrinterDataEx(p, &r2);
2338 }
2339
2340 /*********************************************************
2341 Connect to the client machine.
2342 **********************************************************/
2343
2344 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2345 struct sockaddr_storage *client_ss, const char *remote_machine)
2346 {
2347 NTSTATUS ret;
2348 struct cli_state *the_cli;
2349 struct sockaddr_storage rm_addr;
2350 char addr[INET6_ADDRSTRLEN];
2351
2352 if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2353 DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
2354 remote_machine));
2355 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2356 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2357 return false;
2358 }
2359 print_sockaddr(addr, sizeof(addr), &rm_addr);
2360 } else {
2361 rm_addr = *client_ss;
2362 print_sockaddr(addr, sizeof(addr), &rm_addr);
2363 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2364 addr));
2365 }
2366
2367 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2368 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
2369 addr));
2370 return false;
2371 }
2372
2373 /* setup the connection */
2374 ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2375 &rm_addr, 0, "IPC$", "IPC",
2376 "", /* username */
2377 "", /* domain */
2378 "", /* password */
2379 0, lp_client_signing(), NULL );
2380
2381 if ( !NT_STATUS_IS_OK( ret ) ) {
2382 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2383 remote_machine ));
2384 return false;
2385 }
2386
2387 if ( the_cli->protocol != PROTOCOL_NT1 ) {
2388 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2389 cli_shutdown(the_cli);
2390 return false;
2391 }
2392
2393 /*
2394 * Ok - we have an anonymous connection to the IPC$ share.
2395 * Now start the NT Domain stuff :-).
2396 */
2397
2398 ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2399 if (!NT_STATUS_IS_OK(ret)) {
2400 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2401 remote_machine, nt_errstr(ret)));
2402 cli_shutdown(the_cli);
2403 return false;
2404 }
2405
2406 return true;
2407 }
2408
2409 /***************************************************************************
2410 Connect to the client.
2411 ****************************************************************************/
2412
2413 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2414 uint32_t localprinter, uint32_t type,
2415 struct policy_handle *handle,
2416 struct sockaddr_storage *client_ss)
2417 {
2418 WERROR result;
2419 NTSTATUS status;
2420
2421 /*
2422 * If it's the first connection, contact the client
2423 * and connect to the IPC$ share anonymously
2424 */
2425 if (smb_connections==0) {
2426 fstring unix_printer;
2427
2428 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2429
2430 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2431 return false;
2432
2433 messaging_register(smbd_messaging_context(), NULL,
2434 MSG_PRINTER_NOTIFY2,
2435 receive_notify2_message_list);
2436 /* Tell the connections db we're now interested in printer
2437 * notify messages. */
2438 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2439 }
2440
2441 /*
2442 * Tell the specific printing tdb we want messages for this printer
2443 * by registering our PID.
2444 */
2445
2446 if (!print_notify_register_pid(snum))
2447 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2448
2449 smb_connections++;
2450
2451 status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2452 printer,
2453 localprinter,
2454 type,
2455 0,
2456 NULL,
2457 handle,
2458 &result);
2459 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2460 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2461 win_errstr(result)));
2462
2463 return (W_ERROR_IS_OK(result));
2464 }
2465
2466 /****************************************************************
2467 ****************************************************************/
2468
2469 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2470 const struct spoolss_NotifyOption *r)
2471 {
2472 struct spoolss_NotifyOption *option;
2473 uint32_t i,k;
2474
2475 if (!r) {
2476 return NULL;
2477 }
2478
2479 option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2480 if (!option) {
2481 return NULL;
2482 }
2483
2484 *option = *r;
2485
2486 if (!option->count) {
2487 return option;
2488 }
2489
2490 option->types = talloc_zero_array(option,
2491 struct spoolss_NotifyOptionType, option->count);
2492 if (!option->types) {
2493 talloc_free(option);
2494 return NULL;
2495 }
2496
2497 for (i=0; i < option->count; i++) {
2498 option->types[i] = r->types[i];
2499
2500 if (option->types[i].count) {
2501 option->types[i].fields = talloc_zero_array(option,
2502 union spoolss_Field, option->types[i].count);
2503 if (!option->types[i].fields) {
2504 talloc_free(option);
2505 return NULL;
2506 }
2507 for (k=0; k<option->types[i].count; k++) {
2508 option->types[i].fields[k] =
2509 r->types[i].fields[k];
2510 }
2511 }
2512 }
2513
2514 return option;
2515 }
2516
2517 /****************************************************************
2518 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2519 *
2520 * before replying OK: status=0 a rpc call is made to the workstation
2521 * asking ReplyOpenPrinter
2522 *
2523 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2524 * called from api_spoolss_rffpcnex
2525 ****************************************************************/
2526
2527 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2528 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2529 {
2530 int snum = -1;
2531 struct spoolss_NotifyOption *option = r->in.notify_options;
2532 struct sockaddr_storage client_ss;
2533
2534 /* store the notify value in the printer struct */
2535
2536 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2537
2538 if (!Printer) {
2539 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2540 "Invalid handle (%s:%u:%u).\n",
2541 OUR_HANDLE(r->in.handle)));
2542 return WERR_BADFID;
2543 }
2544
2545 Printer->notify.flags = r->in.flags;
2546 Printer->notify.options = r->in.options;
2547 Printer->notify.printerlocal = r->in.printer_local;
2548
2549 TALLOC_FREE(Printer->notify.option);
2550 Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2551
2552 fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2553
2554 /* Connect to the client machine and send a ReplyOpenPrinter */
2555
2556 if ( Printer->printer_type == SPLHND_SERVER)
2557 snum = -1;
2558 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2559 !get_printer_snum(p, r->in.handle, &snum, NULL) )
2560 return WERR_BADFID;
2561
2562 DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2563 "client_address is %s\n", p->client_address));
2564
2565 if (!interpret_string_addr(&client_ss, p->client_address,
2566 AI_NUMERICHOST)) {
2567 return WERR_SERVER_UNAVAILABLE;
2568 }
2569
2570 if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2571 Printer->notify.printerlocal, 1,
2572 &Printer->notify.client_hnd, &client_ss))
2573 return WERR_SERVER_UNAVAILABLE;
2574
2575 Printer->notify.client_connected = true;
2576
2577 return WERR_OK;
2578 }
2579
2580 /*******************************************************************
2581 * fill a notify_info_data with the servername
2582 ********************************************************************/
2583
2584 static void spoolss_notify_server_name(int snum,
2585 struct spoolss_Notify *data,
2586 print_queue_struct *queue,
2587 NT_PRINTER_INFO_LEVEL *printer,
2588 TALLOC_CTX *mem_ctx)
2589 {
2590 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2591 }
2592
2593 /*******************************************************************
2594 * fill a notify_info_data with the printername (not including the servername).
2595 ********************************************************************/
2596
2597 static void spoolss_notify_printer_name(int snum,
2598 struct spoolss_Notify *data,
2599 print_queue_struct *queue,
2600 NT_PRINTER_INFO_LEVEL *printer,
2601 TALLOC_CTX *mem_ctx)
2602 {
2603 /* the notify name should not contain the \\server\ part */
2604 char *p = strrchr(printer->info_2->printername, '\\');
2605
2606 if (!p) {
2607 p = printer->info_2->printername;
2608 } else {
2609 p++;
2610 }
2611
2612 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2613 }
2614
2615 /*******************************************************************
2616 * fill a notify_info_data with the servicename
2617 ********************************************************************/
2618
2619 static void spoolss_notify_share_name(int snum,
2620 struct spoolss_Notify *data,
2621 print_queue_struct *queue,
2622 NT_PRINTER_INFO_LEVEL *printer,
2623 TALLOC_CTX *mem_ctx)
2624 {
2625 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2626 }
2627
2628 /*******************************************************************
2629 * fill a notify_info_data with the port name
2630 ********************************************************************/
2631
2632 static void spoolss_notify_port_name(int snum,
2633 struct spoolss_Notify *data,
2634 print_queue_struct *queue,
2635 NT_PRINTER_INFO_LEVEL *printer,
2636 TALLOC_CTX *mem_ctx)
2637 {
2638 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2639 }
2640
2641 /*******************************************************************
2642 * fill a notify_info_data with the printername
2643 * but it doesn't exist, have to see what to do
2644 ********************************************************************/
2645
2646 static void spoolss_notify_driver_name(int snum,
2647 struct spoolss_Notify *data,
2648 print_queue_struct *queue,
2649 NT_PRINTER_INFO_LEVEL *printer,
2650 TALLOC_CTX *mem_ctx)
2651 {
2652 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2653 }
2654
2655 /*******************************************************************
2656 * fill a notify_info_data with the comment
2657 ********************************************************************/
2658
2659 static void spoolss_notify_comment(int snum,
2660 struct spoolss_Notify *data,
2661 print_queue_struct *queue,
2662 NT_PRINTER_INFO_LEVEL *printer,
2663 TALLOC_CTX *mem_ctx)
2664 {
2665 char *p;
2666
2667 if (*printer->info_2->comment == '\0') {
2668 p = lp_comment(snum);
2669 } else {
2670 p = printer->info_2->comment;
2671 }
2672
2673 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2674 }
2675
2676 /*******************************************************************
2677 * fill a notify_info_data with the comment
2678 * location = "Room 1, floor 2, building 3"
2679 ********************************************************************/
2680
2681 static void spoolss_notify_location(int snum,
2682 struct spoolss_Notify *data,
2683 print_queue_struct *queue,
2684 NT_PRINTER_INFO_LEVEL *printer,
2685 TALLOC_CTX *mem_ctx)
2686 {
2687 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2688 }
2689
2690 /*******************************************************************
2691 * fill a notify_info_data with the device mode
2692 * jfm:xxxx don't to it for know but that's a real problem !!!
2693 ********************************************************************/
2694
2695 static void spoolss_notify_devmode(int snum,
2696 struct spoolss_Notify *data,
2697 print_queue_struct *queue,
2698 NT_PRINTER_INFO_LEVEL *printer,
2699 TALLOC_CTX *mem_ctx)
2700 {
2701 /* for a dummy implementation we have to zero the fields */
2702 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2703 }
2704
2705 /*******************************************************************
2706 * fill a notify_info_data with the separator file name
2707 ********************************************************************/
2708
2709 static void spoolss_notify_sepfile(int snum,
2710 struct spoolss_Notify *data,
2711 print_queue_struct *queue,
2712 NT_PRINTER_INFO_LEVEL *printer,
2713 TALLOC_CTX *mem_ctx)
2714 {
2715 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2716 }
2717
2718 /*******************************************************************
2719 * fill a notify_info_data with the print processor
2720 * jfm:xxxx return always winprint to indicate we don't do anything to it
2721 ********************************************************************/
2722
2723 static void spoolss_notify_print_processor(int snum,
2724 struct spoolss_Notify *data,
2725 print_queue_struct *queue,
2726 NT_PRINTER_INFO_LEVEL *printer,
2727 TALLOC_CTX *mem_ctx)
2728 {
2729 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2730 }
2731
2732 /*******************************************************************
2733 * fill a notify_info_data with the print processor options
2734 * jfm:xxxx send an empty string
2735 ********************************************************************/
2736
2737 static void spoolss_notify_parameters(int snum,
2738 struct spoolss_Notify *data,
2739 print_queue_struct *queue,
2740 NT_PRINTER_INFO_LEVEL *printer,
2741 TALLOC_CTX *mem_ctx)
2742 {
2743 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2744 }
2745
2746 /*******************************************************************
2747 * fill a notify_info_data with the data type
2748 * jfm:xxxx always send RAW as data type
2749 ********************************************************************/
2750
2751 static void spoolss_notify_datatype(int snum,
2752 struct spoolss_Notify *data,
2753 print_queue_struct *queue,
2754 NT_PRINTER_INFO_LEVEL *printer,
2755 TALLOC_CTX *mem_ctx)
2756 {
2757 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
2758 }
2759
2760 /*******************************************************************
2761 * fill a notify_info_data with the security descriptor
2762 * jfm:xxxx send an null pointer to say no security desc
2763 * have to implement security before !
2764 ********************************************************************/
2765
2766 static void spoolss_notify_security_desc(int snum,
2767 struct spoolss_Notify *data,
2768 print_queue_struct *queue,
2769 NT_PRINTER_INFO_LEVEL *printer,
2770 TALLOC_CTX *mem_ctx)
2771 {
2772 SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
2773 printer->info_2->secdesc_buf->sd_size,
2774 printer->info_2->secdesc_buf->sd);
2775 }
2776
2777 /*******************************************************************
2778 * fill a notify_info_data with the attributes
2779 * jfm:xxxx a samba printer is always shared
2780 ********************************************************************/
2781
2782 static void spoolss_notify_attributes(int snum,
2783 struct spoolss_Notify *data,
2784 print_queue_struct *queue,
2785 NT_PRINTER_INFO_LEVEL *printer,
2786 TALLOC_CTX *mem_ctx)
2787 {
2788 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
2789 }
2790
2791 /*******************************************************************
2792 * fill a notify_info_data with the priority
2793 ********************************************************************/
2794
2795 static void spoolss_notify_priority(int snum,
2796 struct spoolss_Notify *data,
2797 print_queue_struct *queue,
2798 NT_PRINTER_INFO_LEVEL *printer,
2799 TALLOC_CTX *mem_ctx)
2800 {
2801 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
2802 }
2803
2804 /*******************************************************************
2805 * fill a notify_info_data with the default priority
2806 ********************************************************************/
2807
2808 static void spoolss_notify_default_priority(int snum,
2809 struct spoolss_Notify *data,
2810 print_queue_struct *queue,
2811 NT_PRINTER_INFO_LEVEL *printer,
2812 TALLOC_CTX *mem_ctx)
2813 {
2814 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
2815 }
2816
2817 /*******************************************************************
2818 * fill a notify_info_data with the start time
2819 ********************************************************************/
2820
2821 static void spoolss_notify_start_time(int snum,
2822 struct spoolss_Notify *data,
2823 print_queue_struct *queue,
2824 NT_PRINTER_INFO_LEVEL *printer,
2825 TALLOC_CTX *mem_ctx)
2826 {
2827 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
2828 }
2829
2830 /*******************************************************************
2831 * fill a notify_info_data with the until time
2832 ********************************************************************/
2833
2834 static void spoolss_notify_until_time(int snum,
2835 struct spoolss_Notify *data,
2836 print_queue_struct *queue,
2837 NT_PRINTER_INFO_LEVEL *printer,
2838 TALLOC_CTX *mem_ctx)
2839 {
2840 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
2841 }
2842
2843 /*******************************************************************
2844 * fill a notify_info_data with the status
2845 ********************************************************************/
2846
2847 static void spoolss_notify_status(int snum,
2848 struct spoolss_Notify *data,
2849 print_queue_struct *queue,
2850 NT_PRINTER_INFO_LEVEL *printer,
2851 TALLOC_CTX *mem_ctx)
2852 {
2853 print_status_struct status;
2854
2855 print_queue_length(snum, &status);
2856 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
2857 }
2858
2859 /*******************************************************************
2860 * fill a notify_info_data with the number of jobs queued
2861 ********************************************************************/
2862
2863 static void spoolss_notify_cjobs(int snum,
2864 struct spoolss_Notify *data,
2865 print_queue_struct *queue,
2866 NT_PRINTER_INFO_LEVEL *printer,
2867 TALLOC_CTX *mem_ctx)
2868 {
2869 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
2870 }
2871
2872 /*******************************************************************
2873 * fill a notify_info_data with the average ppm
2874 ********************************************************************/
2875
2876 static void spoolss_notify_average_ppm(int snum,
2877 struct spoolss_Notify *data,
2878 print_queue_struct *queue,
2879 NT_PRINTER_INFO_LEVEL *printer,
2880 TALLOC_CTX *mem_ctx)
2881 {
2882 /* always respond 8 pages per minutes */
2883 /* a little hard ! */
2884 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
2885 }
2886
2887 /*******************************************************************
2888 * fill a notify_info_data with username
2889 ********************************************************************/
2890
2891 static void spoolss_notify_username(int snum,
2892 struct spoolss_Notify *data,
2893 print_queue_struct *queue,
2894 NT_PRINTER_INFO_LEVEL *printer,
2895 TALLOC_CTX *mem_ctx)
2896 {
2897 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
2898 }
2899
2900 /*******************************************************************
2901 * fill a notify_info_data with job status
2902 ********************************************************************/
2903
2904 static void spoolss_notify_job_status(int snum,
2905 struct spoolss_Notify *data,
2906 print_queue_struct *queue,
2907 NT_PRINTER_INFO_LEVEL *printer,
2908 TALLOC_CTX *mem_ctx)
2909 {
2910 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
2911 }
2912
2913 /*******************************************************************
2914 * fill a notify_info_data with job name
2915 ********************************************************************/
2916
2917 static void spoolss_notify_job_name(int snum,
2918 struct spoolss_Notify *data,
2919 print_queue_struct *queue,
2920 NT_PRINTER_INFO_LEVEL *printer,
2921 TALLOC_CTX *mem_ctx)
2922 {
2923 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
2924 }
2925
2926 /*******************************************************************
2927 * fill a notify_info_data with job status
2928 ********************************************************************/
2929
2930 static void spoolss_notify_job_status_string(int snum,
2931 struct spoolss_Notify *data,
2932 print_queue_struct *queue,
2933 NT_PRINTER_INFO_LEVEL *printer,
2934 TALLOC_CTX *mem_ctx)
2935 {
2936 /*
2937 * Now we're returning job status codes we just return a "" here. JRA.
2938 */
2939
2940 const char *p = "";
2941
2942 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
2943 p = "unknown";
2944
2945 switch (queue->status) {
2946 case LPQ_QUEUED:
2947 p = "Queued";
2948 break;
2949 case LPQ_PAUSED:
2950 p = ""; /* NT provides the paused string */
2951 break;
2952 case LPQ_SPOOLING:
2953 p = "Spooling";
2954 break;
2955 case LPQ_PRINTING:
2956 p = "Printing";
2957 break;
2958 }
2959 #endif /* NO LONGER NEEDED. */
2960
2961 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2962 }
2963
2964 /*******************************************************************
2965 * fill a notify_info_data with job time
2966 ********************************************************************/
2967
2968 static void spoolss_notify_job_time(int snum,
2969 struct spoolss_Notify *data,
2970 print_queue_struct *queue,
2971 NT_PRINTER_INFO_LEVEL *printer,
2972 TALLOC_CTX *mem_ctx)
2973 {
2974 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
2975 }
2976
2977 /*******************************************************************
2978 * fill a notify_info_data with job size
2979 ********************************************************************/
2980
2981 static void spoolss_notify_job_size(int snum,
2982 struct spoolss_Notify *data,
2983 print_queue_struct *queue,
2984 NT_PRINTER_INFO_LEVEL *printer,
2985 TALLOC_CTX *mem_ctx)
2986 {
2987 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
2988 }
2989
2990 /*******************************************************************
2991 * fill a notify_info_data with page info
2992 ********************************************************************/
2993 static void spoolss_notify_total_pages(int snum,
2994 struct spoolss_Notify *data,
2995 print_queue_struct *queue,
2996 NT_PRINTER_INFO_LEVEL *printer,
2997 TALLOC_CTX *mem_ctx)
2998 {
2999 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3000 }
3001
3002 /*******************************************************************
3003 * fill a notify_info_data with pages printed info.
3004 ********************************************************************/
3005 static void spoolss_notify_pages_printed(int snum,
3006 struct spoolss_Notify *data,
3007 print_queue_struct *queue,
3008 NT_PRINTER_INFO_LEVEL *printer,
3009 TALLOC_CTX *mem_ctx)
3010 {
3011 /* Add code when back-end tracks this */
3012 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3013 }
3014
3015 /*******************************************************************
3016 Fill a notify_info_data with job position.
3017 ********************************************************************/
3018
3019 static void spoolss_notify_job_position(int snum,
3020 struct spoolss_Notify *data,
3021 print_queue_struct *queue,
3022 NT_PRINTER_INFO_LEVEL *printer,
3023 TALLOC_CTX *mem_ctx)
3024 {
3025 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3026 }
3027
3028 /*******************************************************************
3029 Fill a notify_info_data with submitted time.
3030 ********************************************************************/
3031
3032 static void spoolss_notify_submitted_time(int snum,
3033 struct spoolss_Notify *data,
3034 print_queue_struct *queue,
3035 NT_PRINTER_INFO_LEVEL *printer,
3036 TALLOC_CTX *mem_ctx)
3037 {
3038 data->data.string.string = NULL;
3039 data->data.string.size = 0;
3040
3041 init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3042 &data->data.string.string,
3043 &data->data.string.size);
3044
3045 }
3046
3047 struct s_notify_info_data_table
3048 {
3049 enum spoolss_NotifyType type;
3050 uint16_t field;
3051 const char *name;
3052 enum spoolss_NotifyTable variable_type;
3053 void (*fn) (int snum, struct spoolss_Notify *data,
3054 print_queue_struct *queue,
3055 NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3056 };
3057
3058 /* A table describing the various print notification constants and
3059 whether the notification data is a pointer to a variable sized
3060 buffer, a one value uint32_t or a two value uint32_t. */
3061
3062 static const struct s_notify_info_data_table notify_info_data_table[] =
3063 {
3064 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3065 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3066 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_share_name },
3067 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3068 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3069 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING, spoolss_notify_comment },
3070 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING, spoolss_notify_location },
3071 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3072 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING, spoolss_notify_sepfile },
3073 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3074 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3075 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3076 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, spoolss_notify_security_desc },
3077 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD, spoolss_notify_attributes },
3078 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3079 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_default_priority },
3080 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3081 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3082 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_status },
3083 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, NULL },
3084 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD, spoolss_notify_cjobs },
3085 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD, spoolss_notify_average_ppm },
3086 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, NULL },
3087 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3088 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, NULL },
3089 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3090 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINTER_NAME, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3091 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_MACHINE_NAME, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3092 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PORT_NAME, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3093 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3094 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_NOTIFY_NAME, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3095 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DATATYPE, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3096 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINT_PROCESSOR, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3097 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PARAMETERS, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3098 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DRIVER_NAME, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3099 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DEVMODE, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3100 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_job_status },
3101 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS_STRING, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, spoolss_notify_job_status_string },
3102 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, NULL },
3103 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING, spoolss_notify_job_name },
3104 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRIORITY, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3105 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_POSITION, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD, spoolss_notify_job_position },
3106 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME, spoolss_notify_submitted_time },
3107 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_START_TIME, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3108 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_UNTIL_TIME, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3109 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TIME, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_job_time },
3110 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_PAGES, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, spoolss_notify_total_pages },
3111 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PAGES_PRINTED, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, spoolss_notify_pages_printed },
3112 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_BYTES, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, spoolss_notify_job_size },
3113 };
3114
3115 /*******************************************************************
3116 Return the variable_type of info_data structure.
3117 ********************************************************************/
3118
3119 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3120 uint16_t field)
3121 {
3122 int i=0;
3123
3124 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3125 if ( (notify_info_data_table[i].type == type) &&
3126 (notify_info_data_table[i].field == field) ) {
3127 return notify_info_data_table[i].variable_type;
3128 }
3129 }
3130
3131 DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3132
3133 return 0;
3134 }
3135
3136 /****************************************************************************
3137 ****************************************************************************/
3138
3139 static bool search_notify(enum spoolss_NotifyType type,
3140 uint16_t field,
3141 int *value)
3142 {
3143 int i;
3144
3145 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3146 if (notify_info_data_table[i].type == type &&
3147 notify_info_data_table[i].field == field &&
3148 notify_info_data_table[i].fn != NULL) {
3149 *value = i;
3150 return true;
3151 }
3152 }
3153
3154 return false;
3155 }
3156
3157 /****************************************************************************
3158 ****************************************************************************/
3159
3160 void construct_info_data(struct spoolss_Notify *info_data,
3161 enum spoolss_NotifyType type,
3162 uint16_t field,
3163 int id)
3164 {
3165 info_data->type = type;
3166 info_data->field.field = field;
3167 info_data->variable_type = variable_type_of_notify_info_data(type, field);
3168 info_data->job_id = id;
3169 }
3170
3171 /*******************************************************************
3172 *
3173 * fill a notify_info struct with info asked
3174 *
3175 ********************************************************************/
3176
3177 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3178 struct spoolss_NotifyInfo *info,
3179 int snum,
3180 const struct spoolss_NotifyOptionType *option_type,
3181 uint32_t id,
3182 TALLOC_CTX *mem_ctx)
3183 {
3184 int field_num,j;
3185 enum spoolss_NotifyType type;
3186 uint16_t field;
3187
3188 struct spoolss_Notify *current_data;
3189 NT_PRINTER_INFO_LEVEL *printer = NULL;
3190 print_queue_struct *queue=NULL;
3191
3192 type = option_type->type;
3193
3194 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3195 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3196 option_type->count, lp_servicename(snum)));
3197
3198 if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3199 return false;
3200
3201 for(field_num=0; field_num < option_type->count; field_num++) {
3202 field = option_type->fields[field_num].field;
3203
3204 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3205
3206 if (!search_notify(type, field, &j) )
3207 continue;
3208
3209 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3210 struct spoolss_Notify,
3211 info->count + 1);
3212 if (info->notifies == NULL) {
3213 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3214 free_a_printer(&printer, 2);
3215 return false;
3216 }
3217
3218 current_data = &info->notifies[info->count];
3219
3220 construct_info_data(current_data, type, field, id);
3221
3222 DEBUG(10,("construct_notify_printer_info: calling [%s] snum=%d printername=[%s])\n",
3223 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3224
3225 notify_info_data_table[j].fn(snum, current_data, queue,
3226 printer, mem_ctx);
3227
3228 info->count++;
3229 }
3230
3231 free_a_printer(&printer, 2);
3232 return true;
3233 }
3234
3235 /*******************************************************************
3236 *
3237 * fill a notify_info struct with info asked
3238 *
3239 ********************************************************************/
3240
3241 static bool construct_notify_jobs_info(print_queue_struct *queue,
3242 struct spoolss_NotifyInfo *info,
3243 NT_PRINTER_INFO_LEVEL *printer,
3244 int snum,
3245 const struct spoolss_NotifyOptionType *option_type,
3246 uint32_t id,
3247 TALLOC_CTX *mem_ctx)
3248 {
3249 int field_num,j;
3250 enum spoolss_NotifyType type;
3251 uint16_t field;
3252 struct spoolss_Notify *current_data;
3253
3254 DEBUG(4,("construct_notify_jobs_info\n"));
3255
3256 type = option_type->type;
3257
3258 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3259 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3260 option_type->count));
3261
3262 for(field_num=0; field_num<option_type->count; field_num++) {
3263 field = option_type->fields[field_num].field;
3264
3265 if (!search_notify(type, field, &j) )
3266 continue;
3267
3268 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3269 struct spoolss_Notify,
3270 info->count + 1);
3271 if (info->notifies == NULL) {
3272 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3273 return false;
3274 }
3275
3276 current_data=&(info->notifies[info->count]);
3277
3278 construct_info_data(current_data, type, field, id);
3279 notify_info_data_table[j].fn(snum, current_data, queue,
3280 printer, mem_ctx);
3281 info->count++;
3282 }
3283
3284 return true;
3285 }
3286
3287 /*
3288 * JFM: The enumeration is not that simple, it's even non obvious.
3289 *
3290 * let's take an example: I want to monitor the PRINTER SERVER for
3291 * the printer's name and the number of jobs currently queued.
3292 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3293 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3294 *
3295 * I have 3 printers on the back of my server.
3296 *
3297 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3298 * structures.
3299 * Number Data Id
3300 * 1 printer 1 name 1
3301 * 2 printer 1 cjob 1
3302 * 3 printer 2 name 2
3303 * 4 printer 2 cjob 2
3304 * 5 printer 3 name 3
3305 * 6 printer 3 name 3
3306 *
3307 * that's the print server case, the printer case is even worse.
3308 */
3309
3310 /*******************************************************************
3311 *
3312 * enumerate all printers on the printserver
3313 * fill a notify_info struct with info asked
3314 *
3315 ********************************************************************/
3316
3317 static WERROR printserver_notify_info(pipes_struct *p,
3318 struct policy_handle *hnd,
3319 struct spoolss_NotifyInfo *info,
3320 TALLOC_CTX *mem_ctx)
3321 {
3322 int snum;
3323 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3324 int n_services=lp_numservices();
3325 int i;
3326 struct spoolss_NotifyOption *option;
3327 struct spoolss_NotifyOptionType option_type;
3328
3329 DEBUG(4,("printserver_notify_info\n"));
3330
3331 if (!Printer)
3332 return WERR_BADFID;
3333
3334 option = Printer->notify.option;
3335
3336 info->version = 2;
3337 info->notifies = NULL;
3338 info->count = 0;
3339
3340 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3341 sending a ffpcn() request first */
3342
3343 if ( !option )
3344 return WERR_BADFID;
3345
3346 for (i=0; i<option->count; i++) {
3347 option_type = option->types[i];
3348
3349 if (option_type.type != PRINTER_NOTIFY_TYPE)
3350 continue;
3351
3352 for (snum=0; snum<n_services; snum++)
3353 {
3354 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3355 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3356 }
3357 }
3358
3359 #if 0
3360 /*
3361 * Debugging information, don't delete.
3362 */
3363
3364 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3365 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3366 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3367
3368 for (i=0; i<info->count; i++) {
3369 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3370 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3371 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3372 }
3373 #endif
3374
3375 return WERR_OK;
3376 }
3377
3378 /*******************************************************************
3379 *
3380 * fill a notify_info struct with info asked
3381 *
3382 ********************************************************************/
3383
3384 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3385 struct spoolss_NotifyInfo *info,
3386 TALLOC_CTX *mem_ctx)
3387 {
3388 int snum;
3389 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3390 int i;
3391 uint32_t id;
3392 struct spoolss_NotifyOption *option;
3393 struct spoolss_NotifyOptionType option_type;
3394 int count,j;
3395 print_queue_struct *queue=NULL;
3396 print_status_struct status;
3397
3398 DEBUG(4,("printer_notify_info\n"));
3399
3400 if (!Printer)
3401 return WERR_BADFID;
3402
3403 option = Printer->notify.option;
3404 id = 0x0;
3405
3406 info->version = 2;
3407 info->notifies = NULL;
3408 info->count = 0;
3409
3410 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3411 sending a ffpcn() request first */
3412
3413 if ( !option )
3414 return WERR_BADFID;
3415
3416 get_printer_snum(p, hnd, &snum, NULL);
3417
3418 for (i=0; i<option->count; i++) {
3419 option_type = option->types[i];
3420
3421 switch (option_type.type) {
3422 case PRINTER_NOTIFY_TYPE:
3423 if(construct_notify_printer_info(Printer, info, snum,
3424 &option_type, id,
3425 mem_ctx))
3426 id--;
3427 break;
3428
3429 case JOB_NOTIFY_TYPE: {
3430 NT_PRINTER_INFO_LEVEL *printer = NULL;
3431
3432 count = print_queue_status(snum, &queue, &status);
3433
3434 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3435 goto done;
3436
3437 for (j=0; j<count; j++) {
3438 construct_notify_jobs_info(&queue[j], info,
3439 printer, snum,
3440 &option_type,
3441 queue[j].job,
3442 mem_ctx);
3443 }
3444
3445 free_a_printer(&printer, 2);
3446
3447 done:
3448 SAFE_FREE(queue);
3449 break;
3450 }
3451 }
3452 }
3453
3454 /*
3455 * Debugging information, don't delete.
3456 */
3457 /*
3458 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3459 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3460 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3461
3462 for (i=0; i<info->count; i++) {
3463 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3464 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3465 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3466 }
3467 */
3468 return WERR_OK;
3469 }
3470
3471 /****************************************************************
3472 _spoolss_RouterRefreshPrinterChangeNotify
3473 ****************************************************************/
3474
3475 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3476 struct spoolss_RouterRefreshPrinterChangeNotify *r)
3477 {
3478 struct spoolss_NotifyInfo *info;
3479
3480 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3481 WERROR result = WERR_BADFID;
3482
3483 /* we always have a spoolss_NotifyInfo struct */
3484 info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3485 if (!info) {
3486 result = WERR_NOMEM;
3487 goto done;
3488 }
3489
3490 *r->out.info = info;
3491
3492 if (!Printer) {
3493 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3494 "Invalid handle (%s:%u:%u).\n",
3495 OUR_HANDLE(r->in.handle)));
3496 goto done;
3497 }
3498
3499 DEBUG(4,("Printer type %x\n",Printer->printer_type));
3500
3501 /*
3502 * We are now using the change value, and
3503 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3504 * I don't have a global notification system, I'm sending back all the
3505 * informations even when _NOTHING_ has changed.
3506 */
3507
3508 /* We need to keep track of the change value to send back in
3509 RRPCN replies otherwise our updates are ignored. */
3510
3511 Printer->notify.fnpcn = true;
3512
3513 if (Printer->notify.client_connected) {
3514 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3515 "Saving change value in request [%x]\n",
3516 r->in.change_low));
3517 Printer->notify.change = r->in.change_low;
3518 }
3519
3520 /* just ignore the spoolss_NotifyOption */
3521
3522 switch (Printer->printer_type) {
3523 case SPLHND_SERVER:
3524 result = printserver_notify_info(p, r->in.handle,
3525 info, p->mem_ctx);
3526 break;
3527
3528 case SPLHND_PRINTER:
3529 result = printer_notify_info(p, r->in.handle,
3530 info, p->mem_ctx);
3531 break;
3532 }
3533
3534 Printer->notify.fnpcn = false;
3535
3536 done:
3537 return result;
3538 }
3539
3540 /********************************************************************
3541 * construct_printer_info_0
3542 * fill a printer_info_0 struct
3543 ********************************************************************/
3544
3545 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3546 const NT_PRINTER_INFO_LEVEL *ntprinter,
3547 struct spoolss_PrinterInfo0 *r,
3548 int snum)
3549 {
3550 int count;
3551 counter_printer_0 *session_counter;
3552 time_t setuptime;
3553 print_status_struct status;
3554
3555 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3556 W_ERROR_HAVE_NO_MEMORY(r->printername);
3557
3558 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3559 W_ERROR_HAVE_NO_MEMORY(r->servername);
3560
3561 count = print_queue_length(snum, &status);
3562
3563 /* check if we already have a counter for this printer */
3564 for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3565 if (session_counter->snum == snum)
3566 break;
3567 }
3568
3569 /* it's the first time, add it to the list */
3570 if (session_counter == NULL) {
3571 session_counter = SMB_MALLOC_P(counter_printer_0);
3572 W_ERROR_HAVE_NO_MEMORY(session_counter);
3573 ZERO_STRUCTP(session_counter);
3574 session_counter->snum = snum;
3575 session_counter->counter = 0;
3576 DLIST_ADD(counter_list, session_counter);
3577 }
3578
3579 /* increment it */
3580 session_counter->counter++;
3581
3582 r->cjobs = count;
3583 r->total_jobs = 0;
3584 r->total_bytes = 0;
3585
3586 setuptime = (time_t)ntprinter->info_2->setuptime;
3587
3588 init_systemtime(&r->time, gmtime(&setuptime));
3589
3590 /* JFM:
3591 * the global_counter should be stored in a TDB as it's common to all the clients
3592 * and should be zeroed on samba startup
3593 */
3594 r->global_counter = session_counter->counter;
3595 r->total_pages = 0;
3596 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3597 SSVAL(&r->version, 0, 0x0005); /* NT 5 */
3598 SSVAL(&r->version, 2, 0x0893); /* build 2195 */
3599 r->free_build = SPOOLSS_RELEASE_BUILD;
3600 r->spooling = 0;
3601 r->max_spooling = 0;
3602 r->session_counter = session_counter->counter;
3603 r->num_error_out_of_paper = 0x0;
3604 r->num_error_not_ready = 0x0; /* number of print failure */
3605 r->job_error = 0x0;
3606 r->number_of_processors = 0x1;
3607 r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3608 r->high_part_total_bytes = 0x0;
3609 r->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3610 r->last_error = WERR_OK;
3611 r->status = nt_printq_status(status.status);
3612 r->enumerate_network_printers = 0x0;
3613 r->c_setprinter = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3614 r->processor_architecture = 0x0;
3615 r->processor_level = 0x6; /* 6 ???*/
3616 r->ref_ic = 0;
3617 r->reserved2 = 0;
3618 r->reserved3 = 0;
3619
3620 return WERR_OK;
3621 }
3622
3623 /****************************************************************************
3624 Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure. Both pointers
3625 should be valid upon entry
3626 ****************************************************************************/
3627
3628 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3629 struct spoolss_DeviceMode *r,
3630 const NT_DEVICEMODE *ntdevmode)
3631 {
3632 if (!r || !ntdevmode) {
3633 return WERR_INVALID_PARAM;
3634 }
3635
3636 r->devicename = talloc_strdup(mem_ctx, ntdevmode->devicename);
3637 W_ERROR_HAVE_NO_MEMORY(r->devicename);
3638
3639 r->specversion = ntdevmode->specversion;
3640 r->driverversion = ntdevmode->driverversion;
3641 r->size = ntdevmode->size;
3642 r->__driverextra_length = ntdevmode->driverextra;
3643 r->fields = ntdevmode->fields;
3644
3645 r->orientation = ntdevmode->orientation;
3646 r->papersize = ntdevmode->papersize;
3647 r->paperlength = ntdevmode->paperlength;
3648 r->paperwidth = ntdevmode->paperwidth;
3649 r->scale = ntdevmode->scale;
3650 r->copies = ntdevmode->copies;
3651 r->defaultsource = ntdevmode->defaultsource;
3652 r->printquality = ntdevmode->printquality;
3653 r->color = ntdevmode->color;
3654 r->duplex = ntdevmode->duplex;
3655 r->yresolution = ntdevmode->yresolution;
3656 r->ttoption = ntdevmode->ttoption;
3657 r->collate = ntdevmode->collate;
3658
3659 r->formname = talloc_strdup(mem_ctx, ntdevmode->formname);
3660 W_ERROR_HAVE_NO_MEMORY(r->formname);
3661
3662 r->logpixels = ntdevmode->logpixels;
3663 r->bitsperpel = ntdevmode->bitsperpel;
3664 r->pelswidth = ntdevmode->pelswidth;
3665 r->pelsheight = ntdevmode->pelsheight;
3666 r->displayflags = ntdevmode->displayflags;
3667 r->displayfrequency = ntdevmode->displayfrequency;
3668 r->icmmethod = ntdevmode->icmmethod;
3669 r->icmintent = ntdevmode->icmintent;
3670 r->mediatype = ntdevmode->mediatype;
3671 r->dithertype = ntdevmode->dithertype;
3672 r->reserved1 = ntdevmode->reserved1;
3673 r->reserved2 = ntdevmode->reserved2;
3674 r->panningwidth = ntdevmode->panningwidth;
3675 r->panningheight = ntdevmode->panningheight;
3676
3677 if (ntdevmode->nt_dev_private != NULL) {
3678 r->driverextra_data = data_blob_talloc(mem_ctx,
3679 ntdevmode->nt_dev_private,
3680 ntdevmode->driverextra);
3681 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3682 }
3683
3684 return WERR_OK;
3685 }
3686
3687
3688 /****************************************************************************
3689 Create a spoolss_DeviceMode struct. Returns talloced memory.
3690 ****************************************************************************/
3691
3692 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3693 const char *servicename)
3694 {
3695 WERROR result;
3696 NT_PRINTER_INFO_LEVEL *printer = NULL;
3697 struct spoolss_DeviceMode *devmode = NULL;
3698
3699 DEBUG(7,("construct_dev_mode\n"));
3700
3701 DEBUGADD(8,("getting printer characteristics\n"));
3702
3703 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3704 return NULL;
3705
3706 if (!printer->info_2->devmode) {
3707 DEBUG(5, ("BONG! There was no device mode!\n"));
3708 goto done;
3709 }
3710
3711 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3712 if (!devmode) {
3713 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3714 goto done;
3715 }
3716
3717 DEBUGADD(8,("loading DEVICEMODE\n"));
3718
3719 result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3720 if (!W_ERROR_IS_OK(result)) {
3721 TALLOC_FREE(devmode);
3722 }
3723
3724 done:
3725 free_a_printer(&printer,2);
3726
3727 return devmode;
3728 }
3729
3730 /********************************************************************
3731 * construct_printer_info1
3732 * fill a spoolss_PrinterInfo1 struct
3733 ********************************************************************/
3734
3735 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3736 const NT_PRINTER_INFO_LEVEL *ntprinter,
3737 uint32_t flags,
3738 struct spoolss_PrinterInfo1 *r,
3739 int snum)
3740 {
3741 r->flags = flags;
3742
3743 r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
3744 ntprinter->info_2->printername,
3745 ntprinter->info_2->drivername,
3746 ntprinter->info_2->location);
3747 W_ERROR_HAVE_NO_MEMORY(r->description);
3748
3749 if (*ntprinter->info_2->comment == '\0') {
3750 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
3751 } else {
3752 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
3753 }
3754 W_ERROR_HAVE_NO_MEMORY(r->comment);
3755
3756 r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3757 W_ERROR_HAVE_NO_MEMORY(r->name);
3758
3759 return WERR_OK;
3760 }
3761
3762 /********************************************************************
3763 * construct_printer_info2
3764 * fill a spoolss_PrinterInfo2 struct
3765 ********************************************************************/
3766
3767 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3768 const NT_PRINTER_INFO_LEVEL *ntprinter,
3769 struct spoolss_PrinterInfo2 *r,
3770 int snum)
3771 {
3772 int count;
3773
3774 print_status_struct status;
3775
3776 count = print_queue_length(snum, &status);
3777
3778 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3779 W_ERROR_HAVE_NO_MEMORY(r->servername);
3780 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3781 W_ERROR_HAVE_NO_MEMORY(r->printername);
3782 r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
3783 W_ERROR_HAVE_NO_MEMORY(r->sharename);
3784 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
3785 W_ERROR_HAVE_NO_MEMORY(r->portname);
3786 r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
3787 W_ERROR_HAVE_NO_MEMORY(r->drivername);
3788
3789 if (*ntprinter->info_2->comment == '\0') {
3790 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
3791 } else {
3792 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
3793 }
3794 W_ERROR_HAVE_NO_MEMORY(r->comment);
3795
3796 r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
3797 W_ERROR_HAVE_NO_MEMORY(r->location);
3798 r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
3799 W_ERROR_HAVE_NO_MEMORY(r->sepfile);
3800 r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
3801 W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
3802 r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
3803 W_ERROR_HAVE_NO_MEMORY(r->datatype);
3804 r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
3805 W_ERROR_HAVE_NO_MEMORY(r->parameters);
3806
3807 r->attributes = ntprinter->info_2->attributes;
3808
3809 r->priority = ntprinter->info_2->priority;
3810 r->defaultpriority = ntprinter->info_2->default_priority;
3811 r->starttime = ntprinter->info_2->starttime;
3812 r->untiltime = ntprinter->info_2->untiltime;
3813 r->status = nt_printq_status(status.status);
3814 r->cjobs = count;
3815 r->averageppm = ntprinter->info_2->averageppm;
3816
3817 r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
3818 if (!r->devmode) {
3819 DEBUG(8,("Returning NULL Devicemode!\n"));
3820 }
3821
3822 r->secdesc = NULL;
3823
3824 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3825 /* don't use talloc_steal() here unless you do a deep steal of all
3826 the SEC_DESC members */
3827
3828 r->secdesc = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
3829 }
3830
3831 return WERR_OK;
3832 }
3833
3834 /********************************************************************
3835 * construct_printer_info3
3836 * fill a spoolss_PrinterInfo3 struct
3837 ********************************************************************/
3838
3839 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3840 const NT_PRINTER_INFO_LEVEL *ntprinter,
3841 struct spoolss_PrinterInfo3 *r,
3842 int snum)
3843 {
3844 /* These are the components of the SD we are returning. */
3845
3846 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3847 /* don't use talloc_steal() here unless you do a deep steal of all
3848 the SEC_DESC members */
3849
3850 r->secdesc = dup_sec_desc(mem_ctx,
3851 ntprinter->info_2->secdesc_buf->sd);
3852 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3853 }
3854
3855 return WERR_OK;
3856 }
3857
3858 /********************************************************************
3859 * construct_printer_info4
3860 * fill a spoolss_PrinterInfo4 struct
3861 ********************************************************************/
3862
3863 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
3864 const NT_PRINTER_INFO_LEVEL *ntprinter,
3865 struct spoolss_PrinterInfo4 *r,
3866 int snum)
3867 {
3868 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3869 W_ERROR_HAVE_NO_MEMORY(r->printername);
3870 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3871 W_ERROR_HAVE_NO_MEMORY(r->servername);
3872
3873 r->attributes = ntprinter->info_2->attributes;
3874
3875 return WERR_OK;
3876 }
3877
3878 /********************************************************************
3879 * construct_printer_info5
3880 * fill a spoolss_PrinterInfo5 struct
3881 ********************************************************************/
3882
3883 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
3884 const NT_PRINTER_INFO_LEVEL *ntprinter,
3885 struct spoolss_PrinterInfo5 *r,
3886 int snum)
3887 {
3888 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3889 W_ERROR_HAVE_NO_MEMORY(r->printername);
3890 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
3891 W_ERROR_HAVE_NO_MEMORY(r->portname);
3892
3893 r->attributes = ntprinter->info_2->attributes;
3894
3895 /* these two are not used by NT+ according to MSDN */
3896
3897 r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
3898 r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
3899
3900 return WERR_OK;
3901 }
3902
3903 /********************************************************************
3904 * construct_printer_info_6
3905 * fill a spoolss_PrinterInfo6 struct
3906 ********************************************************************/
3907
3908 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
3909 const NT_PRINTER_INFO_LEVEL *ntprinter,
3910 struct spoolss_PrinterInfo6 *r,
3911 int snum)
3912 {
3913 int count;
3914 print_status_struct status;
3915
3916 count = print_queue_length(snum, &status);
3917
3918 r->status = nt_printq_status(status.status);
3919
3920 return WERR_OK;
3921 }
3922
3923 /********************************************************************
3924 * construct_printer_info7
3925 * fill a spoolss_PrinterInfo7 struct
3926 ********************************************************************/
3927
3928 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
3929 Printer_entry *print_hnd,
3930 struct spoolss_PrinterInfo7 *r,
3931 int snum)
3932 {
3933 struct GUID guid;
3934
3935 if (is_printer_published(print_hnd, snum, &guid)) {
3936 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
3937 r->action = DSPRINT_PUBLISH;
3938 } else {
3939 r->guid = talloc_strdup(mem_ctx, "");
3940 r->action = DSPRINT_UNPUBLISH;
3941 }
3942 W_ERROR_HAVE_NO_MEMORY(r->guid);
3943
3944 return WERR_OK;
3945 }
3946
3947 /********************************************************************
3948 * construct_printer_info8
3949 * fill a spoolss_PrinterInfo8 struct
3950 ********************************************************************/
3951
3952 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
3953 const NT_PRINTER_INFO_LEVEL *ntprinter,
3954 struct spoolss_DeviceModeInfo *r,
3955 int snum)
3956 {
3957 r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
3958 if (!r->devmode) {
3959 DEBUG(8,("Returning NULL Devicemode!\n"));
3960 }
3961
3962 return WERR_OK;
3963 }
3964
3965
3966 /********************************************************************
3967 ********************************************************************/
3968
3969 static bool snum_is_shared_printer(int snum)
3970 {
3971 return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
3972 }
3973
3974 /********************************************************************
3975 Spoolss_enumprinters.
3976 ********************************************************************/
3977
3978 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
3979 uint32_t level,
3980 uint32_t flags,
3981 union spoolss_PrinterInfo **info_p,
3982 uint32_t *count_p)
3983 {
3984 int snum;
3985 int n_services = lp_numservices();
3986 union spoolss_PrinterInfo *info = NULL;
3987 uint32_t count = 0;
3988 WERROR result = WERR_OK;
3989
3990 *count_p = 0;
3991 *info_p = NULL;
3992
3993 for (snum = 0; snum < n_services; snum++) {
3994
3995 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
3996
3997 if (!snum_is_shared_printer(snum)) {
3998 continue;
3999 }
4000
4001 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4002 lp_servicename(snum), snum));
4003
4004 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4005 union spoolss_PrinterInfo,
4006 count + 1);
4007 if (!info) {
4008 result = WERR_NOMEM;
4009 goto out;
4010 }
4011
4012 result = get_a_printer(NULL, &ntprinter, 2,
4013 lp_const_servicename(snum));
4014 if (!W_ERROR_IS_OK(result)) {
4015 goto out;
4016 }
4017
4018 switch (level) {
4019 case 0:
4020 result = construct_printer_info0(info, ntprinter,
4021 &info[count].info0, snum);
4022 break;
4023 case 1:
4024 result = construct_printer_info1(info, ntprinter, flags,
4025 &info[count].info1, snum);
4026 break;
4027 case 2:
4028 result = construct_printer_info2(info, ntprinter,
4029 &info[count].info2, snum);
4030 break;
4031 case 4:
4032 result = construct_printer_info4(info, ntprinter,
4033 &info[count].info4, snum);
4034 break;
4035 case 5:
4036 result = construct_printer_info5(info, ntprinter,
4037 &info[count].info5, snum);
4038 break;
4039
4040 default:
4041 result = WERR_UNKNOWN_LEVEL;
4042 free_a_printer(&ntprinter, 2);
4043 goto out;
4044 }
4045
4046 free_a_printer(&ntprinter, 2);
4047 if (!W_ERROR_IS_OK(result)) {
4048 goto out;
4049 }
4050
4051 count++;
4052 }
4053
4054 *count_p = count;
4055 *info_p = info;
4056
4057 out:
4058 if (!W_ERROR_IS_OK(result)) {
4059 TALLOC_FREE(info);
4060 return result;
4061 }
4062
4063 *info_p = info;
4064
4065 return WERR_OK;
4066 }
4067
4068 /********************************************************************
4069 * handle enumeration of printers at level 0
4070 ********************************************************************/
4071
4072 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4073 uint32_t flags,
4074 const char *servername,
4075 union spoolss_PrinterInfo **info,
4076 uint32_t *count)
4077 {
4078 DEBUG(4,("enum_all_printers_info_0\n"));
4079
4080 return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4081 }
4082
4083
4084 /********************************************************************
4085 ********************************************************************/
4086
4087 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4088 uint32_t flags,
4089 union spoolss_PrinterInfo **info,
4090 uint32_t *count)
4091 {
4092 DEBUG(4,("enum_all_printers_info_1\n"));
4093
4094 return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4095 }
4096
4097 /********************************************************************
4098 enum_all_printers_info_1_local.
4099 *********************************************************************/
4100
4101 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4102 union spoolss_PrinterInfo **info,
4103 uint32_t *count)
4104 {
4105 DEBUG(4,("enum_all_printers_info_1_local\n"));
4106
4107 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4108 }
4109
4110 /********************************************************************
4111 enum_all_printers_info_1_name.
4112 *********************************************************************/
4113
4114 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4115 const char *name,
4116 union spoolss_PrinterInfo **info,
4117 uint32_t *count)
4118 {
4119 const char *s = name;
4120
4121 DEBUG(4,("enum_all_printers_info_1_name\n"));
4122
4123 if ((name[0] == '\\') && (name[1] == '\\')) {
4124 s = name + 2;
4125 }
4126
4127 if (!is_myname_or_ipaddr(s)) {
4128 return WERR_INVALID_NAME;
4129 }
4130
4131 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4132 }
4133
4134 /********************************************************************
4135 enum_all_printers_info_1_network.
4136 *********************************************************************/
4137
4138 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4139 const char *name,
4140 union spoolss_PrinterInfo **info,
4141 uint32_t *count)
4142 {
4143 const char *s = name;
4144
4145 DEBUG(4,("enum_all_printers_info_1_network\n"));
4146
4147 /* If we respond to a enum_printers level 1 on our name with flags
4148 set to PRINTER_ENUM_REMOTE with a list of printers then these
4149 printers incorrectly appear in the APW browse list.
4150 Specifically the printers for the server appear at the workgroup
4151 level where all the other servers in the domain are
4152 listed. Windows responds to this call with a
4153 WERR_CAN_NOT_COMPLETE so we should do the same. */
4154
4155 if (name[0] == '\\' && name[1] == '\\') {
4156 s = name + 2;
4157 }
4158
4159 if (is_myname_or_ipaddr(s)) {
4160 return WERR_CAN_NOT_COMPLETE;
4161 }
4162
4163 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4164 }
4165
4166 /********************************************************************
4167 * api_spoolss_enumprinters
4168 *
4169 * called from api_spoolss_enumprinters (see this to understand)
4170 ********************************************************************/
4171
4172 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4173 union spoolss_PrinterInfo **info,
4174 uint32_t *count)
4175 {
4176 DEBUG(4,("enum_all_printers_info_2\n"));
4177
4178 return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4179 }
4180
4181 /********************************************************************
4182 * handle enumeration of printers at level 1
4183 ********************************************************************/
4184
4185 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4186 uint32_t flags,
4187 const char *name,
4188 union spoolss_PrinterInfo **info,
4189 uint32_t *count)
4190 {
4191 /* Not all the flags are equals */
4192
4193 if (flags & PRINTER_ENUM_LOCAL) {
4194 return enum_all_printers_info_1_local(mem_ctx, info, count);
4195 }
4196
4197 if (flags & PRINTER_ENUM_NAME) {
4198 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4199 }
4200
4201 if (flags & PRINTER_ENUM_NETWORK) {
4202 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4203 }
4204
4205 return WERR_OK; /* NT4sp5 does that */
4206 }
4207
4208 /********************************************************************
4209 * handle enumeration of printers at level 2
4210 ********************************************************************/
4211
4212 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4213 uint32_t flags,
4214 const char *servername,
4215 union spoolss_PrinterInfo **info,
4216 uint32_t *count)
4217 {
4218 if (flags & PRINTER_ENUM_LOCAL) {
4219 return enum_all_printers_info_2(mem_ctx, info, count);
4220 }
4221
4222 if (flags & PRINTER_ENUM_NAME) {
4223 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4224 return WERR_INVALID_NAME;
4225 }
4226
4227 return enum_all_printers_info_2(mem_ctx, info, count);
4228 }
4229
4230 if (flags & PRINTER_ENUM_REMOTE) {
4231 return WERR_UNKNOWN_LEVEL;
4232 }
4233
4234 return WERR_OK;
4235 }
4236
4237 /********************************************************************
4238 * handle enumeration of printers at level 4
4239 ********************************************************************/
4240
4241 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4242 uint32_t flags,
4243 const char *servername,
4244 union spoolss_PrinterInfo **info,
4245 uint32_t *count)
4246 {
4247 DEBUG(4,("enum_all_printers_info_4\n"));
4248
4249 return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4250 }
4251
4252
4253 /********************************************************************
4254 * handle enumeration of printers at level 5
4255 ********************************************************************/
4256
4257 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4258 uint32_t flags,
4259 const char *servername,
4260 union spoolss_PrinterInfo **info,
4261 uint32_t *count)
4262 {
4263 DEBUG(4,("enum_all_printers_info_5\n"));
4264
4265 return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4266 }
4267
4268 /****************************************************************
4269 _spoolss_EnumPrinters
4270 ****************************************************************/
4271
4272 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4273 struct spoolss_EnumPrinters *r)
4274 {
4275 const char *name = NULL;
4276 WERROR result;
4277
4278 /* that's an [in out] buffer */
4279
4280 if (!r->in.buffer && (r->in.offered != 0)) {
4281 return WERR_INVALID_PARAM;
4282 }
4283
4284 DEBUG(4,("_spoolss_EnumPrinters\n"));
4285
4286 *r->out.needed = 0;
4287 *r->out.count = 0;
4288 *r->out.info = NULL;
4289
4290 /*
4291 * Level 1:
4292 * flags==PRINTER_ENUM_NAME
4293 * if name=="" then enumerates all printers
4294 * if name!="" then enumerate the printer
4295 * flags==PRINTER_ENUM_REMOTE
4296 * name is NULL, enumerate printers
4297 * Level 2: name!="" enumerates printers, name can't be NULL
4298 * Level 3: doesn't exist
4299 * Level 4: does a local registry lookup
4300 * Level 5: same as Level 2
4301 */
4302
4303 if (r->in.server) {
4304 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4305 W_ERROR_HAVE_NO_MEMORY(name);
4306 }
4307
4308 switch (r->in.level) {
4309 case 0:
4310 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4311 r->out.info, r->out.count);
4312 break;
4313 case 1:
4314 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4315 r->out.info, r->out.count);
4316 break;
4317 case 2:
4318 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4319 r->out.info, r->out.count);
4320 break;
4321 case 4:
4322 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4323 r->out.info, r->out.count);
4324 break;
4325 case 5:
4326 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4327 r->out.info, r->out.count);
4328 break;
4329 default:
4330 return WERR_UNKNOWN_LEVEL;
4331 }
4332
4333 if (!W_ERROR_IS_OK(result)) {
4334 return result;
4335 }
4336
4337 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4338 spoolss_EnumPrinters, NULL,
4339 *r->out.info, r->in.level,
4340 *r->out.count);
4341 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4342 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4343
4344 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4345 }
4346
4347 /****************************************************************
4348 _spoolss_GetPrinter
4349 ****************************************************************/
4350
4351 WERROR _spoolss_GetPrinter(pipes_struct *p,
4352 struct spoolss_GetPrinter *r)
4353 {
4354 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4355 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4356 WERROR result = WERR_OK;
4357
4358 int snum;
4359
4360 /* that's an [in out] buffer */
4361
4362 if (!r->in.buffer && (r->in.offered != 0)) {
4363 return WERR_INVALID_PARAM;
4364 }
4365
4366 *r->out.needed = 0;
4367
4368 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4369 return WERR_BADFID;
4370 }
4371
4372 result = get_a_printer(Printer, &ntprinter, 2,
4373 lp_const_servicename(snum));
4374 if (!W_ERROR_IS_OK(result)) {
4375 return result;
4376 }
4377
4378 switch (r->in.level) {
4379 case 0:
4380 result = construct_printer_info0(p->mem_ctx, ntprinter,
4381 &r->out.info->info0, snum);
4382 break;
4383 case 1:
4384 result = construct_printer_info1(p->mem_ctx, ntprinter,
4385 PRINTER_ENUM_ICON8,
4386 &r->out.info->info1, snum);
4387 break;
4388 case 2:
4389 result = construct_printer_info2(p->mem_ctx, ntprinter,
4390 &r->out.info->info2, snum);
4391 break;
4392 case 3:
4393 result = construct_printer_info3(p->mem_ctx, ntprinter,
4394 &r->out.info->info3, snum);
4395 break;
4396 case 4:
4397 result = construct_printer_info4(p->mem_ctx, ntprinter,
4398 &r->out.info->info4, snum);
4399 break;
4400 case 5:
4401 result = construct_printer_info5(p->mem_ctx, ntprinter,
4402 &r->out.info->info5, snum);
4403 break;
4404 case 6:
4405 result = construct_printer_info6(p->mem_ctx, ntprinter,
4406 &r->out.info->info6, snum);
4407 break;
4408 case 7:
4409 result = construct_printer_info7(p->mem_ctx, Printer,
4410 &r->out.info->info7, snum);
4411 break;
4412 case 8:
4413 result = construct_printer_info8(p->mem_ctx, ntprinter,
4414 &r->out.info->info8, snum);
4415 break;
4416 default:
4417 result = WERR_UNKNOWN_LEVEL;
4418 break;
4419 }
4420
4421 free_a_printer(&ntprinter, 2);
4422
4423 if (!W_ERROR_IS_OK(result)) {
4424 TALLOC_FREE(r->out.info);
4425 return result;
4426 }
4427
4428 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4429 r->out.info, r->in.level);
4430 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4431
4432 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4433 }
4434
4435 /********************************************************************
4436 ********************************************************************/
4437
4438 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4439 const char **string_array,
4440 const char *cservername)
4441 {
4442 int i, num_strings = 0;
4443 const char **array = NULL;
4444
4445 if (!string_array) {
4446 return NULL;
4447 }
4448
4449 for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4450
4451 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4452 cservername, string_array[i]);
4453 if (!str) {
4454 TALLOC_FREE(array);
4455 return NULL;
4456 }
4457
4458
4459 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4460 TALLOC_FREE(array);
4461 return NULL;
4462 }
4463 }
4464
4465 if (i > 0) {
4466 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4467 &array, &num_strings);
4468 }
4469
4470 return array;
4471 }
4472
4473 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4474 do { \
4475 if (in && strlen(in)) { \
4476 out = talloc_strdup(mem_ctx, in); \
4477 W_ERROR_HAVE_NO_MEMORY(out); \
4478 } else { \
4479 out = NULL; \
4480 } \
4481 } while (0);
4482
4483 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, in, out) \
4484 do { \
4485 if (in && strlen(in)) { \
4486 out = talloc_asprintf(mem_ctx, "\\\\%s%s", server, in); \
4487 } else { \
4488 out = talloc_strdup(mem_ctx, ""); \
4489 } \
4490 W_ERROR_HAVE_NO_MEMORY(out); \
4491 } while (0);
4492
4493 /********************************************************************
4494 * fill a spoolss_DriverInfo1 struct
4495 ********************************************************************/
4496
4497 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4498 struct spoolss_DriverInfo1 *r,
4499 const struct spoolss_DriverInfo8 *driver,
4500 const char *servername)
4501 {
4502 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4503 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4504
4505 return WERR_OK;
4506 }
4507
4508 /********************************************************************
4509 * fill a spoolss_DriverInfo2 struct
4510 ********************************************************************/
4511
4512 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4513 struct spoolss_DriverInfo2 *r,
4514 const struct spoolss_DriverInfo8 *driver,
4515 const char *servername)
4516
4517 {
4518 const char *cservername = canon_servername(servername);
4519
4520 r->version = driver->version;
4521
4522 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4523 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4524 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4525 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4526
4527 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4528 driver->driver_path,
4529 r->driver_path);
4530
4531 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4532 driver->data_file,
4533 r->data_file);
4534
4535 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4536 driver->config_file,
4537 r->config_file);
4538
4539 return WERR_OK;
4540 }
4541
4542 /********************************************************************
4543 * fill a spoolss_DriverInfo3 struct
4544 ********************************************************************/
4545
4546 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4547 struct spoolss_DriverInfo3 *r,
4548 const struct spoolss_DriverInfo8 *driver,
4549 const char *servername)
4550 {
4551 const char *cservername = canon_servername(servername);
4552
4553 r->version = driver->version;
4554
4555 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4556 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4557 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4558 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4559
4560 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4561 driver->driver_path,
4562 r->driver_path);
4563
4564 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4565 driver->data_file,
4566 r->data_file);
4567
4568 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4569 driver->config_file,
4570 r->config_file);
4571
4572 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4573 driver->help_file,
4574 r->help_file);
4575
4576 FILL_DRIVER_STRING(mem_ctx,
4577 driver->monitor_name,
4578 r->monitor_name);
4579
4580 FILL_DRIVER_STRING(mem_ctx,
4581 driver->default_datatype,
4582 r->default_datatype);
4583
4584 r->dependent_files = string_array_from_driver_info(mem_ctx,
4585 driver->dependent_files,
4586 cservername);
4587 return WERR_OK;
4588 }
4589
4590 /********************************************************************
4591 * fill a spoolss_DriverInfo4 struct
4592 ********************************************************************/
4593
4594 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4595 struct spoolss_DriverInfo4 *r,
4596 const struct spoolss_DriverInfo8 *driver,
4597 const char *servername)
4598 {
4599 const char *cservername = canon_servername(servername);
4600
4601 r->version = driver->version;
4602
4603 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4604 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4605 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4606 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4607
4608 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4609 driver->driver_path,
4610 r->driver_path);
4611
4612 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4613 driver->data_file,
4614 r->data_file);
4615
4616 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4617 driver->config_file,
4618 r->config_file);
4619
4620 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4621 driver->help_file,
4622 r->help_file);
4623
4624 r->dependent_files = string_array_from_driver_info(mem_ctx,
4625 driver->dependent_files,
4626 cservername);
4627
4628 FILL_DRIVER_STRING(mem_ctx,
4629 driver->monitor_name,
4630 r->monitor_name);
4631
4632 FILL_DRIVER_STRING(mem_ctx,
4633 driver->default_datatype,
4634 r->default_datatype);
4635
4636 r->previous_names = string_array_from_driver_info(mem_ctx,
4637 driver->previous_names,
4638 cservername);
4639
4640 return WERR_OK;
4641 }
4642
4643 /********************************************************************
4644 * fill a spoolss_DriverInfo5 struct
4645 ********************************************************************/
4646
4647 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4648 struct spoolss_DriverInfo5 *r,
4649 const struct spoolss_DriverInfo8 *driver,
4650 const char *servername)
4651 {
4652 const char *cservername = canon_servername(servername);
4653
4654 r->version = driver->version;
4655
4656 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4657 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4658 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4659 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4660
4661 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4662 driver->driver_path,
4663 r->driver_path);
4664
4665 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4666 driver->data_file,
4667 r->data_file);
4668
4669 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4670 driver->config_file,
4671 r->config_file);
4672
4673 r->driver_attributes = 0;
4674 r->config_version = 0;
4675 r->driver_version = 0;
4676
4677 return WERR_OK;
4678 }
4679 /********************************************************************
4680 * fill a spoolss_DriverInfo6 struct
4681 ********************************************************************/
4682
4683 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4684 struct spoolss_DriverInfo6 *r,
4685 const struct spoolss_DriverInfo8 *driver,
4686 const char *servername)
4687 {
4688 const char *cservername = canon_servername(servername);
4689
4690 r->version = driver->version;
4691
4692 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4693 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4694 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4695 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4696
4697 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4698 driver->driver_path,
4699 r->driver_path);
4700
4701 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4702 driver->data_file,
4703 r->data_file);
4704
4705 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4706 driver->config_file,
4707 r->config_file);
4708
4709 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4710 driver->help_file,
4711 r->help_file);
4712
4713 FILL_DRIVER_STRING(mem_ctx,
4714 driver->monitor_name,
4715 r->monitor_name);
4716
4717 FILL_DRIVER_STRING(mem_ctx,
4718 driver->default_datatype,
4719 r->default_datatype);
4720
4721 r->dependent_files = string_array_from_driver_info(mem_ctx,
4722 driver->dependent_files,
4723 cservername);
4724 r->previous_names = string_array_from_driver_info(mem_ctx,
4725 driver->previous_names,
4726 cservername);
4727
4728 r->driver_date = driver->driver_date;
4729 r->driver_version = driver->driver_version;
4730
4731 FILL_DRIVER_STRING(mem_ctx,
4732 driver->manufacturer_name,
4733 r->manufacturer_name);
4734 FILL_DRIVER_STRING(mem_ctx,
4735 driver->manufacturer_url,
4736 r->manufacturer_url);
4737 FILL_DRIVER_STRING(mem_ctx,
4738 driver->hardware_id,
4739 r->hardware_id);
4740 FILL_DRIVER_STRING(mem_ctx,
4741 driver->provider,
4742 r->provider);
4743
4744 return WERR_OK;
4745 }
4746
4747 /********************************************************************
4748 * fill a spoolss_DriverInfo8 struct
4749 ********************************************************************/
4750
4751 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
4752 struct spoolss_DriverInfo8 *r,
4753 const struct spoolss_DriverInfo8 *driver,
4754 const char *servername)
4755 {
4756 const char *cservername = canon_servername(servername);
4757
4758 r->version = driver->version;
4759
4760 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4761 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4762 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4763 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4764
4765 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4766 driver->driver_path,
4767 r->driver_path);
4768
4769 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4770 driver->data_file,
4771 r->data_file);
4772
4773 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4774 driver->config_file,
4775 r->config_file);
4776
4777 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4778 driver->help_file,
4779 r->help_file);
4780
4781 FILL_DRIVER_STRING(mem_ctx,
4782 driver->monitor_name,
4783 r->monitor_name);
4784
4785 FILL_DRIVER_STRING(mem_ctx,
4786 driver->default_datatype,
4787 r->default_datatype);
4788
4789 r->dependent_files = string_array_from_driver_info(mem_ctx,
4790 driver->dependent_files,
4791 cservername);
4792 r->previous_names = string_array_from_driver_info(mem_ctx,
4793 driver->previous_names,
4794 cservername);
4795
4796 r->driver_date = driver->driver_date;
4797 r->driver_version = driver->driver_version;
4798
4799 FILL_DRIVER_STRING(mem_ctx,
4800 driver->manufacturer_name,
4801 r->manufacturer_name);
4802 FILL_DRIVER_STRING(mem_ctx,
4803 driver->manufacturer_url,
4804 r->manufacturer_url);
4805 FILL_DRIVER_STRING(mem_ctx,
4806 driver->hardware_id,
4807 r->hardware_id);
4808 FILL_DRIVER_STRING(mem_ctx,
4809 driver->provider,
4810 r->provider);
4811
4812 FILL_DRIVER_STRING(mem_ctx,
4813 driver->print_processor,
4814 r->print_processor);
4815 FILL_DRIVER_STRING(mem_ctx,
4816 driver->vendor_setup,
4817 r->vendor_setup);
4818
4819 r->color_profiles = string_array_from_driver_info(mem_ctx,
4820 driver->color_profiles,
4821 cservername);
4822
4823 FILL_DRIVER_STRING(mem_ctx,
4824 driver->inf_path,
4825 r->inf_path);
4826
4827 r->printer_driver_attributes = driver->printer_driver_attributes;
4828
4829 r->core_driver_dependencies = string_array_from_driver_info(mem_ctx,
4830 driver->core_driver_dependencies,
4831 cservername);
4832
4833 r->min_inbox_driver_ver_date = driver->min_inbox_driver_ver_date;
4834 r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
4835
4836 return WERR_OK;
4837 }
4838
4839 #if 0 /* disabled until marshalling issues are resolved - gd */
4840 /********************************************************************
4841 ********************************************************************/
4842
4843 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
4844 struct spoolss_DriverFileInfo *r,
4845 const char *cservername,
4846 const char *file_name,
4847 enum spoolss_DriverFileType file_type,
4848 uint32_t file_version)
4849 {
4850 r->file_name = talloc_asprintf(mem_ctx, "\\\\%s%s",
4851 cservername, file_name);
4852 W_ERROR_HAVE_NO_MEMORY(r->file_name);
4853 r->file_type = file_type;
4854 r->file_version = file_version;
4855
4856 return WERR_OK;
4857 }
4858
4859 /********************************************************************
4860 ********************************************************************/
4861
4862 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
4863 const struct spoolss_DriverInfo8 *driver,
4864 const char *cservername,
4865 struct spoolss_DriverFileInfo **info_p,
4866 uint32_t *count_p)
4867 {
4868 struct spoolss_DriverFileInfo *info = NULL;
4869 uint32_t count = 0;
4870 WERROR result;
4871 uint32_t i;
4872
4873 *info_p = NULL;
4874 *count_p = 0;
4875
4876 if (strlen(driver->driver_path)) {
4877 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4878 struct spoolss_DriverFileInfo,
4879 count + 1);
4880 W_ERROR_HAVE_NO_MEMORY(info);
4881 result = fill_spoolss_DriverFileInfo(info,
4882 &info[count],
4883 cservername,
4884 driver->driver_path,
4885 SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
4886 0);
4887 W_ERROR_NOT_OK_RETURN(result);
4888 count++;
4889 }
4890
4891 if (strlen(driver->config_file)) {
4892 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4893 struct spoolss_DriverFileInfo,
4894 count + 1);
4895 W_ERROR_HAVE_NO_MEMORY(info);
4896 result = fill_spoolss_DriverFileInfo(info,
4897 &info[count],
4898 cservername,
4899 driver->config_file,
4900 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
4901 0);
4902 W_ERROR_NOT_OK_RETURN(result);
4903 count++;
4904 }
4905
4906 if (strlen(driver->data_file)) {
4907 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4908 struct spoolss_DriverFileInfo,
4909 count + 1);
4910 W_ERROR_HAVE_NO_MEMORY(info);
4911 result = fill_spoolss_DriverFileInfo(info,
4912 &info[count],
4913 cservername,
4914 driver->data_file,
4915 SPOOLSS_DRIVER_FILE_TYPE_DATA,
4916 0);
4917 W_ERROR_NOT_OK_RETURN(result);
4918 count++;
4919 }
4920
4921 if (strlen(driver->help_file)) {
4922 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4923 struct spoolss_DriverFileInfo,
4924 count + 1);
4925 W_ERROR_HAVE_NO_MEMORY(info);
4926 result = fill_spoolss_DriverFileInfo(info,
4927 &info[count],
4928 cservername,
4929 driver->help_file,
4930 SPOOLSS_DRIVER_FILE_TYPE_HELP,
4931 0);
4932 W_ERROR_NOT_OK_RETURN(result);
4933 count++;
4934 }
4935
4936 for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
4937 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4938 struct spoolss_DriverFileInfo,
4939 count + 1);
4940 W_ERROR_HAVE_NO_MEMORY(info);
4941 result = fill_spoolss_DriverFileInfo(info,
4942 &info[count],
4943 cservername,
4944 driver->dependent_files[i],
4945 SPOOLSS_DRIVER_FILE_TYPE_OTHER,
4946 0);
4947 W_ERROR_NOT_OK_RETURN(result);
4948 count++;
4949 }
4950
4951 *info_p = info;
4952 *count_p = count;
4953
4954 return WERR_OK;
4955 }
4956
4957 /********************************************************************
4958 * fill a spoolss_DriverInfo101 struct
4959 ********************************************************************/
4960
4961 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
4962 struct spoolss_DriverInfo101 *r,
4963 const struct spoolss_DriverInfo8 *driver,
4964 const char *servername)
4965 {
4966 const char *cservername = canon_servername(servername);
4967 WERROR result;
4968
4969 r->version = driver->version;
4970
4971 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4972 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4973 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4974 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4975
4976 result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
4977 cservername,
4978 &r->file_info,
4979 &r->file_count);
4980 if (!W_ERROR_IS_OK(result)) {
4981 return result;
4982 }
4983
4984 FILL_DRIVER_STRING(mem_ctx,
4985 driver->monitor_name,
4986 r->monitor_name);
4987
4988 FILL_DRIVER_STRING(mem_ctx,
4989 driver->default_datatype,
4990 r->default_datatype);
4991
4992 r->previous_names = string_array_from_driver_info(mem_ctx,
4993 driver->previous_names,
4994 cservername);
4995 r->driver_date = driver->driver_date;
4996 r->driver_version = driver->driver_version;
4997
4998 FILL_DRIVER_STRING(mem_ctx,
4999 driver->manufacturer_name,
5000 r->manufacturer_name);
5001 FILL_DRIVER_STRING(mem_ctx,
5002 driver->manufacturer_url,
5003 r->manufacturer_url);
5004 FILL_DRIVER_STRING(mem_ctx,
5005 driver->hardware_id,
5006 r->hardware_id);
5007 FILL_DRIVER_STRING(mem_ctx,
5008 driver->provider,
5009 r->provider);
5010
5011 return WERR_OK;
5012 }
5013 #endif
5014 /********************************************************************
5015 ********************************************************************/
5016
5017 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
5018 uint32_t level,
5019 union spoolss_DriverInfo *r,
5020 int snum,
5021 const char *servername,
5022 const char *architecture,
5023 uint32_t version)
5024 {
5025 NT_PRINTER_INFO_LEVEL *printer = NULL;
5026 struct spoolss_DriverInfo8 *driver;
5027 WERROR result;
5028
5029 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5030
5031 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5032 win_errstr(result)));
5033
5034 if (!W_ERROR_IS_OK(result)) {
5035 return WERR_INVALID_PRINTER_NAME;
5036 }
5037
5038 result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
5039 architecture, version);
5040
5041 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5042 win_errstr(result)));
5043
5044 if (!W_ERROR_IS_OK(result)) {
5045 /*
5046 * Is this a W2k client ?
5047 */
5048
5049 if (version < 3) {
5050 free_a_printer(&printer, 2);
5051 return WERR_UNKNOWN_PRINTER_DRIVER;
5052 }
5053
5054 /* Yes - try again with a WinNT driver. */
5055 version = 2;
5056 result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
5057 architecture, version);
5058 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5059 win_errstr(result)));
5060 if (!W_ERROR_IS_OK(result)) {
5061 free_a_printer(&printer, 2);
5062 return WERR_UNKNOWN_PRINTER_DRIVER;
5063 }
5064 }
5065
5066 switch (level) {
5067 case 1:
5068 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5069 break;
5070 case 2:
5071 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5072 break;
5073 case 3:
5074 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5075 break;
5076 case 4:
5077 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5078 break;
5079 case 5:
5080 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5081 break;
5082 case 6:
5083 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5084 break;
5085 case 8:
5086 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5087 break;
5088 #if 0 /* disabled until marshalling issues are resolved - gd */
5089 case 101:
5090 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5091 break;
5092 #endif
5093 default:
5094 result = WERR_UNKNOWN_LEVEL;
5095 break;
5096 }
5097
5098 free_a_printer(&printer, 2);
5099 free_a_printer_driver(driver);
5100
5101 return result;
5102 }
5103
5104 /****************************************************************
5105 _spoolss_GetPrinterDriver2
5106 ****************************************************************/
5107
5108 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5109 struct spoolss_GetPrinterDriver2 *r)
5110 {
5111 Printer_entry *printer;
5112 WERROR result;
5113
5114 const char *servername;
5115 int snum;
5116
5117 /* that's an [in out] buffer */
5118
5119 if (!r->in.buffer && (r->in.offered != 0)) {
5120 return WERR_INVALID_PARAM;
5121 }
5122
5123 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5124
5125 if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5126 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5127 return WERR_INVALID_PRINTER_NAME;
5128 }
5129
5130 *r->out.needed = 0;
5131 *r->out.server_major_version = 0;
5132 *r->out.server_minor_version = 0;
5133
5134 servername = get_server_name(printer);
5135
5136 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5137 return WERR_BADFID;
5138 }
5139
5140 result = construct_printer_driver_info_level(p->mem_ctx, r->in.level,
5141 r->out.info, snum,
5142 servername,
5143 r->in.architecture,
5144 r->in.client_major_version);
5145 if (!W_ERROR_IS_OK(result)) {
5146 TALLOC_FREE(r->out.info);
5147 return result;
5148 }
5149
5150 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5151 r->out.info, r->in.level);
5152 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5153
5154 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5155 }
5156
5157
5158 /****************************************************************
5159 _spoolss_StartPagePrinter
5160 ****************************************************************/
5161
5162 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5163 struct spoolss_StartPagePrinter *r)
5164 {
5165 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5166
5167 if (!Printer) {
5168 DEBUG(3,("_spoolss_StartPagePrinter: "
5169 "Error in startpageprinter printer handle\n"));
5170 return WERR_BADFID;
5171 }
5172
5173 Printer->page_started = true;
5174 return WERR_OK;
5175 }
5176
5177 /****************************************************************
5178 _spoolss_EndPagePrinter
5179 ****************************************************************/
5180
5181 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5182 struct spoolss_EndPagePrinter *r)
5183 {
5184 int snum;
5185
5186 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5187
5188 if (!Printer) {
5189 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5190 OUR_HANDLE(r->in.handle)));
5191 return WERR_BADFID;
5192 }
5193
5194 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5195 return WERR_BADFID;
5196
5197 Printer->page_started = false;
5198 print_job_endpage(snum, Printer->jobid);
5199
5200 return WERR_OK;
5201 }
5202
5203 /****************************************************************
5204 _spoolss_StartDocPrinter
5205 ****************************************************************/
5206
5207 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5208 struct spoolss_StartDocPrinter *r)
5209 {
5210 struct spoolss_DocumentInfo1 *info_1;
5211 int snum;
5212 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5213
5214 if (!Printer) {
5215 DEBUG(2,("_spoolss_StartDocPrinter: "
5216 "Invalid handle (%s:%u:%u)\n",
5217 OUR_HANDLE(r->in.handle)));
5218 return WERR_BADFID;
5219 }
5220
5221 if (r->in.level != 1) {
5222 return WERR_UNKNOWN_LEVEL;
5223 }
5224
5225 info_1 = r->in.info.info1;
5226
5227 /*
5228 * a nice thing with NT is it doesn't listen to what you tell it.
5229 * when asked to send _only_ RAW datas, it tries to send datas
5230 * in EMF format.
5231 *
5232 * So I add checks like in NT Server ...
5233 */
5234
5235 if (info_1->datatype) {
5236 if (strcmp(info_1->datatype, "RAW") != 0) {
5237 *r->out.job_id = 0;
5238 return WERR_INVALID_DATATYPE;
5239 }
5240 }
5241
5242 /* get the share number of the printer */
5243 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5244 return WERR_BADFID;
5245 }
5246
5247 Printer->jobid = print_job_start(p->server_info, snum,
5248 info_1->document_name,
5249 Printer->nt_devmode);
5250
5251 /* An error occured in print_job_start() so return an appropriate
5252 NT error code. */
5253
5254 if (Printer->jobid == -1) {
5255 return map_werror_from_unix(errno);
5256 }
5257
5258 Printer->document_started = true;
5259 *r->out.job_id = Printer->jobid;
5260
5261 return WERR_OK;
5262 }
5263
5264 /****************************************************************
5265 _spoolss_EndDocPrinter
5266 ****************************************************************/
5267
5268 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5269 struct spoolss_EndDocPrinter *r)
5270 {
5271 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5272 int snum;
5273
5274 if (!Printer) {
5275 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5276 OUR_HANDLE(r->in.handle)));
5277 return WERR_BADFID;
5278 }
5279
5280 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5281 return WERR_BADFID;
5282 }
5283
5284 Printer->document_started = false;
5285 print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
5286 /* error codes unhandled so far ... */
5287
5288 return WERR_OK;
5289 }
5290
5291 /****************************************************************
5292 _spoolss_WritePrinter
5293 ****************************************************************/
5294
5295 WERROR _spoolss_WritePrinter(pipes_struct *p,
5296 struct spoolss_WritePrinter *r)
5297 {
5298 ssize_t buffer_written;
5299 int snum;
5300 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5301
5302 if (!Printer) {
5303 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5304 OUR_HANDLE(r->in.handle)));
5305 *r->out.num_written = r->in._data_size;
5306 return WERR_BADFID;
5307 }
5308
5309 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5310 return WERR_BADFID;
5311
5312 buffer_written = print_job_write(snum, Printer->jobid,
5313 (const char *)r->in.data.data,
5314 (SMB_OFF_T)-1,
5315 (size_t)r->in._data_size);
5316 if (buffer_written == (ssize_t)-1) {
5317 *r->out.num_written = 0;
5318 if (errno == ENOSPC)
5319 return WERR_NO_SPOOL_SPACE;
5320 else
5321 return WERR_ACCESS_DENIED;
5322 }
5323
5324 *r->out.num_written = r->in._data_size;
5325
5326 return WERR_OK;
5327 }
5328
5329 /********************************************************************
5330 * api_spoolss_getprinter
5331 * called from the spoolss dispatcher
5332 *
5333 ********************************************************************/
5334
5335 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5336 pipes_struct *p)
5337 {
5338 int snum;
5339 WERROR errcode = WERR_BADFUNC;
5340 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5341
5342 if (!Printer) {
5343 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5344 OUR_HANDLE(handle)));
5345 return WERR_BADFID;
5346 }
5347
5348 if (!get_printer_snum(p, handle, &snum, NULL))
5349 return WERR_BADFID;
5350
5351 switch (command) {
5352 case SPOOLSS_PRINTER_CONTROL_PAUSE:
5353 errcode = print_queue_pause(p->server_info, snum);
5354 break;
5355 case SPOOLSS_PRINTER_CONTROL_RESUME:
5356 case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5357 errcode = print_queue_resume(p->server_info, snum);
5358 break;
5359 case SPOOLSS_PRINTER_CONTROL_PURGE:
5360 errcode = print_queue_purge(p->server_info, snum);
5361 break;
5362 default:
5363 return WERR_UNKNOWN_LEVEL;
5364 }
5365
5366 return errcode;
5367 }
5368
5369
5370 /****************************************************************
5371 _spoolss_AbortPrinter
5372 * From MSDN: "Deletes printer's spool file if printer is configured
5373 * for spooling"
5374 ****************************************************************/
5375
5376 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5377 struct spoolss_AbortPrinter *r)
5378 {
5379 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5380 int snum;
5381 WERROR errcode = WERR_OK;
5382
5383 if (!Printer) {
5384 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5385 OUR_HANDLE(r->in.handle)));
5386 return WERR_BADFID;
5387 }
5388
5389 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5390 return WERR_BADFID;
5391
5392 print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5393
5394 return errcode;
5395 }
5396
5397 /********************************************************************
5398 * called by spoolss_api_setprinter
5399 * when updating a printer description
5400 ********************************************************************/
5401
5402 static WERROR update_printer_sec(struct policy_handle *handle,
5403 pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5404 {
5405 SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5406 WERROR result;
5407 int snum;
5408
5409 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5410
5411 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5412 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5413 OUR_HANDLE(handle)));
5414
5415 result = WERR_BADFID;
5416 goto done;
5417 }
5418
5419 if (!secdesc_ctr) {
5420 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5421 result = WERR_INVALID_PARAM;
5422 goto done;
5423 }
5424
5425 /* Check the user has permissions to change the security
5426 descriptor. By experimentation with two NT machines, the user
5427 requires Full Access to the printer to change security
5428 information. */
5429
5430 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5431 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5432 result = WERR_ACCESS_DENIED;
5433 goto done;
5434 }
5435
5436 /* NT seems to like setting the security descriptor even though
5437 nothing may have actually changed. */
5438
5439 if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5440 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5441 result = WERR_BADFID;
5442 goto done;
5443 }
5444
5445 if (DEBUGLEVEL >= 10) {
5446 SEC_ACL *the_acl;
5447 int i;
5448
5449 the_acl = old_secdesc_ctr->sd->dacl;
5450 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5451 PRINTERNAME(snum), the_acl->num_aces));
5452
5453 for (i = 0; i < the_acl->num_aces; i++) {
5454 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5455 &the_acl->aces[i].trustee),
5456 the_acl->aces[i].access_mask));
5457 }
5458
5459 the_acl = secdesc_ctr->sd->dacl;
5460
5461 if (the_acl) {
5462 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5463 PRINTERNAME(snum), the_acl->num_aces));
5464
5465 for (i = 0; i < the_acl->num_aces; i++) {
5466 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5467 &the_acl->aces[i].trustee),
5468 the_acl->aces[i].access_mask));
5469 }
5470 } else {
5471 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5472 }
5473 }
5474
5475 new_secdesc_ctr = sec_desc_merge_buf(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5476 if (!new_secdesc_ctr) {
5477 result = WERR_NOMEM;
5478 goto done;
5479 }
5480
5481 if (security_descriptor_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5482 result = WERR_OK;
5483 goto done;
5484 }
5485
5486 result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5487
5488 done:
5489
5490 return result;
5491 }
5492
5493 /********************************************************************
5494 Canonicalize printer info from a client
5495
5496 ATTN: It does not matter what we set the servername to hear
5497 since we do the necessary work in get_a_printer() to set it to
5498 the correct value based on what the client sent in the
5499 _spoolss_open_printer_ex().
5500 ********************************************************************/
5501
5502 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5503 {
5504 fstring printername;
5505 const char *p;
5506
5507 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5508 "portname=%s drivername=%s comment=%s location=%s\n",
5509 info->servername, info->printername, info->sharename,
5510 info->portname, info->drivername, info->comment, info->location));
5511
5512 /* we force some elements to "correct" values */
5513 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5514 fstrcpy(info->sharename, lp_servicename(snum));
5515
5516 /* check to see if we allow printername != sharename */
5517
5518 if ( lp_force_printername(snum) ) {
5519 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5520 global_myname(), info->sharename );
5521 } else {
5522
5523 /* make sure printername is in \\server\printername format */
5524
5525 fstrcpy( printername, info->printername );
5526 p = printername;
5527 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5528 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5529 p++;
5530 }
5531
5532 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5533 global_myname(), p );
5534 }
5535
5536 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5537 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5538
5539
5540
5541 return true;
5542 }
5543
5544 /****************************************************************************
5545 ****************************************************************************/
5546
5547 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5548 {
5549 char *cmd = lp_addport_cmd();
5550 char *command = NULL;
5551 int ret;
5552 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5553 bool is_print_op = false;
5554
5555 if ( !*cmd ) {
5556 return WERR_ACCESS_DENIED;
5557 }
5558
5559 command = talloc_asprintf(ctx,
5560 "%s \"%s\" \"%s\"", cmd, portname, uri );
5561 if (!command) {
5562 return WERR_NOMEM;
5563 }
5564
5565 if ( token )
5566 is_print_op = user_has_privileges( token, &se_printop );
5567
5568 DEBUG(10,("Running [%s]\n", command));
5569
5570 /********* BEGIN SePrintOperatorPrivilege **********/
5571
5572 if ( is_print_op )
5573 become_root();
5574
5575 ret = smbrun(command, NULL);
5576
5577 if ( is_print_op )
5578 unbecome_root();
5579
5580 /********* END SePrintOperatorPrivilege **********/
5581
5582 DEBUGADD(10,("returned [%d]\n", ret));
5583
5584 TALLOC_FREE(command);
5585
5586 if ( ret != 0 ) {
5587 return WERR_ACCESS_DENIED;
5588 }
5589
5590 return WERR_OK;
5591 }
5592
5593 /****************************************************************************
5594 ****************************************************************************/
5595
5596 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5597 {
5598 char *cmd = lp_addprinter_cmd();
5599 char **qlines;
5600 char *command = NULL;
5601 int numlines;
5602 int ret;
5603 int fd;
5604 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5605 bool is_print_op = false;
5606 char *remote_machine = talloc_strdup(ctx, "%m");
5607
5608 if (!remote_machine) {
5609 return false;
5610 }
5611 remote_machine = talloc_sub_basic(ctx,
5612 current_user_info.smb_name,
5613 current_user_info.domain,
5614 remote_machine);
5615 if (!remote_machine) {
5616 return false;
5617 }
5618
5619 command = talloc_asprintf(ctx,
5620 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5621 cmd, printer->info_2->printername, printer->info_2->sharename,
5622 printer->info_2->portname, printer->info_2->drivername,
5623 printer->info_2->location, printer->info_2->comment, remote_machine);
5624 if (!command) {
5625 return false;
5626 }
5627
5628 if ( token )
5629 is_print_op = user_has_privileges( token, &se_printop );
5630
5631 DEBUG(10,("Running [%s]\n", command));
5632
5633 /********* BEGIN SePrintOperatorPrivilege **********/
5634
5635 if ( is_print_op )
5636 become_root();
5637
5638 if ( (ret = smbrun(command, &fd)) == 0 ) {
5639 /* Tell everyone we updated smb.conf. */
5640 message_send_all(smbd_messaging_context(),
5641 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
5642 }
5643
5644 if ( is_print_op )
5645 unbecome_root();
5646
5647 /********* END SePrintOperatorPrivilege **********/
5648
5649 DEBUGADD(10,("returned [%d]\n", ret));
5650
5651 TALLOC_FREE(command);
5652 TALLOC_FREE(remote_machine);
5653
5654 if ( ret != 0 ) {
5655 if (fd != -1)
5656 close(fd);
5657 return false;
5658 }
5659
5660 /* reload our services immediately */
5661 become_root();
5662 reload_services(false);
5663 unbecome_root();
5664
5665 numlines = 0;
5666 /* Get lines and convert them back to dos-codepage */
5667 qlines = fd_lines_load(fd, &numlines, 0, NULL);
5668 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5669 close(fd);
5670
5671 /* Set the portname to what the script says the portname should be. */
5672 /* but don't require anything to be return from the script exit a good error code */
5673
5674 if (numlines) {
5675 /* Set the portname to what the script says the portname should be. */
5676 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
5677 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
5678 }
5679
5680 TALLOC_FREE(qlines);
5681 return true;
5682 }
5683
5684
5685 /********************************************************************
5686 * Called by spoolss_api_setprinter
5687 * when updating a printer description.
5688 ********************************************************************/
5689
5690 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
5691 struct spoolss_SetPrinterInfoCtr *info_ctr,
5692 struct spoolss_DeviceMode *devmode)
5693 {
5694 int snum;
5695 NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
5696 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5697 WERROR result;
5698 DATA_BLOB buffer;
5699 fstring asc_buffer;
5700
5701 DEBUG(8,("update_printer\n"));
5702
5703 result = WERR_OK;
5704
5705 if (!Printer) {
5706 result = WERR_BADFID;
5707 goto done;
5708 }
5709
5710 if (!get_printer_snum(p, handle, &snum, NULL)) {
5711 result = WERR_BADFID;
5712 goto done;
5713 }
5714
5715 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
5716 (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
5717 result = WERR_BADFID;
5718 goto done;
5719 }
5720
5721 DEBUGADD(8,("Converting info_2 struct\n"));
5722
5723 /*
5724 * convert_printer_info converts the incoming
5725 * info from the client and overwrites the info
5726 * just read from the tdb in the pointer 'printer'.
5727 */
5728
5729 if (!convert_printer_info(info_ctr, printer)) {
5730 result = WERR_NOMEM;
5731 goto done;
5732 }
5733
5734 if (devmode) {
5735 /* we have a valid devmode
5736 convert it and link it*/
5737
5738 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5739 if (!convert_devicemode(printer->info_2->printername, devmode,
5740 &printer->info_2->devmode)) {
5741 result = WERR_NOMEM;
5742 goto done;
5743 }
5744 }
5745
5746 /* Do sanity check on the requested changes for Samba */
5747
5748 if (!check_printer_ok(printer->info_2, snum)) {
5749 result = WERR_INVALID_PARAM;
5750 goto done;
5751 }
5752
5753 /* FIXME!!! If the driver has changed we really should verify that
5754 it is installed before doing much else --jerry */
5755
5756 /* Check calling user has permission to update printer description */
5757
5758 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
5759 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5760 result = WERR_ACCESS_DENIED;
5761 goto done;
5762 }
5763
5764 /* Call addprinter hook */
5765 /* Check changes to see if this is really needed */
5766
5767 if ( *lp_addprinter_cmd()
5768 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
5769 || !strequal(printer->info_2->comment, old_printer->info_2->comment)
5770 || !strequal(printer->info_2->portname, old_printer->info_2->portname)
5771 || !strequal(printer->info_2->location, old_printer->info_2->location)) )
5772 {
5773 /* add_printer_hook() will call reload_services() */
5774
5775 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
5776 printer) ) {
5777 result = WERR_ACCESS_DENIED;
5778 goto done;
5779 }
5780 }
5781
5782 /*
5783 * When a *new* driver is bound to a printer, the drivername is used to
5784 * lookup previously saved driver initialization info, which is then
5785 * bound to the printer, simulating what happens in the Windows arch.
5786 */
5787 if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
5788 {
5789 if (!set_driver_init(printer, 2))
5790 {
5791 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
5792 printer->info_2->drivername));
5793 }
5794
5795 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
5796 printer->info_2->drivername));
5797
5798 notify_printer_driver(snum, printer->info_2->drivername);
5799 }
5800
5801 /*
5802 * flag which changes actually occured. This is a small subset of
5803 * all the possible changes. We also have to update things in the
5804 * DsSpooler key.
5805 */
5806
5807 if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
5808 push_reg_sz(talloc_tos(), NULL, &buffer, printer->info_2->comment);
5809 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
5810 REG_SZ, buffer.data, buffer.length);
5811
5812 notify_printer_comment(snum, printer->info_2->comment);
5813 }
5814
5815 if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
5816 push_reg_sz(talloc_tos(), NULL, &buffer, printer->info_2->sharename);
5817 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
5818 REG_SZ, buffer.data, buffer.length);
5819
5820 notify_printer_sharename(snum, printer->info_2->sharename);
5821 }
5822
5823 if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
5824 char *pname;
5825
5826 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
5827 pname++;
5828 else
5829 pname = printer->info_2->printername;
5830
5831
5832 push_reg_sz(talloc_tos(), NULL, &buffer, pname);
5833 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
5834 REG_SZ, buffer.data, buffer.length);
5835
5836 notify_printer_printername( snum, pname );
5837 }
5838
5839 if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
5840 push_reg_sz(talloc_tos(), NULL, &buffer, printer->info_2->portname);
5841 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
5842 REG_SZ, buffer.data, buffer.length);
5843
5844 notify_printer_port(snum, printer->info_2->portname);
5845 }
5846
5847 if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
5848 push_reg_sz(talloc_tos(), NULL, &buffer, printer->info_2->location);
5849 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
5850 REG_SZ, buffer.data, buffer.length);
5851
5852 notify_printer_location(snum, printer->info_2->location);
5853 }
5854
5855 /* here we need to update some more DsSpooler keys */
5856 /* uNCName, serverName, shortServerName */
5857
5858 push_reg_sz(talloc_tos(), NULL, &buffer, global_myname());
5859 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
5860 REG_SZ, buffer.data, buffer.length);
5861 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
5862 REG_SZ, buffer.data, buffer.length);
5863
5864 slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
5865 global_myname(), printer->info_2->sharename );
5866 push_reg_sz(talloc_tos(), NULL, &buffer, asc_buffer);
5867 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
5868 REG_SZ, buffer.data, buffer.length);
5869
5870 /* Update printer info */
5871 result = mod_a_printer(printer, 2);
5872
5873 done:
5874 free_a_printer(&printer, 2);
5875 free_a_printer(&old_printer, 2);
5876
5877
5878 return result;
5879 }
5880
5881 /****************************************************************************
5882 ****************************************************************************/
5883 static WERROR publish_or_unpublish_printer(pipes_struct *p,
5884 struct policy_handle *handle,
5885 struct spoolss_SetPrinterInfo7 *info7)
5886 {
5887 #ifdef HAVE_ADS
5888 int snum;
5889 Printer_entry *Printer;
5890
5891 if ( lp_security() != SEC_ADS ) {
5892 return WERR_UNKNOWN_LEVEL;
5893 }
5894
5895 Printer = find_printer_index_by_hnd(p, handle);
5896
5897 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
5898
5899 if (!Printer)
5900 return WERR_BADFID;
5901
5902 if (!get_printer_snum(p, handle, &snum, NULL))
5903 return WERR_BADFID;
5904
5905 nt_printer_publish(Printer, snum, info7->action);
5906
5907 return WERR_OK;
5908 #else
5909 return WERR_UNKNOWN_LEVEL;
5910 #endif
5911 }
5912
5913 /********************************************************************
5914 ********************************************************************/
5915
5916 static WERROR update_printer_devmode(pipes_struct *p, struct policy_handle *handle,
5917 struct spoolss_DeviceMode *devmode)
5918 {
5919 int snum;
5920 NT_PRINTER_INFO_LEVEL *printer = NULL;
5921 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5922 WERROR result;
5923
5924 DEBUG(8,("update_printer_devmode\n"));
5925
5926 result = WERR_OK;
5927
5928 if (!Printer) {
5929 result = WERR_BADFID;
5930 goto done;
5931 }
5932
5933 if (!get_printer_snum(p, handle, &snum, NULL)) {
5934 result = WERR_BADFID;
5935 goto done;
5936 }
5937
5938 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum)))) {
5939 result = WERR_BADFID;
5940 goto done;
5941 }
5942
5943 if (devmode) {
5944 /* we have a valid devmode
5945 convert it and link it*/
5946
5947 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5948 if (!convert_devicemode(printer->info_2->printername, devmode,
5949 &printer->info_2->devmode)) {
5950 result = WERR_NOMEM;
5951 goto done;
5952 }
5953 }
5954
5955 /* Check calling user has permission to update printer description */
5956
5957 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
5958 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5959 result = WERR_ACCESS_DENIED;
5960 goto done;
5961 }
5962
5963
5964 /* Update printer info */
5965 result = mod_a_printer(printer, 2);
5966
5967 done:
5968 free_a_printer(&printer, 2);
5969
5970 return result;
5971 }
5972
5973
5974 /****************************************************************
5975 _spoolss_SetPrinter
5976 ****************************************************************/
5977
5978 WERROR _spoolss_SetPrinter(pipes_struct *p,
5979 struct spoolss_SetPrinter *r)
5980 {
5981 WERROR result;
5982
5983 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5984
5985 if (!Printer) {
5986 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
5987 OUR_HANDLE(r->in.handle)));
5988 return WERR_BADFID;
5989 }
5990
5991 /* check the level */
5992 switch (r->in.info_ctr->level) {
5993 case 0:
5994 return control_printer(r->in.handle, r->in.command, p);
5995 case 2:
5996 result = update_printer(p, r->in.handle,
5997 r->in.info_ctr,
5998 r->in.devmode_ctr->devmode);
5999 if (!W_ERROR_IS_OK(result))
6000 return result;
6001 if (r->in.secdesc_ctr->sd)
6002 result = update_printer_sec(r->in.handle, p,
6003 r->in.secdesc_ctr);
6004 return result;
6005 case 3:
6006 return update_printer_sec(r->in.handle, p,
6007 r->in.secdesc_ctr);
6008 case 7:
6009 return publish_or_unpublish_printer(p, r->in.handle,
6010 r->in.info_ctr->info.info7);
6011 case 8:
6012 return update_printer_devmode(p, r->in.handle,
6013 r->in.devmode_ctr->devmode);
6014 default:
6015 return WERR_UNKNOWN_LEVEL;
6016 }
6017 }
6018
6019 /****************************************************************
6020 _spoolss_FindClosePrinterNotify
6021 ****************************************************************/
6022
6023 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
6024 struct spoolss_FindClosePrinterNotify *r)
6025 {
6026 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6027
6028 if (!Printer) {
6029 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6030 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6031 return WERR_BADFID;
6032 }
6033
6034 if (Printer->notify.client_connected == true) {
6035 int snum = -1;
6036
6037 if ( Printer->printer_type == SPLHND_SERVER)
6038 snum = -1;
6039 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6040 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6041 return WERR_BADFID;
6042
6043 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6044 }
6045
6046 Printer->notify.flags=0;
6047 Printer->notify.options=0;
6048 Printer->notify.localmachine[0]='\0';
6049 Printer->notify.printerlocal=0;
6050 TALLOC_FREE(Printer->notify.option);
6051 Printer->notify.client_connected = false;
6052
6053 return WERR_OK;
6054 }
6055
6056 /****************************************************************
6057 _spoolss_AddJob
6058 ****************************************************************/
6059
6060 WERROR _spoolss_AddJob(pipes_struct *p,
6061 struct spoolss_AddJob *r)
6062 {
6063 if (!r->in.buffer && (r->in.offered != 0)) {
6064 return WERR_INVALID_PARAM;
6065 }
6066
6067 /* this is what a NT server returns for AddJob. AddJob must fail on
6068 * non-local printers */
6069
6070 if (r->in.level != 1) {
6071 return WERR_UNKNOWN_LEVEL;
6072 }
6073
6074 return WERR_INVALID_PARAM;
6075 }
6076
6077 /****************************************************************************
6078 fill_job_info1
6079 ****************************************************************************/
6080
6081 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6082 struct spoolss_JobInfo1 *r,
6083 const print_queue_struct *queue,
6084 int position, int snum,
6085 const NT_PRINTER_INFO_LEVEL *ntprinter)
6086 {
6087 struct tm *t;
6088
6089 t = gmtime(&queue->time);
6090
6091 r->job_id = queue->job;
6092
6093 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6094 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6095 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6096 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6097 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6098 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6099 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6100 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6101 r->data_type = talloc_strdup(mem_ctx, "RAW");
6102 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6103 r->text_status = talloc_strdup(mem_ctx, "");
6104 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6105
6106 r->status = nt_printj_status(queue->status);
6107 r->priority = queue->priority;
6108 r->position = position;
6109 r->total_pages = queue->page_count;
6110 r->pages_printed = 0; /* ??? */
6111
6112 init_systemtime(&r->submitted, t);
6113
6114 return WERR_OK;
6115 }
6116
6117 /****************************************************************************
6118 fill_job_info2
6119 ****************************************************************************/
6120
6121 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6122 struct spoolss_JobInfo2 *r,
6123 const print_queue_struct *queue,
6124 int position, int snum,
6125 const NT_PRINTER_INFO_LEVEL *ntprinter,
6126 struct spoolss_DeviceMode *devmode)
6127 {
6128 struct tm *t;
6129
6130 t = gmtime(&queue->time);
6131
6132 r->job_id = queue->job;
6133
6134 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6135 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6136 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6137 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6138 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6139 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6140 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6141 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6142 r->notify_name = talloc_strdup(mem_ctx, queue->fs_user);
6143 W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6144 r->data_type = talloc_strdup(mem_ctx, "RAW");
6145 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6146 r->print_processor = talloc_strdup(mem_ctx, "winprint");
6147 W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6148 r->parameters = talloc_strdup(mem_ctx, "");
6149 W_ERROR_HAVE_NO_MEMORY(r->parameters);
6150 r->driver_name = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6151 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6152
6153 r->devmode = devmode;
6154
6155 r->text_status = talloc_strdup(mem_ctx, "");
6156 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6157
6158 r->secdesc = NULL;
6159
6160 r->status = nt_printj_status(queue->status);
6161 r->priority = queue->priority;
6162 r->position = position;
6163 r->start_time = 0;
6164 r->until_time = 0;
6165 r->total_pages = queue->page_count;
6166 r->size = queue->size;
6167 init_systemtime(&r->submitted, t);
6168 r->time = 0;
6169 r->pages_printed = 0; /* ??? */
6170
6171 return WERR_OK;
6172 }
6173
6174 /****************************************************************************
6175 fill_job_info3
6176 ****************************************************************************/
6177
6178 static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
6179 struct spoolss_JobInfo3 *r,
6180 const print_queue_struct *queue,
6181 const print_queue_struct *next_queue,
6182 int position, int snum,
6183 const NT_PRINTER_INFO_LEVEL *ntprinter)
6184 {
6185 r->job_id = queue->job;
6186 r->next_job_id = 0;
6187 if (next_queue) {
6188 r->next_job_id = next_queue->job;
6189 }
6190 r->reserved = 0;
6191
6192 return WERR_OK;
6193 }
6194
6195 /****************************************************************************
6196 Enumjobs at level 1.
6197 ****************************************************************************/
6198
6199 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6200 const print_queue_struct *queue,
6201 uint32_t num_queues, int snum,
6202 const NT_PRINTER_INFO_LEVEL *ntprinter,
6203 union spoolss_JobInfo **info_p,
6204 uint32_t *count)
6205 {
6206 union spoolss_JobInfo *info;
6207 int i;
6208 WERROR result = WERR_OK;
6209
6210 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6211 W_ERROR_HAVE_NO_MEMORY(info);
6212
6213 *count = num_queues;
6214
6215 for (i=0; i<*count; i++) {
6216 result = fill_job_info1(info,
6217 &info[i].info1,
6218 &queue[i],
6219 i,
6220 snum,
6221 ntprinter);
6222 if (!W_ERROR_IS_OK(result)) {
6223 goto out;
6224 }
6225 }
6226
6227 out:
6228 if (!W_ERROR_IS_OK(result)) {
6229 TALLOC_FREE(info);
6230 *count = 0;
6231 return result;
6232 }
6233
6234 *info_p = info;
6235
6236 return WERR_OK;
6237 }
6238
6239 /****************************************************************************
6240 Enumjobs at level 2.
6241 ****************************************************************************/
6242
6243 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6244 const print_queue_struct *queue,
6245 uint32_t num_queues, int snum,
6246 const NT_PRINTER_INFO_LEVEL *ntprinter,
6247 union spoolss_JobInfo **info_p,
6248 uint32_t *count)
6249 {
6250 union spoolss_JobInfo *info;
6251 int i;
6252 WERROR result = WERR_OK;
6253
6254 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6255 W_ERROR_HAVE_NO_MEMORY(info);
6256
6257 *count = num_queues;
6258
6259 for (i=0; i<*count; i++) {
6260
6261 struct spoolss_DeviceMode *devmode;
6262
6263 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6264 if (!devmode) {
6265 result = WERR_NOMEM;
6266 goto out;
6267 }
6268
6269 result = fill_job_info2(info,
6270 &info[i].info2,
6271 &queue[i],
6272 i,
6273 snum,
6274 ntprinter,
6275 devmode);
6276 if (!W_ERROR_IS_OK(result)) {
6277 goto out;
6278 }
6279 }
6280
6281 out:
6282 if (!W_ERROR_IS_OK(result)) {
6283 TALLOC_FREE(info);
6284 *count = 0;
6285 return result;
6286 }
6287
6288 *info_p = info;
6289
6290 return WERR_OK;
6291 }
6292
6293 /****************************************************************************
6294 Enumjobs at level 3.
6295 ****************************************************************************/
6296
6297 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
6298 const print_queue_struct *queue,
6299 uint32_t num_queues, int snum,
6300 const NT_PRINTER_INFO_LEVEL *ntprinter,
6301 union spoolss_JobInfo **info_p,
6302 uint32_t *count)
6303 {
6304 union spoolss_JobInfo *info;
6305 int i;
6306 WERROR result = WERR_OK;
6307
6308 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6309 W_ERROR_HAVE_NO_MEMORY(info);
6310
6311 *count = num_queues;
6312
6313 for (i=0; i<*count; i++) {
6314 const print_queue_struct *next_queue = NULL;
6315
6316 if (i+1 < *count) {
6317 next_queue = &queue[i+1];
6318 }
6319
6320 result = fill_job_info3(info,
6321 &info[i].info3,
6322 &queue[i],
6323 next_queue,
6324 i,
6325 snum,
6326 ntprinter);
6327 if (!W_ERROR_IS_OK(result)) {
6328 goto out;
6329 }
6330 }
6331
6332 out:
6333 if (!W_ERROR_IS_OK(result)) {
6334 TALLOC_FREE(info);
6335 *count = 0;
6336 return result;
6337 }
6338
6339 *info_p = info;
6340
6341 return WERR_OK;
6342 }
6343
6344 /****************************************************************
6345 _spoolss_EnumJobs
6346 ****************************************************************/
6347
6348 WERROR _spoolss_EnumJobs(pipes_struct *p,
6349 struct spoolss_EnumJobs *r)
6350 {
6351 WERROR result;
6352 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6353 int snum;
6354 print_status_struct prt_status;
6355 print_queue_struct *queue = NULL;
6356 uint32_t count;
6357
6358 /* that's an [in out] buffer */
6359
6360 if (!r->in.buffer && (r->in.offered != 0)) {
6361 return WERR_INVALID_PARAM;
6362 }
6363
6364 DEBUG(4,("_spoolss_EnumJobs\n"));
6365
6366 *r->out.needed = 0;
6367 *r->out.count = 0;
6368 *r->out.info = NULL;
6369
6370 /* lookup the printer snum and tdb entry */
6371
6372 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6373 return WERR_BADFID;
6374 }
6375
6376 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6377 if (!W_ERROR_IS_OK(result)) {
6378 return result;
6379 }
6380
6381 count = print_queue_status(snum, &queue, &prt_status);
6382 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6383 count, prt_status.status, prt_status.message));
6384
6385 if (count == 0) {
6386 SAFE_FREE(queue);
6387 free_a_printer(&ntprinter, 2);
6388 return WERR_OK;
6389 }
6390
6391 switch (r->in.level) {
6392 case 1:
6393 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6394 ntprinter, r->out.info, r->out.count);
6395 break;
6396 case 2:
6397 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6398 ntprinter, r->out.info, r->out.count);
6399 break;
6400 case 3:
6401 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
6402 ntprinter, r->out.info, r->out.count);
6403 break;
6404 default:
6405 result = WERR_UNKNOWN_LEVEL;
6406 break;
6407 }
6408
6409 SAFE_FREE(queue);
6410 free_a_printer(&ntprinter, 2);
6411
6412 if (!W_ERROR_IS_OK(result)) {
6413 return result;
6414 }
6415
6416 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6417 spoolss_EnumJobs, NULL,
6418 *r->out.info, r->in.level,
6419 *r->out.count);
6420 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6421 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6422
6423 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6424 }
6425
6426 /****************************************************************
6427 _spoolss_ScheduleJob
6428 ****************************************************************/
6429
6430 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6431 struct spoolss_ScheduleJob *r)
6432 {
6433 return WERR_OK;
6434 }
6435
6436 /****************************************************************
6437 ****************************************************************/
6438
6439 static WERROR spoolss_setjob_1(TALLOC_CTX *mem_ctx,
6440 const char *printer_name,
6441 uint32_t job_id,
6442 struct spoolss_SetJobInfo1 *r)
6443 {
6444 char *old_doc_name;
6445
6446 if (!print_job_get_name(mem_ctx, printer_name, job_id, &old_doc_name)) {
6447 return WERR_BADFID;
6448 }
6449
6450 if (strequal(old_doc_name, r->document_name)) {
6451 return WERR_OK;
6452 }
6453
6454 if (!print_job_set_name(printer_name, job_id, r->document_name)) {
6455 return WERR_BADFID;
6456 }
6457
6458 return WERR_OK;
6459 }
6460
6461 /****************************************************************
6462 _spoolss_SetJob
6463 ****************************************************************/
6464
6465 WERROR _spoolss_SetJob(pipes_struct *p,
6466 struct spoolss_SetJob *r)
6467 {
6468 int snum;
6469 WERROR errcode = WERR_BADFUNC;
6470
6471 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6472 return WERR_BADFID;
6473 }
6474
6475 if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6476 return WERR_INVALID_PRINTER_NAME;
6477 }
6478
6479 switch (r->in.command) {
6480 case SPOOLSS_JOB_CONTROL_CANCEL:
6481 case SPOOLSS_JOB_CONTROL_DELETE:
6482 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6483 errcode = WERR_OK;
6484 }
6485 break;
6486 case SPOOLSS_JOB_CONTROL_PAUSE:
6487 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6488 errcode = WERR_OK;
6489 }
6490 break;
6491 case SPOOLSS_JOB_CONTROL_RESTART:
6492 case SPOOLSS_JOB_CONTROL_RESUME:
6493 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6494 errcode = WERR_OK;
6495 }
6496 break;
6497 case 0:
6498 errcode = WERR_OK;
6499 break;
6500 default:
6501 return WERR_UNKNOWN_LEVEL;
6502 }
6503
6504 if (!W_ERROR_IS_OK(errcode)) {
6505 return errcode;
6506 }
6507
6508 if (r->in.ctr == NULL) {
6509 return errcode;
6510 }
6511
6512 switch (r->in.ctr->level) {
6513 case 1:
6514 errcode = spoolss_setjob_1(p->mem_ctx, lp_const_servicename(snum),
6515 r->in.job_id,
6516 r->in.ctr->info.info1);
6517 break;
6518 case 2:
6519 case 3:
6520 case 4:
6521 default:
6522 return WERR_UNKNOWN_LEVEL;
6523 }
6524
6525 return errcode;
6526 }
6527
6528 /****************************************************************************
6529 Enumerates all printer drivers by level and architecture.
6530 ****************************************************************************/
6531
6532 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
6533 const char *servername,
6534 const char *architecture,
6535 uint32_t level,
6536 union spoolss_DriverInfo **info_p,
6537 uint32_t *count_p)
6538 {
6539 int i;
6540 int ndrivers;
6541 uint32_t version;
6542 fstring *list = NULL;
6543 struct spoolss_DriverInfo8 *driver;
6544 union spoolss_DriverInfo *info = NULL;
6545 uint32_t count = 0;
6546 WERROR result = WERR_OK;
6547
6548 *count_p = 0;
6549 *info_p = NULL;
6550
6551 for (version=0; version<DRIVER_MAX_VERSION; version++) {
6552 list = NULL;
6553 ndrivers = get_ntdrivers(&list, architecture, version);
6554 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6555 ndrivers, architecture, version));
6556
6557 if (ndrivers == -1) {
6558 result = WERR_NOMEM;
6559 goto out;
6560 }
6561
6562 if (ndrivers != 0) {
6563 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6564 union spoolss_DriverInfo,
6565 count + ndrivers);
6566 if (!info) {
6567 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
6568 "failed to enlarge driver info buffer!\n"));
6569 result = WERR_NOMEM;
6570 goto out;
6571 }
6572 }
6573
6574 for (i=0; i<ndrivers; i++) {
6575 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6576 ZERO_STRUCT(driver);
6577 result = get_a_printer_driver(mem_ctx, &driver, list[i],
6578 architecture, version);
6579 if (!W_ERROR_IS_OK(result)) {
6580 goto out;
6581 }
6582
6583 switch (level) {
6584 case 1:
6585 result = fill_printer_driver_info1(info, &info[count+i].info1,
6586 driver, servername);
6587 break;
6588 case 2:
6589 result = fill_printer_driver_info2(info, &info[count+i].info2,
6590 driver, servername);
6591 break;
6592 case 3:
6593 result = fill_printer_driver_info3(info, &info[count+i].info3,
6594 driver, servername);
6595 break;
6596 case 4:
6597 result = fill_printer_driver_info4(info, &info[count+i].info4,
6598 driver, servername);
6599 break;
6600 case 5:
6601 result = fill_printer_driver_info5(info, &info[count+i].info5,
6602 driver, servername);
6603 break;
6604 case 6:
6605 result = fill_printer_driver_info6(info, &info[count+i].info6,
6606 driver, servername);
6607 break;
6608 case 8:
6609 result = fill_printer_driver_info8(info, &info[count+i].info8,
6610 driver, servername);
6611 break;
6612 default:
6613 result = WERR_UNKNOWN_LEVEL;
6614 break;
6615 }
6616
6617 free_a_printer_driver(driver);
6618
6619 if (!W_ERROR_IS_OK(result)) {
6620 goto out;
6621 }
6622 }
6623
6624 count += ndrivers;
6625 SAFE_FREE(list);
6626 }
6627
6628 out:
6629 SAFE_FREE(list);
6630
6631 if (!W_ERROR_IS_OK(result)) {
6632 TALLOC_FREE(info);
6633 return result;
6634 }
6635
6636 *info_p = info;
6637 *count_p = count;
6638
6639 return WERR_OK;
6640 }
6641
6642 /****************************************************************************
6643 Enumerates all printer drivers by level.
6644 ****************************************************************************/
6645
6646 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6647 const char *servername,
6648 const char *architecture,
6649 uint32_t level,
6650 union spoolss_DriverInfo **info_p,
6651 uint32_t *count_p)
6652 {
6653 uint32_t a,i;
6654 WERROR result = WERR_OK;
6655
6656 if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
6657
6658 for (a=0; archi_table[a].long_archi != NULL; a++) {
6659
6660 union spoolss_DriverInfo *info = NULL;
6661 uint32_t count = 0;
6662
6663 result = enumprinterdrivers_level_by_architecture(mem_ctx,
6664 servername,
6665 archi_table[a].long_archi,
6666 level,
6667 &info,
6668 &count);
6669 if (!W_ERROR_IS_OK(result)) {
6670 continue;
6671 }
6672
6673 for (i=0; i < count; i++) {
6674 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
6675 info[i], info_p, count_p);
6676 }
6677 }
6678
6679 return result;
6680 }
6681
6682 return enumprinterdrivers_level_by_architecture(mem_ctx,
6683 servername,
6684 architecture,
6685 level,
6686 info_p,
6687 count_p);
6688 }
6689
6690 /****************************************************************
6691 _spoolss_EnumPrinterDrivers
6692 ****************************************************************/
6693
6694 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6695 struct spoolss_EnumPrinterDrivers *r)
6696 {
6697 const char *cservername;
6698 WERROR result;
6699
6700 /* that's an [in out] buffer */
6701
6702 if (!r->in.buffer && (r->in.offered != 0)) {
6703 return WERR_INVALID_PARAM;
6704 }
6705
6706 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6707
6708 *r->out.needed = 0;
6709 *r->out.count = 0;
6710 *r->out.info = NULL;
6711
6712 cservername = canon_servername(r->in.server);
6713
6714 if (!is_myname_or_ipaddr(cservername)) {
6715 return WERR_UNKNOWN_PRINTER_DRIVER;
6716 }
6717
6718 result = enumprinterdrivers_level(p->mem_ctx, cservername,
6719 r->in.environment,
6720 r->in.level,
6721 r->out.info,
6722 r->out.count);
6723 if (!W_ERROR_IS_OK(result)) {
6724 return result;
6725 }
6726
6727 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6728 spoolss_EnumPrinterDrivers, NULL,
6729 *r->out.info, r->in.level,
6730 *r->out.count);
6731 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6732 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6733
6734 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6735 }
6736
6737 /****************************************************************************
6738 ****************************************************************************/
6739
6740 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
6741 struct spoolss_FormInfo1 *r,
6742 const nt_forms_struct *form)
6743 {
6744 r->form_name = talloc_strdup(mem_ctx, form->name);
6745 W_ERROR_HAVE_NO_MEMORY(r->form_name);
6746
6747 r->flags = form->flag;
6748 r->size.width = form->width;
6749 r->size.height = form->length;
6750 r->area.left = form->left;
6751 r->area.top = form->top;
6752 r->area.right = form->right;
6753 r->area.bottom = form->bottom;
6754
6755 return WERR_OK;
6756 }
6757
6758 /****************************************************************
6759 spoolss_enumforms_level1
6760 ****************************************************************/
6761
6762 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
6763 const nt_forms_struct *builtin_forms,
6764 uint32_t num_builtin_forms,
6765 const nt_forms_struct *user_forms,
6766 uint32_t num_user_forms,
6767 union spoolss_FormInfo **info_p,
6768 uint32_t *count)
6769 {
6770 union spoolss_FormInfo *info;
6771 WERROR result = WERR_OK;
6772 int i;
6773
6774 *count = num_builtin_forms + num_user_forms;
6775
6776 info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
6777 W_ERROR_HAVE_NO_MEMORY(info);
6778
6779 /* construct the list of form structures */
6780 for (i=0; i<num_builtin_forms; i++) {
6781 DEBUGADD(6,("Filling builtin form number [%d]\n",i));
6782 result = fill_form_info_1(info, &info[i].info1,
6783 &builtin_forms[i]);
6784 if (!W_ERROR_IS_OK(result)) {
6785 goto out;
6786 }
6787 }
6788
6789 for (i=0; i<num_user_forms; i++) {
6790 DEBUGADD(6,("Filling user form number [%d]\n",i));
6791 result = fill_form_info_1(info, &info[i+num_builtin_forms].info1,
6792 &user_forms[i]);
6793 if (!W_ERROR_IS_OK(result)) {
6794 goto out;
6795 }
6796 }
6797
6798 out:
6799 if (!W_ERROR_IS_OK(result)) {
6800 TALLOC_FREE(info);
6801 *count = 0;
6802 return result;
6803 }
6804
6805 *info_p = info;
6806
6807 return WERR_OK;
6808 }
6809
6810 /****************************************************************
6811 _spoolss_EnumForms
6812 ****************************************************************/
6813
6814 WERROR _spoolss_EnumForms(pipes_struct *p,
6815 struct spoolss_EnumForms *r)
6816 {
6817 WERROR result;
6818 nt_forms_struct *user_forms = NULL;
6819 nt_forms_struct *builtin_forms = NULL;
6820 uint32_t num_user_forms;
6821 uint32_t num_builtin_forms;
6822
6823 *r->out.count = 0;
6824 *r->out.needed = 0;
6825 *r->out.info = NULL;
6826
6827 /* that's an [in out] buffer */
6828
6829 if (!r->in.buffer && (r->in.offered != 0) ) {
6830 return WERR_INVALID_PARAM;
6831 }
6832
6833 DEBUG(4,("_spoolss_EnumForms\n"));
6834 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6835 DEBUGADD(5,("Info level [%d]\n", r->in.level));
6836
6837 num_builtin_forms = get_builtin_ntforms(&builtin_forms);
6838 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
6839 num_user_forms = get_ntforms(&user_forms);
6840 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
6841
6842 if (num_user_forms + num_builtin_forms == 0) {
6843 SAFE_FREE(builtin_forms);
6844 SAFE_FREE(user_forms);
6845 return WERR_NO_MORE_ITEMS;
6846 }
6847
6848 switch (r->in.level) {
6849 case 1:
6850 result = spoolss_enumforms_level1(p->mem_ctx,
6851 builtin_forms,
6852 num_builtin_forms,
6853 user_forms,
6854 num_user_forms,
6855 r->out.info,
6856 r->out.count);
6857 break;
6858 default:
6859 result = WERR_UNKNOWN_LEVEL;
6860 break;
6861 }
6862
6863 SAFE_FREE(user_forms);
6864 SAFE_FREE(builtin_forms);
6865
6866 if (!W_ERROR_IS_OK(result)) {
6867 return result;
6868 }
6869
6870 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6871 spoolss_EnumForms, NULL,
6872 *r->out.info, r->in.level,
6873 *r->out.count);
6874 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6875 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6876
6877 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6878 }
6879
6880 /****************************************************************
6881 ****************************************************************/
6882
6883 static WERROR find_form_byname(const char *name,
6884 nt_forms_struct *form)
6885 {
6886 nt_forms_struct *list = NULL;
6887 int num_forms = 0, i = 0;
6888
6889 if (get_a_builtin_ntform_by_string(name, form)) {
6890 return WERR_OK;
6891 }
6892
6893 num_forms = get_ntforms(&list);
6894 DEBUGADD(5,("Number of forms [%d]\n", num_forms));
6895
6896 if (num_forms == 0) {
6897 return WERR_BADFID;
6898 }
6899
6900 /* Check if the requested name is in the list of form structures */
6901 for (i = 0; i < num_forms; i++) {
6902
6903 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
6904
6905 if (strequal(name, list[i].name)) {
6906 DEBUGADD(6,("Found form %s number [%d]\n", name, i));
6907 *form = list[i];
6908 SAFE_FREE(list);
6909 return WERR_OK;
6910 }
6911 }
6912
6913 SAFE_FREE(list);
6914
6915 return WERR_BADFID;
6916 }
6917
6918 /****************************************************************
6919 _spoolss_GetForm
6920 ****************************************************************/
6921
6922 WERROR _spoolss_GetForm(pipes_struct *p,
6923 struct spoolss_GetForm *r)
6924 {
6925 WERROR result;
6926 nt_forms_struct form;
6927
6928 /* that's an [in out] buffer */
6929
6930 if (!r->in.buffer && (r->in.offered != 0)) {
6931 return WERR_INVALID_PARAM;
6932 }
6933
6934 DEBUG(4,("_spoolss_GetForm\n"));
6935 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6936 DEBUGADD(5,("Info level [%d]\n", r->in.level));
6937
6938 result = find_form_byname(r->in.form_name, &form);
6939 if (!W_ERROR_IS_OK(result)) {
6940 TALLOC_FREE(r->out.info);
6941 return result;
6942 }
6943
6944 switch (r->in.level) {
6945 case 1:
6946 result = fill_form_info_1(p->mem_ctx,
6947 &r->out.info->info1,
6948 &form);
6949 break;
6950
6951 default:
6952 result = WERR_UNKNOWN_LEVEL;
6953 break;
6954 }
6955
6956 if (!W_ERROR_IS_OK(result)) {
6957 TALLOC_FREE(r->out.info);
6958 return result;
6959 }
6960
6961 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
6962 r->out.info, r->in.level);
6963 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
6964
6965 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6966 }
6967
6968 /****************************************************************************
6969 ****************************************************************************/
6970
6971 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
6972 struct spoolss_PortInfo1 *r,
6973 const char *name)
6974 {
6975 r->port_name = talloc_strdup(mem_ctx, name);
6976 W_ERROR_HAVE_NO_MEMORY(r->port_name);
6977
6978 return WERR_OK;
6979 }
6980
6981 /****************************************************************************
6982 TODO: This probably needs distinguish between TCP/IP and Local ports
6983 somehow.
6984 ****************************************************************************/
6985
6986 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
6987 struct spoolss_PortInfo2 *r,
6988 const char *name)
6989 {
6990 r->port_name = talloc_strdup(mem_ctx, name);
6991 W_ERROR_HAVE_NO_MEMORY(r->port_name);
6992
6993 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
6994 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
6995
6996 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
6997 W_ERROR_HAVE_NO_MEMORY(r->description);
6998
6999 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7000 r->reserved = 0;
7001
7002 return WERR_OK;
7003 }
7004
7005
7006 /****************************************************************************
7007 wrapper around the enumer ports command
7008 ****************************************************************************/
7009
7010 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7011 {
7012 char *cmd = lp_enumports_cmd();
7013 char **qlines = NULL;
7014 char *command = NULL;
7015 int numlines;
7016 int ret;
7017 int fd;
7018
7019 *count = 0;
7020 *lines = NULL;
7021
7022 /* if no hook then just fill in the default port */
7023
7024 if ( !*cmd ) {
7025 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7026 return WERR_NOMEM;
7027 }
7028 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7029 TALLOC_FREE(qlines);
7030 return WERR_NOMEM;
7031 }
7032 qlines[1] = NULL;
7033 numlines = 1;
7034 }
7035 else {
7036 /* we have a valid enumport command */
7037
7038 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7039 if (!command) {
7040 return WERR_NOMEM;
7041 }
7042
7043 DEBUG(10,("Running [%s]\n", command));
7044 ret = smbrun(command, &fd);
7045 DEBUG(10,("Returned [%d]\n", ret));
7046 TALLOC_FREE(command);
7047 if (ret != 0) {
7048 if (fd != -1) {
7049 close(fd);
7050 }
7051 return WERR_ACCESS_DENIED;
7052 }
7053
7054 numlines = 0;
7055 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7056 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7057 close(fd);
7058 }
7059
7060 *count = numlines;
7061 *lines = qlines;
7062
7063 return WERR_OK;
7064 }
7065
7066 /****************************************************************************
7067 enumports level 1.
7068 ****************************************************************************/
7069
7070 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7071 union spoolss_PortInfo **info_p,
7072 uint32_t *count)
7073 {
7074 union spoolss_PortInfo *info = NULL;
7075 int i=0;
7076 WERROR result = WERR_OK;
7077 char **qlines = NULL;
7078 int numlines = 0;
7079
7080 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7081 if (!W_ERROR_IS_OK(result)) {
7082 goto out;
7083 }
7084
7085 if (numlines) {
7086 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7087 if (!info) {
7088 DEBUG(10,("Returning WERR_NOMEM\n"));
7089 result = WERR_NOMEM;
7090 goto out;
7091 }
7092
7093 for (i=0; i<numlines; i++) {
7094 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7095 result = fill_port_1(info, &info[i].info1, qlines[i]);
7096 if (!W_ERROR_IS_OK(result)) {
7097 goto out;
7098 }
7099 }
7100 }
7101 TALLOC_FREE(qlines);
7102
7103 out:
7104 if (!W_ERROR_IS_OK(result)) {
7105 TALLOC_FREE(info);
7106 TALLOC_FREE(qlines);
7107 *count = 0;
7108 *info_p = NULL;
7109 return result;
7110 }
7111
7112 *info_p = info;
7113 *count = numlines;
7114
7115 return WERR_OK;
7116 }
7117
7118 /****************************************************************************
7119 enumports level 2.
7120 ****************************************************************************/
7121
7122 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7123 union spoolss_PortInfo **info_p,
7124 uint32_t *count)
7125 {
7126 union spoolss_PortInfo *info = NULL;
7127 int i=0;
7128 WERROR result = WERR_OK;
7129 char **qlines = NULL;
7130 int numlines = 0;
7131
7132 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7133 if (!W_ERROR_IS_OK(result)) {
7134 goto out;
7135 }
7136
7137 if (numlines) {
7138 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7139 if (!info) {
7140 DEBUG(10,("Returning WERR_NOMEM\n"));
7141 result = WERR_NOMEM;
7142 goto out;
7143 }
7144
7145 for (i=0; i<numlines; i++) {
7146 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7147 result = fill_port_2(info, &info[i].info2, qlines[i]);
7148 if (!W_ERROR_IS_OK(result)) {
7149 goto out;
7150 }
7151 }
7152 }
7153 TALLOC_FREE(qlines);
7154
7155 out:
7156 if (!W_ERROR_IS_OK(result)) {
7157 TALLOC_FREE(info);
7158 TALLOC_FREE(qlines);
7159 *count = 0;
7160 *info_p = NULL;
7161 return result;
7162 }
7163
7164 *info_p = info;
7165 *count = numlines;
7166
7167 return WERR_OK;
7168 }
7169
7170 /****************************************************************
7171 _spoolss_EnumPorts
7172 ****************************************************************/
7173
7174 WERROR _spoolss_EnumPorts(pipes_struct *p,
7175 struct spoolss_EnumPorts *r)
7176 {
7177 WERROR result;
7178
7179 /* that's an [in out] buffer */
7180
7181 if (!r->in.buffer && (r->in.offered != 0)) {
7182 return WERR_INVALID_PARAM;
7183 }
7184
7185 DEBUG(4,("_spoolss_EnumPorts\n"));
7186
7187 *r->out.count = 0;
7188 *r->out.needed = 0;
7189 *r->out.info = NULL;
7190
7191 switch (r->in.level) {
7192 case 1:
7193 result = enumports_level_1(p->mem_ctx, r->out.info,
7194 r->out.count);
7195 break;
7196 case 2:
7197 result = enumports_level_2(p->mem_ctx, r->out.info,
7198 r->out.count);
7199 break;
7200 default:
7201 return WERR_UNKNOWN_LEVEL;
7202 }
7203
7204 if (!W_ERROR_IS_OK(result)) {
7205 return result;
7206 }
7207
7208 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7209 spoolss_EnumPorts, NULL,
7210 *r->out.info, r->in.level,
7211 *r->out.count);
7212 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7213 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7214
7215 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7216 }
7217
7218 /****************************************************************************
7219 ****************************************************************************/
7220
7221 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7222 const char *server,
7223 struct spoolss_SetPrinterInfoCtr *info_ctr,
7224 struct spoolss_DeviceMode *devmode,
7225 struct security_descriptor *sec_desc,
7226 struct spoolss_UserLevelCtr *user_ctr,
7227 struct policy_handle *handle)
7228 {
7229 NT_PRINTER_INFO_LEVEL *printer = NULL;
7230 fstring name;
7231 int snum;
7232 WERROR err = WERR_OK;
7233
7234 if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7235 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7236 return WERR_NOMEM;
7237 }
7238
7239 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7240 if (!convert_printer_info(info_ctr, printer)) {
7241 free_a_printer(&printer, 2);
7242 return WERR_NOMEM;
7243 }
7244
7245 /* samba does not have a concept of local, non-shared printers yet, so
7246 * make sure we always setup sharename - gd */
7247 if ((printer->info_2->sharename[0] == '\0') && (printer->info_2->printername != '\0')) {
7248 DEBUG(5, ("spoolss_addprinterex_level_2: "
7249 "no sharename has been set, setting printername %s as sharename\n",
7250 printer->info_2->printername));
7251 fstrcpy(printer->info_2->sharename, printer->info_2->printername);
7252 }
7253
7254 /* check to see if the printer already exists */
7255
7256 if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7257 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7258 printer->info_2->sharename));
7259 free_a_printer(&printer, 2);
7260 return WERR_PRINTER_ALREADY_EXISTS;
7261 }
7262
7263 if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
7264 if ((snum = print_queue_snum(printer->info_2->printername)) != -1) {
7265 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7266 printer->info_2->printername));
7267 free_a_printer(&printer, 2);
7268 return WERR_PRINTER_ALREADY_EXISTS;
7269 }
7270 }
7271
7272 /* validate printer info struct */
7273 if (!info_ctr->info.info2->printername ||
7274 strlen(info_ctr->info.info2->printername) == 0) {
7275 free_a_printer(&printer,2);
7276 return WERR_INVALID_PRINTER_NAME;
7277 }
7278 if (!info_ctr->info.info2->portname ||
7279 strlen(info_ctr->info.info2->portname) == 0) {
7280 free_a_printer(&printer,2);
7281 return WERR_UNKNOWN_PORT;
7282 }
7283 if (!info_ctr->info.info2->drivername ||
7284 strlen(info_ctr->info.info2->drivername) == 0) {
7285 free_a_printer(&printer,2);
7286 return WERR_UNKNOWN_PRINTER_DRIVER;
7287 }
7288 if (!info_ctr->info.info2->printprocessor ||
7289 strlen(info_ctr->info.info2->printprocessor) == 0) {
7290 free_a_printer(&printer,2);
7291 return WERR_UNKNOWN_PRINTPROCESSOR;
7292 }
7293
7294 /* FIXME!!! smbd should check to see if the driver is installed before
7295 trying to add a printer like this --jerry */
7296
7297 if (*lp_addprinter_cmd() ) {
7298 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7299 printer) ) {
7300 free_a_printer(&printer,2);
7301 return WERR_ACCESS_DENIED;
7302 }
7303 } else {
7304 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7305 "smb.conf parameter \"addprinter command\" is defined. This"
7306 "parameter must exist for this call to succeed\n",
7307 printer->info_2->sharename ));
7308 }
7309
7310 /* use our primary netbios name since get_a_printer() will convert
7311 it to what the client expects on a case by case basis */
7312
7313 slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7314 printer->info_2->sharename);
7315
7316
7317 if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7318 free_a_printer(&printer,2);
7319 return WERR_ACCESS_DENIED;
7320 }
7321
7322 /* you must be a printer admin to add a new printer */
7323 if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
7324 free_a_printer(&printer,2);
7325 return WERR_ACCESS_DENIED;
7326 }
7327
7328 /*
7329 * Do sanity check on the requested changes for Samba.
7330 */
7331
7332 if (!check_printer_ok(printer->info_2, snum)) {
7333 free_a_printer(&printer,2);
7334 return WERR_INVALID_PARAM;
7335 }
7336
7337 /*
7338 * When a printer is created, the drivername bound to the printer is used
7339 * to lookup previously saved driver initialization info, which is then
7340 * bound to the new printer, simulating what happens in the Windows arch.
7341 */
7342
7343 if (!devmode)
7344 {
7345 set_driver_init(printer, 2);
7346 }
7347 else
7348 {
7349 /* A valid devmode was included, convert and link it
7350 */
7351 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7352
7353 if (!convert_devicemode(printer->info_2->printername, devmode,
7354 &printer->info_2->devmode)) {
7355 return WERR_NOMEM;
7356 }
7357 }
7358
7359 /* write the ASCII on disk */
7360 err = mod_a_printer(printer, 2);
7361 if (!W_ERROR_IS_OK(err)) {
7362 free_a_printer(&printer,2);
7363 return err;
7364 }
7365
7366 if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7367 /* Handle open failed - remove addition. */
7368 del_a_printer(printer->info_2->sharename);
7369 free_a_printer(&printer,2);
7370 ZERO_STRUCTP(handle);
7371 return WERR_ACCESS_DENIED;
7372 }
7373
7374 update_c_setprinter(false);
7375 free_a_printer(&printer,2);
7376
7377 return WERR_OK;
7378 }
7379
7380 /****************************************************************
7381 _spoolss_AddPrinterEx
7382 ****************************************************************/
7383
7384 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7385 struct spoolss_AddPrinterEx *r)
7386 {
7387 switch (r->in.info_ctr->level) {
7388 case 1:
7389 /* we don't handle yet */
7390 /* but I know what to do ... */
7391 return WERR_UNKNOWN_LEVEL;
7392 case 2:
7393 return spoolss_addprinterex_level_2(p, r->in.server,
7394 r->in.info_ctr,
7395 r->in.devmode_ctr->devmode,
7396 r->in.secdesc_ctr->sd,
7397 r->in.userlevel_ctr,
7398 r->out.handle);
7399 default:
7400 return WERR_UNKNOWN_LEVEL;
7401 }
7402 }
7403
7404 /****************************************************************
7405 _spoolss_AddPrinter
7406 ****************************************************************/
7407
7408 WERROR _spoolss_AddPrinter(pipes_struct *p,
7409 struct spoolss_AddPrinter *r)
7410 {
7411 struct spoolss_AddPrinterEx a;
7412 struct spoolss_UserLevelCtr userlevel_ctr;
7413
7414 ZERO_STRUCT(userlevel_ctr);
7415
7416 userlevel_ctr.level = 1;
7417
7418 a.in.server = r->in.server;
7419 a.in.info_ctr = r->in.info_ctr;
7420 a.in.devmode_ctr = r->in.devmode_ctr;
7421 a.in.secdesc_ctr = r->in.secdesc_ctr;
7422 a.in.userlevel_ctr = &userlevel_ctr;
7423 a.out.handle = r->out.handle;
7424
7425 return _spoolss_AddPrinterEx(p, &a);
7426 }
7427
7428 /****************************************************************
7429 _spoolss_AddPrinterDriverEx
7430 ****************************************************************/
7431
7432 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7433 struct spoolss_AddPrinterDriverEx *r)
7434 {
7435 WERROR err = WERR_OK;
7436 char *driver_name = NULL;
7437 uint32_t version;
7438 const char *fn;
7439
7440 switch (p->hdr_req.opnum) {
7441 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7442 fn = "_spoolss_AddPrinterDriver";
7443 break;
7444 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7445 fn = "_spoolss_AddPrinterDriverEx";
7446 break;
7447 default:
7448 return WERR_INVALID_PARAM;
7449 }
7450
7451 /*
7452 * we only support the semantics of AddPrinterDriver()
7453 * i.e. only copy files that are newer than existing ones
7454 */
7455
7456 if (r->in.flags == 0) {
7457 return WERR_INVALID_PARAM;
7458 }
7459
7460 if (r->in.flags != APD_COPY_NEW_FILES) {
7461 return WERR_ACCESS_DENIED;
7462 }
7463
7464 /* FIXME */
7465 if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
7466 /* Clever hack from Martin Zielinski <mz@seh.de>
7467 * to allow downgrade from level 8 (Vista).
7468 */
7469 DEBUG(0,("%s: level %d not yet implemented\n", fn,
7470 r->in.info_ctr->level));
7471 return WERR_UNKNOWN_LEVEL;
7472 }
7473
7474 DEBUG(5,("Cleaning driver's information\n"));
7475 err = clean_up_driver_struct(p, r->in.info_ctr);
7476 if (!W_ERROR_IS_OK(err))
7477 goto done;
7478
7479 DEBUG(5,("Moving driver to final destination\n"));
7480 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, r->in.info_ctr,
7481 &err)) ) {
7482 goto done;
7483 }
7484
7485 if (add_a_printer_driver(p->mem_ctx, r->in.info_ctr, &driver_name, &version)!=0) {
7486 err = WERR_ACCESS_DENIED;
7487 goto done;
7488 }
7489
7490 /*
7491 * I think this is where he DrvUpgradePrinter() hook would be
7492 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7493 * server. Right now, we just need to send ourselves a message
7494 * to update each printer bound to this driver. --jerry
7495 */
7496
7497 if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7498 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7499 fn, driver_name));
7500 }
7501
7502 /*
7503 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7504 * decide if the driver init data should be deleted. The rules are:
7505 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7506 * 2) delete init data only if there is no 2k/Xp driver
7507 * 3) always delete init data
7508 * The generalized rule is always use init data from the highest order driver.
7509 * It is necessary to follow the driver install by an initialization step to
7510 * finish off this process.
7511 */
7512
7513 switch (version) {
7514 /*
7515 * 9x printer driver - never delete init data
7516 */
7517 case 0:
7518 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7519 fn, driver_name));
7520 break;
7521
7522 /*
7523 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7524 * there is no 2k/Xp driver init data for this driver name.
7525 */
7526 case 2:
7527 {
7528 struct spoolss_DriverInfo8 *driver1;
7529
7530 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &driver1, driver_name, "Windows NT x86", 3))) {
7531 /*
7532 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7533 */
7534 if (!del_driver_init(driver_name))
7535 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7536 fn, driver_name));
7537 } else {
7538 /*
7539 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7540 */
7541 free_a_printer_driver(driver1);
7542 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7543 fn, driver_name));
7544 }
7545 }
7546 break;
7547
7548 /*
7549 * 2k or Xp printer driver - always delete init data
7550 */
7551 case 3:
7552 if (!del_driver_init(driver_name))
7553 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7554 fn, driver_name));
7555 break;
7556
7557 default:
7558 DEBUG(0,("%s: invalid level=%d\n", fn,
7559 r->in.info_ctr->level));
7560 break;
7561 }
7562
7563
7564 done:
7565 return err;
7566 }
7567
7568 /****************************************************************
7569 _spoolss_AddPrinterDriver
7570 ****************************************************************/
7571
7572 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7573 struct spoolss_AddPrinterDriver *r)
7574 {
7575 struct spoolss_AddPrinterDriverEx a;
7576
7577 switch (r->in.info_ctr->level) {
7578 case 2:
7579 case 3:
7580 case 4:
7581 case 5:
7582 break;
7583 default:
7584 return WERR_UNKNOWN_LEVEL;
7585 }
7586
7587 a.in.servername = r->in.servername;
7588 a.in.info_ctr = r->in.info_ctr;
7589 a.in.flags = APD_COPY_NEW_FILES;
7590
7591 return _spoolss_AddPrinterDriverEx(p, &a);
7592 }
7593
7594 /****************************************************************************
7595 ****************************************************************************/
7596
7597 struct _spoolss_paths {
7598 int type;
7599 const char *share;
7600 const char *dir;
7601 };
7602
7603 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7604
7605 static const struct _spoolss_paths spoolss_paths[]= {
7606 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
7607 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
7608 };
7609
7610 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7611 const char *servername,
7612 const char *environment,
7613 int component,
7614 char **path)
7615 {
7616 const char *pservername = NULL;
7617 const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7618 const char *short_archi;
7619
7620 *path = NULL;
7621
7622 /* environment may be empty */
7623 if (environment && strlen(environment)) {
7624 long_archi = environment;
7625 }
7626
7627 /* servername may be empty */
7628 if (servername && strlen(servername)) {
7629 pservername = canon_servername(servername);
7630
7631 if (!is_myname_or_ipaddr(pservername)) {
7632 return WERR_INVALID_PARAM;
7633 }
7634 }
7635
7636 if (!(short_archi = get_short_archi(long_archi))) {
7637 return WERR_INVALID_ENVIRONMENT;
7638 }
7639
7640 switch (component) {
7641 case SPOOLSS_PRTPROCS_PATH:
7642 case SPOOLSS_DRIVER_PATH:
7643 if (pservername) {
7644 *path = talloc_asprintf(mem_ctx,
7645 "\\\\%s\\%s\\%s",
7646 pservername,
7647 spoolss_paths[component].share,
7648 short_archi);
7649 } else {
7650 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7651 SPOOLSS_DEFAULT_SERVER_PATH,
7652 spoolss_paths[component].dir,
7653 short_archi);
7654 }
7655 break;
7656 default:
7657 return WERR_INVALID_PARAM;
7658 }
7659
7660 if (!*path) {
7661 return WERR_NOMEM;
7662 }
7663
7664 return WERR_OK;
7665 }
7666
7667 /****************************************************************************
7668 ****************************************************************************/
7669
7670 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7671 const char *servername,
7672 const char *environment,
7673 struct spoolss_DriverDirectoryInfo1 *r)
7674 {
7675 WERROR werr;
7676 char *path = NULL;
7677
7678 werr = compose_spoolss_server_path(mem_ctx,
7679 servername,
7680 environment,
7681 SPOOLSS_DRIVER_PATH,
7682 &path);
7683 if (!W_ERROR_IS_OK(werr)) {
7684 return werr;
7685 }
7686
7687 DEBUG(4,("printer driver directory: [%s]\n", path));
7688
7689 r->directory_name = path;
7690
7691 return WERR_OK;
7692 }
7693
7694 /****************************************************************
7695 _spoolss_GetPrinterDriverDirectory
7696 ****************************************************************/
7697
7698 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7699 struct spoolss_GetPrinterDriverDirectory *r)
7700 {
7701 WERROR werror;
7702
7703 /* that's an [in out] buffer */
7704
7705 if (!r->in.buffer && (r->in.offered != 0)) {
7706 return WERR_INVALID_PARAM;
7707 }
7708
7709 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7710 r->in.level));
7711
7712 *r->out.needed = 0;
7713
7714 /* r->in.level is ignored */
7715
7716 werror = getprinterdriverdir_level_1(p->mem_ctx,
7717 r->in.server,
7718 r->in.environment,
7719 &r->out.info->info1);
7720 if (!W_ERROR_IS_OK(werror)) {
7721 TALLOC_FREE(r->out.info);
7722 return werror;
7723 }
7724
7725 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
7726 r->out.info, r->in.level);
7727 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7728
7729 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7730 }
7731
7732 /****************************************************************
7733 _spoolss_EnumPrinterData
7734 ****************************************************************/
7735
7736 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
7737 struct spoolss_EnumPrinterData *r)
7738 {
7739 WERROR result;
7740 struct spoolss_EnumPrinterDataEx r2;
7741 uint32_t count;
7742 struct spoolss_PrinterEnumValues *info, *val = NULL;
7743 uint32_t needed;
7744
7745 r2.in.handle = r->in.handle;
7746 r2.in.key_name = "PrinterDriverData";
7747 r2.in.offered = 0;
7748 r2.out.count = &count;
7749 r2.out.info = &info;
7750 r2.out.needed = &needed;
7751
7752 result = _spoolss_EnumPrinterDataEx(p, &r2);
7753 if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
7754 r2.in.offered = needed;
7755 result = _spoolss_EnumPrinterDataEx(p, &r2);
7756 }
7757 if (!W_ERROR_IS_OK(result)) {
7758 return result;
7759 }
7760
7761 /*
7762 * The NT machine wants to know the biggest size of value and data
7763 *
7764 * cf: MSDN EnumPrinterData remark section
7765 */
7766
7767 if (!r->in.value_offered && !r->in.data_offered) {
7768 uint32_t biggest_valuesize = 0;
7769 uint32_t biggest_datasize = 0;
7770 int i, name_length;
7771
7772 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7773
7774 for (i=0; i<count; i++) {
7775
7776 name_length = strlen(info[i].value_name);
7777 if (strlen(info[i].value_name) > biggest_valuesize) {
7778 biggest_valuesize = name_length;
7779 }
7780
7781 if (info[i].data_length > biggest_datasize) {
7782 biggest_datasize = info[i].data_length;
7783 }
7784
7785 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
7786 biggest_datasize));
7787 }
7788
7789 /* the value is an UNICODE string but real_value_size is the length
7790 in bytes including the trailing 0 */
7791
7792 *r->out.value_needed = 2 * (1 + biggest_valuesize);
7793 *r->out.data_needed = biggest_datasize;
7794
7795 DEBUG(6,("final values: [%d], [%d]\n",
7796 *r->out.value_needed, *r->out.data_needed));
7797
7798 return WERR_OK;
7799 }
7800
7801 if (r->in.enum_index < count) {
7802 val = &info[r->in.enum_index];
7803 }
7804
7805 if (val == NULL) {
7806 /* out_value should default to "" or else NT4 has
7807 problems unmarshalling the response */
7808
7809 if (r->in.value_offered) {
7810 *r->out.value_needed = 1;
7811 r->out.value_name = talloc_strdup(r, "");
7812 if (!r->out.value_name) {
7813 return WERR_NOMEM;
7814 }
7815 } else {
7816 r->out.value_name = NULL;
7817 *r->out.value_needed = 0;
7818 }
7819
7820 /* the data is counted in bytes */
7821
7822 *r->out.data_needed = r->in.data_offered;
7823
7824 result = WERR_NO_MORE_ITEMS;
7825 } else {
7826 /*
7827 * the value is:
7828 * - counted in bytes in the request
7829 * - counted in UNICODE chars in the max reply
7830 * - counted in bytes in the real size
7831 *
7832 * take a pause *before* coding not *during* coding
7833 */
7834
7835 /* name */
7836 if (r->in.value_offered) {
7837 r->out.value_name = talloc_strdup(r, val->value_name);
7838 if (!r->out.value_name) {
7839 return WERR_NOMEM;
7840 }
7841 *r->out.value_needed = val->value_name_len;
7842 } else {
7843 r->out.value_name = NULL;
7844 *r->out.value_needed = 0;
7845 }
7846
7847 /* type */
7848
7849 *r->out.type = val->type;
7850
7851 /* data - counted in bytes */
7852
7853 /*
7854 * See the section "Dynamically Typed Query Parameters"
7855 * in MS-RPRN.
7856 */
7857
7858 if (r->out.data && val->data && val->data->data &&
7859 val->data_length && r->in.data_offered) {
7860 memcpy(r->out.data, val->data->data,
7861 MIN(val->data_length,r->in.data_offered));
7862 }
7863
7864 *r->out.data_needed = val->data_length;
7865
7866 result = WERR_OK;
7867 }
7868
7869 return result;
7870 }
7871
7872 /****************************************************************
7873 _spoolss_SetPrinterData
7874 ****************************************************************/
7875
7876 WERROR _spoolss_SetPrinterData(pipes_struct *p,
7877 struct spoolss_SetPrinterData *r)
7878 {
7879 struct spoolss_SetPrinterDataEx r2;
7880
7881 r2.in.handle = r->in.handle;
7882 r2.in.key_name = "PrinterDriverData";
7883 r2.in.value_name = r->in.value_name;
7884 r2.in.type = r->in.type;
7885 r2.in.data = r->in.data;
7886 r2.in.offered = r->in.offered;
7887
7888 return _spoolss_SetPrinterDataEx(p, &r2);
7889 }
7890
7891 /****************************************************************
7892 _spoolss_ResetPrinter
7893 ****************************************************************/
7894
7895 WERROR _spoolss_ResetPrinter(pipes_struct *p,
7896 struct spoolss_ResetPrinter *r)
7897 {
7898 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7899 int snum;
7900
7901 DEBUG(5,("_spoolss_ResetPrinter\n"));
7902
7903 /*
7904 * All we do is to check to see if the handle and queue is valid.
7905 * This call really doesn't mean anything to us because we only
7906 * support RAW printing. --jerry
7907 */
7908
7909 if (!Printer) {
7910 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
7911 OUR_HANDLE(r->in.handle)));
7912 return WERR_BADFID;
7913 }
7914
7915 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7916 return WERR_BADFID;
7917
7918
7919 /* blindly return success */
7920 return WERR_OK;
7921 }
7922
7923 /****************************************************************
7924 _spoolss_DeletePrinterData
7925 ****************************************************************/
7926
7927 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
7928 struct spoolss_DeletePrinterData *r)
7929 {
7930 struct spoolss_DeletePrinterDataEx r2;
7931
7932 r2.in.handle = r->in.handle;
7933 r2.in.key_name = "PrinterDriverData";
7934 r2.in.value_name = r->in.value_name;
7935
7936 return _spoolss_DeletePrinterDataEx(p, &r2);
7937 }
7938
7939 /****************************************************************
7940 _spoolss_AddForm
7941 ****************************************************************/
7942
7943 WERROR _spoolss_AddForm(pipes_struct *p,
7944 struct spoolss_AddForm *r)
7945 {
7946 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
7947 nt_forms_struct tmpForm;
7948 int snum = -1;
7949 WERROR status = WERR_OK;
7950 NT_PRINTER_INFO_LEVEL *printer = NULL;
7951 SE_PRIV se_printop = SE_PRINT_OPERATOR;
7952
7953 int count=0;
7954 nt_forms_struct *list=NULL;
7955 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7956 int i;
7957
7958 DEBUG(5,("_spoolss_AddForm\n"));
7959
7960 if (!Printer) {
7961 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
7962 OUR_HANDLE(r->in.handle)));
7963 return WERR_BADFID;
7964 }
7965
7966
7967 /* forms can be added on printer or on the print server handle */
7968
7969 if ( Printer->printer_type == SPLHND_PRINTER )
7970 {
7971 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7972 return WERR_BADFID;
7973
7974 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7975 if (!W_ERROR_IS_OK(status))
7976 goto done;
7977 }
7978
7979 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
7980 and not a printer admin, then fail */
7981
7982 if ((p->server_info->utok.uid != sec_initial_uid()) &&
7983 !user_has_privileges(p->server_info->ptok, &se_printop) &&
7984 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7985 NULL, NULL,
7986 p->server_info->ptok,
7987 lp_printer_admin(snum))) {
7988 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
7989 status = WERR_ACCESS_DENIED;
7990 goto done;
7991 }
7992
7993 switch (form->flags) {
7994 case SPOOLSS_FORM_USER:
7995 case SPOOLSS_FORM_BUILTIN:
7996 case SPOOLSS_FORM_PRINTER:
7997 break;
7998 default:
7999 status = WERR_INVALID_PARAM;
8000 goto done;
8001 }
8002
8003 /* can't add if builtin */
8004
8005 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8006 status = WERR_FILE_EXISTS;
8007 goto done;
8008 }
8009
8010 count = get_ntforms(&list);
8011
8012 for (i=0; i < count; i++) {
8013 if (strequal(form->form_name, list[i].name)) {
8014 status = WERR_FILE_EXISTS;
8015 goto done;
8016 }
8017 }
8018
8019 if(!add_a_form(&list, form, &count)) {
8020 status = WERR_NOMEM;
8021 goto done;
8022 }
8023
8024 become_root();
8025 write_ntforms(&list, count);
8026 unbecome_root();
8027
8028 /*
8029 * ChangeID must always be set if this is a printer
8030 */
8031
8032 if ( Printer->printer_type == SPLHND_PRINTER )
8033 status = mod_a_printer(printer, 2);
8034
8035 done:
8036 if ( printer )
8037 free_a_printer(&printer, 2);
8038 SAFE_FREE(list);
8039
8040 return status;
8041 }
8042
8043 /****************************************************************
8044 _spoolss_DeleteForm
8045 ****************************************************************/
8046
8047 WERROR _spoolss_DeleteForm(pipes_struct *p,
8048 struct spoolss_DeleteForm *r)
8049 {
8050 const char *form_name = r->in.form_name;
8051 nt_forms_struct tmpForm;
8052 int count=0;
8053 nt_forms_struct *list=NULL;
8054 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8055 int snum = -1;
8056 WERROR status = WERR_OK;
8057 NT_PRINTER_INFO_LEVEL *printer = NULL;
8058 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8059 bool ret = false;
8060
8061 DEBUG(5,("_spoolss_DeleteForm\n"));
8062
8063 if (!Printer) {
8064 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8065 OUR_HANDLE(r->in.handle)));
8066 return WERR_BADFID;
8067 }
8068
8069 /* forms can be deleted on printer of on the print server handle */
8070
8071 if ( Printer->printer_type == SPLHND_PRINTER )
8072 {
8073 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8074 return WERR_BADFID;
8075
8076 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8077 if (!W_ERROR_IS_OK(status))
8078 goto done;
8079 }
8080
8081 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8082 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8083 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8084 NULL, NULL,
8085 p->server_info->ptok,
8086 lp_printer_admin(snum))) {
8087 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8088 return WERR_ACCESS_DENIED;
8089 }
8090
8091
8092 /* can't delete if builtin */
8093
8094 if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8095 status = WERR_INVALID_PARAM;
8096 goto done;
8097 }
8098
8099 count = get_ntforms(&list);
8100
8101 become_root();
8102 ret = delete_a_form(&list, form_name, &count, &status);
8103 unbecome_root();
8104 if (ret == false) {
8105 goto done;
8106 }
8107
8108 /*
8109 * ChangeID must always be set if this is a printer
8110 */
8111
8112 if ( Printer->printer_type == SPLHND_PRINTER )
8113 status = mod_a_printer(printer, 2);
8114
8115 done:
8116 if ( printer )
8117 free_a_printer(&printer, 2);
8118 SAFE_FREE(list);
8119
8120 return status;
8121 }
8122
8123 /****************************************************************
8124 _spoolss_SetForm
8125 ****************************************************************/
8126
8127 WERROR _spoolss_SetForm(pipes_struct *p,
8128 struct spoolss_SetForm *r)
8129 {
8130 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8131 nt_forms_struct tmpForm;
8132 int snum = -1;
8133 WERROR status = WERR_OK;
8134 NT_PRINTER_INFO_LEVEL *printer = NULL;
8135 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8136
8137 int count=0;
8138 nt_forms_struct *list=NULL;
8139 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8140
8141 DEBUG(5,("_spoolss_SetForm\n"));
8142
8143 if (!Printer) {
8144 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8145 OUR_HANDLE(r->in.handle)));
8146 return WERR_BADFID;
8147 }
8148
8149 /* forms can be modified on printer of on the print server handle */
8150
8151 if ( Printer->printer_type == SPLHND_PRINTER )
8152 {
8153 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8154 return WERR_BADFID;
8155
8156 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8157 if (!W_ERROR_IS_OK(status))
8158 goto done;
8159 }
8160
8161 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8162 and not a printer admin, then fail */
8163
8164 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8165 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8166 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8167 NULL, NULL,
8168 p->server_info->ptok,
8169 lp_printer_admin(snum))) {
8170 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8171 status = WERR_ACCESS_DENIED;
8172 goto done;
8173 }
8174
8175 /* can't set if builtin */
8176 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8177 status = WERR_INVALID_PARAM;
8178 goto done;
8179 }
8180
8181 count = get_ntforms(&list);
8182 update_a_form(&list, form, count);
8183 become_root();
8184 write_ntforms(&list, count);
8185 unbecome_root();
8186
8187 /*
8188 * ChangeID must always be set if this is a printer
8189 */
8190
8191 if ( Printer->printer_type == SPLHND_PRINTER )
8192 status = mod_a_printer(printer, 2);
8193
8194
8195 done:
8196 if ( printer )
8197 free_a_printer(&printer, 2);
8198 SAFE_FREE(list);
8199
8200 return status;
8201 }
8202
8203 /****************************************************************************
8204 fill_print_processor1
8205 ****************************************************************************/
8206
8207 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8208 struct spoolss_PrintProcessorInfo1 *r,
8209 const char *print_processor_name)
8210 {
8211 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8212 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8213
8214 return WERR_OK;
8215 }
8216
8217 /****************************************************************************
8218 enumprintprocessors level 1.
8219 ****************************************************************************/
8220
8221 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8222 union spoolss_PrintProcessorInfo **info_p,
8223 uint32_t *count)
8224 {
8225 union spoolss_PrintProcessorInfo *info;
8226 WERROR result;
8227
8228 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8229 W_ERROR_HAVE_NO_MEMORY(info);
8230
8231 *count = 1;
8232
8233 result = fill_print_processor1(info, &info[0].info1, "winprint");
8234 if (!W_ERROR_IS_OK(result)) {
8235 goto out;
8236 }
8237
8238 out:
8239 if (!W_ERROR_IS_OK(result)) {
8240 TALLOC_FREE(info);
8241 *count = 0;
8242 return result;
8243 }
8244
8245 *info_p = info;
8246
8247 return WERR_OK;
8248 }
8249
8250 /****************************************************************
8251 _spoolss_EnumPrintProcessors
8252 ****************************************************************/
8253
8254 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8255 struct spoolss_EnumPrintProcessors *r)
8256 {
8257 WERROR result;
8258
8259 /* that's an [in out] buffer */
8260
8261 if (!r->in.buffer && (r->in.offered != 0)) {
8262 return WERR_INVALID_PARAM;
8263 }
8264
8265 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8266
8267 /*
8268 * Enumerate the print processors ...
8269 *
8270 * Just reply with "winprint", to keep NT happy
8271 * and I can use my nice printer checker.
8272 */
8273
8274 *r->out.count = 0;
8275 *r->out.needed = 0;
8276 *r->out.info = NULL;
8277
8278 switch (r->in.level) {
8279 case 1:
8280 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8281 r->out.count);
8282 break;
8283 default:
8284 return WERR_UNKNOWN_LEVEL;
8285 }
8286
8287 if (!W_ERROR_IS_OK(result)) {
8288 return result;
8289 }
8290
8291 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8292 spoolss_EnumPrintProcessors, NULL,
8293 *r->out.info, r->in.level,
8294 *r->out.count);
8295 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8296 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8297
8298 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8299 }
8300
8301 /****************************************************************************
8302 fill_printprocdatatype1
8303 ****************************************************************************/
8304
8305 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8306 struct spoolss_PrintProcDataTypesInfo1 *r,
8307 const char *name_array)
8308 {
8309 r->name_array = talloc_strdup(mem_ctx, name_array);
8310 W_ERROR_HAVE_NO_MEMORY(r->name_array);
8311
8312 return WERR_OK;
8313 }
8314
8315 /****************************************************************************
8316 enumprintprocdatatypes level 1.
8317 ****************************************************************************/
8318
8319 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8320 union spoolss_PrintProcDataTypesInfo **info_p,
8321 uint32_t *count)
8322 {
8323 WERROR result;
8324 union spoolss_PrintProcDataTypesInfo *info;
8325
8326 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8327 W_ERROR_HAVE_NO_MEMORY(info);
8328
8329 *count = 1;
8330
8331 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8332 if (!W_ERROR_IS_OK(result)) {
8333 goto out;
8334 }
8335
8336 out:
8337 if (!W_ERROR_IS_OK(result)) {
8338 TALLOC_FREE(info);
8339 *count = 0;
8340 return result;
8341 }
8342
8343 *info_p = info;
8344
8345 return WERR_OK;
8346 }
8347
8348 /****************************************************************
8349 _spoolss_EnumPrintProcDataTypes
8350 ****************************************************************/
8351
8352 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8353 struct spoolss_EnumPrintProcDataTypes *r)
8354 {
8355 WERROR result;
8356
8357 /* that's an [in out] buffer */
8358
8359 if (!r->in.buffer && (r->in.offered != 0)) {
8360 return WERR_INVALID_PARAM;
8361 }
8362
8363 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8364
8365 *r->out.count = 0;
8366 *r->out.needed = 0;
8367 *r->out.info = NULL;
8368
8369 switch (r->in.level) {
8370 case 1:
8371 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8372 r->out.count);
8373 break;
8374 default:
8375 return WERR_UNKNOWN_LEVEL;
8376 }
8377
8378 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8379 spoolss_EnumPrintProcDataTypes, NULL,
8380 *r->out.info, r->in.level,
8381 *r->out.count);
8382 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8383 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8384
8385 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8386 }
8387
8388 /****************************************************************************
8389 fill_monitor_1
8390 ****************************************************************************/
8391
8392 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8393 struct spoolss_MonitorInfo1 *r,
8394 const char *monitor_name)
8395 {
8396 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8397 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8398
8399 return WERR_OK;
8400 }
8401
8402 /****************************************************************************
8403 fill_monitor_2
8404 ****************************************************************************/
8405
8406 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8407 struct spoolss_MonitorInfo2 *r,
8408 const char *monitor_name,
8409 const char *environment,
8410 const char *dll_name)
8411 {
8412 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8413 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8414 r->environment = talloc_strdup(mem_ctx, environment);
8415 W_ERROR_HAVE_NO_MEMORY(r->environment);
8416 r->dll_name = talloc_strdup(mem_ctx, dll_name);
8417 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8418
8419 return WERR_OK;
8420 }
8421
8422 /****************************************************************************
8423 enumprintmonitors level 1.
8424 ****************************************************************************/
8425
8426 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8427 union spoolss_MonitorInfo **info_p,
8428 uint32_t *count)
8429 {
8430 union spoolss_MonitorInfo *info;
8431 WERROR result = WERR_OK;
8432
8433 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8434 W_ERROR_HAVE_NO_MEMORY(info);
8435
8436 *count = 2;
8437
8438 result = fill_monitor_1(info, &info[0].info1,
8439 SPL_LOCAL_PORT);
8440 if (!W_ERROR_IS_OK(result)) {
8441 goto out;
8442 }
8443
8444 result = fill_monitor_1(info, &info[1].info1,
8445 SPL_TCPIP_PORT);
8446 if (!W_ERROR_IS_OK(result)) {
8447 goto out;
8448 }
8449
8450 out:
8451 if (!W_ERROR_IS_OK(result)) {
8452 TALLOC_FREE(info);
8453 *count = 0;
8454 return result;
8455 }
8456
8457 *info_p = info;
8458
8459 return WERR_OK;
8460 }
8461
8462 /****************************************************************************
8463 enumprintmonitors level 2.
8464 ****************************************************************************/
8465
8466 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8467 union spoolss_MonitorInfo **info_p,
8468 uint32_t *count)
8469 {
8470 union spoolss_MonitorInfo *info;
8471 WERROR result = WERR_OK;
8472
8473 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8474 W_ERROR_HAVE_NO_MEMORY(info);
8475
8476 *count = 2;
8477
8478 result = fill_monitor_2(info, &info[0].info2,
8479 SPL_LOCAL_PORT,
8480 "Windows NT X86", /* FIXME */
8481 "localmon.dll");
8482 if (!W_ERROR_IS_OK(result)) {
8483 goto out;
8484 }
8485
8486 result = fill_monitor_2(info, &info[1].info2,
8487 SPL_TCPIP_PORT,
8488 "Windows NT X86", /* FIXME */
8489 "tcpmon.dll");
8490 if (!W_ERROR_IS_OK(result)) {
8491 goto out;
8492 }
8493
8494 out:
8495 if (!W_ERROR_IS_OK(result)) {
8496 TALLOC_FREE(info);
8497 *count = 0;
8498 return result;
8499 }
8500
8501 *info_p = info;
8502
8503 return WERR_OK;
8504 }
8505
8506 /****************************************************************
8507 _spoolss_EnumMonitors
8508 ****************************************************************/
8509
8510 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8511 struct spoolss_EnumMonitors *r)
8512 {
8513 WERROR result;
8514
8515 /* that's an [in out] buffer */
8516
8517 if (!r->in.buffer && (r->in.offered != 0)) {
8518 return WERR_INVALID_PARAM;
8519 }
8520
8521 DEBUG(5,("_spoolss_EnumMonitors\n"));
8522
8523 /*
8524 * Enumerate the print monitors ...
8525 *
8526 * Just reply with "Local Port", to keep NT happy
8527 * and I can use my nice printer checker.
8528 */
8529
8530 *r->out.count = 0;
8531 *r->out.needed = 0;
8532 *r->out.info = NULL;
8533
8534 switch (r->in.level) {
8535 case 1:
8536 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8537 r->out.count);
8538 break;
8539 case 2:
8540 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8541 r->out.count);
8542 break;
8543 default:
8544 return WERR_UNKNOWN_LEVEL;
8545 }
8546
8547 if (!W_ERROR_IS_OK(result)) {
8548 return result;
8549 }
8550
8551 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8552 spoolss_EnumMonitors, NULL,
8553 *r->out.info, r->in.level,
8554 *r->out.count);
8555 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8556 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8557
8558 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8559 }
8560
8561 /****************************************************************************
8562 ****************************************************************************/
8563
8564 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8565 const print_queue_struct *queue,
8566 int count, int snum,
8567 const NT_PRINTER_INFO_LEVEL *ntprinter,
8568 uint32_t jobid,
8569 struct spoolss_JobInfo1 *r)
8570 {
8571 int i = 0;
8572 bool found = false;
8573
8574 for (i=0; i<count; i++) {
8575 if (queue[i].job == (int)jobid) {
8576 found = true;
8577 break;
8578 }
8579 }
8580
8581 if (found == false) {
8582 /* NT treats not found as bad param... yet another bad choice */
8583 return WERR_INVALID_PARAM;
8584 }
8585
8586 return fill_job_info1(mem_ctx,
8587 r,
8588 &queue[i],
8589 i,
8590 snum,
8591 ntprinter);
8592 }
8593
8594 /****************************************************************************
8595 ****************************************************************************/
8596
8597 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8598 const print_queue_struct *queue,
8599 int count, int snum,
8600 const NT_PRINTER_INFO_LEVEL *ntprinter,
8601 uint32_t jobid,
8602 struct spoolss_JobInfo2 *r)
8603 {
8604 int i = 0;
8605 bool found = false;
8606 struct spoolss_DeviceMode *devmode;
8607 NT_DEVICEMODE *nt_devmode;
8608 WERROR result;
8609
8610 for (i=0; i<count; i++) {
8611 if (queue[i].job == (int)jobid) {
8612 found = true;
8613 break;
8614 }
8615 }
8616
8617 if (found == false) {
8618 /* NT treats not found as bad param... yet another bad
8619 choice */
8620 return WERR_INVALID_PARAM;
8621 }
8622
8623 /*
8624 * if the print job does not have a DEVMODE associated with it,
8625 * just use the one for the printer. A NULL devicemode is not
8626 * a failure condition
8627 */
8628
8629 nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8630 if (nt_devmode) {
8631 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
8632 W_ERROR_HAVE_NO_MEMORY(devmode);
8633 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
8634 if (!W_ERROR_IS_OK(result)) {
8635 return result;
8636 }
8637 } else {
8638 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
8639 W_ERROR_HAVE_NO_MEMORY(devmode);
8640 }
8641
8642 return fill_job_info2(mem_ctx,
8643 r,
8644 &queue[i],
8645 i,
8646 snum,
8647 ntprinter,
8648 devmode);
8649 }
8650
8651 /****************************************************************
8652 _spoolss_GetJob
8653 ****************************************************************/
8654
8655 WERROR _spoolss_GetJob(pipes_struct *p,
8656 struct spoolss_GetJob *r)
8657 {
8658 WERROR result = WERR_OK;
8659 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
8660 int snum;
8661 int count;
8662 print_queue_struct *queue = NULL;
8663 print_status_struct prt_status;
8664
8665 /* that's an [in out] buffer */
8666
8667 if (!r->in.buffer && (r->in.offered != 0)) {
8668 return WERR_INVALID_PARAM;
8669 }
8670
8671 DEBUG(5,("_spoolss_GetJob\n"));
8672
8673 *r->out.needed = 0;
8674
8675 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8676 return WERR_BADFID;
8677 }
8678
8679 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
8680 if (!W_ERROR_IS_OK(result)) {
8681 return result;
8682 }
8683
8684 count = print_queue_status(snum, &queue, &prt_status);
8685
8686 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8687 count, prt_status.status, prt_status.message));
8688
8689 switch (r->in.level) {
8690 case 1:
8691 result = getjob_level_1(p->mem_ctx,
8692 queue, count, snum, ntprinter,
8693 r->in.job_id, &r->out.info->info1);
8694 break;
8695 case 2:
8696 result = getjob_level_2(p->mem_ctx,
8697 queue, count, snum, ntprinter,
8698 r->in.job_id, &r->out.info->info2);
8699 break;
8700 default:
8701 result = WERR_UNKNOWN_LEVEL;
8702 break;
8703 }
8704
8705 SAFE_FREE(queue);
8706 free_a_printer(&ntprinter, 2);
8707
8708 if (!W_ERROR_IS_OK(result)) {
8709 TALLOC_FREE(r->out.info);
8710 return result;
8711 }
8712
8713 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
8714 r->out.info, r->in.level);
8715 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8716
8717 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8718 }
8719
8720 /****************************************************************
8721 _spoolss_GetPrinterDataEx
8722 ****************************************************************/
8723
8724 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
8725 struct spoolss_GetPrinterDataEx *r)
8726 {
8727
8728 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8729 struct regval_blob *val = NULL;
8730 NT_PRINTER_INFO_LEVEL *printer = NULL;
8731 int snum = 0;
8732 WERROR result = WERR_OK;
8733 DATA_BLOB blob;
8734
8735 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8736
8737 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8738 r->in.key_name, r->in.value_name));
8739
8740 /* in case of problem, return some default values */
8741
8742 *r->out.needed = 0;
8743 *r->out.type = REG_NONE;
8744
8745 if (!Printer) {
8746 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8747 OUR_HANDLE(r->in.handle)));
8748 result = WERR_BADFID;
8749 goto done;
8750 }
8751
8752 /* Is the handle to a printer or to the server? */
8753
8754 if (Printer->printer_type == SPLHND_SERVER) {
8755
8756 union spoolss_PrinterData data;
8757
8758 result = getprinterdata_printer_server(p->mem_ctx,
8759 r->in.value_name,
8760 r->out.type,
8761 &data);
8762 if (!W_ERROR_IS_OK(result)) {
8763 goto done;
8764 }
8765
8766 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8767 *r->out.type, &data);
8768 if (!W_ERROR_IS_OK(result)) {
8769 goto done;
8770 }
8771
8772 *r->out.needed = blob.length;
8773
8774 if (r->in.offered >= *r->out.needed) {
8775 memcpy(r->out.data, blob.data, blob.length);
8776 }
8777
8778 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
8779 }
8780
8781 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8782 result = WERR_BADFID;
8783 goto done;
8784 }
8785
8786 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8787 if (!W_ERROR_IS_OK(result)) {
8788 goto done;
8789 }
8790
8791 /* check to see if the keyname is valid */
8792 if (!strlen(r->in.key_name)) {
8793 result = WERR_INVALID_PARAM;
8794 goto done;
8795 }
8796
8797 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
8798
8799 if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
8800 strequal(r->in.value_name, "ChangeId")) {
8801 *r->out.type = REG_DWORD;
8802 *r->out.needed = 4;
8803 if (r->in.offered >= *r->out.needed) {
8804 SIVAL(r->out.data, 0, printer->info_2->changeid);
8805 result = WERR_OK;
8806 }
8807 goto done;
8808 }
8809
8810 if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
8811 DEBUG(4,("_spoolss_GetPrinterDataEx: "
8812 "Invalid keyname [%s]\n", r->in.key_name ));
8813 result = WERR_BADFILE;
8814 goto done;
8815 }
8816
8817 val = get_printer_data(printer->info_2,
8818 r->in.key_name, r->in.value_name);
8819 if (!val) {
8820 result = WERR_BADFILE;
8821 goto done;
8822 }
8823
8824 *r->out.needed = regval_size(val);
8825 *r->out.type = regval_type(val);
8826
8827 if (r->in.offered >= *r->out.needed) {
8828 memcpy(r->out.data, regval_data_p(val), regval_size(val));
8829 }
8830 done:
8831 if (printer) {
8832 free_a_printer(&printer, 2);
8833 }
8834
8835 if (!W_ERROR_IS_OK(result)) {
8836 return result;
8837 }
8838
8839 *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
8840 r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
8841
8842 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
8843 }
8844
8845 /****************************************************************
8846 _spoolss_SetPrinterDataEx
8847 ****************************************************************/
8848
8849 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
8850 struct spoolss_SetPrinterDataEx *r)
8851 {
8852 NT_PRINTER_INFO_LEVEL *printer = NULL;
8853 int snum = 0;
8854 WERROR result = WERR_OK;
8855 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8856 char *oid_string;
8857
8858 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
8859
8860 /* From MSDN documentation of SetPrinterDataEx: pass request to
8861 SetPrinterData if key is "PrinterDriverData" */
8862
8863 if (!Printer) {
8864 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8865 OUR_HANDLE(r->in.handle)));
8866 return WERR_BADFID;
8867 }
8868
8869 if (Printer->printer_type == SPLHND_SERVER) {
8870 DEBUG(10,("_spoolss_SetPrinterDataEx: "
8871 "Not implemented for server handles yet\n"));
8872 return WERR_INVALID_PARAM;
8873 }
8874
8875 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8876 return WERR_BADFID;
8877 }
8878
8879 /*
8880 * Access check : NT returns "access denied" if you make a
8881 * SetPrinterData call without the necessary privildge.
8882 * we were originally returning OK if nothing changed
8883 * which made Win2k issue **a lot** of SetPrinterData
8884 * when connecting to a printer --jerry
8885 */
8886
8887 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8888 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
8889 "change denied by handle access permissions\n"));
8890 return WERR_ACCESS_DENIED;
8891 }
8892
8893 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8894 if (!W_ERROR_IS_OK(result)) {
8895 return result;
8896 }
8897
8898 /* check for OID in valuename */
8899
8900 oid_string = strchr(r->in.value_name, ',');
8901 if (oid_string) {
8902 *oid_string = '\0';
8903 oid_string++;
8904 }
8905
8906 /*
8907 * When client side code sets a magic printer data key, detect it and save
8908 * the current printer data and the magic key's data (its the DEVMODE) for
8909 * future printer/driver initializations.
8910 */
8911 if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8912 /* Set devmode and printer initialization info */
8913 result = save_driver_init(printer, 2, r->in.data, r->in.offered);
8914
8915 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8916
8917 goto done;
8918 }
8919
8920 /* save the registry data */
8921
8922 result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
8923 r->in.type, r->in.data, r->in.offered);
8924
8925 if (W_ERROR_IS_OK(result)) {
8926 /* save the OID if one was specified */
8927 if (oid_string) {
8928 char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
8929 r->in.key_name, SPOOL_OID_KEY);
8930 if (!str) {
8931 result = WERR_NOMEM;
8932 goto done;
8933 }
8934
8935 /*
8936 * I'm not checking the status here on purpose. Don't know
8937 * if this is right, but I'm returning the status from the
8938 * previous set_printer_dataex() call. I have no idea if
8939 * this is right. --jerry
8940 */
8941
8942 set_printer_dataex(printer, str, r->in.value_name,
8943 REG_SZ, (uint8_t *)oid_string,
8944 strlen(oid_string)+1);
8945 }
8946
8947 result = mod_a_printer(printer, 2);
8948 }
8949
8950 done:
8951 free_a_printer(&printer, 2);
8952
8953 return result;
8954 }
8955
8956 /****************************************************************
8957 _spoolss_DeletePrinterDataEx
8958 ****************************************************************/
8959
8960 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
8961 struct spoolss_DeletePrinterDataEx *r)
8962 {
8963 NT_PRINTER_INFO_LEVEL *printer = NULL;
8964 int snum=0;
8965 WERROR status = WERR_OK;
8966 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8967
8968 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
8969
8970 if (!Printer) {
8971 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
8972 "Invalid handle (%s:%u:%u).\n",
8973 OUR_HANDLE(r->in.handle)));
8974 return WERR_BADFID;
8975 }
8976
8977 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8978 return WERR_BADFID;
8979
8980 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8981 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
8982 "printer properties change denied by handle\n"));
8983 return WERR_ACCESS_DENIED;
8984 }
8985
8986 if (!r->in.value_name || !r->in.key_name) {
8987 return WERR_NOMEM;
8988 }
8989
8990 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8991 if (!W_ERROR_IS_OK(status))
8992 return status;
8993
8994 status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
8995
8996 if ( W_ERROR_IS_OK(status) )
8997 mod_a_printer( printer, 2 );
8998
8999 free_a_printer(&printer, 2);
9000
9001 return status;
9002 }
9003
9004 /****************************************************************
9005 _spoolss_EnumPrinterKey
9006 ****************************************************************/
9007
9008 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
9009 struct spoolss_EnumPrinterKey *r)
9010 {
9011 fstring *keynames = NULL;
9012 int num_keys;
9013 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9014 NT_PRINTER_DATA *data;
9015 NT_PRINTER_INFO_LEVEL *printer = NULL;
9016 int snum = 0;
9017 WERROR result = WERR_BADFILE;
9018 int i;
9019 const char **array = NULL;
9020 DATA_BLOB blob;
9021
9022 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9023
9024 if (!Printer) {
9025 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9026 OUR_HANDLE(r->in.handle)));
9027 return WERR_BADFID;
9028 }
9029
9030 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9031 return WERR_BADFID;
9032 }
9033
9034 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9035 if (!W_ERROR_IS_OK(result)) {
9036 return result;
9037 }
9038
9039 /* get the list of subkey names */
9040
9041 data = printer->info_2->data;
9042
9043 num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
9044 if (num_keys == -1) {
9045 result = WERR_BADFILE;
9046 goto done;
9047 }
9048
9049 array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 2);
9050 if (!array) {
9051 result = WERR_NOMEM;
9052 goto done;
9053 }
9054
9055 if (!num_keys) {
9056 array[0] = talloc_strdup(array, "");
9057 if (!array[0]) {
9058 result = WERR_NOMEM;
9059 goto done;
9060 }
9061 }
9062
9063 for (i=0; i < num_keys; i++) {
9064
9065 DEBUG(10,("_spoolss_EnumPrinterKey: adding keyname: %s\n",
9066 keynames[i]));
9067
9068 array[i] = talloc_strdup(array, keynames[i]);
9069 if (!array[i]) {
9070 result = WERR_NOMEM;
9071 goto done;
9072 }
9073 }
9074
9075 if (!push_reg_multi_sz(p->mem_ctx, NULL, &blob, array)) {
9076 result = WERR_NOMEM;
9077 goto done;
9078 }
9079
9080 *r->out._ndr_size = r->in.offered / 2;
9081 *r->out.needed = blob.length;
9082
9083 if (r->in.offered < *r->out.needed) {
9084 result = WERR_MORE_DATA;
9085 } else {
9086 result = WERR_OK;
9087 r->out.key_buffer->string_array = array;
9088 }
9089
9090 done:
9091 if (!W_ERROR_IS_OK(result)) {
9092 TALLOC_FREE(array);
9093 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
9094 *r->out.needed = 0;
9095 }
9096 }
9097
9098 free_a_printer(&printer, 2);
9099 SAFE_FREE(keynames);
9100
9101 return result;
9102 }
9103
9104 /****************************************************************
9105 _spoolss_DeletePrinterKey
9106 ****************************************************************/
9107
9108 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9109 struct spoolss_DeletePrinterKey *r)
9110 {
9111 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9112 NT_PRINTER_INFO_LEVEL *printer = NULL;
9113 int snum=0;
9114 WERROR status;
9115
9116 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9117
9118 if (!Printer) {
9119 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9120 OUR_HANDLE(r->in.handle)));
9121 return WERR_BADFID;
9122 }
9123
9124 /* if keyname == NULL, return error */
9125
9126 if ( !r->in.key_name )
9127 return WERR_INVALID_PARAM;
9128
9129 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9130 return WERR_BADFID;
9131
9132 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9133 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9134 "printer properties change denied by handle\n"));
9135 return WERR_ACCESS_DENIED;
9136 }
9137
9138 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9139 if (!W_ERROR_IS_OK(status))
9140 return status;
9141
9142 /* delete the key and all subneys */
9143
9144 status = delete_all_printer_data( printer->info_2, r->in.key_name );
9145
9146 if ( W_ERROR_IS_OK(status) )
9147 status = mod_a_printer(printer, 2);
9148
9149 free_a_printer( &printer, 2 );
9150
9151 return status;
9152 }
9153
9154 /****************************************************************
9155 ****************************************************************/
9156
9157 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9158 struct regval_blob *v,
9159 struct spoolss_PrinterEnumValues *r)
9160 {
9161 r->data = TALLOC_ZERO_P(mem_ctx, DATA_BLOB);
9162 W_ERROR_HAVE_NO_MEMORY(r->data);
9163
9164 r->value_name = talloc_strdup(mem_ctx, regval_name(v));
9165 W_ERROR_HAVE_NO_MEMORY(r->value_name);
9166
9167 r->value_name_len = strlen_m_term(regval_name(v)) * 2;
9168
9169 r->type = regval_type(v);
9170 r->data_length = regval_size(v);
9171
9172 if (r->data_length) {
9173 *r->data = data_blob_talloc(r->data, regval_data_p(v), regval_size(v));
9174 }
9175
9176 return WERR_OK;
9177 }
9178
9179 /****************************************************************
9180 _spoolss_EnumPrinterDataEx
9181 ****************************************************************/
9182
9183 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9184 struct spoolss_EnumPrinterDataEx *r)
9185 {
9186 uint32_t count = 0;
9187 NT_PRINTER_INFO_LEVEL *printer = NULL;
9188 struct spoolss_PrinterEnumValues *info = NULL;
9189 NT_PRINTER_DATA *p_data;
9190 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9191 int snum;
9192 WERROR result;
9193 int key_index;
9194 int i;
9195
9196 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9197
9198 *r->out.count = 0;
9199 *r->out.needed = 0;
9200 *r->out.info = NULL;
9201
9202 if (!Printer) {
9203 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9204 OUR_HANDLE(r->in.handle)));
9205 return WERR_BADFID;
9206 }
9207
9208 /*
9209 * first check for a keyname of NULL or "". Win2k seems to send
9210 * this a lot and we should send back WERR_INVALID_PARAM
9211 * no need to spend time looking up the printer in this case.
9212 * --jerry
9213 */
9214
9215 if (!strlen(r->in.key_name)) {
9216 result = WERR_INVALID_PARAM;
9217 goto done;
9218 }
9219
9220 /* get the printer off of disk */
9221
9222 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9223 return WERR_BADFID;
9224 }
9225
9226 ZERO_STRUCT(printer);
9227 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9228 if (!W_ERROR_IS_OK(result)) {
9229 return result;
9230 }
9231
9232 /* now look for a match on the key name */
9233
9234 p_data = printer->info_2->data;
9235
9236 key_index = lookup_printerkey(p_data, r->in.key_name);
9237 if (key_index == -1) {
9238 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9239 r->in.key_name));
9240 result = WERR_INVALID_PARAM;
9241 goto done;
9242 }
9243
9244 /* allocate the memory for the array of pointers -- if necessary */
9245
9246 count = regval_ctr_numvals(p_data->keys[key_index].values);
9247 if (!count) {
9248 result = WERR_OK; /* ??? */
9249 goto done;
9250 }
9251
9252 info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9253 struct spoolss_PrinterEnumValues,
9254 count);
9255 if (!info) {
9256 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9257 result = WERR_NOMEM;
9258 goto done;
9259 }
9260
9261 /*
9262 * loop through all params and build the array to pass
9263 * back to the client
9264 */
9265
9266 for (i=0; i < count; i++) {
9267
9268 struct regval_blob *val;
9269
9270 /* lookup the registry value */
9271
9272 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9273
9274 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9275
9276 /* copy the data */
9277
9278 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9279 if (!W_ERROR_IS_OK(result)) {
9280 goto done;
9281 }
9282 }
9283
9284 #if 0 /* FIXME - gd */
9285 /* housekeeping information in the reply */
9286
9287 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9288 * the hand marshalled container size is a multiple
9289 * of 4 bytes for RPC alignment.
9290 */
9291
9292 if (needed % 4) {
9293 needed += 4-(needed % 4);
9294 }
9295 #endif
9296 *r->out.count = count;
9297 *r->out.info = info;
9298
9299 done:
9300
9301 if (printer) {
9302 free_a_printer(&printer, 2);
9303 }
9304
9305 if (!W_ERROR_IS_OK(result)) {
9306 return result;
9307 }
9308
9309 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9310 spoolss_EnumPrinterDataEx, NULL,
9311 *r->out.info,
9312 *r->out.count);
9313 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9314 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9315
9316 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9317 }
9318
9319 /****************************************************************************
9320 ****************************************************************************/
9321
9322 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9323 const char *servername,
9324 const char *environment,
9325 struct spoolss_PrintProcessorDirectoryInfo1 *r)
9326 {
9327 WERROR werr;
9328 char *path = NULL;
9329
9330 werr = compose_spoolss_server_path(mem_ctx,
9331 servername,
9332 environment,
9333 SPOOLSS_PRTPROCS_PATH,
9334 &path);
9335 if (!W_ERROR_IS_OK(werr)) {
9336 return werr;
9337 }
9338
9339 DEBUG(4,("print processor directory: [%s]\n", path));
9340
9341 r->directory_name = path;
9342
9343 return WERR_OK;
9344 }
9345
9346 /****************************************************************
9347 _spoolss_GetPrintProcessorDirectory
9348 ****************************************************************/
9349
9350 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9351 struct spoolss_GetPrintProcessorDirectory *r)
9352 {
9353 WERROR result;
9354
9355 /* that's an [in out] buffer */
9356
9357 if (!r->in.buffer && (r->in.offered != 0)) {
9358 return WERR_INVALID_PARAM;
9359 }
9360
9361 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9362 r->in.level));
9363
9364 *r->out.needed = 0;
9365
9366 /* r->in.level is ignored */
9367
9368 /* We always should reply with a local print processor directory so that
9369 * users are not forced to have a [prnproc$] share on the Samba spoolss
9370 * server - Guenther */
9371
9372 result = getprintprocessordirectory_level_1(p->mem_ctx,
9373 NULL, /* r->in.server */
9374 r->in.environment,
9375 &r->out.info->info1);
9376 if (!W_ERROR_IS_OK(result)) {
9377 TALLOC_FREE(r->out.info);
9378 return result;
9379 }
9380
9381 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9382 r->out.info, r->in.level);
9383 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9384
9385 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9386 }
9387
9388 /*******************************************************************
9389 ********************************************************************/
9390
9391 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9392 const char *dllname)
9393 {
9394 enum ndr_err_code ndr_err;
9395 struct spoolss_MonitorUi ui;
9396
9397 ui.dll_name = dllname;
9398
9399 ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9400 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9401 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9402 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9403 }
9404 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9405 }
9406
9407 /*******************************************************************
9408 Streams the monitor UI DLL name in UNICODE
9409 *******************************************************************/
9410
9411 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9412 NT_USER_TOKEN *token, DATA_BLOB *in,
9413 DATA_BLOB *out, uint32_t *needed)
9414 {
9415 const char *dllname = "tcpmonui.dll";
9416
9417 *needed = (strlen(dllname)+1) * 2;
9418
9419 if (out->length < *needed) {
9420 return WERR_INSUFFICIENT_BUFFER;
9421 }
9422
9423 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9424 return WERR_NOMEM;
9425 }
9426
9427 return WERR_OK;
9428 }
9429
9430 /*******************************************************************
9431 ********************************************************************/
9432
9433 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9434 struct spoolss_PortData1 *port1,
9435 const DATA_BLOB *buf)
9436 {
9437 enum ndr_err_code ndr_err;
9438 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9439 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9440 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9441 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9442 }
9443 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9444 }
9445
9446 /*******************************************************************
9447 ********************************************************************/
9448
9449 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9450 struct spoolss_PortData2 *port2,
9451 const DATA_BLOB *buf)
9452 {
9453 enum ndr_err_code ndr_err;
9454 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9455 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9456 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9457 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9458 }
9459 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9460 }
9461
9462 /*******************************************************************
9463 Create a new TCP/IP port
9464 *******************************************************************/
9465
9466 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9467 NT_USER_TOKEN *token, DATA_BLOB *in,
9468 DATA_BLOB *out, uint32_t *needed)
9469 {
9470 struct spoolss_PortData1 port1;
9471 struct spoolss_PortData2 port2;
9472 char *device_uri = NULL;
9473 uint32_t version;
9474
9475 const char *portname;
9476 const char *hostaddress;
9477 const char *queue;
9478 uint32_t port_number;
9479 uint32_t protocol;
9480
9481 /* peek for spoolss_PortData version */
9482
9483 if (!in || (in->length < (128 + 4))) {
9484 return WERR_GENERAL_FAILURE;
9485 }
9486
9487 version = IVAL(in->data, 128);
9488
9489 switch (version) {
9490 case 1:
9491 ZERO_STRUCT(port1);
9492
9493 if (!pull_port_data_1(mem_ctx, &port1, in)) {
9494 return WERR_NOMEM;
9495 }
9496
9497 portname = port1.portname;
9498 hostaddress = port1.hostaddress;
9499 queue = port1.queue;
9500 protocol = port1.protocol;
9501 port_number = port1.port_number;
9502
9503 break;
9504 case 2:
9505 ZERO_STRUCT(port2);
9506
9507 if (!pull_port_data_2(mem_ctx, &port2, in)) {
9508 return WERR_NOMEM;
9509 }
9510
9511 portname = port2.portname;
9512 hostaddress = port2.hostaddress;
9513 queue = port2.queue;
9514 protocol = port2.protocol;
9515 port_number = port2.port_number;
9516
9517 break;
9518 default:
9519 DEBUG(1,("xcvtcp_addport: "
9520 "unknown version of port_data: %d\n", version));
9521 return WERR_UNKNOWN_PORT;
9522 }
9523
9524 /* create the device URI and call the add_port_hook() */
9525
9526 switch (protocol) {
9527 case PROTOCOL_RAWTCP_TYPE:
9528 device_uri = talloc_asprintf(mem_ctx,
9529 "socket://%s:%d/", hostaddress,
9530 port_number);
9531 break;
9532
9533 case PROTOCOL_LPR_TYPE:
9534 device_uri = talloc_asprintf(mem_ctx,
9535 "lpr://%s/%s", hostaddress, queue );
9536 break;
9537
9538 default:
9539 return WERR_UNKNOWN_PORT;
9540 }
9541
9542 if (!device_uri) {
9543 return WERR_NOMEM;
9544 }
9545
9546 return add_port_hook(mem_ctx, token, portname, device_uri);
9547 }
9548
9549 /*******************************************************************
9550 *******************************************************************/
9551
9552 struct xcv_api_table xcvtcp_cmds[] = {
9553 { "MonitorUI", xcvtcp_monitorui },
9554 { "AddPort", xcvtcp_addport},
9555 { NULL, NULL }
9556 };
9557
9558 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9559 NT_USER_TOKEN *token, const char *command,
9560 DATA_BLOB *inbuf,
9561 DATA_BLOB *outbuf,
9562 uint32_t *needed )
9563 {
9564 int i;
9565
9566 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9567
9568 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9569 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9570 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9571 }
9572
9573 return WERR_BADFUNC;
9574 }
9575
9576 /*******************************************************************
9577 *******************************************************************/
9578 #if 0 /* don't support management using the "Local Port" monitor */
9579
9580 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9581 NT_USER_TOKEN *token, DATA_BLOB *in,
9582 DATA_BLOB *out, uint32_t *needed)
9583 {
9584 const char *dllname = "localui.dll";
9585
9586 *needed = (strlen(dllname)+1) * 2;
9587
9588 if (out->length < *needed) {
9589 return WERR_INSUFFICIENT_BUFFER;
9590 }
9591
9592 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9593 return WERR_NOMEM;
9594 }
9595
9596 return WERR_OK;
9597 }
9598
9599 /*******************************************************************
9600 *******************************************************************/
9601
9602 struct xcv_api_table xcvlocal_cmds[] = {
9603 { "MonitorUI", xcvlocal_monitorui },
9604 { NULL, NULL }
9605 };
9606 #else
9607 struct xcv_api_table xcvlocal_cmds[] = {
9608 { NULL, NULL }
9609 };
9610 #endif
9611
9612
9613
9614 /*******************************************************************
9615 *******************************************************************/
9616
9617 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9618 NT_USER_TOKEN *token, const char *command,
9619 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9620 uint32_t *needed)
9621 {
9622 int i;
9623
9624 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9625
9626 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9627 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9628 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9629 }
9630 return WERR_BADFUNC;
9631 }
9632
9633 /****************************************************************
9634 _spoolss_XcvData
9635 ****************************************************************/
9636
9637 WERROR _spoolss_XcvData(pipes_struct *p,
9638 struct spoolss_XcvData *r)
9639 {
9640 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9641 DATA_BLOB out_data = data_blob_null;
9642 WERROR werror;
9643
9644 if (!Printer) {
9645 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9646 OUR_HANDLE(r->in.handle)));
9647 return WERR_BADFID;
9648 }
9649
9650 /* Has to be a handle to the TCP/IP port monitor */
9651
9652 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9653 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9654 return WERR_BADFID;
9655 }
9656
9657 /* requires administrative access to the server */
9658
9659 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9660 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9661 return WERR_ACCESS_DENIED;
9662 }
9663
9664 /* Allocate the outgoing buffer */
9665
9666 if (r->in.out_data_size) {
9667 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9668 if (out_data.data == NULL) {
9669 return WERR_NOMEM;
9670 }
9671 }
9672
9673 switch ( Printer->printer_type ) {
9674 case SPLHND_PORTMON_TCP:
9675 werror = process_xcvtcp_command(p->mem_ctx,
9676 p->server_info->ptok,
9677 r->in.function_name,
9678 &r->in.in_data, &out_data,
9679 r->out.needed);
9680 break;
9681 case SPLHND_PORTMON_LOCAL:
9682 werror = process_xcvlocal_command(p->mem_ctx,
9683 p->server_info->ptok,
9684 r->in.function_name,
9685 &r->in.in_data, &out_data,
9686 r->out.needed);
9687 break;
9688 default:
9689 werror = WERR_INVALID_PRINT_MONITOR;
9690 }
9691
9692 if (!W_ERROR_IS_OK(werror)) {
9693 return werror;
9694 }
9695
9696 *r->out.status_code = 0;
9697
9698 if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
9699 memcpy(r->out.out_data, out_data.data,
9700 MIN(r->in.out_data_size, out_data.length));
9701 }
9702
9703 return WERR_OK;
9704 }
9705
9706 /****************************************************************
9707 _spoolss_AddPrintProcessor
9708 ****************************************************************/
9709
9710 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
9711 struct spoolss_AddPrintProcessor *r)
9712 {
9713 /* for now, just indicate success and ignore the add. We'll
9714 automatically set the winprint processor for printer
9715 entries later. Used to debug the LexMark Optra S 1855 PCL
9716 driver --jerry */
9717
9718 return WERR_OK;
9719 }
9720
9721 /****************************************************************
9722 _spoolss_AddPort
9723 ****************************************************************/
9724
9725 WERROR _spoolss_AddPort(pipes_struct *p,
9726 struct spoolss_AddPort *r)
9727 {
9728 /* do what w2k3 does */
9729
9730 return WERR_NOT_SUPPORTED;
9731 }
9732
9733 /****************************************************************
9734 _spoolss_GetPrinterDriver
9735 ****************************************************************/
9736
9737 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
9738 struct spoolss_GetPrinterDriver *r)
9739 {
9740 p->rng_fault_state = true;
9741 return WERR_NOT_SUPPORTED;
9742 }
9743
9744 /****************************************************************
9745 _spoolss_ReadPrinter
9746 ****************************************************************/
9747
9748 WERROR _spoolss_ReadPrinter(pipes_struct *p,
9749 struct spoolss_ReadPrinter *r)
9750 {
9751 p->rng_fault_state = true;
9752 return WERR_NOT_SUPPORTED;
9753 }
9754
9755 /****************************************************************
9756 _spoolss_WaitForPrinterChange
9757 ****************************************************************/
9758
9759 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
9760 struct spoolss_WaitForPrinterChange *r)
9761 {
9762 p->rng_fault_state = true;
9763 return WERR_NOT_SUPPORTED;
9764 }
9765
9766 /****************************************************************
9767 _spoolss_ConfigurePort
9768 ****************************************************************/
9769
9770 WERROR _spoolss_ConfigurePort(pipes_struct *p,
9771 struct spoolss_ConfigurePort *r)
9772 {
9773 p->rng_fault_state = true;
9774 return WERR_NOT_SUPPORTED;
9775 }
9776
9777 /****************************************************************
9778 _spoolss_DeletePort
9779 ****************************************************************/
9780
9781 WERROR _spoolss_DeletePort(pipes_struct *p,
9782 struct spoolss_DeletePort *r)
9783 {
9784 p->rng_fault_state = true;
9785 return WERR_NOT_SUPPORTED;
9786 }
9787
9788 /****************************************************************
9789 _spoolss_CreatePrinterIC
9790 ****************************************************************/
9791
9792 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
9793 struct spoolss_CreatePrinterIC *r)
9794 {
9795 p->rng_fault_state = true;
9796 return WERR_NOT_SUPPORTED;
9797 }
9798
9799 /****************************************************************
9800 _spoolss_PlayGDIScriptOnPrinterIC
9801 ****************************************************************/
9802
9803 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
9804 struct spoolss_PlayGDIScriptOnPrinterIC *r)
9805 {
9806 p->rng_fault_state = true;
9807 return WERR_NOT_SUPPORTED;
9808 }
9809
9810 /****************************************************************
9811 _spoolss_DeletePrinterIC
9812 ****************************************************************/
9813
9814 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
9815 struct spoolss_DeletePrinterIC *r)
9816 {
9817 p->rng_fault_state = true;
9818 return WERR_NOT_SUPPORTED;
9819 }
9820
9821 /****************************************************************
9822 _spoolss_AddPrinterConnection
9823 ****************************************************************/
9824
9825 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
9826 struct spoolss_AddPrinterConnection *r)
9827 {
9828 p->rng_fault_state = true;
9829 return WERR_NOT_SUPPORTED;
9830 }
9831
9832 /****************************************************************
9833 _spoolss_DeletePrinterConnection
9834 ****************************************************************/
9835
9836 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
9837 struct spoolss_DeletePrinterConnection *r)
9838 {
9839 p->rng_fault_state = true;
9840 return WERR_NOT_SUPPORTED;
9841 }
9842
9843 /****************************************************************
9844 _spoolss_PrinterMessageBox
9845 ****************************************************************/
9846
9847 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
9848 struct spoolss_PrinterMessageBox *r)
9849 {
9850 p->rng_fault_state = true;
9851 return WERR_NOT_SUPPORTED;
9852 }
9853
9854 /****************************************************************
9855 _spoolss_AddMonitor
9856 ****************************************************************/
9857
9858 WERROR _spoolss_AddMonitor(pipes_struct *p,
9859 struct spoolss_AddMonitor *r)
9860 {
9861 p->rng_fault_state = true;
9862 return WERR_NOT_SUPPORTED;
9863 }
9864
9865 /****************************************************************
9866 _spoolss_DeleteMonitor
9867 ****************************************************************/
9868
9869 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
9870 struct spoolss_DeleteMonitor *r)
9871 {
9872 p->rng_fault_state = true;
9873 return WERR_NOT_SUPPORTED;
9874 }
9875
9876 /****************************************************************
9877 _spoolss_DeletePrintProcessor
9878 ****************************************************************/
9879
9880 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
9881 struct spoolss_DeletePrintProcessor *r)
9882 {
9883 p->rng_fault_state = true;
9884 return WERR_NOT_SUPPORTED;
9885 }
9886
9887 /****************************************************************
9888 _spoolss_AddPrintProvidor
9889 ****************************************************************/
9890
9891 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
9892 struct spoolss_AddPrintProvidor *r)
9893 {
9894 p->rng_fault_state = true;
9895 return WERR_NOT_SUPPORTED;
9896 }
9897
9898 /****************************************************************
9899 _spoolss_DeletePrintProvidor
9900 ****************************************************************/
9901
9902 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
9903 struct spoolss_DeletePrintProvidor *r)
9904 {
9905 p->rng_fault_state = true;
9906 return WERR_NOT_SUPPORTED;
9907 }
9908
9909 /****************************************************************
9910 _spoolss_FindFirstPrinterChangeNotification
9911 ****************************************************************/
9912
9913 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
9914 struct spoolss_FindFirstPrinterChangeNotification *r)
9915 {
9916 p->rng_fault_state = true;
9917 return WERR_NOT_SUPPORTED;
9918 }
9919
9920 /****************************************************************
9921 _spoolss_FindNextPrinterChangeNotification
9922 ****************************************************************/
9923
9924 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
9925 struct spoolss_FindNextPrinterChangeNotification *r)
9926 {
9927 p->rng_fault_state = true;
9928 return WERR_NOT_SUPPORTED;
9929 }
9930
9931 /****************************************************************
9932 _spoolss_RouterFindFirstPrinterChangeNotificationOld
9933 ****************************************************************/
9934
9935 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
9936 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
9937 {
9938 p->rng_fault_state = true;
9939 return WERR_NOT_SUPPORTED;
9940 }
9941
9942 /****************************************************************
9943 _spoolss_ReplyOpenPrinter
9944 ****************************************************************/
9945
9946 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
9947 struct spoolss_ReplyOpenPrinter *r)
9948 {
9949 p->rng_fault_state = true;
9950 return WERR_NOT_SUPPORTED;
9951 }
9952
9953 /****************************************************************
9954 _spoolss_RouterReplyPrinter
9955 ****************************************************************/
9956
9957 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
9958 struct spoolss_RouterReplyPrinter *r)
9959 {
9960 p->rng_fault_state = true;
9961 return WERR_NOT_SUPPORTED;
9962 }
9963
9964 /****************************************************************
9965 _spoolss_ReplyClosePrinter
9966 ****************************************************************/
9967
9968 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
9969 struct spoolss_ReplyClosePrinter *r)
9970 {
9971 p->rng_fault_state = true;
9972 return WERR_NOT_SUPPORTED;
9973 }
9974
9975 /****************************************************************
9976 _spoolss_AddPortEx
9977 ****************************************************************/
9978
9979 WERROR _spoolss_AddPortEx(pipes_struct *p,
9980 struct spoolss_AddPortEx *r)
9981 {
9982 p->rng_fault_state = true;
9983 return WERR_NOT_SUPPORTED;
9984 }
9985
9986 /****************************************************************
9987 _spoolss_RouterFindFirstPrinterChangeNotification
9988 ****************************************************************/
9989
9990 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
9991 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
9992 {
9993 p->rng_fault_state = true;
9994 return WERR_NOT_SUPPORTED;
9995 }
9996
9997 /****************************************************************
9998 _spoolss_SpoolerInit
9999 ****************************************************************/
10000
10001 WERROR _spoolss_SpoolerInit(pipes_struct *p,
10002 struct spoolss_SpoolerInit *r)
10003 {
10004 p->rng_fault_state = true;
10005 return WERR_NOT_SUPPORTED;
10006 }
10007
10008 /****************************************************************
10009 _spoolss_ResetPrinterEx
10010 ****************************************************************/
10011
10012 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
10013 struct spoolss_ResetPrinterEx *r)
10014 {
10015 p->rng_fault_state = true;
10016 return WERR_NOT_SUPPORTED;
10017 }
10018
10019 /****************************************************************
10020 _spoolss_RouterReplyPrinterEx
10021 ****************************************************************/
10022
10023 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
10024 struct spoolss_RouterReplyPrinterEx *r)
10025 {
10026 p->rng_fault_state = true;
10027 return WERR_NOT_SUPPORTED;
10028 }
10029
10030 /****************************************************************
10031 _spoolss_44
10032 ****************************************************************/
10033
10034 WERROR _spoolss_44(pipes_struct *p,
10035 struct spoolss_44 *r)
10036 {
10037 p->rng_fault_state = true;
10038 return WERR_NOT_SUPPORTED;
10039 }
10040
10041 /****************************************************************
10042 _spoolss_47
10043 ****************************************************************/
10044
10045 WERROR _spoolss_47(pipes_struct *p,
10046 struct spoolss_47 *r)
10047 {
10048 p->rng_fault_state = true;
10049 return WERR_NOT_SUPPORTED;
10050 }
10051
10052 /****************************************************************
10053 _spoolss_4a
10054 ****************************************************************/
10055
10056 WERROR _spoolss_4a(pipes_struct *p,
10057 struct spoolss_4a *r)
10058 {
10059 p->rng_fault_state = true;
10060 return WERR_NOT_SUPPORTED;
10061 }
10062
10063 /****************************************************************
10064 _spoolss_4b
10065 ****************************************************************/
10066
10067 WERROR _spoolss_4b(pipes_struct *p,
10068 struct spoolss_4b *r)
10069 {
10070 p->rng_fault_state = true;
10071 return WERR_NOT_SUPPORTED;
10072 }
10073
10074 /****************************************************************
10075 _spoolss_4c
10076 ****************************************************************/
10077
10078 WERROR _spoolss_4c(pipes_struct *p,
10079 struct spoolss_4c *r)
10080 {
10081 p->rng_fault_state = true;
10082 return WERR_NOT_SUPPORTED;
10083 }
10084
10085 /****************************************************************
10086 _spoolss_53
10087 ****************************************************************/
10088
10089 WERROR _spoolss_53(pipes_struct *p,
10090 struct spoolss_53 *r)
10091 {
10092 p->rng_fault_state = true;
10093 return WERR_NOT_SUPPORTED;
10094 }
10095
10096 /****************************************************************
10097 _spoolss_55
10098 ****************************************************************/
10099
10100 WERROR _spoolss_55(pipes_struct *p,
10101 struct spoolss_55 *r)
10102 {
10103 p->rng_fault_state = true;
10104 return WERR_NOT_SUPPORTED;
10105 }
10106
10107 /****************************************************************
10108 _spoolss_56
10109 ****************************************************************/
10110
10111 WERROR _spoolss_56(pipes_struct *p,
10112 struct spoolss_56 *r)
10113 {
10114 p->rng_fault_state = true;
10115 return WERR_NOT_SUPPORTED;
10116 }
10117
10118 /****************************************************************
10119 _spoolss_57
10120 ****************************************************************/
10121
10122 WERROR _spoolss_57(pipes_struct *p,
10123 struct spoolss_57 *r)
10124 {
10125 p->rng_fault_state = true;
10126 return WERR_NOT_SUPPORTED;
10127 }
10128
10129 /****************************************************************
10130 _spoolss_5a
10131 ****************************************************************/
10132
10133 WERROR _spoolss_5a(pipes_struct *p,
10134 struct spoolss_5a *r)
10135 {
10136 p->rng_fault_state = true;
10137 return WERR_NOT_SUPPORTED;
10138 }
10139
10140 /****************************************************************
10141 _spoolss_5b
10142 ****************************************************************/
10143
10144 WERROR _spoolss_5b(pipes_struct *p,
10145 struct spoolss_5b *r)
10146 {
10147 p->rng_fault_state = true;
10148 return WERR_NOT_SUPPORTED;
10149 }
10150
10151 /****************************************************************
10152 _spoolss_5c
10153 ****************************************************************/
10154
10155 WERROR _spoolss_5c(pipes_struct *p,
10156 struct spoolss_5c *r)
10157 {
10158 p->rng_fault_state = true;
10159 return WERR_NOT_SUPPORTED;
10160 }
10161
10162 /****************************************************************
10163 _spoolss_5d
10164 ****************************************************************/
10165
10166 WERROR _spoolss_5d(pipes_struct *p,
10167 struct spoolss_5d *r)
10168 {
10169 p->rng_fault_state = true;
10170 return WERR_NOT_SUPPORTED;
10171 }
10172
10173 /****************************************************************
10174 _spoolss_5e
10175 ****************************************************************/
10176
10177 WERROR _spoolss_5e(pipes_struct *p,
10178 struct spoolss_5e *r)
10179 {
10180 p->rng_fault_state = true;
10181 return WERR_NOT_SUPPORTED;
10182 }
10183
10184 /****************************************************************
10185 _spoolss_5f
10186 ****************************************************************/
10187
10188 WERROR _spoolss_5f(pipes_struct *p,
10189 struct spoolss_5f *r)
10190 {
10191 p->rng_fault_state = true;
10192 return WERR_NOT_SUPPORTED;
10193 }
10194
10195 /****************************************************************
10196 _spoolss_60
10197 ****************************************************************/
10198
10199 WERROR _spoolss_60(pipes_struct *p,
10200 struct spoolss_60 *r)
10201 {
10202 p->rng_fault_state = true;
10203 return WERR_NOT_SUPPORTED;
10204 }
10205
10206 /****************************************************************
10207 _spoolss_61
10208 ****************************************************************/
10209
10210 WERROR _spoolss_61(pipes_struct *p,
10211 struct spoolss_61 *r)
10212 {
10213 p->rng_fault_state = true;
10214 return WERR_NOT_SUPPORTED;
10215 }
10216
10217 /****************************************************************
10218 _spoolss_62
10219 ****************************************************************/
10220
10221 WERROR _spoolss_62(pipes_struct *p,
10222 struct spoolss_62 *r)
10223 {
10224 p->rng_fault_state = true;
10225 return WERR_NOT_SUPPORTED;
10226 }
10227
10228 /****************************************************************
10229 _spoolss_63
10230 ****************************************************************/
10231
10232 WERROR _spoolss_63(pipes_struct *p,
10233 struct spoolss_63 *r)
10234 {
10235 p->rng_fault_state = true;
10236 return WERR_NOT_SUPPORTED;
10237 }
10238
10239 /****************************************************************
10240 _spoolss_64
10241 ****************************************************************/
10242
10243 WERROR _spoolss_64(pipes_struct *p,
10244 struct spoolss_64 *r)
10245 {
10246 p->rng_fault_state = true;
10247 return WERR_NOT_SUPPORTED;
10248 }
10249
10250 /****************************************************************
10251 _spoolss_65
10252 ****************************************************************/
10253
10254 WERROR _spoolss_65(pipes_struct *p,
10255 struct spoolss_65 *r)
10256 {
10257 p->rng_fault_state = true;
10258 return WERR_NOT_SUPPORTED;
10259 }
10260
10261 /****************************************************************
10262 _spoolss_GetCorePrinterDrivers
10263 ****************************************************************/
10264
10265 WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p,
10266 struct spoolss_GetCorePrinterDrivers *r)
10267 {
10268 p->rng_fault_state = true;
10269 return WERR_NOT_SUPPORTED;
10270 }
10271
10272 /****************************************************************
10273 _spoolss_67
10274 ****************************************************************/
10275
10276 WERROR _spoolss_67(pipes_struct *p,
10277 struct spoolss_67 *r)
10278 {
10279 p->rng_fault_state = true;
10280 return WERR_NOT_SUPPORTED;
10281 }
10282
10283 /****************************************************************
10284 _spoolss_GetPrinterDriverPackagePath
10285 ****************************************************************/
10286
10287 WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p,
10288 struct spoolss_GetPrinterDriverPackagePath *r)
10289 {
10290 p->rng_fault_state = true;
10291 return WERR_NOT_SUPPORTED;
10292 }
10293
10294 /****************************************************************
10295 _spoolss_69
10296 ****************************************************************/
10297
10298 WERROR _spoolss_69(pipes_struct *p,
10299 struct spoolss_69 *r)
10300 {
10301 p->rng_fault_state = true;
10302 return WERR_NOT_SUPPORTED;
10303 }
10304
10305 /****************************************************************
10306 _spoolss_6a
10307 ****************************************************************/
10308
10309 WERROR _spoolss_6a(pipes_struct *p,
10310 struct spoolss_6a *r)
10311 {
10312 p->rng_fault_state = true;
10313 return WERR_NOT_SUPPORTED;
10314 }
10315
10316 /****************************************************************
10317 _spoolss_6b
10318 ****************************************************************/
10319
10320 WERROR _spoolss_6b(pipes_struct *p,
10321 struct spoolss_6b *r)
10322 {
10323 p->rng_fault_state = true;
10324 return WERR_NOT_SUPPORTED;
10325 }
10326
10327 /****************************************************************
10328 _spoolss_6c
10329 ****************************************************************/
10330
10331 WERROR _spoolss_6c(pipes_struct *p,
10332 struct spoolss_6c *r)
10333 {
10334 p->rng_fault_state = true;
10335 return WERR_NOT_SUPPORTED;
10336 }
10337
10338 /****************************************************************
10339 _spoolss_6d
10340 ****************************************************************/
10341
10342 WERROR _spoolss_6d(pipes_struct *p,
10343 struct spoolss_6d *r)
10344 {
10345 p->rng_fault_state = true;
10346 return WERR_NOT_SUPPORTED;
10347 }
Samba GIT mirror