?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-spoolss: avoid referring to uid 0 in spoolss server (use sec_initial_uid() instead).
[Samba.git] / source3 / rpc_server / srv_spoolss_nt.c
blob0a8c31a2fc0dd1bb300efda1ab3749b3b5ae46f5
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-2000,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6 * Copyright (C) Jean François Micouleau 1998-2000,
7 * Copyright (C) Jeremy Allison 2001-2002,
8 * Copyright (C) Gerald Carter 2000-2004,
9 * Copyright (C) Tim Potter 2001-2002.
10 * Copyright (C) Guenther Deschner 2009.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 3 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <http://www.gnu.org/licenses/>.
24 */
25
26 /* Since the SPOOLSS rpc routines are basically DOS 16-bit calls wrapped
27 up, all the errors returned are DOS errors, not NT status codes. */
28
29 #include "includes.h"
30
31 /* macros stolen from s4 spoolss server */
32 #define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
33 ((info)?ndr_size_##fn(info, level, ic, 0):0)
34
35 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,ic,info,level,count) \
36 ((info)?ndr_size_##fn##_info(mem_ctx, ic, level, count, info):0)
37
38 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,ic,info,count) \
39 ((info)?ndr_size_##fn##_info(mem_ctx, ic, count, info):0)
40
41 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
42
43
44 extern userdom_struct current_user_info;
45
46 #undef DBGC_CLASS
47 #define DBGC_CLASS DBGC_RPC_SRV
48
49 #ifndef MAX_OPEN_PRINTER_EXS
50 #define MAX_OPEN_PRINTER_EXS 50
51 #endif
52
53 #define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
54 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
55
56 struct table_node {
57 const char *long_archi;
58 const char *short_archi;
59 int version;
60 };
61
62 static Printer_entry *printers_list;
63
64 typedef struct _counter_printer_0 {
65 struct _counter_printer_0 *next;
66 struct _counter_printer_0 *prev;
67
68 int snum;
69 uint32_t counter;
70 } counter_printer_0;
71
72 static counter_printer_0 *counter_list;
73
74 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
75 static uint32_t smb_connections = 0;
76
77
78 /* in printing/nt_printing.c */
79
80 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
81
82 /* API table for Xcv Monitor functions */
83
84 struct xcv_api_table {
85 const char *name;
86 WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
87 };
88
89 /********************************************************************
90 * Canonicalize servername.
91 ********************************************************************/
92
93 static const char *canon_servername(const char *servername)
94 {
95 const char *pservername = servername;
96 while (*pservername == '\\') {
97 pservername++;
98 }
99 return pservername;
100 }
101
102 /* translate between internal status numbers and NT status numbers */
103 static int nt_printj_status(int v)
104 {
105 switch (v) {
106 case LPQ_QUEUED:
107 return 0;
108 case LPQ_PAUSED:
109 return JOB_STATUS_PAUSED;
110 case LPQ_SPOOLING:
111 return JOB_STATUS_SPOOLING;
112 case LPQ_PRINTING:
113 return JOB_STATUS_PRINTING;
114 case LPQ_ERROR:
115 return JOB_STATUS_ERROR;
116 case LPQ_DELETING:
117 return JOB_STATUS_DELETING;
118 case LPQ_OFFLINE:
119 return JOB_STATUS_OFFLINE;
120 case LPQ_PAPEROUT:
121 return JOB_STATUS_PAPEROUT;
122 case LPQ_PRINTED:
123 return JOB_STATUS_PRINTED;
124 case LPQ_DELETED:
125 return JOB_STATUS_DELETED;
126 case LPQ_BLOCKED:
127 return JOB_STATUS_BLOCKED_DEVQ;
128 case LPQ_USER_INTERVENTION:
129 return JOB_STATUS_USER_INTERVENTION;
130 }
131 return 0;
132 }
133
134 static int nt_printq_status(int v)
135 {
136 switch (v) {
137 case LPQ_PAUSED:
138 return PRINTER_STATUS_PAUSED;
139 case LPQ_QUEUED:
140 case LPQ_SPOOLING:
141 case LPQ_PRINTING:
142 return 0;
143 }
144 return 0;
145 }
146
147 /***************************************************************************
148 Disconnect from the client
149 ****************************************************************************/
150
151 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
152 {
153 WERROR result;
154 NTSTATUS status;
155
156 /*
157 * Tell the specific printing tdb we no longer want messages for this printer
158 * by deregistering our PID.
159 */
160
161 if (!print_notify_deregister_pid(snum))
162 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
163
164 /* weird if the test succeds !!! */
165 if (smb_connections==0) {
166 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
167 return;
168 }
169
170 status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
171 handle,
172 &result);
173 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
174 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
175 win_errstr(result)));
176
177 /* if it's the last connection, deconnect the IPC$ share */
178 if (smb_connections==1) {
179
180 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
181 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
182
183 messaging_deregister(smbd_messaging_context(),
184 MSG_PRINTER_NOTIFY2, NULL);
185
186 /* Tell the connections db we're no longer interested in
187 * printer notify messages. */
188
189 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
190 }
191
192 smb_connections--;
193 }
194
195 /****************************************************************************
196 Functions to free a printer entry datastruct.
197 ****************************************************************************/
198
199 static int printer_entry_destructor(Printer_entry *Printer)
200 {
201 if (Printer->notify.client_connected == true) {
202 int snum = -1;
203
204 if ( Printer->printer_type == SPLHND_SERVER) {
205 snum = -1;
206 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
207 } else if (Printer->printer_type == SPLHND_PRINTER) {
208 snum = print_queue_snum(Printer->sharename);
209 if (snum != -1)
210 srv_spoolss_replycloseprinter(snum,
211 &Printer->notify.client_hnd);
212 }
213 }
214
215 Printer->notify.flags=0;
216 Printer->notify.options=0;
217 Printer->notify.localmachine[0]='\0';
218 Printer->notify.printerlocal=0;
219 TALLOC_FREE(Printer->notify.option);
220 Printer->notify.client_connected = false;
221
222 free_nt_devicemode( &Printer->nt_devmode );
223 free_a_printer( &Printer->printer_info, 2 );
224
225 /* Remove from the internal list. */
226 DLIST_REMOVE(printers_list, Printer);
227 return 0;
228 }
229
230 /****************************************************************************
231 find printer index by handle
232 ****************************************************************************/
233
234 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
235 struct policy_handle *hnd)
236 {
237 Printer_entry *find_printer = NULL;
238
239 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
240 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
241 return NULL;
242 }
243
244 return find_printer;
245 }
246
247 /****************************************************************************
248 Close printer index by handle.
249 ****************************************************************************/
250
251 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
252 {
253 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
254
255 if (!Printer) {
256 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
257 OUR_HANDLE(hnd)));
258 return false;
259 }
260
261 close_policy_hnd(p, hnd);
262
263 return true;
264 }
265
266 /****************************************************************************
267 Delete a printer given a handle.
268 ****************************************************************************/
269
270 WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename )
271 {
272 char *cmd = lp_deleteprinter_cmd();
273 char *command = NULL;
274 int ret;
275 SE_PRIV se_printop = SE_PRINT_OPERATOR;
276 bool is_print_op = false;
277
278 /* can't fail if we don't try */
279
280 if ( !*cmd )
281 return WERR_OK;
282
283 command = talloc_asprintf(ctx,
284 "%s \"%s\"",
285 cmd, sharename);
286 if (!command) {
287 return WERR_NOMEM;
288 }
289 if ( token )
290 is_print_op = user_has_privileges( token, &se_printop );
291
292 DEBUG(10,("Running [%s]\n", command));
293
294 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
295
296 if ( is_print_op )
297 become_root();
298
299 if ( (ret = smbrun(command, NULL)) == 0 ) {
300 /* Tell everyone we updated smb.conf. */
301 message_send_all(smbd_messaging_context(),
302 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
303 }
304
305 if ( is_print_op )
306 unbecome_root();
307
308 /********** END SePrintOperatorPrivlege BLOCK **********/
309
310 DEBUGADD(10,("returned [%d]\n", ret));
311
312 TALLOC_FREE(command);
313
314 if (ret != 0)
315 return WERR_BADFID; /* What to return here? */
316
317 /* go ahead and re-read the services immediately */
318 reload_services(false);
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", (int)p->pipe_handles->count ));
595
596 return true;
597 }
598
599 /***************************************************************************
600 check to see if the client motify handle is monitoring the notification
601 given by (notify_type, notify_field).
602 **************************************************************************/
603
604 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
605 uint16_t notify_field)
606 {
607 return true;
608 }
609
610 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
611 uint16_t notify_field)
612 {
613 struct spoolss_NotifyOption *option = p->notify.option;
614 uint32_t i, j;
615
616 /*
617 * Flags should always be zero when the change notify
618 * is registered by the client's spooler. A user Win32 app
619 * might use the flags though instead of the NOTIFY_OPTION_INFO
620 * --jerry
621 */
622
623 if (!option) {
624 return false;
625 }
626
627 if (p->notify.flags)
628 return is_monitoring_event_flags(
629 p->notify.flags, notify_type, notify_field);
630
631 for (i = 0; i < option->count; i++) {
632
633 /* Check match for notify_type */
634
635 if (option->types[i].type != notify_type)
636 continue;
637
638 /* Check match for field */
639
640 for (j = 0; j < option->types[i].count; j++) {
641 if (option->types[i].fields[j].field == notify_field) {
642 return true;
643 }
644 }
645 }
646
647 DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
648 p->servername, p->sharename, notify_type, notify_field));
649
650 return false;
651 }
652
653 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
654 _data->data.integer[0] = _integer; \
655 _data->data.integer[1] = 0;
656
657
658 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
659 _data->data.string.string = talloc_strdup(mem_ctx, _p); \
660 if (!_data->data.string.string) {\
661 _data->data.string.size = 0; \
662 } \
663 _data->data.string.size = strlen_m_term(_p) * 2;
664
665 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
666 _data->data.devmode.devmode = _devmode;
667
668 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
669 _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
670 if (!_data->data.sd.sd) { \
671 _data->data.sd.sd_size = 0; \
672 } \
673 _data->data.sd.sd_size = _size;
674
675 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
676 struct tm *t,
677 const char **pp,
678 uint32_t *plen)
679 {
680 struct spoolss_Time st;
681 uint32_t len = 16;
682 char *p;
683
684 if (!init_systemtime(&st, t)) {
685 return;
686 }
687
688 p = talloc_array(mem_ctx, char, len);
689 if (!p) {
690 return;
691 }
692
693 /*
694 * Systemtime must be linearized as a set of UINT16's.
695 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
696 */
697
698 SSVAL(p, 0, st.year);
699 SSVAL(p, 2, st.month);
700 SSVAL(p, 4, st.day_of_week);
701 SSVAL(p, 6, st.day);
702 SSVAL(p, 8, st.hour);
703 SSVAL(p, 10, st.minute);
704 SSVAL(p, 12, st.second);
705 SSVAL(p, 14, st.millisecond);
706
707 *pp = p;
708 *plen = len;
709 }
710
711 /* Convert a notification message to a struct spoolss_Notify */
712
713 static void notify_one_value(struct spoolss_notify_msg *msg,
714 struct spoolss_Notify *data,
715 TALLOC_CTX *mem_ctx)
716 {
717 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
718 }
719
720 static void notify_string(struct spoolss_notify_msg *msg,
721 struct spoolss_Notify *data,
722 TALLOC_CTX *mem_ctx)
723 {
724 /* The length of the message includes the trailing \0 */
725
726 data->data.string.size = msg->len * 2;
727 data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
728 if (!data->data.string.string) {
729 data->data.string.size = 0;
730 return;
731 }
732 }
733
734 static void notify_system_time(struct spoolss_notify_msg *msg,
735 struct spoolss_Notify *data,
736 TALLOC_CTX *mem_ctx)
737 {
738 data->data.string.string = NULL;
739 data->data.string.size = 0;
740
741 if (msg->len != sizeof(time_t)) {
742 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
743 msg->len));
744 return;
745 }
746
747 init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
748 &data->data.string.string,
749 &data->data.string.size);
750 }
751
752 struct notify2_message_table {
753 const char *name;
754 void (*fn)(struct spoolss_notify_msg *msg,
755 struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
756 };
757
758 static struct notify2_message_table printer_notify_table[] = {
759 /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
760 /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
761 /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
762 /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
763 /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
764 /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
765 /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
766 /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
767 /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
768 /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
769 /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
770 /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
771 /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
772 /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
773 /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
774 /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
775 /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
776 /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
777 /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
778 };
779
780 static struct notify2_message_table job_notify_table[] = {
781 /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
782 /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
783 /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
784 /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
785 /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
786 /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
787 /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
788 /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
789 /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
790 /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
791 /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
792 /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
793 /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
794 /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
795 /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
796 /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
797 /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
798 /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
799 /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
800 /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
801 /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
802 /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
803 /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
804 /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
805 };
806
807
808 /***********************************************************************
809 Allocate talloc context for container object
810 **********************************************************************/
811
812 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
813 {
814 if ( !ctr )
815 return;
816
817 ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
818
819 return;
820 }
821
822 /***********************************************************************
823 release all allocated memory and zero out structure
824 **********************************************************************/
825
826 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
827 {
828 if ( !ctr )
829 return;
830
831 if ( ctr->ctx )
832 talloc_destroy(ctr->ctx);
833
834 ZERO_STRUCTP(ctr);
835
836 return;
837 }
838
839 /***********************************************************************
840 **********************************************************************/
841
842 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
843 {
844 if ( !ctr )
845 return NULL;
846
847 return ctr->ctx;
848 }
849
850 /***********************************************************************
851 **********************************************************************/
852
853 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
854 {
855 if ( !ctr || !ctr->msg_groups )
856 return NULL;
857
858 if ( idx >= ctr->num_groups )
859 return NULL;
860
861 return &ctr->msg_groups[idx];
862
863 }
864
865 /***********************************************************************
866 How many groups of change messages do we have ?
867 **********************************************************************/
868
869 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
870 {
871 if ( !ctr )
872 return 0;
873
874 return ctr->num_groups;
875 }
876
877 /***********************************************************************
878 Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
879 **********************************************************************/
880
881 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
882 {
883 SPOOLSS_NOTIFY_MSG_GROUP *groups = NULL;
884 SPOOLSS_NOTIFY_MSG_GROUP *msg_grp = NULL;
885 SPOOLSS_NOTIFY_MSG *msg_list = NULL;
886 int i, new_slot;
887
888 if ( !ctr || !msg )
889 return 0;
890
891 /* loop over all groups looking for a matching printer name */
892
893 for ( i=0; i<ctr->num_groups; i++ ) {
894 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
895 break;
896 }
897
898 /* add a new group? */
899
900 if ( i == ctr->num_groups ) {
901 ctr->num_groups++;
902
903 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
904 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
905 return 0;
906 }
907 ctr->msg_groups = groups;
908
909 /* clear the new entry and set the printer name */
910
911 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
912 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
913 }
914
915 /* add the change messages; 'i' is the correct index now regardless */
916
917 msg_grp = &ctr->msg_groups[i];
918
919 msg_grp->num_msgs++;
920
921 if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
922 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
923 return 0;
924 }
925 msg_grp->msgs = msg_list;
926
927 new_slot = msg_grp->num_msgs-1;
928 memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
929
930 /* need to allocate own copy of data */
931
932 if ( msg->len != 0 )
933 msg_grp->msgs[new_slot].notify.data = (char *)
934 TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
935
936 return ctr->num_groups;
937 }
938
939 /***********************************************************************
940 Send a change notication message on all handles which have a call
941 back registered
942 **********************************************************************/
943
944 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
945 {
946 Printer_entry *p;
947 TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
948 SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
949 SPOOLSS_NOTIFY_MSG *messages;
950 int sending_msg_count;
951
952 if ( !msg_group ) {
953 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
954 return;
955 }
956
957 messages = msg_group->msgs;
958
959 if ( !messages ) {
960 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
961 return;
962 }
963
964 DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
965
966 /* loop over all printers */
967
968 for (p = printers_list; p; p = p->next) {
969 struct spoolss_Notify *notifies;
970 uint32_t count = 0;
971 uint32_t id;
972 int i;
973
974 /* Is there notification on this handle? */
975
976 if ( !p->notify.client_connected )
977 continue;
978
979 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
980
981 /* For this printer? Print servers always receive
982 notifications. */
983
984 if ( ( p->printer_type == SPLHND_PRINTER ) &&
985 ( !strequal(msg_group->printername, p->sharename) ) )
986 continue;
987
988 DEBUG(10,("Our printer\n"));
989
990 /* allocate the max entries possible */
991
992 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
993 if (!notifies) {
994 return;
995 }
996
997 /* build the array of change notifications */
998
999 sending_msg_count = 0;
1000
1001 for ( i=0; i<msg_group->num_msgs; i++ ) {
1002 SPOOLSS_NOTIFY_MSG *msg = &messages[i];
1003
1004 /* Are we monitoring this event? */
1005
1006 if (!is_monitoring_event(p, msg->type, msg->field))
1007 continue;
1008
1009 sending_msg_count++;
1010
1011
1012 DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1013 msg->type, msg->field, p->sharename));
1014
1015 /*
1016 * if the is a printer notification handle and not a job notification
1017 * type, then set the id to 0. Other wise just use what was specified
1018 * in the message.
1019 *
1020 * When registering change notification on a print server handle
1021 * we always need to send back the id (snum) matching the printer
1022 * for which the change took place. For change notify registered
1023 * on a printer handle, this does not matter and the id should be 0.
1024 *
1025 * --jerry
1026 */
1027
1028 if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1029 id = 0;
1030 else
1031 id = msg->id;
1032
1033
1034 /* Convert unix jobid to smb jobid */
1035
1036 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1037 id = sysjob_to_jobid(msg->id);
1038
1039 if (id == -1) {
1040 DEBUG(3, ("no such unix jobid %d\n", msg->id));
1041 goto done;
1042 }
1043 }
1044
1045 construct_info_data( &notifies[count], msg->type, msg->field, id );
1046
1047 switch(msg->type) {
1048 case PRINTER_NOTIFY_TYPE:
1049 if ( printer_notify_table[msg->field].fn )
1050 printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1051 break;
1052
1053 case JOB_NOTIFY_TYPE:
1054 if ( job_notify_table[msg->field].fn )
1055 job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1056 break;
1057
1058 default:
1059 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1060 goto done;
1061 }
1062
1063 count++;
1064 }
1065
1066 if ( sending_msg_count ) {
1067 NTSTATUS status;
1068 WERROR werr;
1069 union spoolss_ReplyPrinterInfo info;
1070 struct spoolss_NotifyInfo info0;
1071 uint32_t reply_result;
1072
1073 info0.version = 0x2;
1074 info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1075 info0.count = count;
1076 info0.notifies = notifies;
1077
1078 info.info0 = &info0;
1079
1080 status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1081 &p->notify.client_hnd,
1082 p->notify.change, /* color */
1083 p->notify.flags,
1084 &reply_result,
1085 0, /* reply_type, must be 0 */
1086 info,
1087 &werr);
1088 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1089 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1090 notify_cli_pipe->srv_name_slash,
1091 win_errstr(werr)));
1092 }
1093 switch (reply_result) {
1094 case 0:
1095 break;
1096 case PRINTER_NOTIFY_INFO_DISCARDED:
1097 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1098 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1099 break;
1100 default:
1101 break;
1102 }
1103 }
1104 }
1105
1106 done:
1107 DEBUG(8,("send_notify2_changes: Exit...\n"));
1108 return;
1109 }
1110
1111 /***********************************************************************
1112 **********************************************************************/
1113
1114 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1115 {
1116
1117 uint32_t tv_sec, tv_usec;
1118 size_t offset = 0;
1119
1120 /* Unpack message */
1121
1122 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1123 msg->printer);
1124
1125 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1126 &tv_sec, &tv_usec,
1127 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1128
1129 if (msg->len == 0)
1130 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1131 &msg->notify.value[0], &msg->notify.value[1]);
1132 else
1133 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1134 &msg->len, &msg->notify.data);
1135
1136 DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1137 msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1138
1139 tv->tv_sec = tv_sec;
1140 tv->tv_usec = tv_usec;
1141
1142 if (msg->len == 0)
1143 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1144 msg->notify.value[1]));
1145 else
1146 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1147
1148 return true;
1149 }
1150
1151 /********************************************************************
1152 Receive a notify2 message list
1153 ********************************************************************/
1154
1155 static void receive_notify2_message_list(struct messaging_context *msg,
1156 void *private_data,
1157 uint32_t msg_type,
1158 struct server_id server_id,
1159 DATA_BLOB *data)
1160 {
1161 size_t msg_count, i;
1162 char *buf = (char *)data->data;
1163 char *msg_ptr;
1164 size_t msg_len;
1165 SPOOLSS_NOTIFY_MSG notify;
1166 SPOOLSS_NOTIFY_MSG_CTR messages;
1167 int num_groups;
1168
1169 if (data->length < 4) {
1170 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1171 return;
1172 }
1173
1174 msg_count = IVAL(buf, 0);
1175 msg_ptr = buf + 4;
1176
1177 DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1178
1179 if (msg_count == 0) {
1180 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1181 return;
1182 }
1183
1184 /* initialize the container */
1185
1186 ZERO_STRUCT( messages );
1187 notify_msg_ctr_init( &messages );
1188
1189 /*
1190 * build message groups for each printer identified
1191 * in a change_notify msg. Remember that a PCN message
1192 * includes the handle returned for the srv_spoolss_replyopenprinter()
1193 * call. Therefore messages are grouped according to printer handle.
1194 */
1195
1196 for ( i=0; i<msg_count; i++ ) {
1197 struct timeval msg_tv;
1198
1199 if (msg_ptr + 4 - buf > data->length) {
1200 DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1201 return;
1202 }
1203
1204 msg_len = IVAL(msg_ptr,0);
1205 msg_ptr += 4;
1206
1207 if (msg_ptr + msg_len - buf > data->length) {
1208 DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1209 return;
1210 }
1211
1212 /* unpack messages */
1213
1214 ZERO_STRUCT( notify );
1215 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1216 msg_ptr += msg_len;
1217
1218 /* add to correct list in container */
1219
1220 notify_msg_ctr_addmsg( &messages, &notify );
1221
1222 /* free memory that might have been allocated by notify2_unpack_msg() */
1223
1224 if ( notify.len != 0 )
1225 SAFE_FREE( notify.notify.data );
1226 }
1227
1228 /* process each group of messages */
1229
1230 num_groups = notify_msg_ctr_numgroups( &messages );
1231 for ( i=0; i<num_groups; i++ )
1232 send_notify2_changes( &messages, i );
1233
1234
1235 /* cleanup */
1236
1237 DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1238 (uint32_t)msg_count ));
1239
1240 notify_msg_ctr_destroy( &messages );
1241
1242 return;
1243 }
1244
1245 /********************************************************************
1246 Send a message to ourself about new driver being installed
1247 so we can upgrade the information for each printer bound to this
1248 driver
1249 ********************************************************************/
1250
1251 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1252 {
1253 int len = strlen(drivername);
1254
1255 if (!len)
1256 return false;
1257
1258 DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1259 drivername));
1260
1261 messaging_send_buf(smbd_messaging_context(), procid_self(),
1262 MSG_PRINTER_DRVUPGRADE,
1263 (uint8_t *)drivername, len+1);
1264
1265 return true;
1266 }
1267
1268 /**********************************************************************
1269 callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1270 over all printers, upgrading ones as necessary
1271 **********************************************************************/
1272
1273 void do_drv_upgrade_printer(struct messaging_context *msg,
1274 void *private_data,
1275 uint32_t msg_type,
1276 struct server_id server_id,
1277 DATA_BLOB *data)
1278 {
1279 fstring drivername;
1280 int snum;
1281 int n_services = lp_numservices();
1282 size_t len;
1283
1284 len = MIN(data->length,sizeof(drivername)-1);
1285 strncpy(drivername, (const char *)data->data, len);
1286
1287 DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1288
1289 /* Iterate the printer list */
1290
1291 for (snum=0; snum<n_services; snum++)
1292 {
1293 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1294 {
1295 WERROR result;
1296 NT_PRINTER_INFO_LEVEL *printer = NULL;
1297
1298 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1299 if (!W_ERROR_IS_OK(result))
1300 continue;
1301
1302 if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1303 {
1304 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1305
1306 /* all we care about currently is the change_id */
1307
1308 result = mod_a_printer(printer, 2);
1309 if (!W_ERROR_IS_OK(result)) {
1310 DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1311 win_errstr(result)));
1312 }
1313 }
1314
1315 free_a_printer(&printer, 2);
1316 }
1317 }
1318
1319 /* all done */
1320 }
1321
1322 /********************************************************************
1323 Update the cache for all printq's with a registered client
1324 connection
1325 ********************************************************************/
1326
1327 void update_monitored_printq_cache( void )
1328 {
1329 Printer_entry *printer = printers_list;
1330 int snum;
1331
1332 /* loop through all printers and update the cache where
1333 client_connected == true */
1334 while ( printer )
1335 {
1336 if ( (printer->printer_type == SPLHND_PRINTER)
1337 && printer->notify.client_connected )
1338 {
1339 snum = print_queue_snum(printer->sharename);
1340 print_queue_status( snum, NULL, NULL );
1341 }
1342
1343 printer = printer->next;
1344 }
1345
1346 return;
1347 }
1348 /********************************************************************
1349 Send a message to ourself about new driver being installed
1350 so we can upgrade the information for each printer bound to this
1351 driver
1352 ********************************************************************/
1353
1354 static bool srv_spoolss_reset_printerdata(char* drivername)
1355 {
1356 int len = strlen(drivername);
1357
1358 if (!len)
1359 return false;
1360
1361 DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1362 drivername));
1363
1364 messaging_send_buf(smbd_messaging_context(), procid_self(),
1365 MSG_PRINTERDATA_INIT_RESET,
1366 (uint8_t *)drivername, len+1);
1367
1368 return true;
1369 }
1370
1371 /**********************************************************************
1372 callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1373 over all printers, resetting printer data as neessary
1374 **********************************************************************/
1375
1376 void reset_all_printerdata(struct messaging_context *msg,
1377 void *private_data,
1378 uint32_t msg_type,
1379 struct server_id server_id,
1380 DATA_BLOB *data)
1381 {
1382 fstring drivername;
1383 int snum;
1384 int n_services = lp_numservices();
1385 size_t len;
1386
1387 len = MIN( data->length, sizeof(drivername)-1 );
1388 strncpy( drivername, (const char *)data->data, len );
1389
1390 DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1391
1392 /* Iterate the printer list */
1393
1394 for ( snum=0; snum<n_services; snum++ )
1395 {
1396 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1397 {
1398 WERROR result;
1399 NT_PRINTER_INFO_LEVEL *printer = NULL;
1400
1401 result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1402 if ( !W_ERROR_IS_OK(result) )
1403 continue;
1404
1405 /*
1406 * if the printer is bound to the driver,
1407 * then reset to the new driver initdata
1408 */
1409
1410 if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1411 {
1412 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1413
1414 if ( !set_driver_init(printer, 2) ) {
1415 DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1416 printer->info_2->printername, printer->info_2->drivername));
1417 }
1418
1419 result = mod_a_printer( printer, 2 );
1420 if ( !W_ERROR_IS_OK(result) ) {
1421 DEBUG(3,("reset_all_printerdata: mod_a_printer() failed! (%s)\n",
1422 get_dos_error_msg(result)));
1423 }
1424 }
1425
1426 free_a_printer( &printer, 2 );
1427 }
1428 }
1429
1430 /* all done */
1431
1432 return;
1433 }
1434
1435 /****************************************************************
1436 _spoolss_OpenPrinter
1437 ****************************************************************/
1438
1439 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1440 struct spoolss_OpenPrinter *r)
1441 {
1442 struct spoolss_OpenPrinterEx e;
1443 WERROR werr;
1444
1445 ZERO_STRUCT(e.in.userlevel);
1446
1447 e.in.printername = r->in.printername;
1448 e.in.datatype = r->in.datatype;
1449 e.in.devmode_ctr = r->in.devmode_ctr;
1450 e.in.access_mask = r->in.access_mask;
1451 e.in.level = 0;
1452
1453 e.out.handle = r->out.handle;
1454
1455 werr = _spoolss_OpenPrinterEx(p, &e);
1456
1457 if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1458 /* OpenPrinterEx returns this for a bad
1459 * printer name. We must return WERR_INVALID_PRINTER_NAME
1460 * instead.
1461 */
1462 werr = WERR_INVALID_PRINTER_NAME;
1463 }
1464
1465 return werr;
1466 }
1467
1468 /********************************************************************
1469 ********************************************************************/
1470
1471 bool convert_devicemode(const char *printername,
1472 const struct spoolss_DeviceMode *devmode,
1473 NT_DEVICEMODE **pp_nt_devmode)
1474 {
1475 NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1476
1477 /*
1478 * Ensure nt_devmode is a valid pointer
1479 * as we will be overwriting it.
1480 */
1481
1482 if (nt_devmode == NULL) {
1483 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1484 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1485 return false;
1486 }
1487
1488 rpcstr_push(nt_devmode->devicename, devmode->devicename, 31, 0);
1489 rpcstr_push(nt_devmode->formname, devmode->formname, 31, 0);
1490
1491 nt_devmode->specversion = devmode->specversion;
1492 nt_devmode->driverversion = devmode->driverversion;
1493 nt_devmode->size = devmode->size;
1494 nt_devmode->fields = devmode->fields;
1495 nt_devmode->orientation = devmode->orientation;
1496 nt_devmode->papersize = devmode->papersize;
1497 nt_devmode->paperlength = devmode->paperlength;
1498 nt_devmode->paperwidth = devmode->paperwidth;
1499 nt_devmode->scale = devmode->scale;
1500 nt_devmode->copies = devmode->copies;
1501 nt_devmode->defaultsource = devmode->defaultsource;
1502 nt_devmode->printquality = devmode->printquality;
1503 nt_devmode->color = devmode->color;
1504 nt_devmode->duplex = devmode->duplex;
1505 nt_devmode->yresolution = devmode->yresolution;
1506 nt_devmode->ttoption = devmode->ttoption;
1507 nt_devmode->collate = devmode->collate;
1508
1509 nt_devmode->logpixels = devmode->logpixels;
1510 nt_devmode->bitsperpel = devmode->bitsperpel;
1511 nt_devmode->pelswidth = devmode->pelswidth;
1512 nt_devmode->pelsheight = devmode->pelsheight;
1513 nt_devmode->displayflags = devmode->displayflags;
1514 nt_devmode->displayfrequency = devmode->displayfrequency;
1515 nt_devmode->icmmethod = devmode->icmmethod;
1516 nt_devmode->icmintent = devmode->icmintent;
1517 nt_devmode->mediatype = devmode->mediatype;
1518 nt_devmode->dithertype = devmode->dithertype;
1519 nt_devmode->reserved1 = devmode->reserved1;
1520 nt_devmode->reserved2 = devmode->reserved2;
1521 nt_devmode->panningwidth = devmode->panningwidth;
1522 nt_devmode->panningheight = devmode->panningheight;
1523
1524 /*
1525 * Only change private and driverextra if the incoming devmode
1526 * has a new one. JRA.
1527 */
1528
1529 if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1530 SAFE_FREE(nt_devmode->nt_dev_private);
1531 nt_devmode->driverextra = devmode->__driverextra_length;
1532 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1533 return false;
1534 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1535 }
1536
1537 *pp_nt_devmode = nt_devmode;
1538
1539 return true;
1540 }
1541
1542 /****************************************************************
1543 _spoolss_OpenPrinterEx
1544 ****************************************************************/
1545
1546 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1547 struct spoolss_OpenPrinterEx *r)
1548 {
1549 int snum;
1550 Printer_entry *Printer=NULL;
1551
1552 if (!r->in.printername) {
1553 return WERR_INVALID_PARAM;
1554 }
1555
1556 /* some sanity check because you can open a printer or a print server */
1557 /* aka: \\server\printer or \\server */
1558
1559 DEBUGADD(3,("checking name: %s\n", r->in.printername));
1560
1561 if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1562 ZERO_STRUCTP(r->out.handle);
1563 return WERR_INVALID_PARAM;
1564 }
1565
1566 Printer = find_printer_index_by_hnd(p, r->out.handle);
1567 if ( !Printer ) {
1568 DEBUG(0,("_spoolss_OpenPrinterEx: logic error. Can't find printer "
1569 "handle we created for printer %s\n", r->in.printername));
1570 close_printer_handle(p, r->out.handle);
1571 ZERO_STRUCTP(r->out.handle);
1572 return WERR_INVALID_PARAM;
1573 }
1574
1575 /*
1576 * First case: the user is opening the print server:
1577 *
1578 * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1579 * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1580 *
1581 * Then both Win2k and WinNT clients try an OpenPrinterEx with
1582 * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1583 * or if the user is listed in the smb.conf printer admin parameter.
1584 *
1585 * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1586 * client view printer folder, but does not show the MSAPW.
1587 *
1588 * Note: this test needs code to check access rights here too. Jeremy
1589 * could you look at this?
1590 *
1591 * Second case: the user is opening a printer:
1592 * NT doesn't let us connect to a printer if the connecting user
1593 * doesn't have print permission.
1594 *
1595 * Third case: user is opening a Port Monitor
1596 * access checks same as opening a handle to the print server.
1597 */
1598
1599 switch (Printer->printer_type )
1600 {
1601 case SPLHND_SERVER:
1602 case SPLHND_PORTMON_TCP:
1603 case SPLHND_PORTMON_LOCAL:
1604 /* Printserver handles use global struct... */
1605
1606 snum = -1;
1607
1608 /* Map standard access rights to object specific access rights */
1609
1610 se_map_standard(&r->in.access_mask,
1611 &printserver_std_mapping);
1612
1613 /* Deny any object specific bits that don't apply to print
1614 servers (i.e printer and job specific bits) */
1615
1616 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1617
1618 if (r->in.access_mask &
1619 ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1620 DEBUG(3, ("access DENIED for non-printserver bits\n"));
1621 close_printer_handle(p, r->out.handle);
1622 ZERO_STRUCTP(r->out.handle);
1623 return WERR_ACCESS_DENIED;
1624 }
1625
1626 /* Allow admin access */
1627
1628 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1629 {
1630 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1631
1632 if (!lp_ms_add_printer_wizard()) {
1633 close_printer_handle(p, r->out.handle);
1634 ZERO_STRUCTP(r->out.handle);
1635 return WERR_ACCESS_DENIED;
1636 }
1637
1638 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1639 and not a printer admin, then fail */
1640
1641 if ((p->server_info->utok.uid != sec_initial_uid()) &&
1642 !user_has_privileges(p->server_info->ptok,
1643 &se_printop ) &&
1644 !token_contains_name_in_list(
1645 uidtoname(p->server_info->utok.uid),
1646 NULL, NULL,
1647 p->server_info->ptok,
1648 lp_printer_admin(snum))) {
1649 close_printer_handle(p, r->out.handle);
1650 ZERO_STRUCTP(r->out.handle);
1651 return WERR_ACCESS_DENIED;
1652 }
1653
1654 r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1655 }
1656 else
1657 {
1658 r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1659 }
1660
1661 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1662 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1663
1664 /* We fall through to return WERR_OK */
1665 break;
1666
1667 case SPLHND_PRINTER:
1668 /* NT doesn't let us connect to a printer if the connecting user
1669 doesn't have print permission. */
1670
1671 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1672 close_printer_handle(p, r->out.handle);
1673 ZERO_STRUCTP(r->out.handle);
1674 return WERR_BADFID;
1675 }
1676
1677 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1678
1679 /* map an empty access mask to the minimum access mask */
1680 if (r->in.access_mask == 0x0)
1681 r->in.access_mask = PRINTER_ACCESS_USE;
1682
1683 /*
1684 * If we are not serving the printer driver for this printer,
1685 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1686 * will keep NT clients happy --jerry
1687 */
1688
1689 if (lp_use_client_driver(snum)
1690 && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1691 {
1692 r->in.access_mask = PRINTER_ACCESS_USE;
1693 }
1694
1695 /* check smb.conf parameters and the the sec_desc */
1696
1697 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1698 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1699 ZERO_STRUCTP(r->out.handle);
1700 return WERR_ACCESS_DENIED;
1701 }
1702
1703 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1704 p->server_info->ptok, snum) ||
1705 !print_access_check(p->server_info, snum,
1706 r->in.access_mask)) {
1707 DEBUG(3, ("access DENIED for printer open\n"));
1708 close_printer_handle(p, r->out.handle);
1709 ZERO_STRUCTP(r->out.handle);
1710 return WERR_ACCESS_DENIED;
1711 }
1712
1713 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1714 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1715 close_printer_handle(p, r->out.handle);
1716 ZERO_STRUCTP(r->out.handle);
1717 return WERR_ACCESS_DENIED;
1718 }
1719
1720 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1721 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1722 else
1723 r->in.access_mask = PRINTER_ACCESS_USE;
1724
1725 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1726 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1727
1728 break;
1729
1730 default:
1731 /* sanity check to prevent programmer error */
1732 ZERO_STRUCTP(r->out.handle);
1733 return WERR_BADFID;
1734 }
1735
1736 Printer->access_granted = r->in.access_mask;
1737
1738 /*
1739 * If the client sent a devmode in the OpenPrinter() call, then
1740 * save it here in case we get a job submission on this handle
1741 */
1742
1743 if ((Printer->printer_type != SPLHND_SERVER) &&
1744 r->in.devmode_ctr.devmode) {
1745 convert_devicemode(Printer->sharename,
1746 r->in.devmode_ctr.devmode,
1747 &Printer->nt_devmode);
1748 }
1749
1750 #if 0 /* JERRY -- I'm doubtful this is really effective */
1751 /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1752 optimization in Windows 2000 clients --jerry */
1753
1754 if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1755 && (RA_WIN2K == get_remote_arch()) )
1756 {
1757 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1758 sys_usleep( 500000 );
1759 }
1760 #endif
1761
1762 return WERR_OK;
1763 }
1764
1765 /****************************************************************************
1766 ****************************************************************************/
1767
1768 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1769 NT_PRINTER_INFO_LEVEL_2 *d)
1770 {
1771 DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1772
1773 if (!r || !d) {
1774 return false;
1775 }
1776
1777 d->attributes = r->attributes;
1778 d->priority = r->priority;
1779 d->default_priority = r->defaultpriority;
1780 d->starttime = r->starttime;
1781 d->untiltime = r->untiltime;
1782 d->status = r->status;
1783 d->cjobs = r->cjobs;
1784
1785 fstrcpy(d->servername, r->servername);
1786 fstrcpy(d->printername, r->printername);
1787 fstrcpy(d->sharename, r->sharename);
1788 fstrcpy(d->portname, r->portname);
1789 fstrcpy(d->drivername, r->drivername);
1790 slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1791 fstrcpy(d->location, r->location);
1792 fstrcpy(d->sepfile, r->sepfile);
1793 fstrcpy(d->printprocessor, r->printprocessor);
1794 fstrcpy(d->datatype, r->datatype);
1795 fstrcpy(d->parameters, r->parameters);
1796
1797 return true;
1798 }
1799
1800 /****************************************************************************
1801 ****************************************************************************/
1802
1803 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1804 NT_PRINTER_INFO_LEVEL *printer)
1805 {
1806 bool ret;
1807
1808 switch (info_ctr->level) {
1809 case 2:
1810 /* allocate memory if needed. Messy because
1811 convert_printer_info is used to update an existing
1812 printer or build a new one */
1813
1814 if (!printer->info_2) {
1815 printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1816 if (!printer->info_2) {
1817 DEBUG(0,("convert_printer_info: "
1818 "talloc() failed!\n"));
1819 return false;
1820 }
1821 }
1822
1823 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1824 printer->info_2);
1825 printer->info_2->setuptime = time(NULL);
1826 return ret;
1827 }
1828
1829 return false;
1830 }
1831
1832 /*******************************************************************
1833 ********************************************************************/
1834
1835 static bool string_array_to_fstring_array(const char **sarray, fstring **farray)
1836 {
1837 int i;
1838
1839 if (!sarray) {
1840 *farray = NULL;
1841 return true;
1842 }
1843
1844 *farray = SMB_MALLOC_ARRAY(fstring, 1);
1845 if (!*farray) {
1846 return false;
1847 }
1848
1849 for (i=0; sarray[i] != NULL; i++) {
1850 *farray = SMB_REALLOC_ARRAY(*farray, fstring, i+2);
1851 if (!*farray) {
1852 return false;
1853 }
1854 fstrcpy((*farray)[i], sarray[i]);
1855 }
1856
1857 fstrcpy((*farray)[i], "");
1858
1859 return true;
1860 }
1861
1862 /*******************************************************************
1863 ********************************************************************/
1864
1865 static bool driver_info3_to_nt_driver_info3(struct spoolss_AddDriverInfo3 *r,
1866 NT_PRINTER_DRIVER_INFO_LEVEL_3 **p)
1867 {
1868 NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
1869
1870 DEBUG(7,("driver_info3_to_nt_driver_info3: Converting from UNICODE to ASCII\n"));
1871
1872 if (*p == NULL) {
1873 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
1874 if (*p == NULL) {
1875 return false;
1876 }
1877 ZERO_STRUCTP(*p);
1878 }
1879
1880 d = *p;
1881
1882 d->cversion = r->version;
1883
1884 fstrcpy(d->name, r->driver_name);
1885 fstrcpy(d->environment, r->architecture);
1886 fstrcpy(d->driverpath, r->driver_path);
1887 fstrcpy(d->datafile, r->data_file);
1888 fstrcpy(d->configfile, r->config_file);
1889 fstrcpy(d->helpfile, r->help_file);
1890 fstrcpy(d->monitorname, r->monitor_name);
1891 fstrcpy(d->defaultdatatype, r->default_datatype);
1892
1893 DEBUGADD(8,( "version: %d\n", d->cversion));
1894 DEBUGADD(8,( "name: %s\n", d->name));
1895 DEBUGADD(8,( "environment: %s\n", d->environment));
1896 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
1897 DEBUGADD(8,( "datafile: %s\n", d->datafile));
1898 DEBUGADD(8,( "configfile: %s\n", d->configfile));
1899 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
1900 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
1901 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1902
1903 if (r->dependent_files) {
1904 if (!string_array_to_fstring_array(r->dependent_files->string,
1905 &d->dependentfiles)) {
1906 SAFE_FREE(*p);
1907 return false;
1908 }
1909 }
1910
1911 return true;
1912 }
1913
1914 /*******************************************************************
1915 ********************************************************************/
1916
1917 static bool driver_info6_to_nt_driver_info6(struct spoolss_AddDriverInfo6 *r,
1918 NT_PRINTER_DRIVER_INFO_LEVEL_6 **p)
1919 {
1920 NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
1921
1922 DEBUG(7,("driver_info6_to_nt_driver_info6: Converting from UNICODE to ASCII\n"));
1923
1924 if (*p == NULL) {
1925 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
1926 if (*p == NULL) {
1927 return false;
1928 }
1929 ZERO_STRUCTP(*p);
1930 }
1931
1932 d = *p;
1933
1934 d->version = r->version;
1935
1936 fstrcpy(d->name, r->driver_name);
1937 fstrcpy(d->environment, r->architecture);
1938 fstrcpy(d->driverpath, r->driver_path);
1939 fstrcpy(d->datafile, r->data_file);
1940 fstrcpy(d->configfile, r->config_file);
1941 fstrcpy(d->helpfile, r->help_file);
1942 fstrcpy(d->monitorname, r->monitor_name);
1943 fstrcpy(d->defaultdatatype, r->default_datatype);
1944
1945 DEBUGADD(8,( "version: %d\n", d->version));
1946 DEBUGADD(8,( "name: %s\n", d->name));
1947 DEBUGADD(8,( "environment: %s\n", d->environment));
1948 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
1949 DEBUGADD(8,( "datafile: %s\n", d->datafile));
1950 DEBUGADD(8,( "configfile: %s\n", d->configfile));
1951 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
1952 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
1953 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1954
1955 if (r->dependent_files) {
1956 if (!string_array_to_fstring_array(r->dependent_files->string,
1957 &d->dependentfiles)) {
1958 goto error;
1959 }
1960 }
1961
1962 if (r->previous_names) {
1963 if (!string_array_to_fstring_array(r->previous_names->string,
1964 &d->previousnames)) {
1965 goto error;
1966 }
1967 }
1968
1969 return true;
1970
1971 error:
1972 SAFE_FREE(*p);
1973 return false;
1974 }
1975
1976 /********************************************************************
1977 ********************************************************************/
1978
1979 static bool convert_printer_driver_info(const struct spoolss_AddDriverInfoCtr *r,
1980 NT_PRINTER_DRIVER_INFO_LEVEL *printer,
1981 uint32_t level)
1982 {
1983 switch (level) {
1984 case 3:
1985 printer->info_3 = NULL;
1986 if (!driver_info3_to_nt_driver_info3(r->info.info3, &printer->info_3)) {
1987 return false;
1988 }
1989 break;
1990 case 6:
1991 printer->info_6 = NULL;
1992 if (!driver_info6_to_nt_driver_info6(r->info.info6, &printer->info_6)) {
1993 return false;
1994 }
1995 break;
1996 default:
1997 return false;
1998 }
1999
2000 return true;
2001 }
2002
2003 /********************************************************************
2004 * _spoolss_enddocprinter_internal.
2005 ********************************************************************/
2006
2007 static WERROR _spoolss_enddocprinter_internal(pipes_struct *p,
2008 struct policy_handle *handle)
2009 {
2010 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
2011 int snum;
2012
2013 if (!Printer) {
2014 DEBUG(2,("_spoolss_enddocprinter_internal: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
2015 return WERR_BADFID;
2016 }
2017
2018 if (!get_printer_snum(p, handle, &snum, NULL))
2019 return WERR_BADFID;
2020
2021 Printer->document_started = false;
2022 print_job_end(snum, Printer->jobid,NORMAL_CLOSE);
2023 /* error codes unhandled so far ... */
2024
2025 return WERR_OK;
2026 }
2027
2028 /****************************************************************
2029 _spoolss_ClosePrinter
2030 ****************************************************************/
2031
2032 WERROR _spoolss_ClosePrinter(pipes_struct *p,
2033 struct spoolss_ClosePrinter *r)
2034 {
2035 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2036
2037 if (Printer && Printer->document_started)
2038 _spoolss_enddocprinter_internal(p, r->in.handle); /* print job was not closed */
2039
2040 if (!close_printer_handle(p, r->in.handle))
2041 return WERR_BADFID;
2042
2043 /* clear the returned printer handle. Observed behavior
2044 from Win2k server. Don't think this really matters.
2045 Previous code just copied the value of the closed
2046 handle. --jerry */
2047
2048 ZERO_STRUCTP(r->out.handle);
2049
2050 return WERR_OK;
2051 }
2052
2053 /****************************************************************
2054 _spoolss_DeletePrinter
2055 ****************************************************************/
2056
2057 WERROR _spoolss_DeletePrinter(pipes_struct *p,
2058 struct spoolss_DeletePrinter *r)
2059 {
2060 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2061 WERROR result;
2062
2063 if (Printer && Printer->document_started)
2064 _spoolss_enddocprinter_internal(p, r->in.handle); /* print job was not closed */
2065
2066 result = delete_printer_handle(p, r->in.handle);
2067
2068 update_c_setprinter(false);
2069
2070 return result;
2071 }
2072
2073 /*******************************************************************
2074 * static function to lookup the version id corresponding to an
2075 * long architecture string
2076 ******************************************************************/
2077
2078 static int get_version_id(const char *arch)
2079 {
2080 int i;
2081 struct table_node archi_table[]= {
2082
2083 {"Windows 4.0", "WIN40", 0 },
2084 {"Windows NT x86", "W32X86", 2 },
2085 {"Windows NT R4000", "W32MIPS", 2 },
2086 {"Windows NT Alpha_AXP", "W32ALPHA", 2 },
2087 {"Windows NT PowerPC", "W32PPC", 2 },
2088 {"Windows IA64", "IA64", 3 },
2089 {"Windows x64", "x64", 3 },
2090 {NULL, "", -1 }
2091 };
2092
2093 for (i=0; archi_table[i].long_archi != NULL; i++)
2094 {
2095 if (strcmp(arch, archi_table[i].long_archi) == 0)
2096 return (archi_table[i].version);
2097 }
2098
2099 return -1;
2100 }
2101
2102 /****************************************************************
2103 _spoolss_DeletePrinterDriver
2104 ****************************************************************/
2105
2106 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
2107 struct spoolss_DeletePrinterDriver *r)
2108 {
2109 NT_PRINTER_DRIVER_INFO_LEVEL info;
2110 NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
2111 int version;
2112 WERROR status;
2113 WERROR status_win2k = WERR_ACCESS_DENIED;
2114 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2115
2116 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2117 and not a printer admin, then fail */
2118
2119 if ( (p->server_info->utok.uid != sec_initial_uid())
2120 && !user_has_privileges(p->server_info->ptok, &se_printop )
2121 && !token_contains_name_in_list(
2122 uidtoname(p->server_info->utok.uid), NULL,
2123 NULL, p->server_info->ptok,
2124 lp_printer_admin(-1)) )
2125 {
2126 return WERR_ACCESS_DENIED;
2127 }
2128
2129 /* check that we have a valid driver name first */
2130
2131 if ((version = get_version_id(r->in.architecture)) == -1)
2132 return WERR_INVALID_ENVIRONMENT;
2133
2134 ZERO_STRUCT(info);
2135 ZERO_STRUCT(info_win2k);
2136
2137 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2138 r->in.architecture,
2139 version)))
2140 {
2141 /* try for Win2k driver if "Windows NT x86" */
2142
2143 if ( version == 2 ) {
2144 version = 3;
2145 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3,
2146 r->in.driver,
2147 r->in.architecture,
2148 version))) {
2149 status = WERR_UNKNOWN_PRINTER_DRIVER;
2150 goto done;
2151 }
2152 }
2153 /* otherwise it was a failure */
2154 else {
2155 status = WERR_UNKNOWN_PRINTER_DRIVER;
2156 goto done;
2157 }
2158
2159 }
2160
2161 if (printer_driver_in_use(info.info_3)) {
2162 status = WERR_PRINTER_DRIVER_IN_USE;
2163 goto done;
2164 }
2165
2166 if ( version == 2 )
2167 {
2168 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2169 r->in.driver,
2170 r->in.architecture, 3)))
2171 {
2172 /* if we get to here, we now have 2 driver info structures to remove */
2173 /* remove the Win2k driver first*/
2174
2175 status_win2k = delete_printer_driver(
2176 p, info_win2k.info_3, 3, false);
2177 free_a_printer_driver( info_win2k, 3 );
2178
2179 /* this should not have failed---if it did, report to client */
2180 if ( !W_ERROR_IS_OK(status_win2k) )
2181 {
2182 status = status_win2k;
2183 goto done;
2184 }
2185 }
2186 }
2187
2188 status = delete_printer_driver(p, info.info_3, version, false);
2189
2190 /* if at least one of the deletes succeeded return OK */
2191
2192 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2193 status = WERR_OK;
2194
2195 done:
2196 free_a_printer_driver( info, 3 );
2197
2198 return status;
2199 }
2200
2201 /****************************************************************
2202 _spoolss_DeletePrinterDriverEx
2203 ****************************************************************/
2204
2205 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2206 struct spoolss_DeletePrinterDriverEx *r)
2207 {
2208 NT_PRINTER_DRIVER_INFO_LEVEL info;
2209 NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
2210 int version;
2211 bool delete_files;
2212 WERROR status;
2213 WERROR status_win2k = WERR_ACCESS_DENIED;
2214 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2215
2216 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2217 and not a printer admin, then fail */
2218
2219 if ( (p->server_info->utok.uid != sec_initial_uid())
2220 && !user_has_privileges(p->server_info->ptok, &se_printop )
2221 && !token_contains_name_in_list(
2222 uidtoname(p->server_info->utok.uid), NULL, NULL,
2223 p->server_info->ptok, lp_printer_admin(-1)) )
2224 {
2225 return WERR_ACCESS_DENIED;
2226 }
2227
2228 /* check that we have a valid driver name first */
2229 if ((version = get_version_id(r->in.architecture)) == -1) {
2230 /* this is what NT returns */
2231 return WERR_INVALID_ENVIRONMENT;
2232 }
2233
2234 if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2235 version = r->in.version;
2236
2237 ZERO_STRUCT(info);
2238 ZERO_STRUCT(info_win2k);
2239
2240 status = get_a_printer_driver(&info, 3, r->in.driver,
2241 r->in.architecture, version);
2242
2243 if ( !W_ERROR_IS_OK(status) )
2244 {
2245 /*
2246 * if the client asked for a specific version,
2247 * or this is something other than Windows NT x86,
2248 * then we've failed
2249 */
2250
2251 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2252 goto done;
2253
2254 /* try for Win2k driver if "Windows NT x86" */
2255
2256 version = 3;
2257 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2258 r->in.architecture,
2259 version))) {
2260 status = WERR_UNKNOWN_PRINTER_DRIVER;
2261 goto done;
2262 }
2263 }
2264
2265 if ( printer_driver_in_use(info.info_3) ) {
2266 status = WERR_PRINTER_DRIVER_IN_USE;
2267 goto done;
2268 }
2269
2270 /*
2271 * we have a couple of cases to consider.
2272 * (1) Are any files in use? If so and DPD_DELTE_ALL_FILE is set,
2273 * then the delete should fail if **any** files overlap with
2274 * other drivers
2275 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2276 * non-overlapping files
2277 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2278 * is set, the do not delete any files
2279 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2280 */
2281
2282 delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2283
2284 /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2285
2286 if ( delete_files && printer_driver_files_in_use(info.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2287 /* no idea of the correct error here */
2288 status = WERR_ACCESS_DENIED;
2289 goto done;
2290 }
2291
2292
2293 /* also check for W32X86/3 if necessary; maybe we already have? */
2294
2295 if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
2296 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2297 r->in.driver,
2298 r->in.architecture, 3)))
2299 {
2300
2301 if ( delete_files && printer_driver_files_in_use(info_win2k.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2302 /* no idea of the correct error here */
2303 free_a_printer_driver( info_win2k, 3 );
2304 status = WERR_ACCESS_DENIED;
2305 goto done;
2306 }
2307
2308 /* if we get to here, we now have 2 driver info structures to remove */
2309 /* remove the Win2k driver first*/
2310
2311 status_win2k = delete_printer_driver(
2312 p, info_win2k.info_3, 3, delete_files);
2313 free_a_printer_driver( info_win2k, 3 );
2314
2315 /* this should not have failed---if it did, report to client */
2316
2317 if ( !W_ERROR_IS_OK(status_win2k) )
2318 goto done;
2319 }
2320 }
2321
2322 status = delete_printer_driver(p, info.info_3, version, delete_files);
2323
2324 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2325 status = WERR_OK;
2326 done:
2327 free_a_printer_driver( info, 3 );
2328
2329 return status;
2330 }
2331
2332
2333 /****************************************************************************
2334 Internal routine for removing printerdata
2335 ***************************************************************************/
2336
2337 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2338 {
2339 return delete_printer_data( printer->info_2, key, value );
2340 }
2341
2342 /****************************************************************************
2343 Internal routine for storing printerdata
2344 ***************************************************************************/
2345
2346 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2347 const char *key, const char *value,
2348 uint32_t type, uint8_t *data, int real_len)
2349 {
2350 /* the registry objects enforce uniqueness based on value name */
2351
2352 return add_printer_data( printer->info_2, key, value, type, data, real_len );
2353 }
2354
2355 /********************************************************************
2356 GetPrinterData on a printer server Handle.
2357 ********************************************************************/
2358
2359 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2360 const char *value,
2361 enum winreg_Type *type,
2362 union spoolss_PrinterData *data)
2363 {
2364 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2365
2366 if (!StrCaseCmp(value, "W3SvcInstalled")) {
2367 *type = REG_DWORD;
2368 data->value = 0x00;
2369 return WERR_OK;
2370 }
2371
2372 if (!StrCaseCmp(value, "BeepEnabled")) {
2373 *type = REG_DWORD;
2374 data->value = 0x00;
2375 return WERR_OK;
2376 }
2377
2378 if (!StrCaseCmp(value, "EventLog")) {
2379 *type = REG_DWORD;
2380 /* formally was 0x1b */
2381 data->value = 0x00;
2382 return WERR_OK;
2383 }
2384
2385 if (!StrCaseCmp(value, "NetPopup")) {
2386 *type = REG_DWORD;
2387 data->value = 0x00;
2388 return WERR_OK;
2389 }
2390
2391 if (!StrCaseCmp(value, "MajorVersion")) {
2392 *type = REG_DWORD;
2393
2394 /* Windows NT 4.0 seems to not allow uploading of drivers
2395 to a server that reports 0x3 as the MajorVersion.
2396 need to investigate more how Win2k gets around this .
2397 -- jerry */
2398
2399 if (RA_WINNT == get_remote_arch()) {
2400 data->value = 0x02;
2401 } else {
2402 data->value = 0x03;
2403 }
2404
2405 return WERR_OK;
2406 }
2407
2408 if (!StrCaseCmp(value, "MinorVersion")) {
2409 *type = REG_DWORD;
2410 data->value = 0x00;
2411 return WERR_OK;
2412 }
2413
2414 /* REG_BINARY
2415 * uint32_t size = 0x114
2416 * uint32_t major = 5
2417 * uint32_t minor = [0|1]
2418 * uint32_t build = [2195|2600]
2419 * extra unicode string = e.g. "Service Pack 3"
2420 */
2421 if (!StrCaseCmp(value, "OSVersion")) {
2422 DATA_BLOB blob;
2423 enum ndr_err_code ndr_err;
2424 struct spoolss_OSVersion os;
2425
2426 os.major = 5; /* Windows 2000 == 5.0 */
2427 os.minor = 0;
2428 os.build = 2195; /* build */
2429 os.extra_string = ""; /* leave extra string empty */
2430
2431 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2432 (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2433 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2434 return WERR_GENERAL_FAILURE;
2435 }
2436
2437 *type = REG_BINARY;
2438 data->binary = blob;
2439
2440 return WERR_OK;
2441 }
2442
2443
2444 if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2445 *type = REG_SZ;
2446
2447 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2448 W_ERROR_HAVE_NO_MEMORY(data->string);
2449
2450 return WERR_OK;
2451 }
2452
2453 if (!StrCaseCmp(value, "Architecture")) {
2454 *type = REG_SZ;
2455
2456 data->string = talloc_strdup(mem_ctx, "Windows NT x86");
2457 W_ERROR_HAVE_NO_MEMORY(data->string);
2458
2459 return WERR_OK;
2460 }
2461
2462 if (!StrCaseCmp(value, "DsPresent")) {
2463 *type = REG_DWORD;
2464
2465 /* only show the publish check box if we are a
2466 member of a AD domain */
2467
2468 if (lp_security() == SEC_ADS) {
2469 data->value = 0x01;
2470 } else {
2471 data->value = 0x00;
2472 }
2473 return WERR_OK;
2474 }
2475
2476 if (!StrCaseCmp(value, "DNSMachineName")) {
2477 const char *hostname = get_mydnsfullname();
2478
2479 if (!hostname) {
2480 return WERR_BADFILE;
2481 }
2482
2483 *type = REG_SZ;
2484 data->string = talloc_strdup(mem_ctx, hostname);
2485 W_ERROR_HAVE_NO_MEMORY(data->string);
2486
2487 return WERR_OK;
2488 }
2489
2490 return WERR_INVALID_PARAM;
2491 }
2492
2493 /****************************************************************
2494 _spoolss_GetPrinterData
2495 ****************************************************************/
2496
2497 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2498 struct spoolss_GetPrinterData *r)
2499 {
2500 WERROR result;
2501 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2502 NT_PRINTER_INFO_LEVEL *printer = NULL;
2503 int snum = 0;
2504
2505 /*
2506 * Reminder: when it's a string, the length is in BYTES
2507 * even if UNICODE is negociated.
2508 *
2509 * JFM, 4/19/1999
2510 */
2511
2512 /* in case of problem, return some default values */
2513
2514 *r->out.needed = 0;
2515 *r->out.type = 0;
2516
2517 DEBUG(4,("_spoolss_GetPrinterData\n"));
2518
2519 if (!Printer) {
2520 DEBUG(2,("_spoolss_GetPrinterData: Invalid handle (%s:%u:%u).\n",
2521 OUR_HANDLE(r->in.handle)));
2522 result = WERR_BADFID;
2523 goto done;
2524 }
2525
2526 if (Printer->printer_type == SPLHND_SERVER) {
2527 result = getprinterdata_printer_server(p->mem_ctx,
2528 r->in.value_name,
2529 r->out.type,
2530 r->out.data);
2531 } else {
2532 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
2533 result = WERR_BADFID;
2534 goto done;
2535 }
2536
2537 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
2538 if (!W_ERROR_IS_OK(result)) {
2539 goto done;
2540 }
2541
2542 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
2543
2544 if (strequal(r->in.value_name, "ChangeId")) {
2545 *r->out.type = REG_DWORD;
2546 r->out.data->value = printer->info_2->changeid;
2547 result = WERR_OK;
2548 } else {
2549 REGISTRY_VALUE *v;
2550 DATA_BLOB blob;
2551
2552 v = get_printer_data(printer->info_2,
2553 SPOOL_PRINTERDATA_KEY,
2554 r->in.value_name);
2555 if (!v) {
2556 result = WERR_BADFILE;
2557 goto done;
2558 }
2559
2560 *r->out.type = v->type;
2561
2562 blob = data_blob_const(v->data_p, v->size);
2563
2564 result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
2565 r->out.data,
2566 *r->out.type);
2567 }
2568 }
2569
2570 done:
2571 /* cleanup & exit */
2572
2573 if (printer) {
2574 free_a_printer(&printer, 2);
2575 }
2576
2577 if (!W_ERROR_IS_OK(result)) {
2578 return result;
2579 }
2580
2581 *r->out.needed = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
2582 *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
2583 r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
2584
2585 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
2586 }
2587
2588 /*********************************************************
2589 Connect to the client machine.
2590 **********************************************************/
2591
2592 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2593 struct sockaddr_storage *client_ss, const char *remote_machine)
2594 {
2595 NTSTATUS ret;
2596 struct cli_state *the_cli;
2597 struct sockaddr_storage rm_addr;
2598
2599 if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2600 if ( !resolve_name( remote_machine, &rm_addr, 0x20) ) {
2601 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2602 return false;
2603 }
2604
2605 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2606 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
2607 return false;
2608 }
2609 } else {
2610 char addr[INET6_ADDRSTRLEN];
2611 rm_addr = *client_ss;
2612 print_sockaddr(addr, sizeof(addr), &rm_addr);
2613 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2614 addr));
2615 }
2616
2617 /* setup the connection */
2618
2619 ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2620 &rm_addr, 0, "IPC$", "IPC",
2621 "", /* username */
2622 "", /* domain */
2623 "", /* password */
2624 0, lp_client_signing(), NULL );
2625
2626 if ( !NT_STATUS_IS_OK( ret ) ) {
2627 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2628 remote_machine ));
2629 return false;
2630 }
2631
2632 if ( the_cli->protocol != PROTOCOL_NT1 ) {
2633 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2634 cli_shutdown(the_cli);
2635 return false;
2636 }
2637
2638 /*
2639 * Ok - we have an anonymous connection to the IPC$ share.
2640 * Now start the NT Domain stuff :-).
2641 */
2642
2643 ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2644 if (!NT_STATUS_IS_OK(ret)) {
2645 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2646 remote_machine, nt_errstr(ret)));
2647 cli_shutdown(the_cli);
2648 return false;
2649 }
2650
2651 return true;
2652 }
2653
2654 /***************************************************************************
2655 Connect to the client.
2656 ****************************************************************************/
2657
2658 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2659 uint32_t localprinter, uint32_t type,
2660 struct policy_handle *handle,
2661 struct sockaddr_storage *client_ss)
2662 {
2663 WERROR result;
2664 NTSTATUS status;
2665
2666 /*
2667 * If it's the first connection, contact the client
2668 * and connect to the IPC$ share anonymously
2669 */
2670 if (smb_connections==0) {
2671 fstring unix_printer;
2672
2673 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2674
2675 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2676 return false;
2677
2678 messaging_register(smbd_messaging_context(), NULL,
2679 MSG_PRINTER_NOTIFY2,
2680 receive_notify2_message_list);
2681 /* Tell the connections db we're now interested in printer
2682 * notify messages. */
2683 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2684 }
2685
2686 /*
2687 * Tell the specific printing tdb we want messages for this printer
2688 * by registering our PID.
2689 */
2690
2691 if (!print_notify_register_pid(snum))
2692 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2693
2694 smb_connections++;
2695
2696 status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2697 printer,
2698 localprinter,
2699 type,
2700 0,
2701 NULL,
2702 handle,
2703 &result);
2704 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2705 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2706 win_errstr(result)));
2707
2708 return (W_ERROR_IS_OK(result));
2709 }
2710
2711 /****************************************************************
2712 ****************************************************************/
2713
2714 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2715 const struct spoolss_NotifyOption *r)
2716 {
2717 struct spoolss_NotifyOption *option;
2718 uint32_t i,k;
2719
2720 if (!r) {
2721 return NULL;
2722 }
2723
2724 option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2725 if (!option) {
2726 return NULL;
2727 }
2728
2729 *option = *r;
2730
2731 if (!option->count) {
2732 return option;
2733 }
2734
2735 option->types = talloc_zero_array(option,
2736 struct spoolss_NotifyOptionType, option->count);
2737 if (!option->types) {
2738 talloc_free(option);
2739 return NULL;
2740 }
2741
2742 for (i=0; i < option->count; i++) {
2743 option->types[i] = r->types[i];
2744
2745 if (option->types[i].count) {
2746 option->types[i].fields = talloc_zero_array(option,
2747 union spoolss_Field, option->types[i].count);
2748 if (!option->types[i].fields) {
2749 talloc_free(option);
2750 return NULL;
2751 }
2752 for (k=0; k<option->types[i].count; k++) {
2753 option->types[i].fields[k] =
2754 r->types[i].fields[k];
2755 }
2756 }
2757 }
2758
2759 return option;
2760 }
2761
2762 /****************************************************************
2763 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2764 *
2765 * before replying OK: status=0 a rpc call is made to the workstation
2766 * asking ReplyOpenPrinter
2767 *
2768 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2769 * called from api_spoolss_rffpcnex
2770 ****************************************************************/
2771
2772 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2773 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2774 {
2775 int snum = -1;
2776 struct spoolss_NotifyOption *option = r->in.notify_options;
2777 struct sockaddr_storage client_ss;
2778
2779 /* store the notify value in the printer struct */
2780
2781 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2782
2783 if (!Printer) {
2784 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2785 "Invalid handle (%s:%u:%u).\n",
2786 OUR_HANDLE(r->in.handle)));
2787 return WERR_BADFID;
2788 }
2789
2790 Printer->notify.flags = r->in.flags;
2791 Printer->notify.options = r->in.options;
2792 Printer->notify.printerlocal = r->in.printer_local;
2793
2794 TALLOC_FREE(Printer->notify.option);
2795 Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2796
2797 fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2798
2799 /* Connect to the client machine and send a ReplyOpenPrinter */
2800
2801 if ( Printer->printer_type == SPLHND_SERVER)
2802 snum = -1;
2803 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2804 !get_printer_snum(p, r->in.handle, &snum, NULL) )
2805 return WERR_BADFID;
2806
2807 if (!interpret_string_addr(&client_ss, p->client_address,
2808 AI_NUMERICHOST)) {
2809 return WERR_SERVER_UNAVAILABLE;
2810 }
2811
2812 if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2813 Printer->notify.printerlocal, 1,
2814 &Printer->notify.client_hnd, &client_ss))
2815 return WERR_SERVER_UNAVAILABLE;
2816
2817 Printer->notify.client_connected = true;
2818
2819 return WERR_OK;
2820 }
2821
2822 /*******************************************************************
2823 * fill a notify_info_data with the servername
2824 ********************************************************************/
2825
2826 void spoolss_notify_server_name(int snum,
2827 struct spoolss_Notify *data,
2828 print_queue_struct *queue,
2829 NT_PRINTER_INFO_LEVEL *printer,
2830 TALLOC_CTX *mem_ctx)
2831 {
2832 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2833 }
2834
2835 /*******************************************************************
2836 * fill a notify_info_data with the printername (not including the servername).
2837 ********************************************************************/
2838
2839 void spoolss_notify_printer_name(int snum,
2840 struct spoolss_Notify *data,
2841 print_queue_struct *queue,
2842 NT_PRINTER_INFO_LEVEL *printer,
2843 TALLOC_CTX *mem_ctx)
2844 {
2845 /* the notify name should not contain the \\server\ part */
2846 char *p = strrchr(printer->info_2->printername, '\\');
2847
2848 if (!p) {
2849 p = printer->info_2->printername;
2850 } else {
2851 p++;
2852 }
2853
2854 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2855 }
2856
2857 /*******************************************************************
2858 * fill a notify_info_data with the servicename
2859 ********************************************************************/
2860
2861 void spoolss_notify_share_name(int snum,
2862 struct spoolss_Notify *data,
2863 print_queue_struct *queue,
2864 NT_PRINTER_INFO_LEVEL *printer,
2865 TALLOC_CTX *mem_ctx)
2866 {
2867 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2868 }
2869
2870 /*******************************************************************
2871 * fill a notify_info_data with the port name
2872 ********************************************************************/
2873
2874 void spoolss_notify_port_name(int snum,
2875 struct spoolss_Notify *data,
2876 print_queue_struct *queue,
2877 NT_PRINTER_INFO_LEVEL *printer,
2878 TALLOC_CTX *mem_ctx)
2879 {
2880 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2881 }
2882
2883 /*******************************************************************
2884 * fill a notify_info_data with the printername
2885 * but it doesn't exist, have to see what to do
2886 ********************************************************************/
2887
2888 void spoolss_notify_driver_name(int snum,
2889 struct spoolss_Notify *data,
2890 print_queue_struct *queue,
2891 NT_PRINTER_INFO_LEVEL *printer,
2892 TALLOC_CTX *mem_ctx)
2893 {
2894 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2895 }
2896
2897 /*******************************************************************
2898 * fill a notify_info_data with the comment
2899 ********************************************************************/
2900
2901 void spoolss_notify_comment(int snum,
2902 struct spoolss_Notify *data,
2903 print_queue_struct *queue,
2904 NT_PRINTER_INFO_LEVEL *printer,
2905 TALLOC_CTX *mem_ctx)
2906 {
2907 char *p;
2908
2909 if (*printer->info_2->comment == '\0') {
2910 p = lp_comment(snum);
2911 } else {
2912 p = printer->info_2->comment;
2913 }
2914
2915 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2916 }
2917
2918 /*******************************************************************
2919 * fill a notify_info_data with the comment
2920 * location = "Room 1, floor 2, building 3"
2921 ********************************************************************/
2922
2923 void spoolss_notify_location(int snum,
2924 struct spoolss_Notify *data,
2925 print_queue_struct *queue,
2926 NT_PRINTER_INFO_LEVEL *printer,
2927 TALLOC_CTX *mem_ctx)
2928 {
2929 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2930 }
2931
2932 /*******************************************************************
2933 * fill a notify_info_data with the device mode
2934 * jfm:xxxx don't to it for know but that's a real problem !!!
2935 ********************************************************************/
2936
2937 static void spoolss_notify_devmode(int snum,
2938 struct spoolss_Notify *data,
2939 print_queue_struct *queue,
2940 NT_PRINTER_INFO_LEVEL *printer,
2941 TALLOC_CTX *mem_ctx)
2942 {
2943 /* for a dummy implementation we have to zero the fields */
2944 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2945 }
2946
2947 /*******************************************************************
2948 * fill a notify_info_data with the separator file name
2949 ********************************************************************/
2950
2951 void spoolss_notify_sepfile(int snum,
2952 struct spoolss_Notify *data,
2953 print_queue_struct *queue,
2954 NT_PRINTER_INFO_LEVEL *printer,
2955 TALLOC_CTX *mem_ctx)
2956 {
2957 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2958 }
2959
2960 /*******************************************************************
2961 * fill a notify_info_data with the print processor
2962 * jfm:xxxx return always winprint to indicate we don't do anything to it
2963 ********************************************************************/
2964
2965 void spoolss_notify_print_processor(int snum,
2966 struct spoolss_Notify *data,
2967 print_queue_struct *queue,
2968 NT_PRINTER_INFO_LEVEL *printer,
2969 TALLOC_CTX *mem_ctx)
2970 {
2971 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2972 }
2973
2974 /*******************************************************************
2975 * fill a notify_info_data with the print processor options
2976 * jfm:xxxx send an empty string
2977 ********************************************************************/
2978
2979 void spoolss_notify_parameters(int snum,
2980 struct spoolss_Notify *data,
2981 print_queue_struct *queue,
2982 NT_PRINTER_INFO_LEVEL *printer,
2983 TALLOC_CTX *mem_ctx)
2984 {
2985 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2986 }
2987
2988 /*******************************************************************
2989 * fill a notify_info_data with the data type
2990 * jfm:xxxx always send RAW as data type
2991 ********************************************************************/
2992
2993 void spoolss_notify_datatype(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_STRING(data, printer->info_2->datatype);
3000 }
3001
3002 /*******************************************************************
3003 * fill a notify_info_data with the security descriptor
3004 * jfm:xxxx send an null pointer to say no security desc
3005 * have to implement security before !
3006 ********************************************************************/
3007
3008 static void spoolss_notify_security_desc(int snum,
3009 struct spoolss_Notify *data,
3010 print_queue_struct *queue,
3011 NT_PRINTER_INFO_LEVEL *printer,
3012 TALLOC_CTX *mem_ctx)
3013 {
3014 SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
3015 printer->info_2->secdesc_buf->sd_size,
3016 printer->info_2->secdesc_buf->sd);
3017 }
3018
3019 /*******************************************************************
3020 * fill a notify_info_data with the attributes
3021 * jfm:xxxx a samba printer is always shared
3022 ********************************************************************/
3023
3024 void spoolss_notify_attributes(int snum,
3025 struct spoolss_Notify *data,
3026 print_queue_struct *queue,
3027 NT_PRINTER_INFO_LEVEL *printer,
3028 TALLOC_CTX *mem_ctx)
3029 {
3030 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
3031 }
3032
3033 /*******************************************************************
3034 * fill a notify_info_data with the priority
3035 ********************************************************************/
3036
3037 static void spoolss_notify_priority(int snum,
3038 struct spoolss_Notify *data,
3039 print_queue_struct *queue,
3040 NT_PRINTER_INFO_LEVEL *printer,
3041 TALLOC_CTX *mem_ctx)
3042 {
3043 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
3044 }
3045
3046 /*******************************************************************
3047 * fill a notify_info_data with the default priority
3048 ********************************************************************/
3049
3050 static void spoolss_notify_default_priority(int snum,
3051 struct spoolss_Notify *data,
3052 print_queue_struct *queue,
3053 NT_PRINTER_INFO_LEVEL *printer,
3054 TALLOC_CTX *mem_ctx)
3055 {
3056 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
3057 }
3058
3059 /*******************************************************************
3060 * fill a notify_info_data with the start time
3061 ********************************************************************/
3062
3063 static void spoolss_notify_start_time(int snum,
3064 struct spoolss_Notify *data,
3065 print_queue_struct *queue,
3066 NT_PRINTER_INFO_LEVEL *printer,
3067 TALLOC_CTX *mem_ctx)
3068 {
3069 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
3070 }
3071
3072 /*******************************************************************
3073 * fill a notify_info_data with the until time
3074 ********************************************************************/
3075
3076 static void spoolss_notify_until_time(int snum,
3077 struct spoolss_Notify *data,
3078 print_queue_struct *queue,
3079 NT_PRINTER_INFO_LEVEL *printer,
3080 TALLOC_CTX *mem_ctx)
3081 {
3082 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
3083 }
3084
3085 /*******************************************************************
3086 * fill a notify_info_data with the status
3087 ********************************************************************/
3088
3089 static void spoolss_notify_status(int snum,
3090 struct spoolss_Notify *data,
3091 print_queue_struct *queue,
3092 NT_PRINTER_INFO_LEVEL *printer,
3093 TALLOC_CTX *mem_ctx)
3094 {
3095 print_status_struct status;
3096
3097 print_queue_length(snum, &status);
3098 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3099 }
3100
3101 /*******************************************************************
3102 * fill a notify_info_data with the number of jobs queued
3103 ********************************************************************/
3104
3105 void spoolss_notify_cjobs(int snum,
3106 struct spoolss_Notify *data,
3107 print_queue_struct *queue,
3108 NT_PRINTER_INFO_LEVEL *printer,
3109 TALLOC_CTX *mem_ctx)
3110 {
3111 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
3112 }
3113
3114 /*******************************************************************
3115 * fill a notify_info_data with the average ppm
3116 ********************************************************************/
3117
3118 static void spoolss_notify_average_ppm(int snum,
3119 struct spoolss_Notify *data,
3120 print_queue_struct *queue,
3121 NT_PRINTER_INFO_LEVEL *printer,
3122 TALLOC_CTX *mem_ctx)
3123 {
3124 /* always respond 8 pages per minutes */
3125 /* a little hard ! */
3126 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
3127 }
3128
3129 /*******************************************************************
3130 * fill a notify_info_data with username
3131 ********************************************************************/
3132
3133 static void spoolss_notify_username(int snum,
3134 struct spoolss_Notify *data,
3135 print_queue_struct *queue,
3136 NT_PRINTER_INFO_LEVEL *printer,
3137 TALLOC_CTX *mem_ctx)
3138 {
3139 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3140 }
3141
3142 /*******************************************************************
3143 * fill a notify_info_data with job status
3144 ********************************************************************/
3145
3146 static void spoolss_notify_job_status(int snum,
3147 struct spoolss_Notify *data,
3148 print_queue_struct *queue,
3149 NT_PRINTER_INFO_LEVEL *printer,
3150 TALLOC_CTX *mem_ctx)
3151 {
3152 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3153 }
3154
3155 /*******************************************************************
3156 * fill a notify_info_data with job name
3157 ********************************************************************/
3158
3159 static void spoolss_notify_job_name(int snum,
3160 struct spoolss_Notify *data,
3161 print_queue_struct *queue,
3162 NT_PRINTER_INFO_LEVEL *printer,
3163 TALLOC_CTX *mem_ctx)
3164 {
3165 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3166 }
3167
3168 /*******************************************************************
3169 * fill a notify_info_data with job status
3170 ********************************************************************/
3171
3172 static void spoolss_notify_job_status_string(int snum,
3173 struct spoolss_Notify *data,
3174 print_queue_struct *queue,
3175 NT_PRINTER_INFO_LEVEL *printer,
3176 TALLOC_CTX *mem_ctx)
3177 {
3178 /*
3179 * Now we're returning job status codes we just return a "" here. JRA.
3180 */
3181
3182 const char *p = "";
3183
3184 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3185 p = "unknown";
3186
3187 switch (queue->status) {
3188 case LPQ_QUEUED:
3189 p = "Queued";
3190 break;
3191 case LPQ_PAUSED:
3192 p = ""; /* NT provides the paused string */
3193 break;
3194 case LPQ_SPOOLING:
3195 p = "Spooling";
3196 break;
3197 case LPQ_PRINTING:
3198 p = "Printing";
3199 break;
3200 }
3201 #endif /* NO LONGER NEEDED. */
3202
3203 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3204 }
3205
3206 /*******************************************************************
3207 * fill a notify_info_data with job time
3208 ********************************************************************/
3209
3210 static void spoolss_notify_job_time(int snum,
3211 struct spoolss_Notify *data,
3212 print_queue_struct *queue,
3213 NT_PRINTER_INFO_LEVEL *printer,
3214 TALLOC_CTX *mem_ctx)
3215 {
3216 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3217 }
3218
3219 /*******************************************************************
3220 * fill a notify_info_data with job size
3221 ********************************************************************/
3222
3223 static void spoolss_notify_job_size(int snum,
3224 struct spoolss_Notify *data,
3225 print_queue_struct *queue,
3226 NT_PRINTER_INFO_LEVEL *printer,
3227 TALLOC_CTX *mem_ctx)
3228 {
3229 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3230 }
3231
3232 /*******************************************************************
3233 * fill a notify_info_data with page info
3234 ********************************************************************/
3235 static void spoolss_notify_total_pages(int snum,
3236 struct spoolss_Notify *data,
3237 print_queue_struct *queue,
3238 NT_PRINTER_INFO_LEVEL *printer,
3239 TALLOC_CTX *mem_ctx)
3240 {
3241 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3242 }
3243
3244 /*******************************************************************
3245 * fill a notify_info_data with pages printed info.
3246 ********************************************************************/
3247 static void spoolss_notify_pages_printed(int snum,
3248 struct spoolss_Notify *data,
3249 print_queue_struct *queue,
3250 NT_PRINTER_INFO_LEVEL *printer,
3251 TALLOC_CTX *mem_ctx)
3252 {
3253 /* Add code when back-end tracks this */
3254 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3255 }
3256
3257 /*******************************************************************
3258 Fill a notify_info_data with job position.
3259 ********************************************************************/
3260
3261 static void spoolss_notify_job_position(int snum,
3262 struct spoolss_Notify *data,
3263 print_queue_struct *queue,
3264 NT_PRINTER_INFO_LEVEL *printer,
3265 TALLOC_CTX *mem_ctx)
3266 {
3267 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3268 }
3269
3270 /*******************************************************************
3271 Fill a notify_info_data with submitted time.
3272 ********************************************************************/
3273
3274 static void spoolss_notify_submitted_time(int snum,
3275 struct spoolss_Notify *data,
3276 print_queue_struct *queue,
3277 NT_PRINTER_INFO_LEVEL *printer,
3278 TALLOC_CTX *mem_ctx)
3279 {
3280 data->data.string.string = NULL;
3281 data->data.string.size = 0;
3282
3283 init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3284 &data->data.string.string,
3285 &data->data.string.size);
3286
3287 }
3288
3289 struct s_notify_info_data_table
3290 {
3291 enum spoolss_NotifyType type;
3292 uint16_t field;
3293 const char *name;
3294 enum spoolss_NotifyTable variable_type;
3295 void (*fn) (int snum, struct spoolss_Notify *data,
3296 print_queue_struct *queue,
3297 NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3298 };
3299
3300 /* A table describing the various print notification constants and
3301 whether the notification data is a pointer to a variable sized
3302 buffer, a one value uint32_t or a two value uint32_t. */
3303
3304 static const struct s_notify_info_data_table notify_info_data_table[] =
3305 {
3306 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3307 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3308 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_share_name },
3309 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3310 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3311 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING, spoolss_notify_comment },
3312 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING, spoolss_notify_location },
3313 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3314 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING, spoolss_notify_sepfile },
3315 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3316 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3317 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3318 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, spoolss_notify_security_desc },
3319 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD, spoolss_notify_attributes },
3320 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3321 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_default_priority },
3322 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3323 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3324 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_status },
3325 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, NULL },
3326 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD, spoolss_notify_cjobs },
3327 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD, spoolss_notify_average_ppm },
3328 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, NULL },
3329 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3330 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, NULL },
3331 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3332 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINTER_NAME, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3333 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_MACHINE_NAME, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3334 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PORT_NAME, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3335 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3336 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_NOTIFY_NAME, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3337 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DATATYPE, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3338 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINT_PROCESSOR, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3339 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PARAMETERS, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3340 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DRIVER_NAME, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3341 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DEVMODE, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3342 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_job_status },
3343 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS_STRING, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, spoolss_notify_job_status_string },
3344 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, NULL },
3345 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING, spoolss_notify_job_name },
3346 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRIORITY, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3347 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_POSITION, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD, spoolss_notify_job_position },
3348 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME, spoolss_notify_submitted_time },
3349 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_START_TIME, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3350 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_UNTIL_TIME, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3351 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TIME, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_job_time },
3352 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_PAGES, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, spoolss_notify_total_pages },
3353 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PAGES_PRINTED, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, spoolss_notify_pages_printed },
3354 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_BYTES, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, spoolss_notify_job_size },
3355 };
3356
3357 /*******************************************************************
3358 Return the variable_type of info_data structure.
3359 ********************************************************************/
3360
3361 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3362 uint16_t field)
3363 {
3364 int i=0;
3365
3366 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3367 if ( (notify_info_data_table[i].type == type) &&
3368 (notify_info_data_table[i].field == field) ) {
3369 return notify_info_data_table[i].variable_type;
3370 }
3371 }
3372
3373 DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3374
3375 return 0;
3376 }
3377
3378 /****************************************************************************
3379 ****************************************************************************/
3380
3381 static bool search_notify(enum spoolss_NotifyType type,
3382 uint16_t field,
3383 int *value)
3384 {
3385 int i;
3386
3387 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3388 if (notify_info_data_table[i].type == type &&
3389 notify_info_data_table[i].field == field &&
3390 notify_info_data_table[i].fn != NULL) {
3391 *value = i;
3392 return true;
3393 }
3394 }
3395
3396 return false;
3397 }
3398
3399 /****************************************************************************
3400 ****************************************************************************/
3401
3402 void construct_info_data(struct spoolss_Notify *info_data,
3403 enum spoolss_NotifyType type,
3404 uint16_t field,
3405 int id)
3406 {
3407 info_data->type = type;
3408 info_data->field.field = field;
3409 info_data->variable_type = variable_type_of_notify_info_data(type, field);
3410 info_data->job_id = id;
3411 }
3412
3413 /*******************************************************************
3414 *
3415 * fill a notify_info struct with info asked
3416 *
3417 ********************************************************************/
3418
3419 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3420 struct spoolss_NotifyInfo *info,
3421 int snum,
3422 const struct spoolss_NotifyOptionType *option_type,
3423 uint32_t id,
3424 TALLOC_CTX *mem_ctx)
3425 {
3426 int field_num,j;
3427 enum spoolss_NotifyType type;
3428 uint16_t field;
3429
3430 struct spoolss_Notify *current_data;
3431 NT_PRINTER_INFO_LEVEL *printer = NULL;
3432 print_queue_struct *queue=NULL;
3433
3434 type = option_type->type;
3435
3436 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3437 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3438 option_type->count, lp_servicename(snum)));
3439
3440 if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3441 return false;
3442
3443 for(field_num=0; field_num < option_type->count; field_num++) {
3444 field = option_type->fields[field_num].field;
3445
3446 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3447
3448 if (!search_notify(type, field, &j) )
3449 continue;
3450
3451 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3452 struct spoolss_Notify,
3453 info->count + 1);
3454 if (info->notifies == NULL) {
3455 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3456 free_a_printer(&printer, 2);
3457 return false;
3458 }
3459
3460 current_data = &info->notifies[info->count];
3461
3462 construct_info_data(current_data, type, field, id);
3463
3464 DEBUG(10,("construct_notify_printer_info: calling [%s] snum=%d printername=[%s])\n",
3465 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3466
3467 notify_info_data_table[j].fn(snum, current_data, queue,
3468 printer, mem_ctx);
3469
3470 info->count++;
3471 }
3472
3473 free_a_printer(&printer, 2);
3474 return true;
3475 }
3476
3477 /*******************************************************************
3478 *
3479 * fill a notify_info struct with info asked
3480 *
3481 ********************************************************************/
3482
3483 static bool construct_notify_jobs_info(print_queue_struct *queue,
3484 struct spoolss_NotifyInfo *info,
3485 NT_PRINTER_INFO_LEVEL *printer,
3486 int snum,
3487 const struct spoolss_NotifyOptionType *option_type,
3488 uint32_t id,
3489 TALLOC_CTX *mem_ctx)
3490 {
3491 int field_num,j;
3492 enum spoolss_NotifyType type;
3493 uint16_t field;
3494 struct spoolss_Notify *current_data;
3495
3496 DEBUG(4,("construct_notify_jobs_info\n"));
3497
3498 type = option_type->type;
3499
3500 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3501 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3502 option_type->count));
3503
3504 for(field_num=0; field_num<option_type->count; field_num++) {
3505 field = option_type->fields[field_num].field;
3506
3507 if (!search_notify(type, field, &j) )
3508 continue;
3509
3510 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3511 struct spoolss_Notify,
3512 info->count + 1);
3513 if (info->notifies == NULL) {
3514 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3515 return false;
3516 }
3517
3518 current_data=&(info->notifies[info->count]);
3519
3520 construct_info_data(current_data, type, field, id);
3521 notify_info_data_table[j].fn(snum, current_data, queue,
3522 printer, mem_ctx);
3523 info->count++;
3524 }
3525
3526 return true;
3527 }
3528
3529 /*
3530 * JFM: The enumeration is not that simple, it's even non obvious.
3531 *
3532 * let's take an example: I want to monitor the PRINTER SERVER for
3533 * the printer's name and the number of jobs currently queued.
3534 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3535 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3536 *
3537 * I have 3 printers on the back of my server.
3538 *
3539 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3540 * structures.
3541 * Number Data Id
3542 * 1 printer 1 name 1
3543 * 2 printer 1 cjob 1
3544 * 3 printer 2 name 2
3545 * 4 printer 2 cjob 2
3546 * 5 printer 3 name 3
3547 * 6 printer 3 name 3
3548 *
3549 * that's the print server case, the printer case is even worse.
3550 */
3551
3552 /*******************************************************************
3553 *
3554 * enumerate all printers on the printserver
3555 * fill a notify_info struct with info asked
3556 *
3557 ********************************************************************/
3558
3559 static WERROR printserver_notify_info(pipes_struct *p,
3560 struct policy_handle *hnd,
3561 struct spoolss_NotifyInfo *info,
3562 TALLOC_CTX *mem_ctx)
3563 {
3564 int snum;
3565 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3566 int n_services=lp_numservices();
3567 int i;
3568 struct spoolss_NotifyOption *option;
3569 struct spoolss_NotifyOptionType option_type;
3570
3571 DEBUG(4,("printserver_notify_info\n"));
3572
3573 if (!Printer)
3574 return WERR_BADFID;
3575
3576 option = Printer->notify.option;
3577
3578 info->version = 2;
3579 info->notifies = NULL;
3580 info->count = 0;
3581
3582 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3583 sending a ffpcn() request first */
3584
3585 if ( !option )
3586 return WERR_BADFID;
3587
3588 for (i=0; i<option->count; i++) {
3589 option_type = option->types[i];
3590
3591 if (option_type.type != PRINTER_NOTIFY_TYPE)
3592 continue;
3593
3594 for (snum=0; snum<n_services; snum++)
3595 {
3596 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3597 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3598 }
3599 }
3600
3601 #if 0
3602 /*
3603 * Debugging information, don't delete.
3604 */
3605
3606 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3607 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3608 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3609
3610 for (i=0; i<info->count; i++) {
3611 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3612 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3613 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3614 }
3615 #endif
3616
3617 return WERR_OK;
3618 }
3619
3620 /*******************************************************************
3621 *
3622 * fill a notify_info struct with info asked
3623 *
3624 ********************************************************************/
3625
3626 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3627 struct spoolss_NotifyInfo *info,
3628 TALLOC_CTX *mem_ctx)
3629 {
3630 int snum;
3631 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3632 int i;
3633 uint32_t id;
3634 struct spoolss_NotifyOption *option;
3635 struct spoolss_NotifyOptionType option_type;
3636 int count,j;
3637 print_queue_struct *queue=NULL;
3638 print_status_struct status;
3639
3640 DEBUG(4,("printer_notify_info\n"));
3641
3642 if (!Printer)
3643 return WERR_BADFID;
3644
3645 option = Printer->notify.option;
3646 id = 0x0;
3647
3648 info->version = 2;
3649 info->notifies = NULL;
3650 info->count = 0;
3651
3652 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3653 sending a ffpcn() request first */
3654
3655 if ( !option )
3656 return WERR_BADFID;
3657
3658 get_printer_snum(p, hnd, &snum, NULL);
3659
3660 for (i=0; i<option->count; i++) {
3661 option_type = option->types[i];
3662
3663 switch (option_type.type) {
3664 case PRINTER_NOTIFY_TYPE:
3665 if(construct_notify_printer_info(Printer, info, snum,
3666 &option_type, id,
3667 mem_ctx))
3668 id--;
3669 break;
3670
3671 case JOB_NOTIFY_TYPE: {
3672 NT_PRINTER_INFO_LEVEL *printer = NULL;
3673
3674 count = print_queue_status(snum, &queue, &status);
3675
3676 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3677 goto done;
3678
3679 for (j=0; j<count; j++) {
3680 construct_notify_jobs_info(&queue[j], info,
3681 printer, snum,
3682 &option_type,
3683 queue[j].job,
3684 mem_ctx);
3685 }
3686
3687 free_a_printer(&printer, 2);
3688
3689 done:
3690 SAFE_FREE(queue);
3691 break;
3692 }
3693 }
3694 }
3695
3696 /*
3697 * Debugging information, don't delete.
3698 */
3699 /*
3700 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3701 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3702 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3703
3704 for (i=0; i<info->count; i++) {
3705 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3706 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3707 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3708 }
3709 */
3710 return WERR_OK;
3711 }
3712
3713 /****************************************************************
3714 _spoolss_RouterRefreshPrinterChangeNotify
3715 ****************************************************************/
3716
3717 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3718 struct spoolss_RouterRefreshPrinterChangeNotify *r)
3719 {
3720 struct spoolss_NotifyInfo *info;
3721
3722 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3723 WERROR result = WERR_BADFID;
3724
3725 /* we always have a spoolss_NotifyInfo struct */
3726 info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3727 if (!info) {
3728 result = WERR_NOMEM;
3729 goto done;
3730 }
3731
3732 *r->out.info = info;
3733
3734 if (!Printer) {
3735 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3736 "Invalid handle (%s:%u:%u).\n",
3737 OUR_HANDLE(r->in.handle)));
3738 goto done;
3739 }
3740
3741 DEBUG(4,("Printer type %x\n",Printer->printer_type));
3742
3743 /*
3744 * We are now using the change value, and
3745 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3746 * I don't have a global notification system, I'm sending back all the
3747 * informations even when _NOTHING_ has changed.
3748 */
3749
3750 /* We need to keep track of the change value to send back in
3751 RRPCN replies otherwise our updates are ignored. */
3752
3753 Printer->notify.fnpcn = true;
3754
3755 if (Printer->notify.client_connected) {
3756 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3757 "Saving change value in request [%x]\n",
3758 r->in.change_low));
3759 Printer->notify.change = r->in.change_low;
3760 }
3761
3762 /* just ignore the spoolss_NotifyOption */
3763
3764 switch (Printer->printer_type) {
3765 case SPLHND_SERVER:
3766 result = printserver_notify_info(p, r->in.handle,
3767 info, p->mem_ctx);
3768 break;
3769
3770 case SPLHND_PRINTER:
3771 result = printer_notify_info(p, r->in.handle,
3772 info, p->mem_ctx);
3773 break;
3774 }
3775
3776 Printer->notify.fnpcn = false;
3777
3778 done:
3779 return result;
3780 }
3781
3782 /********************************************************************
3783 * construct_printer_info_0
3784 * fill a printer_info_0 struct
3785 ********************************************************************/
3786
3787 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3788 const NT_PRINTER_INFO_LEVEL *ntprinter,
3789 struct spoolss_PrinterInfo0 *r,
3790 int snum)
3791 {
3792 int count;
3793 counter_printer_0 *session_counter;
3794 time_t setuptime;
3795 print_status_struct status;
3796
3797 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3798 W_ERROR_HAVE_NO_MEMORY(r->printername);
3799
3800 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3801 W_ERROR_HAVE_NO_MEMORY(r->servername);
3802
3803 count = print_queue_length(snum, &status);
3804
3805 /* check if we already have a counter for this printer */
3806 for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3807 if (session_counter->snum == snum)
3808 break;
3809 }
3810
3811 /* it's the first time, add it to the list */
3812 if (session_counter == NULL) {
3813 session_counter = SMB_MALLOC_P(counter_printer_0);
3814 W_ERROR_HAVE_NO_MEMORY(session_counter);
3815 ZERO_STRUCTP(session_counter);
3816 session_counter->snum = snum;
3817 session_counter->counter = 0;
3818 DLIST_ADD(counter_list, session_counter);
3819 }
3820
3821 /* increment it */
3822 session_counter->counter++;
3823
3824 r->cjobs = count;
3825 r->total_jobs = 0;
3826 r->total_bytes = 0;
3827
3828 setuptime = (time_t)ntprinter->info_2->setuptime;
3829
3830 init_systemtime(&r->time, gmtime(&setuptime));
3831
3832 /* JFM:
3833 * the global_counter should be stored in a TDB as it's common to all the clients
3834 * and should be zeroed on samba startup
3835 */
3836 r->global_counter = session_counter->counter;
3837 r->total_pages = 0;
3838 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3839 r->version = 0x0005; /* NT 5 */
3840 r->free_build = 0x0893; /* build 2195 */
3841 r->spooling = 0;
3842 r->max_spooling = 0;
3843 r->session_counter = session_counter->counter;
3844 r->num_error_out_of_paper = 0x0;
3845 r->num_error_not_ready = 0x0; /* number of print failure */
3846 r->job_error = 0x0;
3847 r->number_of_processors = 0x1;
3848 r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3849 r->high_part_total_bytes = 0x0;
3850 r->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3851 r->last_error = WERR_OK;
3852 r->status = nt_printq_status(status.status);
3853 r->enumerate_network_printers = 0x0;
3854 r->c_setprinter = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3855 r->processor_architecture = 0x0;
3856 r->processor_level = 0x6; /* 6 ???*/
3857 r->ref_ic = 0;
3858 r->reserved2 = 0;
3859 r->reserved3 = 0;
3860
3861 return WERR_OK;
3862 }
3863
3864 /****************************************************************************
3865 Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure. Both pointers
3866 should be valid upon entry
3867 ****************************************************************************/
3868
3869 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3870 struct spoolss_DeviceMode *r,
3871 const NT_DEVICEMODE *ntdevmode)
3872 {
3873 if (!r || !ntdevmode) {
3874 return WERR_INVALID_PARAM;
3875 }
3876
3877 r->devicename = talloc_strdup(mem_ctx, ntdevmode->devicename);
3878 W_ERROR_HAVE_NO_MEMORY(r->devicename);
3879
3880 r->specversion = ntdevmode->specversion;
3881 r->driverversion = ntdevmode->driverversion;
3882 r->size = ntdevmode->size;
3883 r->__driverextra_length = ntdevmode->driverextra;
3884 r->fields = ntdevmode->fields;
3885
3886 r->orientation = ntdevmode->orientation;
3887 r->papersize = ntdevmode->papersize;
3888 r->paperlength = ntdevmode->paperlength;
3889 r->paperwidth = ntdevmode->paperwidth;
3890 r->scale = ntdevmode->scale;
3891 r->copies = ntdevmode->copies;
3892 r->defaultsource = ntdevmode->defaultsource;
3893 r->printquality = ntdevmode->printquality;
3894 r->color = ntdevmode->color;
3895 r->duplex = ntdevmode->duplex;
3896 r->yresolution = ntdevmode->yresolution;
3897 r->ttoption = ntdevmode->ttoption;
3898 r->collate = ntdevmode->collate;
3899
3900 r->formname = talloc_strdup(mem_ctx, ntdevmode->formname);
3901 W_ERROR_HAVE_NO_MEMORY(r->formname);
3902
3903 /* all 0 below are values that have not been set in the old parsing/copy
3904 * function, maybe they should... - gd */
3905
3906 r->logpixels = 0;
3907 r->bitsperpel = 0;
3908 r->pelswidth = 0;
3909 r->pelsheight = 0;
3910 r->displayflags = 0;
3911 r->displayfrequency = 0;
3912 r->icmmethod = ntdevmode->icmmethod;
3913 r->icmintent = ntdevmode->icmintent;
3914 r->mediatype = ntdevmode->mediatype;
3915 r->dithertype = ntdevmode->dithertype;
3916 r->reserved1 = 0;
3917 r->reserved2 = 0;
3918 r->panningwidth = 0;
3919 r->panningheight = 0;
3920
3921 if (ntdevmode->nt_dev_private != NULL) {
3922 r->driverextra_data = data_blob_talloc(mem_ctx,
3923 ntdevmode->nt_dev_private,
3924 ntdevmode->driverextra);
3925 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3926 }
3927
3928 return WERR_OK;
3929 }
3930
3931
3932 /****************************************************************************
3933 Create a spoolss_DeviceMode struct. Returns talloced memory.
3934 ****************************************************************************/
3935
3936 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3937 const char *servicename)
3938 {
3939 WERROR result;
3940 NT_PRINTER_INFO_LEVEL *printer = NULL;
3941 struct spoolss_DeviceMode *devmode = NULL;
3942
3943 DEBUG(7,("construct_dev_mode\n"));
3944
3945 DEBUGADD(8,("getting printer characteristics\n"));
3946
3947 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3948 return NULL;
3949
3950 if (!printer->info_2->devmode) {
3951 DEBUG(5, ("BONG! There was no device mode!\n"));
3952 goto done;
3953 }
3954
3955 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3956 if (!devmode) {
3957 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3958 goto done;
3959 }
3960
3961 DEBUGADD(8,("loading DEVICEMODE\n"));
3962
3963 result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3964 if (!W_ERROR_IS_OK(result)) {
3965 TALLOC_FREE(devmode);
3966 }
3967
3968 done:
3969 free_a_printer(&printer,2);
3970
3971 return devmode;
3972 }
3973
3974 /********************************************************************
3975 * construct_printer_info3
3976 * fill a spoolss_PrinterInfo3 struct
3977 ********************************************************************/
3978
3979 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3980 const NT_PRINTER_INFO_LEVEL *ntprinter,
3981 struct spoolss_PrinterInfo3 *r,
3982 int snum)
3983 {
3984 /* These are the components of the SD we are returning. */
3985
3986 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3987 /* don't use talloc_steal() here unless you do a deep steal of all
3988 the SEC_DESC members */
3989
3990 r->secdesc = dup_sec_desc(mem_ctx,
3991 ntprinter->info_2->secdesc_buf->sd);
3992 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3993 }
3994
3995 return WERR_OK;
3996 }
3997
3998 /********************************************************************
3999 * construct_printer_info4
4000 * fill a spoolss_PrinterInfo4 struct
4001 ********************************************************************/
4002
4003 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
4004 const NT_PRINTER_INFO_LEVEL *ntprinter,
4005 struct spoolss_PrinterInfo4 *r,
4006 int snum)
4007 {
4008 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4009 W_ERROR_HAVE_NO_MEMORY(r->printername);
4010 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
4011 W_ERROR_HAVE_NO_MEMORY(r->servername);
4012
4013 r->attributes = ntprinter->info_2->attributes;
4014
4015 return WERR_OK;
4016 }
4017
4018 /********************************************************************
4019 * construct_printer_info5
4020 * fill a spoolss_PrinterInfo5 struct
4021 ********************************************************************/
4022
4023 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
4024 const NT_PRINTER_INFO_LEVEL *ntprinter,
4025 struct spoolss_PrinterInfo5 *r,
4026 int snum)
4027 {
4028 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4029 W_ERROR_HAVE_NO_MEMORY(r->printername);
4030 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4031 W_ERROR_HAVE_NO_MEMORY(r->portname);
4032
4033 r->attributes = ntprinter->info_2->attributes;
4034
4035 /* these two are not used by NT+ according to MSDN */
4036
4037 r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
4038 r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
4039
4040 return WERR_OK;
4041 }
4042
4043 /********************************************************************
4044 * construct_printer_info_6
4045 * fill a spoolss_PrinterInfo6 struct
4046 ********************************************************************/
4047
4048 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
4049 const NT_PRINTER_INFO_LEVEL *ntprinter,
4050 struct spoolss_PrinterInfo6 *r,
4051 int snum)
4052 {
4053 int count;
4054 print_status_struct status;
4055
4056 count = print_queue_length(snum, &status);
4057
4058 r->status = nt_printq_status(status.status);
4059
4060 return WERR_OK;
4061 }
4062
4063 /********************************************************************
4064 * construct_printer_info7
4065 * fill a spoolss_PrinterInfo7 struct
4066 ********************************************************************/
4067
4068 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4069 Printer_entry *print_hnd,
4070 struct spoolss_PrinterInfo7 *r,
4071 int snum)
4072 {
4073 struct GUID guid;
4074
4075 if (is_printer_published(print_hnd, snum, &guid)) {
4076 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
4077 r->action = DSPRINT_PUBLISH;
4078 } else {
4079 r->guid = talloc_strdup(mem_ctx, "");
4080 r->action = DSPRINT_UNPUBLISH;
4081 }
4082 W_ERROR_HAVE_NO_MEMORY(r->guid);
4083
4084 return WERR_OK;
4085 }
4086
4087 /********************************************************************
4088 * construct_printer_info8
4089 * fill a spoolss_PrinterInfo8 struct
4090 ********************************************************************/
4091
4092 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4093 const NT_PRINTER_INFO_LEVEL *ntprinter,
4094 struct spoolss_DeviceModeInfo *r,
4095 int snum)
4096 {
4097 struct spoolss_DeviceMode *devmode;
4098 WERROR result;
4099
4100 if (!ntprinter->info_2->devmode) {
4101 r->devmode = NULL;
4102 return WERR_OK;
4103 }
4104
4105 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
4106 W_ERROR_HAVE_NO_MEMORY(devmode);
4107
4108 result = convert_nt_devicemode(mem_ctx, devmode, ntprinter->info_2->devmode);
4109 if (!W_ERROR_IS_OK(result)) {
4110 TALLOC_FREE(devmode);
4111 return result;
4112 }
4113
4114 r->devmode = devmode;
4115
4116 return WERR_OK;
4117 }
4118
4119
4120 /********************************************************************
4121 * construct_printer_info1
4122 * fill a spoolss_PrinterInfo1 struct
4123 ********************************************************************/
4124
4125 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
4126 const NT_PRINTER_INFO_LEVEL *ntprinter,
4127 uint32_t flags,
4128 struct spoolss_PrinterInfo1 *r,
4129 int snum)
4130 {
4131 r->flags = flags;
4132
4133 r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
4134 ntprinter->info_2->printername,
4135 ntprinter->info_2->drivername,
4136 ntprinter->info_2->location);
4137 W_ERROR_HAVE_NO_MEMORY(r->description);
4138
4139 if (*ntprinter->info_2->comment == '\0') {
4140 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
4141 } else {
4142 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
4143 }
4144 W_ERROR_HAVE_NO_MEMORY(r->comment);
4145
4146 r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4147 W_ERROR_HAVE_NO_MEMORY(r->name);
4148
4149 return WERR_OK;
4150 }
4151
4152 /********************************************************************
4153 * construct_printer_info2
4154 * fill a spoolss_PrinterInfo2 struct
4155 ********************************************************************/
4156
4157 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
4158 const NT_PRINTER_INFO_LEVEL *ntprinter,
4159 struct spoolss_PrinterInfo2 *r,
4160 int snum)
4161 {
4162 int count;
4163
4164 print_status_struct status;
4165
4166 count = print_queue_length(snum, &status);
4167
4168 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
4169 W_ERROR_HAVE_NO_MEMORY(r->servername);
4170 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4171 W_ERROR_HAVE_NO_MEMORY(r->printername);
4172 r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
4173 W_ERROR_HAVE_NO_MEMORY(r->sharename);
4174 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4175 W_ERROR_HAVE_NO_MEMORY(r->portname);
4176 r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
4177 W_ERROR_HAVE_NO_MEMORY(r->drivername);
4178
4179 if (*ntprinter->info_2->comment == '\0') {
4180 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
4181 } else {
4182 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
4183 }
4184 W_ERROR_HAVE_NO_MEMORY(r->comment);
4185
4186 r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
4187 W_ERROR_HAVE_NO_MEMORY(r->location);
4188 r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
4189 W_ERROR_HAVE_NO_MEMORY(r->sepfile);
4190 r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
4191 W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
4192 r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
4193 W_ERROR_HAVE_NO_MEMORY(r->datatype);
4194 r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
4195 W_ERROR_HAVE_NO_MEMORY(r->parameters);
4196
4197 r->attributes = ntprinter->info_2->attributes;
4198
4199 r->priority = ntprinter->info_2->priority;
4200 r->defaultpriority = ntprinter->info_2->default_priority;
4201 r->starttime = ntprinter->info_2->starttime;
4202 r->untiltime = ntprinter->info_2->untiltime;
4203 r->status = nt_printq_status(status.status);
4204 r->cjobs = count;
4205 r->averageppm = ntprinter->info_2->averageppm;
4206
4207 r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
4208 if (!r->devmode) {
4209 DEBUG(8,("Returning NULL Devicemode!\n"));
4210 }
4211
4212 r->secdesc = NULL;
4213
4214 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
4215 /* don't use talloc_steal() here unless you do a deep steal of all
4216 the SEC_DESC members */
4217
4218 r->secdesc = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
4219 }
4220
4221 return WERR_OK;
4222 }
4223
4224 /********************************************************************
4225 ********************************************************************/
4226
4227 static bool snum_is_shared_printer(int snum)
4228 {
4229 return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
4230 }
4231
4232 /********************************************************************
4233 Spoolss_enumprinters.
4234 ********************************************************************/
4235
4236 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4237 uint32_t level,
4238 uint32_t flags,
4239 union spoolss_PrinterInfo **info_p,
4240 uint32_t *count_p)
4241 {
4242 int snum;
4243 int n_services = lp_numservices();
4244 union spoolss_PrinterInfo *info = NULL;
4245 uint32_t count = 0;
4246 WERROR result = WERR_OK;
4247
4248 *count_p = 0;
4249 *info_p = NULL;
4250
4251 for (snum = 0; snum < n_services; snum++) {
4252
4253 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4254
4255 if (!snum_is_shared_printer(snum)) {
4256 continue;
4257 }
4258
4259 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4260 lp_servicename(snum), snum));
4261
4262 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4263 union spoolss_PrinterInfo,
4264 count + 1);
4265 if (!info) {
4266 result = WERR_NOMEM;
4267 goto out;
4268 }
4269
4270 result = get_a_printer(NULL, &ntprinter, 2,
4271 lp_const_servicename(snum));
4272 if (!W_ERROR_IS_OK(result)) {
4273 goto out;
4274 }
4275
4276 switch (level) {
4277 case 0:
4278 result = construct_printer_info0(info, ntprinter,
4279 &info[count].info0, snum);
4280 break;
4281 case 1:
4282 result = construct_printer_info1(info, ntprinter, flags,
4283 &info[count].info1, snum);
4284 break;
4285 case 2:
4286 result = construct_printer_info2(info, ntprinter,
4287 &info[count].info2, snum);
4288 break;
4289 case 4:
4290 result = construct_printer_info4(info, ntprinter,
4291 &info[count].info4, snum);
4292 break;
4293 case 5:
4294 result = construct_printer_info5(info, ntprinter,
4295 &info[count].info5, snum);
4296 break;
4297
4298 default:
4299 result = WERR_UNKNOWN_LEVEL;
4300 free_a_printer(&ntprinter, 2);
4301 goto out;
4302 }
4303
4304 free_a_printer(&ntprinter, 2);
4305 if (!W_ERROR_IS_OK(result)) {
4306 goto out;
4307 }
4308
4309 count++;
4310 }
4311
4312 *count_p = count;
4313 *info_p = info;
4314
4315 out:
4316 if (!W_ERROR_IS_OK(result)) {
4317 TALLOC_FREE(info);
4318 return result;
4319 }
4320
4321 *info_p = info;
4322
4323 return WERR_OK;
4324 }
4325
4326 /********************************************************************
4327 * handle enumeration of printers at level 0
4328 ********************************************************************/
4329
4330 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4331 uint32_t flags,
4332 const char *servername,
4333 union spoolss_PrinterInfo **info,
4334 uint32_t *count)
4335 {
4336 DEBUG(4,("enum_all_printers_info_0\n"));
4337
4338 return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4339 }
4340
4341
4342 /********************************************************************
4343 ********************************************************************/
4344
4345 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4346 uint32_t flags,
4347 union spoolss_PrinterInfo **info,
4348 uint32_t *count)
4349 {
4350 DEBUG(4,("enum_all_printers_info_1\n"));
4351
4352 return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4353 }
4354
4355 /********************************************************************
4356 enum_all_printers_info_1_local.
4357 *********************************************************************/
4358
4359 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4360 union spoolss_PrinterInfo **info,
4361 uint32_t *count)
4362 {
4363 DEBUG(4,("enum_all_printers_info_1_local\n"));
4364
4365 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4366 }
4367
4368 /********************************************************************
4369 enum_all_printers_info_1_name.
4370 *********************************************************************/
4371
4372 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4373 const char *name,
4374 union spoolss_PrinterInfo **info,
4375 uint32_t *count)
4376 {
4377 const char *s = name;
4378
4379 DEBUG(4,("enum_all_printers_info_1_name\n"));
4380
4381 if ((name[0] == '\\') && (name[1] == '\\')) {
4382 s = name + 2;
4383 }
4384
4385 if (!is_myname_or_ipaddr(s)) {
4386 return WERR_INVALID_NAME;
4387 }
4388
4389 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4390 }
4391
4392 /********************************************************************
4393 enum_all_printers_info_1_network.
4394 *********************************************************************/
4395
4396 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4397 const char *name,
4398 union spoolss_PrinterInfo **info,
4399 uint32_t *count)
4400 {
4401 const char *s = name;
4402
4403 DEBUG(4,("enum_all_printers_info_1_network\n"));
4404
4405 /* If we respond to a enum_printers level 1 on our name with flags
4406 set to PRINTER_ENUM_REMOTE with a list of printers then these
4407 printers incorrectly appear in the APW browse list.
4408 Specifically the printers for the server appear at the workgroup
4409 level where all the other servers in the domain are
4410 listed. Windows responds to this call with a
4411 WERR_CAN_NOT_COMPLETE so we should do the same. */
4412
4413 if (name[0] == '\\' && name[1] == '\\') {
4414 s = name + 2;
4415 }
4416
4417 if (is_myname_or_ipaddr(s)) {
4418 return WERR_CAN_NOT_COMPLETE;
4419 }
4420
4421 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4422 }
4423
4424 /********************************************************************
4425 * api_spoolss_enumprinters
4426 *
4427 * called from api_spoolss_enumprinters (see this to understand)
4428 ********************************************************************/
4429
4430 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4431 union spoolss_PrinterInfo **info,
4432 uint32_t *count)
4433 {
4434 DEBUG(4,("enum_all_printers_info_2\n"));
4435
4436 return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4437 }
4438
4439 /********************************************************************
4440 * handle enumeration of printers at level 1
4441 ********************************************************************/
4442
4443 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4444 uint32_t flags,
4445 const char *name,
4446 union spoolss_PrinterInfo **info,
4447 uint32_t *count)
4448 {
4449 /* Not all the flags are equals */
4450
4451 if (flags & PRINTER_ENUM_LOCAL) {
4452 return enum_all_printers_info_1_local(mem_ctx, info, count);
4453 }
4454
4455 if (flags & PRINTER_ENUM_NAME) {
4456 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4457 }
4458
4459 if (flags & PRINTER_ENUM_NETWORK) {
4460 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4461 }
4462
4463 return WERR_OK; /* NT4sp5 does that */
4464 }
4465
4466 /********************************************************************
4467 * handle enumeration of printers at level 2
4468 ********************************************************************/
4469
4470 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4471 uint32_t flags,
4472 const char *servername,
4473 union spoolss_PrinterInfo **info,
4474 uint32_t *count)
4475 {
4476 if (flags & PRINTER_ENUM_LOCAL) {
4477 return enum_all_printers_info_2(mem_ctx, info, count);
4478 }
4479
4480 if (flags & PRINTER_ENUM_NAME) {
4481 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4482 return WERR_INVALID_NAME;
4483 }
4484
4485 return enum_all_printers_info_2(mem_ctx, info, count);
4486 }
4487
4488 if (flags & PRINTER_ENUM_REMOTE) {
4489 return WERR_UNKNOWN_LEVEL;
4490 }
4491
4492 return WERR_OK;
4493 }
4494
4495 /********************************************************************
4496 * handle enumeration of printers at level 4
4497 ********************************************************************/
4498
4499 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4500 uint32_t flags,
4501 const char *servername,
4502 union spoolss_PrinterInfo **info,
4503 uint32_t *count)
4504 {
4505 DEBUG(4,("enum_all_printers_info_4\n"));
4506
4507 return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4508 }
4509
4510
4511 /********************************************************************
4512 * handle enumeration of printers at level 5
4513 ********************************************************************/
4514
4515 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4516 uint32_t flags,
4517 const char *servername,
4518 union spoolss_PrinterInfo **info,
4519 uint32_t *count)
4520 {
4521 DEBUG(4,("enum_all_printers_info_5\n"));
4522
4523 return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4524 }
4525
4526 /****************************************************************
4527 _spoolss_EnumPrinters
4528 ****************************************************************/
4529
4530 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4531 struct spoolss_EnumPrinters *r)
4532 {
4533 const char *name;
4534 WERROR result;
4535
4536 /* that's an [in out] buffer */
4537
4538 if (!r->in.buffer && (r->in.offered != 0)) {
4539 return WERR_INVALID_PARAM;
4540 }
4541
4542 DEBUG(4,("_spoolss_EnumPrinters\n"));
4543
4544 *r->out.needed = 0;
4545 *r->out.count = 0;
4546 *r->out.info = NULL;
4547
4548 /*
4549 * Level 1:
4550 * flags==PRINTER_ENUM_NAME
4551 * if name=="" then enumerates all printers
4552 * if name!="" then enumerate the printer
4553 * flags==PRINTER_ENUM_REMOTE
4554 * name is NULL, enumerate printers
4555 * Level 2: name!="" enumerates printers, name can't be NULL
4556 * Level 3: doesn't exist
4557 * Level 4: does a local registry lookup
4558 * Level 5: same as Level 2
4559 */
4560
4561 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4562 W_ERROR_HAVE_NO_MEMORY(name);
4563
4564 switch (r->in.level) {
4565 case 0:
4566 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4567 r->out.info, r->out.count);
4568 break;
4569 case 1:
4570 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4571 r->out.info, r->out.count);
4572 break;
4573 case 2:
4574 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4575 r->out.info, r->out.count);
4576 break;
4577 case 4:
4578 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4579 r->out.info, r->out.count);
4580 break;
4581 case 5:
4582 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4583 r->out.info, r->out.count);
4584 break;
4585 default:
4586 return WERR_UNKNOWN_LEVEL;
4587 }
4588
4589 if (!W_ERROR_IS_OK(result)) {
4590 return result;
4591 }
4592
4593 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4594 spoolss_EnumPrinters, NULL,
4595 *r->out.info, r->in.level,
4596 *r->out.count);
4597 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4598 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4599
4600 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4601 }
4602
4603 /****************************************************************
4604 _spoolss_GetPrinter
4605 ****************************************************************/
4606
4607 WERROR _spoolss_GetPrinter(pipes_struct *p,
4608 struct spoolss_GetPrinter *r)
4609 {
4610 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4611 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4612 WERROR result = WERR_OK;
4613
4614 int snum;
4615
4616 /* that's an [in out] buffer */
4617
4618 if (!r->in.buffer && (r->in.offered != 0)) {
4619 return WERR_INVALID_PARAM;
4620 }
4621
4622 *r->out.needed = 0;
4623
4624 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4625 return WERR_BADFID;
4626 }
4627
4628 result = get_a_printer(Printer, &ntprinter, 2,
4629 lp_const_servicename(snum));
4630 if (!W_ERROR_IS_OK(result)) {
4631 return result;
4632 }
4633
4634 switch (r->in.level) {
4635 case 0:
4636 result = construct_printer_info0(p->mem_ctx, ntprinter,
4637 &r->out.info->info0, snum);
4638 break;
4639 case 1:
4640 result = construct_printer_info1(p->mem_ctx, ntprinter,
4641 PRINTER_ENUM_ICON8,
4642 &r->out.info->info1, snum);
4643 break;
4644 case 2:
4645 result = construct_printer_info2(p->mem_ctx, ntprinter,
4646 &r->out.info->info2, snum);
4647 break;
4648 case 3:
4649 result = construct_printer_info3(p->mem_ctx, ntprinter,
4650 &r->out.info->info3, snum);
4651 break;
4652 case 4:
4653 result = construct_printer_info4(p->mem_ctx, ntprinter,
4654 &r->out.info->info4, snum);
4655 break;
4656 case 5:
4657 result = construct_printer_info5(p->mem_ctx, ntprinter,
4658 &r->out.info->info5, snum);
4659 break;
4660 case 6:
4661 result = construct_printer_info6(p->mem_ctx, ntprinter,
4662 &r->out.info->info6, snum);
4663 break;
4664 case 7:
4665 result = construct_printer_info7(p->mem_ctx, Printer,
4666 &r->out.info->info7, snum);
4667 break;
4668 case 8:
4669 result = construct_printer_info8(p->mem_ctx, ntprinter,
4670 &r->out.info->info8, snum);
4671 break;
4672 default:
4673 result = WERR_UNKNOWN_LEVEL;
4674 break;
4675 }
4676
4677 free_a_printer(&ntprinter, 2);
4678
4679 if (!W_ERROR_IS_OK(result)) {
4680 TALLOC_FREE(r->out.info);
4681 return result;
4682 }
4683
4684 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4685 r->out.info, r->in.level);
4686 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4687
4688 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4689 }
4690
4691 /********************************************************************
4692 ********************************************************************/
4693
4694 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4695 fstring *fstring_array,
4696 const char *cservername)
4697 {
4698 int i, num_strings = 0;
4699 const char **array = NULL;
4700
4701 for (i=0; fstring_array && fstring_array[i][0] != '\0'; i++) {
4702
4703 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4704 cservername, fstring_array[i]);
4705 if (!str) {
4706 TALLOC_FREE(array);
4707 return NULL;
4708 }
4709
4710
4711 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4712 TALLOC_FREE(array);
4713 return NULL;
4714 }
4715 }
4716
4717 if (i > 0) {
4718 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4719 &array, &num_strings);
4720 }
4721
4722 return array;
4723 }
4724
4725 /********************************************************************
4726 * fill a spoolss_DriverInfo1 struct
4727 ********************************************************************/
4728
4729 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4730 struct spoolss_DriverInfo1 *r,
4731 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4732 const char *servername,
4733 const char *architecture)
4734 {
4735 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4736 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4737
4738 return WERR_OK;
4739 }
4740
4741 /********************************************************************
4742 * fill a spoolss_DriverInfo2 struct
4743 ********************************************************************/
4744
4745 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4746 struct spoolss_DriverInfo2 *r,
4747 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4748 const char *servername)
4749
4750 {
4751 const char *cservername = canon_servername(servername);
4752
4753 r->version = driver->info_3->cversion;
4754
4755 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4756 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4757 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4758 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4759
4760 if (strlen(driver->info_3->driverpath)) {
4761 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4762 cservername, driver->info_3->driverpath);
4763 } else {
4764 r->driver_path = talloc_strdup(mem_ctx, "");
4765 }
4766 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4767
4768 if (strlen(driver->info_3->datafile)) {
4769 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4770 cservername, driver->info_3->datafile);
4771 } else {
4772 r->data_file = talloc_strdup(mem_ctx, "");
4773 }
4774 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4775
4776 if (strlen(driver->info_3->configfile)) {
4777 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4778 cservername, driver->info_3->configfile);
4779 } else {
4780 r->config_file = talloc_strdup(mem_ctx, "");
4781 }
4782 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4783
4784 return WERR_OK;
4785 }
4786
4787 /********************************************************************
4788 * fill a spoolss_DriverInfo3 struct
4789 ********************************************************************/
4790
4791 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4792 struct spoolss_DriverInfo3 *r,
4793 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4794 const char *servername)
4795 {
4796 const char *cservername = canon_servername(servername);
4797
4798 r->version = driver->info_3->cversion;
4799
4800 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4801 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4802 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4803 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4804
4805 if (strlen(driver->info_3->driverpath)) {
4806 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4807 cservername, driver->info_3->driverpath);
4808 } else {
4809 r->driver_path = talloc_strdup(mem_ctx, "");
4810 }
4811 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4812
4813 if (strlen(driver->info_3->datafile)) {
4814 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4815 cservername, driver->info_3->datafile);
4816 } else {
4817 r->data_file = talloc_strdup(mem_ctx, "");
4818 }
4819 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4820
4821 if (strlen(driver->info_3->configfile)) {
4822 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4823 cservername, driver->info_3->configfile);
4824 } else {
4825 r->config_file = talloc_strdup(mem_ctx, "");
4826 }
4827 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4828
4829 if (strlen(driver->info_3->helpfile)) {
4830 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4831 cservername, driver->info_3->helpfile);
4832 } else {
4833 r->help_file = talloc_strdup(mem_ctx, "");
4834 }
4835 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4836
4837 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4838 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4839 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4840 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4841
4842 r->dependent_files = string_array_from_driver_info(mem_ctx,
4843 driver->info_3->dependentfiles,
4844 cservername);
4845 return WERR_OK;
4846 }
4847
4848 /********************************************************************
4849 * fill a spoolss_DriverInfo4 struct
4850 ********************************************************************/
4851
4852 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4853 struct spoolss_DriverInfo4 *r,
4854 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4855 const char *servername)
4856 {
4857 const char *cservername = canon_servername(servername);
4858
4859 r->version = driver->info_3->cversion;
4860
4861 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4862 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4863 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4864 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4865
4866 if (strlen(driver->info_3->driverpath)) {
4867 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4868 cservername, driver->info_3->driverpath);
4869 } else {
4870 r->driver_path = talloc_strdup(mem_ctx, "");
4871 }
4872 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4873
4874 if (strlen(driver->info_3->datafile)) {
4875 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4876 cservername, driver->info_3->datafile);
4877 } else {
4878 r->data_file = talloc_strdup(mem_ctx, "");
4879 }
4880 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4881
4882 if (strlen(driver->info_3->configfile)) {
4883 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4884 cservername, driver->info_3->configfile);
4885 } else {
4886 r->config_file = talloc_strdup(mem_ctx, "");
4887 }
4888 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4889
4890 if (strlen(driver->info_3->helpfile)) {
4891 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4892 cservername, driver->info_3->helpfile);
4893 } else {
4894 r->help_file = talloc_strdup(mem_ctx, "");
4895 }
4896 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4897
4898 r->dependent_files = string_array_from_driver_info(mem_ctx,
4899 driver->info_3->dependentfiles,
4900 cservername);
4901
4902
4903 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4904 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4905 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4906 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4907
4908 r->previous_names = string_array_from_driver_info(mem_ctx,
4909 NULL,
4910 cservername);
4911
4912 return WERR_OK;
4913 }
4914
4915 /********************************************************************
4916 * fill a spoolss_DriverInfo5 struct
4917 ********************************************************************/
4918
4919 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4920 struct spoolss_DriverInfo5 *r,
4921 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4922 const char *servername)
4923 {
4924 const char *cservername = canon_servername(servername);
4925
4926 r->version = driver->info_3->cversion;
4927
4928 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4929 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4930 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4931 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4932
4933 if (strlen(driver->info_3->driverpath)) {
4934 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4935 cservername, driver->info_3->driverpath);
4936 } else {
4937 r->driver_path = talloc_strdup(mem_ctx, "");
4938 }
4939 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4940
4941 if (strlen(driver->info_3->datafile)) {
4942 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4943 cservername, driver->info_3->datafile);
4944 } else {
4945 r->data_file = talloc_strdup(mem_ctx, "");
4946 }
4947 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4948
4949 if (strlen(driver->info_3->configfile)) {
4950 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4951 cservername, driver->info_3->configfile);
4952 } else {
4953 r->config_file = talloc_strdup(mem_ctx, "");
4954 }
4955 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4956
4957 r->driver_attributes = 0;
4958 r->config_version = 0;
4959 r->driver_version = 0;
4960
4961 return WERR_OK;
4962 }
4963 /********************************************************************
4964 * fill a spoolss_DriverInfo6 struct
4965 ********************************************************************/
4966
4967 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4968 struct spoolss_DriverInfo6 *r,
4969 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4970 const char *servername)
4971 {
4972 const char *cservername = canon_servername(servername);
4973
4974 r->version = driver->info_3->cversion;
4975
4976 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4977 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4978 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4979 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4980
4981 if (strlen(driver->info_3->driverpath)) {
4982 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4983 cservername, driver->info_3->driverpath);
4984 } else {
4985 r->driver_path = talloc_strdup(mem_ctx, "");
4986 }
4987 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4988
4989 if (strlen(driver->info_3->datafile)) {
4990 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4991 cservername, driver->info_3->datafile);
4992 } else {
4993 r->data_file = talloc_strdup(mem_ctx, "");
4994 }
4995 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4996
4997 if (strlen(driver->info_3->configfile)) {
4998 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4999 cservername, driver->info_3->configfile);
5000 } else {
5001 r->config_file = talloc_strdup(mem_ctx, "");
5002 }
5003 W_ERROR_HAVE_NO_MEMORY(r->config_file);
5004
5005 if (strlen(driver->info_3->helpfile)) {
5006 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
5007 cservername, driver->info_3->helpfile);
5008 } else {
5009 r->help_file = talloc_strdup(mem_ctx, "");
5010 }
5011 W_ERROR_HAVE_NO_MEMORY(r->help_file);
5012
5013 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
5014 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
5015 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
5016 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
5017
5018 r->dependent_files = string_array_from_driver_info(mem_ctx,
5019 driver->info_3->dependentfiles,
5020 cservername);
5021 r->previous_names = string_array_from_driver_info(mem_ctx,
5022 NULL,
5023 cservername);
5024
5025 r->driver_date = 0;
5026 r->driver_version = 0;
5027
5028 r->manufacturer_name = talloc_strdup(mem_ctx, "");
5029 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5030 r->manufacturer_url = talloc_strdup(mem_ctx, "");
5031 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5032 r->hardware_id = talloc_strdup(mem_ctx, "");
5033 W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5034 r->provider = talloc_strdup(mem_ctx, "");
5035 W_ERROR_HAVE_NO_MEMORY(r->provider);
5036
5037 return WERR_OK;
5038 }
5039
5040 /********************************************************************
5041 ********************************************************************/
5042
5043 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5044 struct spoolss_DriverFileInfo *r,
5045 const char *cservername,
5046 const char *file_name,
5047 enum spoolss_DriverFileType file_type,
5048 uint32_t file_version)
5049 {
5050 r->file_name = talloc_asprintf(mem_ctx, "\\\\%s%s",
5051 cservername, file_name);
5052 W_ERROR_HAVE_NO_MEMORY(r->file_name);
5053 r->file_type = file_type;
5054 r->file_version = file_version;
5055
5056 return WERR_OK;
5057 }
5058
5059 /********************************************************************
5060 ********************************************************************/
5061
5062 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5063 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5064 const char *cservername,
5065 struct spoolss_DriverFileInfo **info_p,
5066 uint32_t *count_p)
5067 {
5068 struct spoolss_DriverFileInfo *info = NULL;
5069 uint32_t count = 0;
5070 WERROR result;
5071 uint32_t i;
5072
5073 *info_p = NULL;
5074 *count_p = 0;
5075
5076 if (strlen(driver->info_3->driverpath)) {
5077 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5078 struct spoolss_DriverFileInfo,
5079 count + 1);
5080 W_ERROR_HAVE_NO_MEMORY(info);
5081 result = fill_spoolss_DriverFileInfo(info,
5082 &info[count],
5083 cservername,
5084 driver->info_3->driverpath,
5085 SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5086 0);
5087 W_ERROR_NOT_OK_RETURN(result);
5088 count++;
5089 }
5090
5091 if (strlen(driver->info_3->configfile)) {
5092 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5093 struct spoolss_DriverFileInfo,
5094 count + 1);
5095 W_ERROR_HAVE_NO_MEMORY(info);
5096 result = fill_spoolss_DriverFileInfo(info,
5097 &info[count],
5098 cservername,
5099 driver->info_3->configfile,
5100 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5101 0);
5102 W_ERROR_NOT_OK_RETURN(result);
5103 count++;
5104 }
5105
5106 if (strlen(driver->info_3->datafile)) {
5107 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5108 struct spoolss_DriverFileInfo,
5109 count + 1);
5110 W_ERROR_HAVE_NO_MEMORY(info);
5111 result = fill_spoolss_DriverFileInfo(info,
5112 &info[count],
5113 cservername,
5114 driver->info_3->datafile,
5115 SPOOLSS_DRIVER_FILE_TYPE_DATA,
5116 0);
5117 W_ERROR_NOT_OK_RETURN(result);
5118 count++;
5119 }
5120
5121 if (strlen(driver->info_3->helpfile)) {
5122 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5123 struct spoolss_DriverFileInfo,
5124 count + 1);
5125 W_ERROR_HAVE_NO_MEMORY(info);
5126 result = fill_spoolss_DriverFileInfo(info,
5127 &info[count],
5128 cservername,
5129 driver->info_3->helpfile,
5130 SPOOLSS_DRIVER_FILE_TYPE_HELP,
5131 0);
5132 W_ERROR_NOT_OK_RETURN(result);
5133 count++;
5134 }
5135
5136 for (i=0; driver->info_3->dependentfiles[i][0] != '\0'; i++) {
5137 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5138 struct spoolss_DriverFileInfo,
5139 count + 1);
5140 W_ERROR_HAVE_NO_MEMORY(info);
5141 result = fill_spoolss_DriverFileInfo(info,
5142 &info[count],
5143 cservername,
5144 driver->info_3->dependentfiles[i],
5145 SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5146 0);
5147 W_ERROR_NOT_OK_RETURN(result);
5148 count++;
5149 }
5150
5151 *info_p = info;
5152 *count_p = count;
5153
5154 return WERR_OK;
5155 }
5156
5157 /********************************************************************
5158 * fill a spoolss_DriverInfo101 sttruct
5159 ********************************************************************/
5160
5161 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5162 struct spoolss_DriverInfo101 *r,
5163 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5164 const char *servername)
5165 {
5166 const char *cservername = canon_servername(servername);
5167 WERROR result;
5168
5169 r->version = driver->info_3->cversion;
5170
5171 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
5172 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5173 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
5174 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5175
5176 result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5177 cservername,
5178 &r->file_info,
5179 &r->file_count);
5180 if (!W_ERROR_IS_OK(result)) {
5181 return result;
5182 }
5183
5184 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
5185 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
5186
5187 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
5188 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
5189
5190 r->previous_names = string_array_from_driver_info(mem_ctx,
5191 NULL,
5192 cservername);
5193 r->driver_date = 0;
5194 r->driver_version = 0;
5195
5196 r->manufacturer_name = talloc_strdup(mem_ctx, "");
5197 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5198 r->manufacturer_url = talloc_strdup(mem_ctx, "");
5199 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5200 r->hardware_id = talloc_strdup(mem_ctx, "");
5201 W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5202 r->provider = talloc_strdup(mem_ctx, "");
5203 W_ERROR_HAVE_NO_MEMORY(r->provider);
5204
5205 return WERR_OK;
5206 }
5207
5208 /********************************************************************
5209 * construct_printer_driver_info_1
5210 ********************************************************************/
5211
5212 static WERROR construct_printer_driver_info_1(TALLOC_CTX *mem_ctx,
5213 struct spoolss_DriverInfo1 *r,
5214 int snum,
5215 const char *servername,
5216 const char *architecture,
5217 uint32_t version)
5218 {
5219 NT_PRINTER_INFO_LEVEL *printer = NULL;
5220 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5221 WERROR result;
5222
5223 ZERO_STRUCT(driver);
5224
5225 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5226 return WERR_INVALID_PRINTER_NAME;
5227
5228 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5229 free_a_printer(&printer, 2);
5230 return WERR_UNKNOWN_PRINTER_DRIVER;
5231 }
5232
5233 result = fill_printer_driver_info1(mem_ctx, r, &driver, servername, architecture);
5234
5235 free_a_printer(&printer,2);
5236
5237 return result;
5238 }
5239
5240 /********************************************************************
5241 * construct_printer_driver_info_2
5242 * fill a printer_info_2 struct
5243 ********************************************************************/
5244
5245 static WERROR construct_printer_driver_info_2(TALLOC_CTX *mem_ctx,
5246 struct spoolss_DriverInfo2 *r,
5247 int snum,
5248 const char *servername,
5249 const char *architecture,
5250 uint32_t version)
5251 {
5252 NT_PRINTER_INFO_LEVEL *printer = NULL;
5253 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5254 WERROR result;
5255
5256 ZERO_STRUCT(printer);
5257 ZERO_STRUCT(driver);
5258
5259 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5260 return WERR_INVALID_PRINTER_NAME;
5261
5262 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5263 free_a_printer(&printer, 2);
5264 return WERR_UNKNOWN_PRINTER_DRIVER;
5265 }
5266
5267 result = fill_printer_driver_info2(mem_ctx, r, &driver, servername);
5268
5269 free_a_printer(&printer,2);
5270
5271 return result;
5272 }
5273
5274 /********************************************************************
5275 * construct_printer_info_3
5276 * fill a printer_info_3 struct
5277 ********************************************************************/
5278
5279 static WERROR construct_printer_driver_info_3(TALLOC_CTX *mem_ctx,
5280 struct spoolss_DriverInfo3 *r,
5281 int snum,
5282 const char *servername,
5283 const char *architecture,
5284 uint32_t version)
5285 {
5286 NT_PRINTER_INFO_LEVEL *printer = NULL;
5287 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5288 WERROR status;
5289 ZERO_STRUCT(driver);
5290
5291 status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5292 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5293 if (!W_ERROR_IS_OK(status))
5294 return WERR_INVALID_PRINTER_NAME;
5295
5296 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5297 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5298
5299 #if 0 /* JERRY */
5300
5301 /*
5302 * I put this code in during testing. Helpful when commenting out the
5303 * support for DRIVER_INFO_6 in regards to win2k. Not needed in general
5304 * as win2k always queries the driver using an infor level of 6.
5305 * I've left it in (but ifdef'd out) because I'll probably
5306 * use it in experimentation again in the future. --jerry 22/01/2002
5307 */
5308
5309 if (!W_ERROR_IS_OK(status)) {
5310 /*
5311 * Is this a W2k client ?
5312 */
5313 if (version == 3) {
5314 /* Yes - try again with a WinNT driver. */
5315 version = 2;
5316 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5317 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5318 }
5319 #endif
5320
5321 if (!W_ERROR_IS_OK(status)) {
5322 free_a_printer(&printer,2);
5323 return WERR_UNKNOWN_PRINTER_DRIVER;
5324 }
5325
5326 #if 0 /* JERRY */
5327 }
5328 #endif
5329
5330
5331 status = fill_printer_driver_info3(mem_ctx, r, &driver, servername);
5332
5333 free_a_printer(&printer,2);
5334
5335 return status;
5336 }
5337
5338 /********************************************************************
5339 * construct_printer_info_6
5340 * fill a printer_info_6 struct
5341 ********************************************************************/
5342
5343 static WERROR construct_printer_driver_info_6(TALLOC_CTX *mem_ctx,
5344 struct spoolss_DriverInfo6 *r,
5345 int snum,
5346 const char *servername,
5347 const char *architecture,
5348 uint32_t version)
5349 {
5350 NT_PRINTER_INFO_LEVEL *printer = NULL;
5351 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5352 WERROR status;
5353
5354 ZERO_STRUCT(driver);
5355
5356 status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5357
5358 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5359
5360 if (!W_ERROR_IS_OK(status))
5361 return WERR_INVALID_PRINTER_NAME;
5362
5363 status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5364
5365 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5366
5367 if (!W_ERROR_IS_OK(status))
5368 {
5369 /*
5370 * Is this a W2k client ?
5371 */
5372
5373 if (version < 3) {
5374 free_a_printer(&printer,2);
5375 return WERR_UNKNOWN_PRINTER_DRIVER;
5376 }
5377
5378 /* Yes - try again with a WinNT driver. */
5379 version = 2;
5380 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5381 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5382 if (!W_ERROR_IS_OK(status)) {
5383 free_a_printer(&printer,2);
5384 return WERR_UNKNOWN_PRINTER_DRIVER;
5385 }
5386 }
5387
5388 status = fill_printer_driver_info6(mem_ctx, r, &driver, servername);
5389
5390 free_a_printer(&printer,2);
5391 free_a_printer_driver(driver, 3);
5392
5393 return status;
5394 }
5395
5396 /********************************************************************
5397 * construct_printer_info_101
5398 * fill a printer_info_101 struct
5399 ********************************************************************/
5400
5401 static WERROR construct_printer_driver_info_101(TALLOC_CTX *mem_ctx,
5402 struct spoolss_DriverInfo101 *r,
5403 int snum,
5404 const char *servername,
5405 const char *architecture,
5406 uint32_t version)
5407 {
5408 NT_PRINTER_INFO_LEVEL *printer = NULL;
5409 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5410 WERROR result;
5411
5412 ZERO_STRUCT(driver);
5413
5414 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5415
5416 DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5417 win_errstr(result)));
5418
5419 if (!W_ERROR_IS_OK(result)) {
5420 return WERR_INVALID_PRINTER_NAME;
5421 }
5422
5423 result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5424 architecture, version);
5425
5426 DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5427 win_errstr(result)));
5428
5429 if (!W_ERROR_IS_OK(result)) {
5430 /*
5431 * Is this a W2k client ?
5432 */
5433
5434 if (version < 3) {
5435 free_a_printer(&printer, 2);
5436 return WERR_UNKNOWN_PRINTER_DRIVER;
5437 }
5438
5439 /* Yes - try again with a WinNT driver. */
5440 version = 2;
5441 result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5442 architecture, version);
5443 DEBUG(8,("construct_printer_driver_info_6: status: %s\n",
5444 win_errstr(result)));
5445 if (!W_ERROR_IS_OK(result)) {
5446 free_a_printer(&printer, 2);
5447 return WERR_UNKNOWN_PRINTER_DRIVER;
5448 }
5449 }
5450
5451 result = fill_printer_driver_info101(mem_ctx, r, &driver, servername);
5452
5453 free_a_printer(&printer, 2);
5454 free_a_printer_driver(driver, 3);
5455
5456 return result;
5457 }
5458
5459 /****************************************************************
5460 _spoolss_GetPrinterDriver2
5461 ****************************************************************/
5462
5463 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5464 struct spoolss_GetPrinterDriver2 *r)
5465 {
5466 Printer_entry *printer;
5467 WERROR result;
5468
5469 const char *servername;
5470 int snum;
5471
5472 /* that's an [in out] buffer */
5473
5474 if (!r->in.buffer && (r->in.offered != 0)) {
5475 return WERR_INVALID_PARAM;
5476 }
5477
5478 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5479
5480 if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5481 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5482 return WERR_INVALID_PRINTER_NAME;
5483 }
5484
5485 *r->out.needed = 0;
5486 *r->out.server_major_version = 0;
5487 *r->out.server_minor_version = 0;
5488
5489 servername = get_server_name(printer);
5490
5491 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5492 return WERR_BADFID;
5493 }
5494
5495 switch (r->in.level) {
5496 case 1:
5497 result = construct_printer_driver_info_1(p->mem_ctx,
5498 &r->out.info->info1,
5499 snum,
5500 servername,
5501 r->in.architecture,
5502 r->in.client_major_version);
5503 break;
5504 case 2:
5505 result = construct_printer_driver_info_2(p->mem_ctx,
5506 &r->out.info->info2,
5507 snum,
5508 servername,
5509 r->in.architecture,
5510 r->in.client_major_version);
5511 break;
5512 case 3:
5513 result = construct_printer_driver_info_3(p->mem_ctx,
5514 &r->out.info->info3,
5515 snum,
5516 servername,
5517 r->in.architecture,
5518 r->in.client_major_version);
5519 break;
5520 case 6:
5521 result = construct_printer_driver_info_6(p->mem_ctx,
5522 &r->out.info->info6,
5523 snum,
5524 servername,
5525 r->in.architecture,
5526 r->in.client_major_version);
5527 break;
5528 case 101:
5529 result = construct_printer_driver_info_101(p->mem_ctx,
5530 &r->out.info->info101,
5531 snum,
5532 servername,
5533 r->in.architecture,
5534 r->in.client_major_version);
5535 break;
5536 default:
5537 result = WERR_UNKNOWN_LEVEL;
5538 break;
5539 }
5540
5541 if (!W_ERROR_IS_OK(result)) {
5542 TALLOC_FREE(r->out.info);
5543 return result;
5544 }
5545
5546 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5547 r->out.info, r->in.level);
5548 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5549
5550 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5551 }
5552
5553
5554 /****************************************************************
5555 _spoolss_StartPagePrinter
5556 ****************************************************************/
5557
5558 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5559 struct spoolss_StartPagePrinter *r)
5560 {
5561 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5562
5563 if (!Printer) {
5564 DEBUG(3,("_spoolss_StartPagePrinter: "
5565 "Error in startpageprinter printer handle\n"));
5566 return WERR_BADFID;
5567 }
5568
5569 Printer->page_started = true;
5570 return WERR_OK;
5571 }
5572
5573 /****************************************************************
5574 _spoolss_EndPagePrinter
5575 ****************************************************************/
5576
5577 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5578 struct spoolss_EndPagePrinter *r)
5579 {
5580 int snum;
5581
5582 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5583
5584 if (!Printer) {
5585 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5586 OUR_HANDLE(r->in.handle)));
5587 return WERR_BADFID;
5588 }
5589
5590 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5591 return WERR_BADFID;
5592
5593 Printer->page_started = false;
5594 print_job_endpage(snum, Printer->jobid);
5595
5596 return WERR_OK;
5597 }
5598
5599 /****************************************************************
5600 _spoolss_StartDocPrinter
5601 ****************************************************************/
5602
5603 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5604 struct spoolss_StartDocPrinter *r)
5605 {
5606 struct spoolss_DocumentInfo1 *info_1;
5607 int snum;
5608 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5609
5610 if (!Printer) {
5611 DEBUG(2,("_spoolss_StartDocPrinter: "
5612 "Invalid handle (%s:%u:%u)\n",
5613 OUR_HANDLE(r->in.handle)));
5614 return WERR_BADFID;
5615 }
5616
5617 if (r->in.level != 1) {
5618 return WERR_UNKNOWN_LEVEL;
5619 }
5620
5621 info_1 = r->in.info.info1;
5622
5623 /*
5624 * a nice thing with NT is it doesn't listen to what you tell it.
5625 * when asked to send _only_ RAW datas, it tries to send datas
5626 * in EMF format.
5627 *
5628 * So I add checks like in NT Server ...
5629 */
5630
5631 if (info_1->datatype) {
5632 if (strcmp(info_1->datatype, "RAW") != 0) {
5633 *r->out.job_id = 0;
5634 return WERR_INVALID_DATATYPE;
5635 }
5636 }
5637
5638 /* get the share number of the printer */
5639 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5640 return WERR_BADFID;
5641 }
5642
5643 Printer->jobid = print_job_start(p->server_info, snum,
5644 info_1->document_name,
5645 Printer->nt_devmode);
5646
5647 /* An error occured in print_job_start() so return an appropriate
5648 NT error code. */
5649
5650 if (Printer->jobid == -1) {
5651 return map_werror_from_unix(errno);
5652 }
5653
5654 Printer->document_started = true;
5655 *r->out.job_id = Printer->jobid;
5656
5657 return WERR_OK;
5658 }
5659
5660 /****************************************************************
5661 _spoolss_EndDocPrinter
5662 ****************************************************************/
5663
5664 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5665 struct spoolss_EndDocPrinter *r)
5666 {
5667 return _spoolss_enddocprinter_internal(p, r->in.handle);
5668 }
5669
5670 /****************************************************************
5671 _spoolss_WritePrinter
5672 ****************************************************************/
5673
5674 WERROR _spoolss_WritePrinter(pipes_struct *p,
5675 struct spoolss_WritePrinter *r)
5676 {
5677 uint32_t buffer_written;
5678 int snum;
5679 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5680
5681 if (!Printer) {
5682 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5683 OUR_HANDLE(r->in.handle)));
5684 *r->out.num_written = r->in._data_size;
5685 return WERR_BADFID;
5686 }
5687
5688 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5689 return WERR_BADFID;
5690
5691 buffer_written = (uint32_t)print_job_write(snum, Printer->jobid,
5692 (const char *)r->in.data.data,
5693 (SMB_OFF_T)-1,
5694 (size_t)r->in._data_size);
5695 if (buffer_written == (uint32_t)-1) {
5696 *r->out.num_written = 0;
5697 if (errno == ENOSPC)
5698 return WERR_NO_SPOOL_SPACE;
5699 else
5700 return WERR_ACCESS_DENIED;
5701 }
5702
5703 *r->out.num_written = r->in._data_size;
5704
5705 return WERR_OK;
5706 }
5707
5708 /********************************************************************
5709 * api_spoolss_getprinter
5710 * called from the spoolss dispatcher
5711 *
5712 ********************************************************************/
5713
5714 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5715 pipes_struct *p)
5716 {
5717 int snum;
5718 WERROR errcode = WERR_BADFUNC;
5719 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5720
5721 if (!Printer) {
5722 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5723 OUR_HANDLE(handle)));
5724 return WERR_BADFID;
5725 }
5726
5727 if (!get_printer_snum(p, handle, &snum, NULL))
5728 return WERR_BADFID;
5729
5730 switch (command) {
5731 case SPOOLSS_PRINTER_CONTROL_PAUSE:
5732 if (print_queue_pause(p->server_info, snum, &errcode)) {
5733 errcode = WERR_OK;
5734 }
5735 break;
5736 case SPOOLSS_PRINTER_CONTROL_RESUME:
5737 case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5738 if (print_queue_resume(p->server_info, snum, &errcode)) {
5739 errcode = WERR_OK;
5740 }
5741 break;
5742 case SPOOLSS_PRINTER_CONTROL_PURGE:
5743 if (print_queue_purge(p->server_info, snum, &errcode)) {
5744 errcode = WERR_OK;
5745 }
5746 break;
5747 default:
5748 return WERR_UNKNOWN_LEVEL;
5749 }
5750
5751 return errcode;
5752 }
5753
5754
5755 /****************************************************************
5756 _spoolss_AbortPrinter
5757 * From MSDN: "Deletes printer's spool file if printer is configured
5758 * for spooling"
5759 ****************************************************************/
5760
5761 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5762 struct spoolss_AbortPrinter *r)
5763 {
5764 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5765 int snum;
5766 WERROR errcode = WERR_OK;
5767
5768 if (!Printer) {
5769 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5770 OUR_HANDLE(r->in.handle)));
5771 return WERR_BADFID;
5772 }
5773
5774 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5775 return WERR_BADFID;
5776
5777 print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5778
5779 return errcode;
5780 }
5781
5782 /********************************************************************
5783 * called by spoolss_api_setprinter
5784 * when updating a printer description
5785 ********************************************************************/
5786
5787 static WERROR update_printer_sec(struct policy_handle *handle,
5788 pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5789 {
5790 SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5791 WERROR result;
5792 int snum;
5793
5794 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5795
5796 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5797 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5798 OUR_HANDLE(handle)));
5799
5800 result = WERR_BADFID;
5801 goto done;
5802 }
5803
5804 if (!secdesc_ctr) {
5805 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5806 result = WERR_INVALID_PARAM;
5807 goto done;
5808 }
5809
5810 /* Check the user has permissions to change the security
5811 descriptor. By experimentation with two NT machines, the user
5812 requires Full Access to the printer to change security
5813 information. */
5814
5815 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5816 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5817 result = WERR_ACCESS_DENIED;
5818 goto done;
5819 }
5820
5821 /* NT seems to like setting the security descriptor even though
5822 nothing may have actually changed. */
5823
5824 if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5825 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5826 result = WERR_BADFID;
5827 goto done;
5828 }
5829
5830 if (DEBUGLEVEL >= 10) {
5831 SEC_ACL *the_acl;
5832 int i;
5833
5834 the_acl = old_secdesc_ctr->sd->dacl;
5835 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5836 PRINTERNAME(snum), the_acl->num_aces));
5837
5838 for (i = 0; i < the_acl->num_aces; i++) {
5839 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5840 &the_acl->aces[i].trustee),
5841 the_acl->aces[i].access_mask));
5842 }
5843
5844 the_acl = secdesc_ctr->sd->dacl;
5845
5846 if (the_acl) {
5847 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5848 PRINTERNAME(snum), the_acl->num_aces));
5849
5850 for (i = 0; i < the_acl->num_aces; i++) {
5851 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5852 &the_acl->aces[i].trustee),
5853 the_acl->aces[i].access_mask));
5854 }
5855 } else {
5856 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5857 }
5858 }
5859
5860 new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5861 if (!new_secdesc_ctr) {
5862 result = WERR_NOMEM;
5863 goto done;
5864 }
5865
5866 if (sec_desc_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5867 result = WERR_OK;
5868 goto done;
5869 }
5870
5871 result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5872
5873 done:
5874
5875 return result;
5876 }
5877
5878 /********************************************************************
5879 Canonicalize printer info from a client
5880
5881 ATTN: It does not matter what we set the servername to hear
5882 since we do the necessary work in get_a_printer() to set it to
5883 the correct value based on what the client sent in the
5884 _spoolss_open_printer_ex().
5885 ********************************************************************/
5886
5887 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5888 {
5889 fstring printername;
5890 const char *p;
5891
5892 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5893 "portname=%s drivername=%s comment=%s location=%s\n",
5894 info->servername, info->printername, info->sharename,
5895 info->portname, info->drivername, info->comment, info->location));
5896
5897 /* we force some elements to "correct" values */
5898 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5899 fstrcpy(info->sharename, lp_servicename(snum));
5900
5901 /* check to see if we allow printername != sharename */
5902
5903 if ( lp_force_printername(snum) ) {
5904 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5905 global_myname(), info->sharename );
5906 } else {
5907
5908 /* make sure printername is in \\server\printername format */
5909
5910 fstrcpy( printername, info->printername );
5911 p = printername;
5912 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5913 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5914 p++;
5915 }
5916
5917 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5918 global_myname(), p );
5919 }
5920
5921 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5922 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5923
5924
5925
5926 return true;
5927 }
5928
5929 /****************************************************************************
5930 ****************************************************************************/
5931
5932 WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri )
5933 {
5934 char *cmd = lp_addport_cmd();
5935 char *command = NULL;
5936 int ret;
5937 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5938 bool is_print_op = false;
5939
5940 if ( !*cmd ) {
5941 return WERR_ACCESS_DENIED;
5942 }
5943
5944 command = talloc_asprintf(ctx,
5945 "%s \"%s\" \"%s\"", cmd, portname, uri );
5946 if (!command) {
5947 return WERR_NOMEM;
5948 }
5949
5950 if ( token )
5951 is_print_op = user_has_privileges( token, &se_printop );
5952
5953 DEBUG(10,("Running [%s]\n", command));
5954
5955 /********* BEGIN SePrintOperatorPrivilege **********/
5956
5957 if ( is_print_op )
5958 become_root();
5959
5960 ret = smbrun(command, NULL);
5961
5962 if ( is_print_op )
5963 unbecome_root();
5964
5965 /********* END SePrintOperatorPrivilege **********/
5966
5967 DEBUGADD(10,("returned [%d]\n", ret));
5968
5969 TALLOC_FREE(command);
5970
5971 if ( ret != 0 ) {
5972 return WERR_ACCESS_DENIED;
5973 }
5974
5975 return WERR_OK;
5976 }
5977
5978 /****************************************************************************
5979 ****************************************************************************/
5980
5981 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5982 {
5983 char *cmd = lp_addprinter_cmd();
5984 char **qlines;
5985 char *command = NULL;
5986 int numlines;
5987 int ret;
5988 int fd;
5989 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5990 bool is_print_op = false;
5991 char *remote_machine = talloc_strdup(ctx, "%m");
5992
5993 if (!remote_machine) {
5994 return false;
5995 }
5996 remote_machine = talloc_sub_basic(ctx,
5997 current_user_info.smb_name,
5998 current_user_info.domain,
5999 remote_machine);
6000 if (!remote_machine) {
6001 return false;
6002 }
6003
6004 command = talloc_asprintf(ctx,
6005 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
6006 cmd, printer->info_2->printername, printer->info_2->sharename,
6007 printer->info_2->portname, printer->info_2->drivername,
6008 printer->info_2->location, printer->info_2->comment, remote_machine);
6009 if (!command) {
6010 return false;
6011 }
6012
6013 if ( token )
6014 is_print_op = user_has_privileges( token, &se_printop );
6015
6016 DEBUG(10,("Running [%s]\n", command));
6017
6018 /********* BEGIN SePrintOperatorPrivilege **********/
6019
6020 if ( is_print_op )
6021 become_root();
6022
6023 if ( (ret = smbrun(command, &fd)) == 0 ) {
6024 /* Tell everyone we updated smb.conf. */
6025 message_send_all(smbd_messaging_context(),
6026 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6027 }
6028
6029 if ( is_print_op )
6030 unbecome_root();
6031
6032 /********* END SePrintOperatorPrivilege **********/
6033
6034 DEBUGADD(10,("returned [%d]\n", ret));
6035
6036 TALLOC_FREE(command);
6037 TALLOC_FREE(remote_machine);
6038
6039 if ( ret != 0 ) {
6040 if (fd != -1)
6041 close(fd);
6042 return false;
6043 }
6044
6045 /* reload our services immediately */
6046 reload_services(false);
6047
6048 numlines = 0;
6049 /* Get lines and convert them back to dos-codepage */
6050 qlines = fd_lines_load(fd, &numlines, 0, NULL);
6051 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6052 close(fd);
6053
6054 /* Set the portname to what the script says the portname should be. */
6055 /* but don't require anything to be return from the script exit a good error code */
6056
6057 if (numlines) {
6058 /* Set the portname to what the script says the portname should be. */
6059 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
6060 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6061 }
6062
6063 TALLOC_FREE(qlines);
6064 return true;
6065 }
6066
6067
6068 /********************************************************************
6069 * Called by spoolss_api_setprinter
6070 * when updating a printer description.
6071 ********************************************************************/
6072
6073 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
6074 struct spoolss_SetPrinterInfoCtr *info_ctr,
6075 struct spoolss_DeviceMode *devmode)
6076 {
6077 int snum;
6078 NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
6079 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6080 WERROR result;
6081 UNISTR2 buffer;
6082 fstring asc_buffer;
6083
6084 DEBUG(8,("update_printer\n"));
6085
6086 result = WERR_OK;
6087
6088 if (!Printer) {
6089 result = WERR_BADFID;
6090 goto done;
6091 }
6092
6093 if (!get_printer_snum(p, handle, &snum, NULL)) {
6094 result = WERR_BADFID;
6095 goto done;
6096 }
6097
6098 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
6099 (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
6100 result = WERR_BADFID;
6101 goto done;
6102 }
6103
6104 DEBUGADD(8,("Converting info_2 struct\n"));
6105
6106 /*
6107 * convert_printer_info converts the incoming
6108 * info from the client and overwrites the info
6109 * just read from the tdb in the pointer 'printer'.
6110 */
6111
6112 if (!convert_printer_info(info_ctr, printer)) {
6113 result = WERR_NOMEM;
6114 goto done;
6115 }
6116
6117 if (devmode) {
6118 /* we have a valid devmode
6119 convert it and link it*/
6120
6121 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
6122 if (!convert_devicemode(printer->info_2->printername, devmode,
6123 &printer->info_2->devmode)) {
6124 result = WERR_NOMEM;
6125 goto done;
6126 }
6127 }
6128
6129 /* Do sanity check on the requested changes for Samba */
6130
6131 if (!check_printer_ok(printer->info_2, snum)) {
6132 result = WERR_INVALID_PARAM;
6133 goto done;
6134 }
6135
6136 /* FIXME!!! If the driver has changed we really should verify that
6137 it is installed before doing much else --jerry */
6138
6139 /* Check calling user has permission to update printer description */
6140
6141 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6142 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6143 result = WERR_ACCESS_DENIED;
6144 goto done;
6145 }
6146
6147 /* Call addprinter hook */
6148 /* Check changes to see if this is really needed */
6149
6150 if ( *lp_addprinter_cmd()
6151 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
6152 || !strequal(printer->info_2->comment, old_printer->info_2->comment)
6153 || !strequal(printer->info_2->portname, old_printer->info_2->portname)
6154 || !strequal(printer->info_2->location, old_printer->info_2->location)) )
6155 {
6156 /* add_printer_hook() will call reload_services() */
6157
6158 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
6159 printer) ) {
6160 result = WERR_ACCESS_DENIED;
6161 goto done;
6162 }
6163 }
6164
6165 /*
6166 * When a *new* driver is bound to a printer, the drivername is used to
6167 * lookup previously saved driver initialization info, which is then
6168 * bound to the printer, simulating what happens in the Windows arch.
6169 */
6170 if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
6171 {
6172 if (!set_driver_init(printer, 2))
6173 {
6174 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
6175 printer->info_2->drivername));
6176 }
6177
6178 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
6179 printer->info_2->drivername));
6180
6181 notify_printer_driver(snum, printer->info_2->drivername);
6182 }
6183
6184 /*
6185 * flag which changes actually occured. This is a small subset of
6186 * all the possible changes. We also have to update things in the
6187 * DsSpooler key.
6188 */
6189
6190 if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
6191 init_unistr2( &buffer, printer->info_2->comment, UNI_STR_TERMINATE);
6192 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
6193 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6194
6195 notify_printer_comment(snum, printer->info_2->comment);
6196 }
6197
6198 if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
6199 init_unistr2( &buffer, printer->info_2->sharename, UNI_STR_TERMINATE);
6200 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
6201 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6202
6203 notify_printer_sharename(snum, printer->info_2->sharename);
6204 }
6205
6206 if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
6207 char *pname;
6208
6209 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
6210 pname++;
6211 else
6212 pname = printer->info_2->printername;
6213
6214
6215 init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
6216 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
6217 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6218
6219 notify_printer_printername( snum, pname );
6220 }
6221
6222 if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
6223 init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
6224 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
6225 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6226
6227 notify_printer_port(snum, printer->info_2->portname);
6228 }
6229
6230 if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
6231 init_unistr2( &buffer, printer->info_2->location, UNI_STR_TERMINATE);
6232 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
6233 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6234
6235 notify_printer_location(snum, printer->info_2->location);
6236 }
6237
6238 /* here we need to update some more DsSpooler keys */
6239 /* uNCName, serverName, shortServerName */
6240
6241 init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
6242 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
6243 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6244 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
6245 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6246
6247 slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
6248 global_myname(), printer->info_2->sharename );
6249 init_unistr2( &buffer, asc_buffer, UNI_STR_TERMINATE);
6250 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
6251 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6252
6253 /* Update printer info */
6254 result = mod_a_printer(printer, 2);
6255
6256 done:
6257 free_a_printer(&printer, 2);
6258 free_a_printer(&old_printer, 2);
6259
6260
6261 return result;
6262 }
6263
6264 /****************************************************************************
6265 ****************************************************************************/
6266 static WERROR publish_or_unpublish_printer(pipes_struct *p,
6267 struct policy_handle *handle,
6268 struct spoolss_SetPrinterInfo7 *info7)
6269 {
6270 #ifdef HAVE_ADS
6271 int snum;
6272 Printer_entry *Printer;
6273
6274 if ( lp_security() != SEC_ADS ) {
6275 return WERR_UNKNOWN_LEVEL;
6276 }
6277
6278 Printer = find_printer_index_by_hnd(p, handle);
6279
6280 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6281
6282 if (!Printer)
6283 return WERR_BADFID;
6284
6285 if (!get_printer_snum(p, handle, &snum, NULL))
6286 return WERR_BADFID;
6287
6288 nt_printer_publish(Printer, snum, info7->action);
6289
6290 return WERR_OK;
6291 #else
6292 return WERR_UNKNOWN_LEVEL;
6293 #endif
6294 }
6295
6296 /****************************************************************
6297 _spoolss_SetPrinter
6298 ****************************************************************/
6299
6300 WERROR _spoolss_SetPrinter(pipes_struct *p,
6301 struct spoolss_SetPrinter *r)
6302 {
6303 WERROR result;
6304
6305 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6306
6307 if (!Printer) {
6308 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6309 OUR_HANDLE(r->in.handle)));
6310 return WERR_BADFID;
6311 }
6312
6313 /* check the level */
6314 switch (r->in.info_ctr->level) {
6315 case 0:
6316 return control_printer(r->in.handle, r->in.command, p);
6317 case 2:
6318 result = update_printer(p, r->in.handle,
6319 r->in.info_ctr,
6320 r->in.devmode_ctr->devmode);
6321 if (!W_ERROR_IS_OK(result))
6322 return result;
6323 if (r->in.secdesc_ctr->sd)
6324 result = update_printer_sec(r->in.handle, p,
6325 r->in.secdesc_ctr);
6326 return result;
6327 case 3:
6328 return update_printer_sec(r->in.handle, p,
6329 r->in.secdesc_ctr);
6330 case 7:
6331 return publish_or_unpublish_printer(p, r->in.handle,
6332 r->in.info_ctr->info.info7);
6333 default:
6334 return WERR_UNKNOWN_LEVEL;
6335 }
6336 }
6337
6338 /****************************************************************
6339 _spoolss_FindClosePrinterNotify
6340 ****************************************************************/
6341
6342 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
6343 struct spoolss_FindClosePrinterNotify *r)
6344 {
6345 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6346
6347 if (!Printer) {
6348 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6349 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6350 return WERR_BADFID;
6351 }
6352
6353 if (Printer->notify.client_connected == true) {
6354 int snum = -1;
6355
6356 if ( Printer->printer_type == SPLHND_SERVER)
6357 snum = -1;
6358 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6359 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6360 return WERR_BADFID;
6361
6362 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6363 }
6364
6365 Printer->notify.flags=0;
6366 Printer->notify.options=0;
6367 Printer->notify.localmachine[0]='\0';
6368 Printer->notify.printerlocal=0;
6369 TALLOC_FREE(Printer->notify.option);
6370 Printer->notify.client_connected = false;
6371
6372 return WERR_OK;
6373 }
6374
6375 /****************************************************************
6376 _spoolss_AddJob
6377 ****************************************************************/
6378
6379 WERROR _spoolss_AddJob(pipes_struct *p,
6380 struct spoolss_AddJob *r)
6381 {
6382 if (!r->in.buffer && (r->in.offered != 0)) {
6383 return WERR_INVALID_PARAM;
6384 }
6385
6386 /* this is what a NT server returns for AddJob. AddJob must fail on
6387 * non-local printers */
6388
6389 if (r->in.level != 1) {
6390 return WERR_UNKNOWN_LEVEL;
6391 }
6392
6393 return WERR_INVALID_PARAM;
6394 }
6395
6396 /****************************************************************************
6397 fill_job_info1
6398 ****************************************************************************/
6399
6400 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6401 struct spoolss_JobInfo1 *r,
6402 const print_queue_struct *queue,
6403 int position, int snum,
6404 const NT_PRINTER_INFO_LEVEL *ntprinter)
6405 {
6406 struct tm *t;
6407
6408 t = gmtime(&queue->time);
6409
6410 r->job_id = queue->job;
6411
6412 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6413 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6414 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6415 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6416 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6417 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6418 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6419 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6420 r->data_type = talloc_strdup(mem_ctx, "RAW");
6421 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6422 r->text_status = talloc_strdup(mem_ctx, "");
6423 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6424
6425 r->status = nt_printj_status(queue->status);
6426 r->priority = queue->priority;
6427 r->position = position;
6428 r->total_pages = queue->page_count;
6429 r->pages_printed = 0; /* ??? */
6430
6431 init_systemtime(&r->submitted, t);
6432
6433 return WERR_OK;
6434 }
6435
6436 /****************************************************************************
6437 fill_job_info2
6438 ****************************************************************************/
6439
6440 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6441 struct spoolss_JobInfo2 *r,
6442 const print_queue_struct *queue,
6443 int position, int snum,
6444 const NT_PRINTER_INFO_LEVEL *ntprinter,
6445 struct spoolss_DeviceMode *devmode)
6446 {
6447 struct tm *t;
6448
6449 t = gmtime(&queue->time);
6450
6451 r->job_id = queue->job;
6452
6453 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6454 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6455 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6456 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6457 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6458 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6459 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6460 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6461 r->notify_name = talloc_strdup(mem_ctx, queue->fs_user);
6462 W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6463 r->data_type = talloc_strdup(mem_ctx, "RAW");
6464 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6465 r->print_processor = talloc_strdup(mem_ctx, "winprint");
6466 W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6467 r->parameters = talloc_strdup(mem_ctx, "");
6468 W_ERROR_HAVE_NO_MEMORY(r->parameters);
6469 r->driver_name = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6470 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6471
6472 r->devmode = devmode;
6473
6474 r->text_status = talloc_strdup(mem_ctx, "");
6475 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6476
6477 r->secdesc = NULL;
6478
6479 r->status = nt_printj_status(queue->status);
6480 r->priority = queue->priority;
6481 r->position = position;
6482 r->start_time = 0;
6483 r->until_time = 0;
6484 r->total_pages = queue->page_count;
6485 r->size = queue->size;
6486 init_systemtime(&r->submitted, t);
6487 r->time = 0;
6488 r->pages_printed = 0; /* ??? */
6489
6490 return WERR_OK;
6491 }
6492
6493 /****************************************************************************
6494 Enumjobs at level 1.
6495 ****************************************************************************/
6496
6497 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6498 const print_queue_struct *queue,
6499 uint32_t num_queues, int snum,
6500 const NT_PRINTER_INFO_LEVEL *ntprinter,
6501 union spoolss_JobInfo **info_p,
6502 uint32_t *count)
6503 {
6504 union spoolss_JobInfo *info;
6505 int i;
6506 WERROR result = WERR_OK;
6507
6508 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6509 W_ERROR_HAVE_NO_MEMORY(info);
6510
6511 *count = num_queues;
6512
6513 for (i=0; i<*count; i++) {
6514 result = fill_job_info1(info,
6515 &info[i].info1,
6516 &queue[i],
6517 i,
6518 snum,
6519 ntprinter);
6520 if (!W_ERROR_IS_OK(result)) {
6521 goto out;
6522 }
6523 }
6524
6525 out:
6526 if (!W_ERROR_IS_OK(result)) {
6527 TALLOC_FREE(info);
6528 *count = 0;
6529 return result;
6530 }
6531
6532 *info_p = info;
6533
6534 return WERR_OK;
6535 }
6536
6537 /****************************************************************************
6538 Enumjobs at level 2.
6539 ****************************************************************************/
6540
6541 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6542 const print_queue_struct *queue,
6543 uint32_t num_queues, int snum,
6544 const NT_PRINTER_INFO_LEVEL *ntprinter,
6545 union spoolss_JobInfo **info_p,
6546 uint32_t *count)
6547 {
6548 union spoolss_JobInfo *info;
6549 int i;
6550 WERROR result = WERR_OK;
6551
6552 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6553 W_ERROR_HAVE_NO_MEMORY(info);
6554
6555 *count = num_queues;
6556
6557 for (i=0; i<*count; i++) {
6558
6559 struct spoolss_DeviceMode *devmode;
6560
6561 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6562 if (!devmode) {
6563 result = WERR_NOMEM;
6564 goto out;
6565 }
6566
6567 result = fill_job_info2(info,
6568 &info[i].info2,
6569 &queue[i],
6570 i,
6571 snum,
6572 ntprinter,
6573 devmode);
6574 if (!W_ERROR_IS_OK(result)) {
6575 goto out;
6576 }
6577 }
6578
6579 out:
6580 if (!W_ERROR_IS_OK(result)) {
6581 TALLOC_FREE(info);
6582 *count = 0;
6583 return result;
6584 }
6585
6586 *info_p = info;
6587
6588 return WERR_OK;
6589 }
6590
6591 /****************************************************************
6592 _spoolss_EnumJobs
6593 ****************************************************************/
6594
6595 WERROR _spoolss_EnumJobs(pipes_struct *p,
6596 struct spoolss_EnumJobs *r)
6597 {
6598 WERROR result;
6599 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6600 int snum;
6601 print_status_struct prt_status;
6602 print_queue_struct *queue = NULL;
6603 uint32_t count;
6604
6605 /* that's an [in out] buffer */
6606
6607 if (!r->in.buffer && (r->in.offered != 0)) {
6608 return WERR_INVALID_PARAM;
6609 }
6610
6611 DEBUG(4,("_spoolss_EnumJobs\n"));
6612
6613 *r->out.needed = 0;
6614 *r->out.count = 0;
6615 *r->out.info = NULL;
6616
6617 /* lookup the printer snum and tdb entry */
6618
6619 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6620 return WERR_BADFID;
6621 }
6622
6623 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6624 if (!W_ERROR_IS_OK(result)) {
6625 return result;
6626 }
6627
6628 count = print_queue_status(snum, &queue, &prt_status);
6629 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6630 count, prt_status.status, prt_status.message));
6631
6632 if (count == 0) {
6633 SAFE_FREE(queue);
6634 free_a_printer(&ntprinter, 2);
6635 return WERR_OK;
6636 }
6637
6638 switch (r->in.level) {
6639 case 1:
6640 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6641 ntprinter, r->out.info, r->out.count);
6642 break;
6643 case 2:
6644 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6645 ntprinter, r->out.info, r->out.count);
6646 break;
6647 default:
6648 result = WERR_UNKNOWN_LEVEL;
6649 break;
6650 }
6651
6652 SAFE_FREE(queue);
6653 free_a_printer(&ntprinter, 2);
6654
6655 if (!W_ERROR_IS_OK(result)) {
6656 return result;
6657 }
6658
6659 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6660 spoolss_EnumJobs, NULL,
6661 *r->out.info, r->in.level,
6662 *r->out.count);
6663 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6664 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6665
6666 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6667 }
6668
6669 /****************************************************************
6670 _spoolss_ScheduleJob
6671 ****************************************************************/
6672
6673 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6674 struct spoolss_ScheduleJob *r)
6675 {
6676 return WERR_OK;
6677 }
6678
6679 /****************************************************************
6680 _spoolss_SetJob
6681 ****************************************************************/
6682
6683 WERROR _spoolss_SetJob(pipes_struct *p,
6684 struct spoolss_SetJob *r)
6685 {
6686 int snum;
6687 WERROR errcode = WERR_BADFUNC;
6688
6689 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6690 return WERR_BADFID;
6691 }
6692
6693 if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6694 return WERR_INVALID_PRINTER_NAME;
6695 }
6696
6697 switch (r->in.command) {
6698 case SPOOLSS_JOB_CONTROL_CANCEL:
6699 case SPOOLSS_JOB_CONTROL_DELETE:
6700 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6701 errcode = WERR_OK;
6702 }
6703 break;
6704 case SPOOLSS_JOB_CONTROL_PAUSE:
6705 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6706 errcode = WERR_OK;
6707 }
6708 break;
6709 case SPOOLSS_JOB_CONTROL_RESTART:
6710 case SPOOLSS_JOB_CONTROL_RESUME:
6711 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6712 errcode = WERR_OK;
6713 }
6714 break;
6715 default:
6716 return WERR_UNKNOWN_LEVEL;
6717 }
6718
6719 return errcode;
6720 }
6721
6722 /****************************************************************************
6723 Enumerates all printer drivers by level.
6724 ****************************************************************************/
6725
6726 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6727 const char *servername,
6728 const char *architecture,
6729 uint32_t level,
6730 union spoolss_DriverInfo **info_p,
6731 uint32_t *count_p)
6732 {
6733 int i;
6734 int ndrivers;
6735 uint32_t version;
6736 fstring *list = NULL;
6737 NT_PRINTER_DRIVER_INFO_LEVEL driver;
6738 union spoolss_DriverInfo *info = NULL;
6739 uint32_t count = 0;
6740 WERROR result = WERR_OK;
6741
6742 *count_p = 0;
6743 *info_p = NULL;
6744
6745 for (version=0; version<DRIVER_MAX_VERSION; version++) {
6746 list = NULL;
6747 ndrivers = get_ntdrivers(&list, architecture, version);
6748 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6749 ndrivers, architecture, version));
6750
6751 if (ndrivers == -1) {
6752 result = WERR_NOMEM;
6753 goto out;
6754 }
6755
6756 if (ndrivers != 0) {
6757 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6758 union spoolss_DriverInfo,
6759 count + ndrivers);
6760 if (!info) {
6761 DEBUG(0,("enumprinterdrivers_level1: "
6762 "failed to enlarge driver info buffer!\n"));
6763 result = WERR_NOMEM;
6764 goto out;
6765 }
6766 }
6767
6768 for (i=0; i<ndrivers; i++) {
6769 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6770 ZERO_STRUCT(driver);
6771 result = get_a_printer_driver(&driver, 3, list[i],
6772 architecture, version);
6773 if (!W_ERROR_IS_OK(result)) {
6774 goto out;
6775 }
6776
6777 switch (level) {
6778 case 1:
6779 result = fill_printer_driver_info1(info, &info[count+i].info1,
6780 &driver, servername,
6781 architecture);
6782 break;
6783 case 2:
6784 result = fill_printer_driver_info2(info, &info[count+i].info2,
6785 &driver, servername);
6786 break;
6787 case 3:
6788 result = fill_printer_driver_info3(info, &info[count+i].info3,
6789 &driver, servername);
6790 break;
6791 case 4:
6792 result = fill_printer_driver_info4(info, &info[count+i].info4,
6793 &driver, servername);
6794 break;
6795 case 5:
6796 result = fill_printer_driver_info5(info, &info[count+i].info5,
6797 &driver, servername);
6798 break;
6799 case 6:
6800 result = fill_printer_driver_info6(info, &info[count+i].info6,
6801 &driver, servername);
6802 break;
6803 default:
6804 result = WERR_UNKNOWN_LEVEL;
6805 break;
6806 }
6807
6808 if (!W_ERROR_IS_OK(result)) {
6809 free_a_printer_driver(driver, 3);
6810 goto out;
6811 }
6812 free_a_printer_driver(driver, 3);
6813 }
6814
6815 count += ndrivers;
6816 SAFE_FREE(list);
6817 }
6818
6819 out:
6820 SAFE_FREE(list);
6821
6822 if (!W_ERROR_IS_OK(result)) {
6823 TALLOC_FREE(info);
6824 return result;
6825 }
6826
6827 *info_p = info;
6828 *count_p = count;
6829
6830 return WERR_OK;
6831 }
6832
6833 /****************************************************************************
6834 Enumerates all printer drivers at level 1.
6835 ****************************************************************************/
6836
6837 static WERROR enumprinterdrivers_level1(TALLOC_CTX *mem_ctx,
6838 const char *servername,
6839 const char *architecture,
6840 union spoolss_DriverInfo **info_p,
6841 uint32_t *count)
6842 {
6843 return enumprinterdrivers_level(mem_ctx, servername, architecture, 1,
6844 info_p, count);
6845 }
6846
6847 /****************************************************************************
6848 Enumerates all printer drivers at level 2.
6849 ****************************************************************************/
6850
6851 static WERROR enumprinterdrivers_level2(TALLOC_CTX *mem_ctx,
6852 const char *servername,
6853 const char *architecture,
6854 union spoolss_DriverInfo **info_p,
6855 uint32_t *count)
6856 {
6857 return enumprinterdrivers_level(mem_ctx, servername, architecture, 2,
6858 info_p, count);
6859 }
6860
6861 /****************************************************************************
6862 Enumerates all printer drivers at level 3.
6863 ****************************************************************************/
6864
6865 static WERROR enumprinterdrivers_level3(TALLOC_CTX *mem_ctx,
6866 const char *servername,
6867 const char *architecture,
6868 union spoolss_DriverInfo **info_p,
6869 uint32_t *count)
6870 {
6871 return enumprinterdrivers_level(mem_ctx, servername, architecture, 3,
6872 info_p, count);
6873 }
6874
6875 /****************************************************************************
6876 Enumerates all printer drivers at level 4.
6877 ****************************************************************************/
6878
6879 static WERROR enumprinterdrivers_level4(TALLOC_CTX *mem_ctx,
6880 const char *servername,
6881 const char *architecture,
6882 union spoolss_DriverInfo **info_p,
6883 uint32_t *count)
6884 {
6885 return enumprinterdrivers_level(mem_ctx, servername, architecture, 4,
6886 info_p, count);
6887 }
6888
6889 /****************************************************************************
6890 Enumerates all printer drivers at level 5.
6891 ****************************************************************************/
6892
6893 static WERROR enumprinterdrivers_level5(TALLOC_CTX *mem_ctx,
6894 const char *servername,
6895 const char *architecture,
6896 union spoolss_DriverInfo **info_p,
6897 uint32_t *count)
6898 {
6899 return enumprinterdrivers_level(mem_ctx, servername, architecture, 5,
6900 info_p, count);
6901 }
6902
6903 /****************************************************************************
6904 Enumerates all printer drivers at level 6.
6905 ****************************************************************************/
6906
6907 static WERROR enumprinterdrivers_level6(TALLOC_CTX *mem_ctx,
6908 const char *servername,
6909 const char *architecture,
6910 union spoolss_DriverInfo **info_p,
6911 uint32_t *count)
6912 {
6913 return enumprinterdrivers_level(mem_ctx, servername, architecture, 6,
6914 info_p, count);
6915 }
6916
6917
6918 /****************************************************************
6919 _spoolss_EnumPrinterDrivers
6920 ****************************************************************/
6921
6922 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6923 struct spoolss_EnumPrinterDrivers *r)
6924 {
6925 const char *cservername;
6926 WERROR result;
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_EnumPrinterDrivers\n"));
6935
6936 *r->out.needed = 0;
6937 *r->out.count = 0;
6938 *r->out.info = NULL;
6939
6940 cservername = canon_servername(r->in.server);
6941
6942 if (!is_myname_or_ipaddr(cservername)) {
6943 return WERR_UNKNOWN_PRINTER_DRIVER;
6944 }
6945
6946 switch (r->in.level) {
6947 case 1:
6948 result = enumprinterdrivers_level1(p->mem_ctx, cservername,
6949 r->in.environment,
6950 r->out.info, r->out.count);
6951 break;
6952 case 2:
6953 result = enumprinterdrivers_level2(p->mem_ctx, cservername,
6954 r->in.environment,
6955 r->out.info, r->out.count);
6956 break;
6957 case 3:
6958 result = enumprinterdrivers_level3(p->mem_ctx, cservername,
6959 r->in.environment,
6960 r->out.info, r->out.count);
6961 break;
6962 case 4:
6963 result = enumprinterdrivers_level4(p->mem_ctx, cservername,
6964 r->in.environment,
6965 r->out.info, r->out.count);
6966 break;
6967 case 5:
6968 result = enumprinterdrivers_level5(p->mem_ctx, cservername,
6969 r->in.environment,
6970 r->out.info, r->out.count);
6971 break;
6972 case 6:
6973 result = enumprinterdrivers_level6(p->mem_ctx, cservername,
6974 r->in.environment,
6975 r->out.info, r->out.count);
6976 break;
6977 default:
6978 return WERR_UNKNOWN_LEVEL;
6979 }
6980
6981 if (!W_ERROR_IS_OK(result)) {
6982 return result;
6983 }
6984
6985 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6986 spoolss_EnumPrinterDrivers, NULL,
6987 *r->out.info, r->in.level,
6988 *r->out.count);
6989 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6990 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6991
6992 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6993 }
6994
6995 /****************************************************************************
6996 ****************************************************************************/
6997
6998 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
6999 struct spoolss_FormInfo1 *r,
7000 const nt_forms_struct *form)
7001 {
7002 r->form_name = talloc_strdup(mem_ctx, form->name);
7003 W_ERROR_HAVE_NO_MEMORY(r->form_name);
7004
7005 r->flags = form->flag;
7006 r->size.width = form->width;
7007 r->size.height = form->length;
7008 r->area.left = form->left;
7009 r->area.top = form->top;
7010 r->area.right = form->right;
7011 r->area.bottom = form->bottom;
7012
7013 return WERR_OK;
7014 }
7015
7016 /****************************************************************
7017 spoolss_enumforms_level1
7018 ****************************************************************/
7019
7020 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
7021 const nt_forms_struct *builtin_forms,
7022 uint32_t num_builtin_forms,
7023 const nt_forms_struct *user_forms,
7024 uint32_t num_user_forms,
7025 union spoolss_FormInfo **info_p,
7026 uint32_t *count)
7027 {
7028 union spoolss_FormInfo *info;
7029 WERROR result = WERR_OK;
7030 int i;
7031
7032 *count = num_builtin_forms + num_user_forms;
7033
7034 info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
7035 W_ERROR_HAVE_NO_MEMORY(info);
7036
7037 /* construct the list of form structures */
7038 for (i=0; i<num_builtin_forms; i++) {
7039 DEBUGADD(6,("Filling form number [%d]\n",i));
7040 result = fill_form_info_1(info, &info[i].info1,
7041 &builtin_forms[i]);
7042 if (!W_ERROR_IS_OK(result)) {
7043 goto out;
7044 }
7045 }
7046
7047 for (; i<num_user_forms; i++) {
7048 DEBUGADD(6,("Filling form number [%d]\n",i));
7049 result = fill_form_info_1(info, &info[i].info1,
7050 &user_forms[i-num_builtin_forms]);
7051 if (!W_ERROR_IS_OK(result)) {
7052 goto out;
7053 }
7054 }
7055
7056 out:
7057 if (!W_ERROR_IS_OK(result)) {
7058 TALLOC_FREE(info);
7059 *count = 0;
7060 return result;
7061 }
7062
7063 *info_p = info;
7064
7065 return WERR_OK;
7066 }
7067
7068 /****************************************************************
7069 _spoolss_EnumForms
7070 ****************************************************************/
7071
7072 WERROR _spoolss_EnumForms(pipes_struct *p,
7073 struct spoolss_EnumForms *r)
7074 {
7075 WERROR result;
7076 nt_forms_struct *user_forms = NULL;
7077 nt_forms_struct *builtin_forms = NULL;
7078 uint32_t num_user_forms;
7079 uint32_t num_builtin_forms;
7080
7081 *r->out.count = 0;
7082 *r->out.needed = 0;
7083 *r->out.info = NULL;
7084
7085 /* that's an [in out] buffer */
7086
7087 if (!r->in.buffer && (r->in.offered != 0) ) {
7088 return WERR_INVALID_PARAM;
7089 }
7090
7091 DEBUG(4,("_spoolss_EnumForms\n"));
7092 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7093 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7094
7095 num_builtin_forms = get_builtin_ntforms(&builtin_forms);
7096 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
7097 num_user_forms = get_ntforms(&user_forms);
7098 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
7099
7100 if (num_user_forms + num_builtin_forms == 0) {
7101 SAFE_FREE(builtin_forms);
7102 SAFE_FREE(user_forms);
7103 return WERR_NO_MORE_ITEMS;
7104 }
7105
7106 switch (r->in.level) {
7107 case 1:
7108 result = spoolss_enumforms_level1(p->mem_ctx,
7109 builtin_forms,
7110 num_builtin_forms,
7111 user_forms,
7112 num_user_forms,
7113 r->out.info,
7114 r->out.count);
7115 break;
7116 default:
7117 result = WERR_UNKNOWN_LEVEL;
7118 break;
7119 }
7120
7121 SAFE_FREE(user_forms);
7122 SAFE_FREE(builtin_forms);
7123
7124 if (!W_ERROR_IS_OK(result)) {
7125 return result;
7126 }
7127
7128 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7129 spoolss_EnumForms, NULL,
7130 *r->out.info, r->in.level,
7131 *r->out.count);
7132 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7133 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7134
7135 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7136 }
7137
7138 /****************************************************************
7139 ****************************************************************/
7140
7141 static WERROR find_form_byname(const char *name,
7142 nt_forms_struct *form)
7143 {
7144 nt_forms_struct *list = NULL;
7145 int num_forms = 0, i = 0;
7146
7147 if (get_a_builtin_ntform_by_string(name, form)) {
7148 return WERR_OK;
7149 }
7150
7151 num_forms = get_ntforms(&list);
7152 DEBUGADD(5,("Number of forms [%d]\n", num_forms));
7153
7154 if (num_forms == 0) {
7155 return WERR_BADFID;
7156 }
7157
7158 /* Check if the requested name is in the list of form structures */
7159 for (i = 0; i < num_forms; i++) {
7160
7161 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
7162
7163 if (strequal(name, list[i].name)) {
7164 DEBUGADD(6,("Found form %s number [%d]\n", name, i));
7165 *form = list[i];
7166 SAFE_FREE(list);
7167 return WERR_OK;
7168 }
7169 }
7170
7171 SAFE_FREE(list);
7172
7173 return WERR_BADFID;
7174 }
7175
7176 /****************************************************************
7177 _spoolss_GetForm
7178 ****************************************************************/
7179
7180 WERROR _spoolss_GetForm(pipes_struct *p,
7181 struct spoolss_GetForm *r)
7182 {
7183 WERROR result;
7184 nt_forms_struct form;
7185
7186 /* that's an [in out] buffer */
7187
7188 if (!r->in.buffer && (r->in.offered != 0)) {
7189 return WERR_INVALID_PARAM;
7190 }
7191
7192 DEBUG(4,("_spoolss_GetForm\n"));
7193 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7194 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7195
7196 result = find_form_byname(r->in.form_name, &form);
7197 if (!W_ERROR_IS_OK(result)) {
7198 TALLOC_FREE(r->out.info);
7199 return result;
7200 }
7201
7202 switch (r->in.level) {
7203 case 1:
7204 result = fill_form_info_1(p->mem_ctx,
7205 &r->out.info->info1,
7206 &form);
7207 break;
7208
7209 default:
7210 result = WERR_UNKNOWN_LEVEL;
7211 break;
7212 }
7213
7214 if (!W_ERROR_IS_OK(result)) {
7215 TALLOC_FREE(r->out.info);
7216 return result;
7217 }
7218
7219 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
7220 r->out.info, r->in.level);
7221 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7222
7223 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7224 }
7225
7226 /****************************************************************************
7227 ****************************************************************************/
7228
7229 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7230 struct spoolss_PortInfo1 *r,
7231 const char *name)
7232 {
7233 r->port_name = talloc_strdup(mem_ctx, name);
7234 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7235
7236 return WERR_OK;
7237 }
7238
7239 /****************************************************************************
7240 TODO: This probably needs distinguish between TCP/IP and Local ports
7241 somehow.
7242 ****************************************************************************/
7243
7244 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7245 struct spoolss_PortInfo2 *r,
7246 const char *name)
7247 {
7248 r->port_name = talloc_strdup(mem_ctx, name);
7249 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7250
7251 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7252 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7253
7254 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7255 W_ERROR_HAVE_NO_MEMORY(r->description);
7256
7257 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7258 r->reserved = 0;
7259
7260 return WERR_OK;
7261 }
7262
7263
7264 /****************************************************************************
7265 wrapper around the enumer ports command
7266 ****************************************************************************/
7267
7268 WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines )
7269 {
7270 char *cmd = lp_enumports_cmd();
7271 char **qlines = NULL;
7272 char *command = NULL;
7273 int numlines;
7274 int ret;
7275 int fd;
7276
7277 *count = 0;
7278 *lines = NULL;
7279
7280 /* if no hook then just fill in the default port */
7281
7282 if ( !*cmd ) {
7283 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7284 return WERR_NOMEM;
7285 }
7286 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7287 TALLOC_FREE(qlines);
7288 return WERR_NOMEM;
7289 }
7290 qlines[1] = NULL;
7291 numlines = 1;
7292 }
7293 else {
7294 /* we have a valid enumport command */
7295
7296 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7297 if (!command) {
7298 return WERR_NOMEM;
7299 }
7300
7301 DEBUG(10,("Running [%s]\n", command));
7302 ret = smbrun(command, &fd);
7303 DEBUG(10,("Returned [%d]\n", ret));
7304 TALLOC_FREE(command);
7305 if (ret != 0) {
7306 if (fd != -1) {
7307 close(fd);
7308 }
7309 return WERR_ACCESS_DENIED;
7310 }
7311
7312 numlines = 0;
7313 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7314 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7315 close(fd);
7316 }
7317
7318 *count = numlines;
7319 *lines = qlines;
7320
7321 return WERR_OK;
7322 }
7323
7324 /****************************************************************************
7325 enumports level 1.
7326 ****************************************************************************/
7327
7328 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7329 union spoolss_PortInfo **info_p,
7330 uint32_t *count)
7331 {
7332 union spoolss_PortInfo *info = NULL;
7333 int i=0;
7334 WERROR result = WERR_OK;
7335 char **qlines = NULL;
7336 int numlines = 0;
7337
7338 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7339 if (!W_ERROR_IS_OK(result)) {
7340 goto out;
7341 }
7342
7343 if (numlines) {
7344 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7345 if (!info) {
7346 DEBUG(10,("Returning WERR_NOMEM\n"));
7347 result = WERR_NOMEM;
7348 goto out;
7349 }
7350
7351 for (i=0; i<numlines; i++) {
7352 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7353 result = fill_port_1(info, &info[i].info1, qlines[i]);
7354 if (!W_ERROR_IS_OK(result)) {
7355 goto out;
7356 }
7357 }
7358 }
7359 TALLOC_FREE(qlines);
7360
7361 out:
7362 if (!W_ERROR_IS_OK(result)) {
7363 TALLOC_FREE(info);
7364 TALLOC_FREE(qlines);
7365 *count = 0;
7366 *info_p = NULL;
7367 return result;
7368 }
7369
7370 *info_p = info;
7371 *count = numlines;
7372
7373 return WERR_OK;
7374 }
7375
7376 /****************************************************************************
7377 enumports level 2.
7378 ****************************************************************************/
7379
7380 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7381 union spoolss_PortInfo **info_p,
7382 uint32_t *count)
7383 {
7384 union spoolss_PortInfo *info = NULL;
7385 int i=0;
7386 WERROR result = WERR_OK;
7387 char **qlines = NULL;
7388 int numlines = 0;
7389
7390 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7391 if (!W_ERROR_IS_OK(result)) {
7392 goto out;
7393 }
7394
7395 if (numlines) {
7396 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7397 if (!info) {
7398 DEBUG(10,("Returning WERR_NOMEM\n"));
7399 result = WERR_NOMEM;
7400 goto out;
7401 }
7402
7403 for (i=0; i<numlines; i++) {
7404 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7405 result = fill_port_2(info, &info[i].info2, qlines[i]);
7406 if (!W_ERROR_IS_OK(result)) {
7407 goto out;
7408 }
7409 }
7410 }
7411 TALLOC_FREE(qlines);
7412
7413 out:
7414 if (!W_ERROR_IS_OK(result)) {
7415 TALLOC_FREE(info);
7416 TALLOC_FREE(qlines);
7417 *count = 0;
7418 *info_p = NULL;
7419 return result;
7420 }
7421
7422 *info_p = info;
7423 *count = numlines;
7424
7425 return WERR_OK;
7426 }
7427
7428 /****************************************************************
7429 _spoolss_EnumPorts
7430 ****************************************************************/
7431
7432 WERROR _spoolss_EnumPorts(pipes_struct *p,
7433 struct spoolss_EnumPorts *r)
7434 {
7435 WERROR result;
7436
7437 /* that's an [in out] buffer */
7438
7439 if (!r->in.buffer && (r->in.offered != 0)) {
7440 return WERR_INVALID_PARAM;
7441 }
7442
7443 DEBUG(4,("_spoolss_EnumPorts\n"));
7444
7445 *r->out.count = 0;
7446 *r->out.needed = 0;
7447 *r->out.info = NULL;
7448
7449 switch (r->in.level) {
7450 case 1:
7451 result = enumports_level_1(p->mem_ctx, r->out.info,
7452 r->out.count);
7453 break;
7454 case 2:
7455 result = enumports_level_2(p->mem_ctx, r->out.info,
7456 r->out.count);
7457 break;
7458 default:
7459 return WERR_UNKNOWN_LEVEL;
7460 }
7461
7462 if (!W_ERROR_IS_OK(result)) {
7463 return result;
7464 }
7465
7466 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7467 spoolss_EnumPorts, NULL,
7468 *r->out.info, r->in.level,
7469 *r->out.count);
7470 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7471 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7472
7473 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7474 }
7475
7476 /****************************************************************************
7477 ****************************************************************************/
7478
7479 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7480 const char *server,
7481 struct spoolss_SetPrinterInfoCtr *info_ctr,
7482 struct spoolss_DeviceMode *devmode,
7483 struct security_descriptor *sec_desc,
7484 struct spoolss_UserLevelCtr *user_ctr,
7485 struct policy_handle *handle)
7486 {
7487 NT_PRINTER_INFO_LEVEL *printer = NULL;
7488 fstring name;
7489 int snum;
7490 WERROR err = WERR_OK;
7491
7492 if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7493 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7494 return WERR_NOMEM;
7495 }
7496
7497 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7498 if (!convert_printer_info(info_ctr, printer)) {
7499 free_a_printer(&printer, 2);
7500 return WERR_NOMEM;
7501 }
7502
7503 /* check to see if the printer already exists */
7504
7505 if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7506 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7507 printer->info_2->sharename));
7508 free_a_printer(&printer, 2);
7509 return WERR_PRINTER_ALREADY_EXISTS;
7510 }
7511
7512 /* FIXME!!! smbd should check to see if the driver is installed before
7513 trying to add a printer like this --jerry */
7514
7515 if (*lp_addprinter_cmd() ) {
7516 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7517 printer) ) {
7518 free_a_printer(&printer,2);
7519 return WERR_ACCESS_DENIED;
7520 }
7521 } else {
7522 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7523 "smb.conf parameter \"addprinter command\" is defined. This"
7524 "parameter must exist for this call to succeed\n",
7525 printer->info_2->sharename ));
7526 }
7527
7528 /* use our primary netbios name since get_a_printer() will convert
7529 it to what the client expects on a case by case basis */
7530
7531 slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7532 printer->info_2->sharename);
7533
7534
7535 if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7536 free_a_printer(&printer,2);
7537 return WERR_ACCESS_DENIED;
7538 }
7539
7540 /* you must be a printer admin to add a new printer */
7541 if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
7542 free_a_printer(&printer,2);
7543 return WERR_ACCESS_DENIED;
7544 }
7545
7546 /*
7547 * Do sanity check on the requested changes for Samba.
7548 */
7549
7550 if (!check_printer_ok(printer->info_2, snum)) {
7551 free_a_printer(&printer,2);
7552 return WERR_INVALID_PARAM;
7553 }
7554
7555 /*
7556 * When a printer is created, the drivername bound to the printer is used
7557 * to lookup previously saved driver initialization info, which is then
7558 * bound to the new printer, simulating what happens in the Windows arch.
7559 */
7560
7561 if (!devmode)
7562 {
7563 set_driver_init(printer, 2);
7564 }
7565 else
7566 {
7567 /* A valid devmode was included, convert and link it
7568 */
7569 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7570
7571 if (!convert_devicemode(printer->info_2->printername, devmode,
7572 &printer->info_2->devmode)) {
7573 return WERR_NOMEM;
7574 }
7575 }
7576
7577 /* write the ASCII on disk */
7578 err = mod_a_printer(printer, 2);
7579 if (!W_ERROR_IS_OK(err)) {
7580 free_a_printer(&printer,2);
7581 return err;
7582 }
7583
7584 if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7585 /* Handle open failed - remove addition. */
7586 del_a_printer(printer->info_2->sharename);
7587 free_a_printer(&printer,2);
7588 ZERO_STRUCTP(handle);
7589 return WERR_ACCESS_DENIED;
7590 }
7591
7592 update_c_setprinter(false);
7593 free_a_printer(&printer,2);
7594
7595 return WERR_OK;
7596 }
7597
7598 /****************************************************************
7599 _spoolss_AddPrinterEx
7600 ****************************************************************/
7601
7602 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7603 struct spoolss_AddPrinterEx *r)
7604 {
7605 switch (r->in.info_ctr->level) {
7606 case 1:
7607 /* we don't handle yet */
7608 /* but I know what to do ... */
7609 return WERR_UNKNOWN_LEVEL;
7610 case 2:
7611 return spoolss_addprinterex_level_2(p, r->in.server,
7612 r->in.info_ctr,
7613 r->in.devmode_ctr->devmode,
7614 r->in.secdesc_ctr->sd,
7615 r->in.userlevel_ctr,
7616 r->out.handle);
7617 default:
7618 return WERR_UNKNOWN_LEVEL;
7619 }
7620 }
7621
7622 /****************************************************************
7623 _spoolss_AddPrinterDriver
7624 ****************************************************************/
7625
7626 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7627 struct spoolss_AddPrinterDriver *r)
7628 {
7629 uint32_t level = r->in.info_ctr->level;
7630 struct spoolss_AddDriverInfoCtr *info = r->in.info_ctr;
7631 WERROR err = WERR_OK;
7632 NT_PRINTER_DRIVER_INFO_LEVEL driver;
7633 const char *driver_name = NULL;
7634 uint32_t version;
7635 const char *fn;
7636
7637 switch (p->hdr_req.opnum) {
7638 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7639 fn = "_spoolss_AddPrinterDriver";
7640 break;
7641 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7642 fn = "_spoolss_AddPrinterDriverEx";
7643 break;
7644 default:
7645 return WERR_INVALID_PARAM;
7646 }
7647
7648
7649 /* FIXME */
7650 if (level != 3 && level != 6) {
7651 /* Clever hack from Martin Zielinski <mz@seh.de>
7652 * to allow downgrade from level 8 (Vista).
7653 */
7654 DEBUG(0,("%s: level %d not yet implemented\n", fn, level));
7655 return WERR_UNKNOWN_LEVEL;
7656 }
7657
7658 ZERO_STRUCT(driver);
7659
7660 if (!convert_printer_driver_info(info, &driver, level)) {
7661 err = WERR_NOMEM;
7662 goto done;
7663 }
7664
7665 DEBUG(5,("Cleaning driver's information\n"));
7666 err = clean_up_driver_struct(p, driver, level);
7667 if (!W_ERROR_IS_OK(err))
7668 goto done;
7669
7670 DEBUG(5,("Moving driver to final destination\n"));
7671 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, driver, level,
7672 &err)) ) {
7673 goto done;
7674 }
7675
7676 if (add_a_printer_driver(driver, level)!=0) {
7677 err = WERR_ACCESS_DENIED;
7678 goto done;
7679 }
7680
7681 switch(level) {
7682 case 3:
7683 driver_name = driver.info_3->name ? driver.info_3->name : "";
7684 break;
7685 case 6:
7686 driver_name = driver.info_6->name ? driver.info_6->name : "";
7687 break;
7688 }
7689
7690 /*
7691 * I think this is where he DrvUpgradePrinter() hook would be
7692 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7693 * server. Right now, we just need to send ourselves a message
7694 * to update each printer bound to this driver. --jerry
7695 */
7696
7697 if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7698 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7699 fn, driver_name));
7700 }
7701
7702 /*
7703 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7704 * decide if the driver init data should be deleted. The rules are:
7705 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7706 * 2) delete init data only if there is no 2k/Xp driver
7707 * 3) always delete init data
7708 * The generalized rule is always use init data from the highest order driver.
7709 * It is necessary to follow the driver install by an initialization step to
7710 * finish off this process.
7711 */
7712 if (level == 3)
7713 version = driver.info_3->cversion;
7714 else if (level == 6)
7715 version = driver.info_6->version;
7716 else
7717 version = -1;
7718 switch (version) {
7719 /*
7720 * 9x printer driver - never delete init data
7721 */
7722 case 0:
7723 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7724 fn, driver_name));
7725 break;
7726
7727 /*
7728 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7729 * there is no 2k/Xp driver init data for this driver name.
7730 */
7731 case 2:
7732 {
7733 NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7734
7735 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7736 /*
7737 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7738 */
7739 if (!del_driver_init(driver_name))
7740 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7741 fn, driver_name));
7742 } else {
7743 /*
7744 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7745 */
7746 free_a_printer_driver(driver1,3);
7747 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7748 fn, driver_name));
7749 }
7750 }
7751 break;
7752
7753 /*
7754 * 2k or Xp printer driver - always delete init data
7755 */
7756 case 3:
7757 if (!del_driver_init(driver_name))
7758 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7759 fn, driver_name));
7760 break;
7761
7762 default:
7763 DEBUG(0,("%s: invalid level=%d\n", fn, level));
7764 break;
7765 }
7766
7767
7768 done:
7769 free_a_printer_driver(driver, level);
7770 return err;
7771 }
7772
7773 /****************************************************************
7774 _spoolss_AddPrinterDriverEx
7775 ****************************************************************/
7776
7777 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7778 struct spoolss_AddPrinterDriverEx *r)
7779 {
7780 struct spoolss_AddPrinterDriver a;
7781
7782 /*
7783 * we only support the semantics of AddPrinterDriver()
7784 * i.e. only copy files that are newer than existing ones
7785 */
7786
7787 if (r->in.flags != APD_COPY_NEW_FILES) {
7788 return WERR_ACCESS_DENIED;
7789 }
7790
7791 a.in.servername = r->in.servername;
7792 a.in.info_ctr = r->in.info_ctr;
7793
7794 return _spoolss_AddPrinterDriver(p, &a);
7795 }
7796
7797 /****************************************************************************
7798 ****************************************************************************/
7799
7800 struct _spoolss_paths {
7801 int type;
7802 const char *share;
7803 const char *dir;
7804 };
7805
7806 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7807
7808 static const struct _spoolss_paths spoolss_paths[]= {
7809 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
7810 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
7811 };
7812
7813 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7814 const char *servername,
7815 const char *environment,
7816 int component,
7817 char **path)
7818 {
7819 const char *pservername = NULL;
7820 const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7821 const char *short_archi;
7822
7823 *path = NULL;
7824
7825 /* environment may be empty */
7826 if (environment && strlen(environment)) {
7827 long_archi = environment;
7828 }
7829
7830 /* servername may be empty */
7831 if (servername && strlen(servername)) {
7832 pservername = canon_servername(servername);
7833
7834 if (!is_myname_or_ipaddr(pservername)) {
7835 return WERR_INVALID_PARAM;
7836 }
7837 }
7838
7839 if (!(short_archi = get_short_archi(long_archi))) {
7840 return WERR_INVALID_ENVIRONMENT;
7841 }
7842
7843 switch (component) {
7844 case SPOOLSS_PRTPROCS_PATH:
7845 case SPOOLSS_DRIVER_PATH:
7846 if (pservername) {
7847 *path = talloc_asprintf(mem_ctx,
7848 "\\\\%s\\%s\\%s",
7849 pservername,
7850 spoolss_paths[component].share,
7851 short_archi);
7852 } else {
7853 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7854 SPOOLSS_DEFAULT_SERVER_PATH,
7855 spoolss_paths[component].dir,
7856 short_archi);
7857 }
7858 break;
7859 default:
7860 return WERR_INVALID_PARAM;
7861 }
7862
7863 if (!*path) {
7864 return WERR_NOMEM;
7865 }
7866
7867 return WERR_OK;
7868 }
7869
7870 /****************************************************************************
7871 ****************************************************************************/
7872
7873 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7874 const char *servername,
7875 const char *environment,
7876 struct spoolss_DriverDirectoryInfo1 *r)
7877 {
7878 WERROR werr;
7879 char *path = NULL;
7880
7881 werr = compose_spoolss_server_path(mem_ctx,
7882 servername,
7883 environment,
7884 SPOOLSS_DRIVER_PATH,
7885 &path);
7886 if (!W_ERROR_IS_OK(werr)) {
7887 return werr;
7888 }
7889
7890 DEBUG(4,("printer driver directory: [%s]\n", path));
7891
7892 r->directory_name = path;
7893
7894 return WERR_OK;
7895 }
7896
7897 /****************************************************************
7898 _spoolss_GetPrinterDriverDirectory
7899 ****************************************************************/
7900
7901 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7902 struct spoolss_GetPrinterDriverDirectory *r)
7903 {
7904 WERROR werror;
7905
7906 /* that's an [in out] buffer */
7907
7908 if (!r->in.buffer && (r->in.offered != 0)) {
7909 return WERR_INVALID_PARAM;
7910 }
7911
7912 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7913 r->in.level));
7914
7915 *r->out.needed = 0;
7916
7917 /* r->in.level is ignored */
7918
7919 werror = getprinterdriverdir_level_1(p->mem_ctx,
7920 r->in.server,
7921 r->in.environment,
7922 &r->out.info->info1);
7923 if (!W_ERROR_IS_OK(werror)) {
7924 TALLOC_FREE(r->out.info);
7925 return werror;
7926 }
7927
7928 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
7929 r->out.info, r->in.level);
7930 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7931
7932 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7933 }
7934
7935 /****************************************************************
7936 _spoolss_EnumPrinterData
7937 ****************************************************************/
7938
7939 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
7940 struct spoolss_EnumPrinterData *r)
7941 {
7942 NT_PRINTER_INFO_LEVEL *printer = NULL;
7943 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7944 int snum;
7945 WERROR result;
7946 REGISTRY_VALUE *val = NULL;
7947 NT_PRINTER_DATA *p_data;
7948 int i, key_index, num_values;
7949 int name_length;
7950
7951 *r->out.value_needed = 0;
7952 *r->out.type = REG_NONE;
7953 *r->out.data_needed = 0;
7954
7955 DEBUG(5,("_spoolss_EnumPrinterData\n"));
7956
7957 if (!Printer) {
7958 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
7959 OUR_HANDLE(r->in.handle)));
7960 return WERR_BADFID;
7961 }
7962
7963 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7964 return WERR_BADFID;
7965 }
7966
7967 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7968 if (!W_ERROR_IS_OK(result)) {
7969 return result;
7970 }
7971
7972 p_data = printer->info_2->data;
7973 key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
7974
7975 result = WERR_OK;
7976
7977 /*
7978 * The NT machine wants to know the biggest size of value and data
7979 *
7980 * cf: MSDN EnumPrinterData remark section
7981 */
7982
7983 if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
7984
7985 uint32_t biggest_valuesize = 0;
7986 uint32_t biggest_datasize = 0;
7987
7988 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7989
7990 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
7991
7992 for ( i=0; i<num_values; i++ )
7993 {
7994 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
7995
7996 name_length = strlen(val->valuename);
7997 if ( strlen(val->valuename) > biggest_valuesize )
7998 biggest_valuesize = name_length;
7999
8000 if ( val->size > biggest_datasize )
8001 biggest_datasize = val->size;
8002
8003 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8004 biggest_datasize));
8005 }
8006
8007 /* the value is an UNICODE string but real_value_size is the length
8008 in bytes including the trailing 0 */
8009
8010 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8011 *r->out.data_needed = biggest_datasize;
8012
8013 DEBUG(6,("final values: [%d], [%d]\n",
8014 *r->out.value_needed, *r->out.data_needed));
8015
8016 goto done;
8017 }
8018
8019 /*
8020 * the value len is wrong in NT sp3
8021 * that's the number of bytes not the number of unicode chars
8022 */
8023
8024 if (key_index != -1) {
8025 val = regval_ctr_specific_value(p_data->keys[key_index].values,
8026 r->in.enum_index);
8027 }
8028
8029 if (!val) {
8030
8031 /* out_value should default to "" or else NT4 has
8032 problems unmarshalling the response */
8033
8034 if (r->in.value_offered) {
8035 *r->out.value_needed = 1;
8036 r->out.value_name = talloc_strdup(r, "");
8037 if (!r->out.value_name) {
8038 result = WERR_NOMEM;
8039 goto done;
8040 }
8041 } else {
8042 r->out.value_name = NULL;
8043 *r->out.value_needed = 0;
8044 }
8045
8046 /* the data is counted in bytes */
8047
8048 *r->out.data_needed = r->in.data_offered;
8049
8050 result = WERR_NO_MORE_ITEMS;
8051 } else {
8052 /*
8053 * the value is:
8054 * - counted in bytes in the request
8055 * - counted in UNICODE chars in the max reply
8056 * - counted in bytes in the real size
8057 *
8058 * take a pause *before* coding not *during* coding
8059 */
8060
8061 /* name */
8062 if (r->in.value_offered) {
8063 r->out.value_name = talloc_strdup(r, regval_name(val));
8064 if (!r->out.value_name) {
8065 result = WERR_NOMEM;
8066 goto done;
8067 }
8068 *r->out.value_needed = strlen_m(regval_name(val));
8069 } else {
8070 r->out.value_name = NULL;
8071 *r->out.value_needed = 0;
8072 }
8073
8074 /* type */
8075
8076 *r->out.type = regval_type(val);
8077
8078 /* data - counted in bytes */
8079
8080 if (r->out.data && regval_size(val)) {
8081 memcpy(r->out.data, regval_data_p(val), regval_size(val));
8082 }
8083
8084 *r->out.data_needed = regval_size(val);
8085 }
8086
8087 done:
8088 free_a_printer(&printer, 2);
8089 return result;
8090 }
8091
8092 /****************************************************************
8093 _spoolss_SetPrinterData
8094 ****************************************************************/
8095
8096 WERROR _spoolss_SetPrinterData(pipes_struct *p,
8097 struct spoolss_SetPrinterData *r)
8098 {
8099 NT_PRINTER_INFO_LEVEL *printer = NULL;
8100 int snum=0;
8101 WERROR result = WERR_OK;
8102 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8103 DATA_BLOB blob;
8104
8105 DEBUG(5,("_spoolss_SetPrinterData\n"));
8106
8107 if (!Printer) {
8108 DEBUG(2,("_spoolss_SetPrinterData: Invalid handle (%s:%u:%u).\n",
8109 OUR_HANDLE(r->in.handle)));
8110 return WERR_BADFID;
8111 }
8112
8113 if (Printer->printer_type == SPLHND_SERVER) {
8114 DEBUG(10,("_spoolss_SetPrinterData: "
8115 "Not implemented for server handles yet\n"));
8116 return WERR_INVALID_PARAM;
8117 }
8118
8119 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8120 return WERR_BADFID;
8121 }
8122
8123 /*
8124 * Access check : NT returns "access denied" if you make a
8125 * SetPrinterData call without the necessary privildge.
8126 * we were originally returning OK if nothing changed
8127 * which made Win2k issue **a lot** of SetPrinterData
8128 * when connecting to a printer --jerry
8129 */
8130
8131 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8132 DEBUG(3,("_spoolss_SetPrinterData: "
8133 "change denied by handle access permissions\n"));
8134 result = WERR_ACCESS_DENIED;
8135 goto done;
8136 }
8137
8138 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8139 if (!W_ERROR_IS_OK(result)) {
8140 return result;
8141 }
8142
8143 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8144 r->in.type, &r->in.data);
8145 if (!W_ERROR_IS_OK(result)) {
8146 goto done;
8147 }
8148
8149 /*
8150 * When client side code sets a magic printer data key, detect it and save
8151 * the current printer data and the magic key's data (its the DEVMODE) for
8152 * future printer/driver initializations.
8153 */
8154 if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8155 /* Set devmode and printer initialization info */
8156 result = save_driver_init(printer, 2, blob.data, blob.length);
8157
8158 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8159
8160 goto done;
8161 }
8162
8163 result = set_printer_dataex(printer, SPOOL_PRINTERDATA_KEY,
8164 r->in.value_name, r->in.type,
8165 blob.data, blob.length);
8166 if (W_ERROR_IS_OK(result)) {
8167 result = mod_a_printer(printer, 2);
8168 }
8169
8170 done:
8171 free_a_printer(&printer, 2);
8172
8173 return result;
8174 }
8175
8176 /****************************************************************
8177 _spoolss_ResetPrinter
8178 ****************************************************************/
8179
8180 WERROR _spoolss_ResetPrinter(pipes_struct *p,
8181 struct spoolss_ResetPrinter *r)
8182 {
8183 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8184 int snum;
8185
8186 DEBUG(5,("_spoolss_ResetPrinter\n"));
8187
8188 /*
8189 * All we do is to check to see if the handle and queue is valid.
8190 * This call really doesn't mean anything to us because we only
8191 * support RAW printing. --jerry
8192 */
8193
8194 if (!Printer) {
8195 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8196 OUR_HANDLE(r->in.handle)));
8197 return WERR_BADFID;
8198 }
8199
8200 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8201 return WERR_BADFID;
8202
8203
8204 /* blindly return success */
8205 return WERR_OK;
8206 }
8207
8208 /****************************************************************
8209 _spoolss_DeletePrinterData
8210 ****************************************************************/
8211
8212 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
8213 struct spoolss_DeletePrinterData *r)
8214 {
8215 NT_PRINTER_INFO_LEVEL *printer = NULL;
8216 int snum=0;
8217 WERROR status = WERR_OK;
8218 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8219
8220 DEBUG(5,("_spoolss_DeletePrinterData\n"));
8221
8222 if (!Printer) {
8223 DEBUG(2,("_spoolss_DeletePrinterData: Invalid handle (%s:%u:%u).\n",
8224 OUR_HANDLE(r->in.handle)));
8225 return WERR_BADFID;
8226 }
8227
8228 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8229 return WERR_BADFID;
8230
8231 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8232 DEBUG(3, ("_spoolss_DeletePrinterData: "
8233 "printer properties change denied by handle\n"));
8234 return WERR_ACCESS_DENIED;
8235 }
8236
8237 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8238 if (!W_ERROR_IS_OK(status))
8239 return status;
8240
8241 if (!r->in.value_name) {
8242 free_a_printer(&printer, 2);
8243 return WERR_NOMEM;
8244 }
8245
8246 status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY,
8247 r->in.value_name );
8248
8249 if ( W_ERROR_IS_OK(status) )
8250 mod_a_printer( printer, 2 );
8251
8252 free_a_printer(&printer, 2);
8253
8254 return status;
8255 }
8256
8257 /****************************************************************
8258 _spoolss_AddForm
8259 ****************************************************************/
8260
8261 WERROR _spoolss_AddForm(pipes_struct *p,
8262 struct spoolss_AddForm *r)
8263 {
8264 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8265 nt_forms_struct tmpForm;
8266 int snum = -1;
8267 WERROR status = WERR_OK;
8268 NT_PRINTER_INFO_LEVEL *printer = NULL;
8269 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8270
8271 int count=0;
8272 nt_forms_struct *list=NULL;
8273 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8274
8275 DEBUG(5,("_spoolss_AddForm\n"));
8276
8277 if (!Printer) {
8278 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8279 OUR_HANDLE(r->in.handle)));
8280 return WERR_BADFID;
8281 }
8282
8283
8284 /* forms can be added on printer of on the print server handle */
8285
8286 if ( Printer->printer_type == SPLHND_PRINTER )
8287 {
8288 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8289 return WERR_BADFID;
8290
8291 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8292 if (!W_ERROR_IS_OK(status))
8293 goto done;
8294 }
8295
8296 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8297 and not a printer admin, then fail */
8298
8299 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8300 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8301 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8302 NULL, NULL,
8303 p->server_info->ptok,
8304 lp_printer_admin(snum))) {
8305 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8306 return WERR_ACCESS_DENIED;
8307 }
8308
8309 /* can't add if builtin */
8310
8311 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8312 status = WERR_FILE_EXISTS;
8313 goto done;
8314 }
8315
8316 count = get_ntforms(&list);
8317
8318 if(!add_a_form(&list, form, &count)) {
8319 status = WERR_NOMEM;
8320 goto done;
8321 }
8322
8323 become_root();
8324 write_ntforms(&list, count);
8325 unbecome_root();
8326
8327 /*
8328 * ChangeID must always be set if this is a printer
8329 */
8330
8331 if ( Printer->printer_type == SPLHND_PRINTER )
8332 status = mod_a_printer(printer, 2);
8333
8334 done:
8335 if ( printer )
8336 free_a_printer(&printer, 2);
8337 SAFE_FREE(list);
8338
8339 return status;
8340 }
8341
8342 /****************************************************************
8343 _spoolss_DeleteForm
8344 ****************************************************************/
8345
8346 WERROR _spoolss_DeleteForm(pipes_struct *p,
8347 struct spoolss_DeleteForm *r)
8348 {
8349 const char *form_name = r->in.form_name;
8350 nt_forms_struct tmpForm;
8351 int count=0;
8352 nt_forms_struct *list=NULL;
8353 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8354 int snum = -1;
8355 WERROR status = WERR_OK;
8356 NT_PRINTER_INFO_LEVEL *printer = NULL;
8357 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8358 bool ret = false;
8359
8360 DEBUG(5,("_spoolss_DeleteForm\n"));
8361
8362 if (!Printer) {
8363 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8364 OUR_HANDLE(r->in.handle)));
8365 return WERR_BADFID;
8366 }
8367
8368 /* forms can be deleted on printer of on the print server handle */
8369
8370 if ( Printer->printer_type == SPLHND_PRINTER )
8371 {
8372 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8373 return WERR_BADFID;
8374
8375 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8376 if (!W_ERROR_IS_OK(status))
8377 goto done;
8378 }
8379
8380 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8381 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8382 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8383 NULL, NULL,
8384 p->server_info->ptok,
8385 lp_printer_admin(snum))) {
8386 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8387 return WERR_ACCESS_DENIED;
8388 }
8389
8390
8391 /* can't delete if builtin */
8392
8393 if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8394 status = WERR_INVALID_PARAM;
8395 goto done;
8396 }
8397
8398 count = get_ntforms(&list);
8399
8400 become_root();
8401 ret = delete_a_form(&list, form_name, &count, &status);
8402 unbecome_root();
8403 if (ret == false) {
8404 goto done;
8405 }
8406
8407 /*
8408 * ChangeID must always be set if this is a printer
8409 */
8410
8411 if ( Printer->printer_type == SPLHND_PRINTER )
8412 status = mod_a_printer(printer, 2);
8413
8414 done:
8415 if ( printer )
8416 free_a_printer(&printer, 2);
8417 SAFE_FREE(list);
8418
8419 return status;
8420 }
8421
8422 /****************************************************************
8423 _spoolss_SetForm
8424 ****************************************************************/
8425
8426 WERROR _spoolss_SetForm(pipes_struct *p,
8427 struct spoolss_SetForm *r)
8428 {
8429 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8430 nt_forms_struct tmpForm;
8431 int snum = -1;
8432 WERROR status = WERR_OK;
8433 NT_PRINTER_INFO_LEVEL *printer = NULL;
8434 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8435
8436 int count=0;
8437 nt_forms_struct *list=NULL;
8438 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8439
8440 DEBUG(5,("_spoolss_SetForm\n"));
8441
8442 if (!Printer) {
8443 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8444 OUR_HANDLE(r->in.handle)));
8445 return WERR_BADFID;
8446 }
8447
8448 /* forms can be modified on printer of on the print server handle */
8449
8450 if ( Printer->printer_type == SPLHND_PRINTER )
8451 {
8452 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8453 return WERR_BADFID;
8454
8455 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8456 if (!W_ERROR_IS_OK(status))
8457 goto done;
8458 }
8459
8460 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8461 and not a printer admin, then fail */
8462
8463 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8464 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8465 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8466 NULL, NULL,
8467 p->server_info->ptok,
8468 lp_printer_admin(snum))) {
8469 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8470 return WERR_ACCESS_DENIED;
8471 }
8472
8473 /* can't set if builtin */
8474 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8475 status = WERR_INVALID_PARAM;
8476 goto done;
8477 }
8478
8479 count = get_ntforms(&list);
8480 update_a_form(&list, form, count);
8481 become_root();
8482 write_ntforms(&list, count);
8483 unbecome_root();
8484
8485 /*
8486 * ChangeID must always be set if this is a printer
8487 */
8488
8489 if ( Printer->printer_type == SPLHND_PRINTER )
8490 status = mod_a_printer(printer, 2);
8491
8492
8493 done:
8494 if ( printer )
8495 free_a_printer(&printer, 2);
8496 SAFE_FREE(list);
8497
8498 return status;
8499 }
8500
8501 /****************************************************************************
8502 fill_print_processor1
8503 ****************************************************************************/
8504
8505 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8506 struct spoolss_PrintProcessorInfo1 *r,
8507 const char *print_processor_name)
8508 {
8509 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8510 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8511
8512 return WERR_OK;
8513 }
8514
8515 /****************************************************************************
8516 enumprintprocessors level 1.
8517 ****************************************************************************/
8518
8519 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8520 union spoolss_PrintProcessorInfo **info_p,
8521 uint32_t *count)
8522 {
8523 union spoolss_PrintProcessorInfo *info;
8524 WERROR result;
8525
8526 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8527 W_ERROR_HAVE_NO_MEMORY(info);
8528
8529 *count = 1;
8530
8531 result = fill_print_processor1(info, &info[0].info1, "winprint");
8532 if (!W_ERROR_IS_OK(result)) {
8533 goto out;
8534 }
8535
8536 out:
8537 if (!W_ERROR_IS_OK(result)) {
8538 TALLOC_FREE(info);
8539 *count = 0;
8540 return result;
8541 }
8542
8543 *info_p = info;
8544
8545 return WERR_OK;
8546 }
8547
8548 /****************************************************************
8549 _spoolss_EnumPrintProcessors
8550 ****************************************************************/
8551
8552 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8553 struct spoolss_EnumPrintProcessors *r)
8554 {
8555 WERROR result;
8556
8557 /* that's an [in out] buffer */
8558
8559 if (!r->in.buffer && (r->in.offered != 0)) {
8560 return WERR_INVALID_PARAM;
8561 }
8562
8563 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8564
8565 /*
8566 * Enumerate the print processors ...
8567 *
8568 * Just reply with "winprint", to keep NT happy
8569 * and I can use my nice printer checker.
8570 */
8571
8572 *r->out.count = 0;
8573 *r->out.needed = 0;
8574 *r->out.info = NULL;
8575
8576 switch (r->in.level) {
8577 case 1:
8578 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8579 r->out.count);
8580 break;
8581 default:
8582 return WERR_UNKNOWN_LEVEL;
8583 }
8584
8585 if (!W_ERROR_IS_OK(result)) {
8586 return result;
8587 }
8588
8589 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8590 spoolss_EnumPrintProcessors, NULL,
8591 *r->out.info, r->in.level,
8592 *r->out.count);
8593 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8594 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8595
8596 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8597 }
8598
8599 /****************************************************************************
8600 fill_printprocdatatype1
8601 ****************************************************************************/
8602
8603 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8604 struct spoolss_PrintProcDataTypesInfo1 *r,
8605 const char *name_array)
8606 {
8607 r->name_array = talloc_strdup(mem_ctx, name_array);
8608 W_ERROR_HAVE_NO_MEMORY(r->name_array);
8609
8610 return WERR_OK;
8611 }
8612
8613 /****************************************************************************
8614 enumprintprocdatatypes level 1.
8615 ****************************************************************************/
8616
8617 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8618 union spoolss_PrintProcDataTypesInfo **info_p,
8619 uint32_t *count)
8620 {
8621 WERROR result;
8622 union spoolss_PrintProcDataTypesInfo *info;
8623
8624 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8625 W_ERROR_HAVE_NO_MEMORY(info);
8626
8627 *count = 1;
8628
8629 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8630 if (!W_ERROR_IS_OK(result)) {
8631 goto out;
8632 }
8633
8634 out:
8635 if (!W_ERROR_IS_OK(result)) {
8636 TALLOC_FREE(info);
8637 *count = 0;
8638 return result;
8639 }
8640
8641 *info_p = info;
8642
8643 return WERR_OK;
8644 }
8645
8646 /****************************************************************
8647 _spoolss_EnumPrintProcDataTypes
8648 ****************************************************************/
8649
8650 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8651 struct spoolss_EnumPrintProcDataTypes *r)
8652 {
8653 WERROR result;
8654
8655 /* that's an [in out] buffer */
8656
8657 if (!r->in.buffer && (r->in.offered != 0)) {
8658 return WERR_INVALID_PARAM;
8659 }
8660
8661 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8662
8663 *r->out.count = 0;
8664 *r->out.needed = 0;
8665 *r->out.info = NULL;
8666
8667 switch (r->in.level) {
8668 case 1:
8669 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8670 r->out.count);
8671 break;
8672 default:
8673 return WERR_UNKNOWN_LEVEL;
8674 }
8675
8676 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8677 spoolss_EnumPrintProcDataTypes, NULL,
8678 *r->out.info, r->in.level,
8679 *r->out.count);
8680 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8681 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8682
8683 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8684 }
8685
8686 /****************************************************************************
8687 fill_monitor_1
8688 ****************************************************************************/
8689
8690 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8691 struct spoolss_MonitorInfo1 *r,
8692 const char *monitor_name)
8693 {
8694 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8695 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8696
8697 return WERR_OK;
8698 }
8699
8700 /****************************************************************************
8701 fill_monitor_2
8702 ****************************************************************************/
8703
8704 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8705 struct spoolss_MonitorInfo2 *r,
8706 const char *monitor_name,
8707 const char *environment,
8708 const char *dll_name)
8709 {
8710 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8711 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8712 r->environment = talloc_strdup(mem_ctx, environment);
8713 W_ERROR_HAVE_NO_MEMORY(r->environment);
8714 r->dll_name = talloc_strdup(mem_ctx, dll_name);
8715 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8716
8717 return WERR_OK;
8718 }
8719
8720 /****************************************************************************
8721 enumprintmonitors level 1.
8722 ****************************************************************************/
8723
8724 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8725 union spoolss_MonitorInfo **info_p,
8726 uint32_t *count)
8727 {
8728 union spoolss_MonitorInfo *info;
8729 WERROR result = WERR_OK;
8730
8731 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8732 W_ERROR_HAVE_NO_MEMORY(info);
8733
8734 *count = 2;
8735
8736 result = fill_monitor_1(info, &info[0].info1,
8737 SPL_LOCAL_PORT);
8738 if (!W_ERROR_IS_OK(result)) {
8739 goto out;
8740 }
8741
8742 result = fill_monitor_1(info, &info[1].info1,
8743 SPL_TCPIP_PORT);
8744 if (!W_ERROR_IS_OK(result)) {
8745 goto out;
8746 }
8747
8748 out:
8749 if (!W_ERROR_IS_OK(result)) {
8750 TALLOC_FREE(info);
8751 *count = 0;
8752 return result;
8753 }
8754
8755 *info_p = info;
8756
8757 return WERR_OK;
8758 }
8759
8760 /****************************************************************************
8761 enumprintmonitors level 2.
8762 ****************************************************************************/
8763
8764 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8765 union spoolss_MonitorInfo **info_p,
8766 uint32_t *count)
8767 {
8768 union spoolss_MonitorInfo *info;
8769 WERROR result = WERR_OK;
8770
8771 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8772 W_ERROR_HAVE_NO_MEMORY(info);
8773
8774 *count = 2;
8775
8776 result = fill_monitor_2(info, &info[0].info2,
8777 SPL_LOCAL_PORT,
8778 "Windows NT X86", /* FIXME */
8779 "localmon.dll");
8780 if (!W_ERROR_IS_OK(result)) {
8781 goto out;
8782 }
8783
8784 result = fill_monitor_2(info, &info[1].info2,
8785 SPL_TCPIP_PORT,
8786 "Windows NT X86", /* FIXME */
8787 "tcpmon.dll");
8788 if (!W_ERROR_IS_OK(result)) {
8789 goto out;
8790 }
8791
8792 out:
8793 if (!W_ERROR_IS_OK(result)) {
8794 TALLOC_FREE(info);
8795 *count = 0;
8796 return result;
8797 }
8798
8799 *info_p = info;
8800
8801 return WERR_OK;
8802 }
8803
8804 /****************************************************************
8805 _spoolss_EnumMonitors
8806 ****************************************************************/
8807
8808 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8809 struct spoolss_EnumMonitors *r)
8810 {
8811 WERROR result;
8812
8813 /* that's an [in out] buffer */
8814
8815 if (!r->in.buffer && (r->in.offered != 0)) {
8816 return WERR_INVALID_PARAM;
8817 }
8818
8819 DEBUG(5,("_spoolss_EnumMonitors\n"));
8820
8821 /*
8822 * Enumerate the print monitors ...
8823 *
8824 * Just reply with "Local Port", to keep NT happy
8825 * and I can use my nice printer checker.
8826 */
8827
8828 *r->out.count = 0;
8829 *r->out.needed = 0;
8830 *r->out.info = NULL;
8831
8832 switch (r->in.level) {
8833 case 1:
8834 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8835 r->out.count);
8836 break;
8837 case 2:
8838 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8839 r->out.count);
8840 break;
8841 default:
8842 return WERR_UNKNOWN_LEVEL;
8843 }
8844
8845 if (!W_ERROR_IS_OK(result)) {
8846 return result;
8847 }
8848
8849 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8850 spoolss_EnumMonitors, NULL,
8851 *r->out.info, r->in.level,
8852 *r->out.count);
8853 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8854 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8855
8856 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8857 }
8858
8859 /****************************************************************************
8860 ****************************************************************************/
8861
8862 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8863 const print_queue_struct *queue,
8864 int count, int snum,
8865 const NT_PRINTER_INFO_LEVEL *ntprinter,
8866 uint32_t jobid,
8867 struct spoolss_JobInfo1 *r)
8868 {
8869 int i = 0;
8870 bool found = false;
8871
8872 for (i=0; i<count && found == false; i++) {
8873 if (queue[i].job == (int)jobid) {
8874 found = true;
8875 }
8876 }
8877
8878 if (found == false) {
8879 /* NT treats not found as bad param... yet another bad choice */
8880 return WERR_INVALID_PARAM;
8881 }
8882
8883 return fill_job_info1(mem_ctx,
8884 r,
8885 &queue[i-1],
8886 i,
8887 snum,
8888 ntprinter);
8889 }
8890
8891 /****************************************************************************
8892 ****************************************************************************/
8893
8894 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8895 const print_queue_struct *queue,
8896 int count, int snum,
8897 const NT_PRINTER_INFO_LEVEL *ntprinter,
8898 uint32_t jobid,
8899 struct spoolss_JobInfo2 *r)
8900 {
8901 int i = 0;
8902 bool found = false;
8903 struct spoolss_DeviceMode *devmode;
8904 NT_DEVICEMODE *nt_devmode;
8905 WERROR result;
8906
8907 for (i=0; i<count && found == false; i++) {
8908 if (queue[i].job == (int)jobid) {
8909 found = true;
8910 }
8911 }
8912
8913 if (found == false) {
8914 /* NT treats not found as bad param... yet another bad
8915 choice */
8916 return WERR_INVALID_PARAM;
8917 }
8918
8919 /*
8920 * if the print job does not have a DEVMODE associated with it,
8921 * just use the one for the printer. A NULL devicemode is not
8922 * a failure condition
8923 */
8924
8925 nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8926 if (nt_devmode) {
8927 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
8928 W_ERROR_HAVE_NO_MEMORY(devmode);
8929 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
8930 if (!W_ERROR_IS_OK(result)) {
8931 return result;
8932 }
8933 } else {
8934 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
8935 W_ERROR_HAVE_NO_MEMORY(devmode);
8936 }
8937
8938 return fill_job_info2(mem_ctx,
8939 r,
8940 &queue[i-1],
8941 i,
8942 snum,
8943 ntprinter,
8944 devmode);
8945 }
8946
8947 /****************************************************************
8948 _spoolss_GetJob
8949 ****************************************************************/
8950
8951 WERROR _spoolss_GetJob(pipes_struct *p,
8952 struct spoolss_GetJob *r)
8953 {
8954 WERROR result = WERR_OK;
8955 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
8956 int snum;
8957 int count;
8958 print_queue_struct *queue = NULL;
8959 print_status_struct prt_status;
8960
8961 /* that's an [in out] buffer */
8962
8963 if (!r->in.buffer && (r->in.offered != 0)) {
8964 return WERR_INVALID_PARAM;
8965 }
8966
8967 DEBUG(5,("_spoolss_GetJob\n"));
8968
8969 *r->out.needed = 0;
8970
8971 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8972 return WERR_BADFID;
8973 }
8974
8975 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
8976 if (!W_ERROR_IS_OK(result)) {
8977 return result;
8978 }
8979
8980 count = print_queue_status(snum, &queue, &prt_status);
8981
8982 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8983 count, prt_status.status, prt_status.message));
8984
8985 switch (r->in.level) {
8986 case 1:
8987 result = getjob_level_1(p->mem_ctx,
8988 queue, count, snum, ntprinter,
8989 r->in.job_id, &r->out.info->info1);
8990 break;
8991 case 2:
8992 result = getjob_level_2(p->mem_ctx,
8993 queue, count, snum, ntprinter,
8994 r->in.job_id, &r->out.info->info2);
8995 break;
8996 default:
8997 result = WERR_UNKNOWN_LEVEL;
8998 break;
8999 }
9000
9001 SAFE_FREE(queue);
9002 free_a_printer(&ntprinter, 2);
9003
9004 if (!W_ERROR_IS_OK(result)) {
9005 TALLOC_FREE(r->out.info);
9006 return result;
9007 }
9008
9009 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
9010 r->out.info, r->in.level);
9011 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9012
9013 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9014 }
9015
9016 /****************************************************************
9017 _spoolss_GetPrinterDataEx
9018
9019 From MSDN documentation of GetPrinterDataEx: pass request
9020 to GetPrinterData if key is "PrinterDriverData".
9021 ****************************************************************/
9022
9023 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
9024 struct spoolss_GetPrinterDataEx *r)
9025 {
9026
9027 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9028 REGISTRY_VALUE *val = NULL;
9029 NT_PRINTER_INFO_LEVEL *printer = NULL;
9030 int snum = 0;
9031 WERROR result = WERR_OK;
9032
9033 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9034
9035 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9036 r->in.key_name, r->in.value_name));
9037
9038 /* in case of problem, return some default values */
9039
9040 *r->out.needed = 0;
9041 *r->out.type = REG_NONE;
9042
9043 if (!Printer) {
9044 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9045 OUR_HANDLE(r->in.handle)));
9046 result = WERR_BADFID;
9047 goto done;
9048 }
9049
9050 /* Is the handle to a printer or to the server? */
9051
9052 if (Printer->printer_type == SPLHND_SERVER) {
9053 DEBUG(10,("_spoolss_GetPrinterDataEx: "
9054 "Not implemented for server handles yet\n"));
9055 result = WERR_INVALID_PARAM;
9056 goto done;
9057 }
9058
9059 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9060 return WERR_BADFID;
9061 }
9062
9063 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9064 if (!W_ERROR_IS_OK(result)) {
9065 goto done;
9066 }
9067
9068 /* check to see if the keyname is valid */
9069 if (!strlen(r->in.key_name)) {
9070 result = WERR_INVALID_PARAM;
9071 goto done;
9072 }
9073
9074 if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
9075 DEBUG(4,("_spoolss_GetPrinterDataEx: "
9076 "Invalid keyname [%s]\n", r->in.key_name ));
9077 result = WERR_BADFILE;
9078 goto done;
9079 }
9080
9081 /* When given a new keyname, we should just create it */
9082
9083 val = get_printer_data(printer->info_2,
9084 r->in.key_name, r->in.value_name);
9085 if (!val) {
9086 result = WERR_BADFILE;
9087 goto done;
9088 }
9089
9090 *r->out.needed = regval_size(val);
9091
9092 if (*r->out.needed > r->in.offered) {
9093 result = WERR_MORE_DATA;
9094 goto done;
9095 }
9096
9097 *r->out.type = regval_type(val);
9098
9099 memcpy(r->out.buffer, regval_data_p(val), regval_size(val));
9100
9101 done:
9102 if (printer) {
9103 free_a_printer(&printer, 2);
9104 }
9105
9106 return result;
9107 }
9108
9109 /****************************************************************
9110 _spoolss_SetPrinterDataEx
9111 ****************************************************************/
9112
9113 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
9114 struct spoolss_SetPrinterDataEx *r)
9115 {
9116 NT_PRINTER_INFO_LEVEL *printer = NULL;
9117 int snum = 0;
9118 WERROR result = WERR_OK;
9119 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9120 char *oid_string;
9121
9122 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9123
9124 /* From MSDN documentation of SetPrinterDataEx: pass request to
9125 SetPrinterData if key is "PrinterDriverData" */
9126
9127 if (!Printer) {
9128 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9129 OUR_HANDLE(r->in.handle)));
9130 return WERR_BADFID;
9131 }
9132
9133 if (Printer->printer_type == SPLHND_SERVER) {
9134 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9135 "Not implemented for server handles yet\n"));
9136 return WERR_INVALID_PARAM;
9137 }
9138
9139 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9140 return WERR_BADFID;
9141 }
9142
9143 /*
9144 * Access check : NT returns "access denied" if you make a
9145 * SetPrinterData call without the necessary privildge.
9146 * we were originally returning OK if nothing changed
9147 * which made Win2k issue **a lot** of SetPrinterData
9148 * when connecting to a printer --jerry
9149 */
9150
9151 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9152 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9153 "change denied by handle access permissions\n"));
9154 return WERR_ACCESS_DENIED;
9155 }
9156
9157 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9158 if (!W_ERROR_IS_OK(result)) {
9159 return result;
9160 }
9161
9162 /* check for OID in valuename */
9163
9164 oid_string = strchr(r->in.value_name, ',');
9165 if (oid_string) {
9166 *oid_string = '\0';
9167 oid_string++;
9168 }
9169
9170 /* save the registry data */
9171
9172 result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
9173 r->in.type, r->in.buffer, r->in.offered);
9174
9175 if (W_ERROR_IS_OK(result)) {
9176 /* save the OID if one was specified */
9177 if (oid_string) {
9178 char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
9179 r->in.key_name, SPOOL_OID_KEY);
9180 if (!str) {
9181 result = WERR_NOMEM;
9182 goto done;
9183 }
9184
9185 /*
9186 * I'm not checking the status here on purpose. Don't know
9187 * if this is right, but I'm returning the status from the
9188 * previous set_printer_dataex() call. I have no idea if
9189 * this is right. --jerry
9190 */
9191
9192 set_printer_dataex(printer, str, r->in.value_name,
9193 REG_SZ, (uint8_t *)oid_string,
9194 strlen(oid_string)+1);
9195 }
9196
9197 result = mod_a_printer(printer, 2);
9198 }
9199
9200 done:
9201 free_a_printer(&printer, 2);
9202
9203 return result;
9204 }
9205
9206 /****************************************************************
9207 _spoolss_DeletePrinterDataEx
9208 ****************************************************************/
9209
9210 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
9211 struct spoolss_DeletePrinterDataEx *r)
9212 {
9213 NT_PRINTER_INFO_LEVEL *printer = NULL;
9214 int snum=0;
9215 WERROR status = WERR_OK;
9216 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9217
9218 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9219
9220 if (!Printer) {
9221 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9222 "Invalid handle (%s:%u:%u).\n",
9223 OUR_HANDLE(r->in.handle)));
9224 return WERR_BADFID;
9225 }
9226
9227 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9228 return WERR_BADFID;
9229
9230 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9231 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9232 "printer properties change denied by handle\n"));
9233 return WERR_ACCESS_DENIED;
9234 }
9235
9236 if (!r->in.value_name || !r->in.key_name) {
9237 return WERR_NOMEM;
9238 }
9239
9240 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9241 if (!W_ERROR_IS_OK(status))
9242 return status;
9243
9244 status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
9245
9246 if ( W_ERROR_IS_OK(status) )
9247 mod_a_printer( printer, 2 );
9248
9249 free_a_printer(&printer, 2);
9250
9251 return status;
9252 }
9253
9254 /****************************************************************
9255 _spoolss_EnumPrinterKey
9256 ****************************************************************/
9257
9258 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
9259 struct spoolss_EnumPrinterKey *r)
9260 {
9261 fstring *keynames = NULL;
9262 int num_keys;
9263 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9264 NT_PRINTER_DATA *data;
9265 NT_PRINTER_INFO_LEVEL *printer = NULL;
9266 int snum = 0;
9267 WERROR result = WERR_BADFILE;
9268 int i;
9269 const char **array = NULL;
9270
9271
9272 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9273
9274 if (!Printer) {
9275 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9276 OUR_HANDLE(r->in.handle)));
9277 return WERR_BADFID;
9278 }
9279
9280 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9281 return WERR_BADFID;
9282 }
9283
9284 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9285 if (!W_ERROR_IS_OK(result)) {
9286 return result;
9287 }
9288
9289 /* get the list of subkey names */
9290
9291 data = printer->info_2->data;
9292
9293 num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
9294 if (num_keys == -1) {
9295 result = WERR_BADFILE;
9296 goto done;
9297 }
9298
9299 *r->out.needed = 4;
9300
9301 array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 1);
9302 if (!array) {
9303 result = WERR_NOMEM;
9304 goto done;
9305 }
9306
9307 for (i=0; i < num_keys; i++) {
9308 array[i] = talloc_strdup(array, keynames[i]);
9309 if (!array[i]) {
9310 result = WERR_NOMEM;
9311 goto done;
9312 }
9313
9314 *r->out.needed += strlen_m_term(keynames[i]) * 2;
9315 }
9316
9317 if (r->in.offered < *r->out.needed) {
9318 result = WERR_MORE_DATA;
9319 goto done;
9320 }
9321
9322 result = WERR_OK;
9323
9324 *r->out.key_buffer = array;
9325
9326 done:
9327 if (!W_ERROR_IS_OK(result)) {
9328 TALLOC_FREE(array);
9329 ZERO_STRUCTP(r->out.key_buffer);
9330 }
9331
9332 free_a_printer(&printer, 2);
9333 SAFE_FREE(keynames);
9334
9335 return result;
9336 }
9337
9338 /****************************************************************
9339 _spoolss_DeletePrinterKey
9340 ****************************************************************/
9341
9342 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9343 struct spoolss_DeletePrinterKey *r)
9344 {
9345 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9346 NT_PRINTER_INFO_LEVEL *printer = NULL;
9347 int snum=0;
9348 WERROR status;
9349
9350 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9351
9352 if (!Printer) {
9353 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9354 OUR_HANDLE(r->in.handle)));
9355 return WERR_BADFID;
9356 }
9357
9358 /* if keyname == NULL, return error */
9359
9360 if ( !r->in.key_name )
9361 return WERR_INVALID_PARAM;
9362
9363 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9364 return WERR_BADFID;
9365
9366 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9367 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9368 "printer properties change denied by handle\n"));
9369 return WERR_ACCESS_DENIED;
9370 }
9371
9372 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9373 if (!W_ERROR_IS_OK(status))
9374 return status;
9375
9376 /* delete the key and all subneys */
9377
9378 status = delete_all_printer_data( printer->info_2, r->in.key_name );
9379
9380 if ( W_ERROR_IS_OK(status) )
9381 status = mod_a_printer(printer, 2);
9382
9383 free_a_printer( &printer, 2 );
9384
9385 return status;
9386 }
9387
9388 /****************************************************************
9389 ****************************************************************/
9390
9391 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9392 REGISTRY_VALUE *v,
9393 struct spoolss_PrinterEnumValues *r)
9394 {
9395 WERROR result;
9396
9397 r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
9398 W_ERROR_HAVE_NO_MEMORY(r->data);
9399
9400 r->value_name = talloc_strdup(mem_ctx, regval_name(v));
9401 W_ERROR_HAVE_NO_MEMORY(r->value_name);
9402
9403 r->type = regval_type(v);
9404 r->data_length = regval_size(v);
9405
9406 if (r->data_length) {
9407 DATA_BLOB blob = data_blob_const(regval_data_p(v),
9408 regval_size(v));
9409 result = pull_spoolss_PrinterData(mem_ctx, &blob,
9410 r->data,
9411 r->type);
9412 if (!W_ERROR_IS_OK(result)) {
9413 return result;
9414 }
9415 }
9416
9417 return WERR_OK;
9418 }
9419
9420 /****************************************************************
9421 _spoolss_EnumPrinterDataEx
9422 ****************************************************************/
9423
9424 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9425 struct spoolss_EnumPrinterDataEx *r)
9426 {
9427 uint32_t count = 0;
9428 NT_PRINTER_INFO_LEVEL *printer = NULL;
9429 struct spoolss_PrinterEnumValues *info = NULL;
9430 NT_PRINTER_DATA *p_data;
9431 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9432 int snum;
9433 WERROR result;
9434 int key_index;
9435 int i;
9436
9437 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9438
9439 *r->out.count = 0;
9440 *r->out.needed = 0;
9441 *r->out.info = NULL;
9442
9443 if (!Printer) {
9444 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9445 OUR_HANDLE(r->in.handle)));
9446 return WERR_BADFID;
9447 }
9448
9449 /*
9450 * first check for a keyname of NULL or "". Win2k seems to send
9451 * this a lot and we should send back WERR_INVALID_PARAM
9452 * no need to spend time looking up the printer in this case.
9453 * --jerry
9454 */
9455
9456 if (!strlen(r->in.key_name)) {
9457 result = WERR_INVALID_PARAM;
9458 goto done;
9459 }
9460
9461 /* get the printer off of disk */
9462
9463 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9464 return WERR_BADFID;
9465 }
9466
9467 ZERO_STRUCT(printer);
9468 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9469 if (!W_ERROR_IS_OK(result)) {
9470 return result;
9471 }
9472
9473 /* now look for a match on the key name */
9474
9475 p_data = printer->info_2->data;
9476
9477 key_index = lookup_printerkey(p_data, r->in.key_name);
9478 if (key_index == -1) {
9479 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9480 r->in.key_name));
9481 result = WERR_INVALID_PARAM;
9482 goto done;
9483 }
9484
9485 /* allocate the memory for the array of pointers -- if necessary */
9486
9487 count = regval_ctr_numvals(p_data->keys[key_index].values);
9488 if (!count) {
9489 result = WERR_OK; /* ??? */
9490 goto done;
9491 }
9492
9493 info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9494 struct spoolss_PrinterEnumValues,
9495 count);
9496 if (!info) {
9497 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9498 result = WERR_NOMEM;
9499 goto done;
9500 }
9501
9502 /*
9503 * loop through all params and build the array to pass
9504 * back to the client
9505 */
9506
9507 for (i=0; i < count; i++) {
9508
9509 REGISTRY_VALUE *val;
9510
9511 /* lookup the registry value */
9512
9513 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9514
9515 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9516
9517 /* copy the data */
9518
9519 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9520 if (!W_ERROR_IS_OK(result)) {
9521 goto done;
9522 }
9523 }
9524
9525 #if 0 /* FIXME - gd */
9526 /* housekeeping information in the reply */
9527
9528 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9529 * the hand marshalled container size is a multiple
9530 * of 4 bytes for RPC alignment.
9531 */
9532
9533 if (needed % 4) {
9534 needed += 4-(needed % 4);
9535 }
9536 #endif
9537 *r->out.count = count;
9538 *r->out.info = info;
9539
9540 done:
9541
9542 if (printer) {
9543 free_a_printer(&printer, 2);
9544 }
9545
9546 if (!W_ERROR_IS_OK(result)) {
9547 return result;
9548 }
9549
9550 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9551 spoolss_EnumPrinterDataEx, NULL,
9552 *r->out.info,
9553 *r->out.count);
9554 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9555 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9556
9557 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9558 }
9559
9560 /****************************************************************************
9561 ****************************************************************************/
9562
9563 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9564 const char *servername,
9565 const char *environment,
9566 struct spoolss_PrintProcessorDirectoryInfo1 *r)
9567 {
9568 WERROR werr;
9569 char *path = NULL;
9570
9571 werr = compose_spoolss_server_path(mem_ctx,
9572 servername,
9573 environment,
9574 SPOOLSS_PRTPROCS_PATH,
9575 &path);
9576 if (!W_ERROR_IS_OK(werr)) {
9577 return werr;
9578 }
9579
9580 DEBUG(4,("print processor directory: [%s]\n", path));
9581
9582 r->directory_name = path;
9583
9584 return WERR_OK;
9585 }
9586
9587 /****************************************************************
9588 _spoolss_GetPrintProcessorDirectory
9589 ****************************************************************/
9590
9591 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9592 struct spoolss_GetPrintProcessorDirectory *r)
9593 {
9594 WERROR result;
9595
9596 /* that's an [in out] buffer */
9597
9598 if (!r->in.buffer && (r->in.offered != 0)) {
9599 return WERR_INVALID_PARAM;
9600 }
9601
9602 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9603 r->in.level));
9604
9605 *r->out.needed = 0;
9606
9607 /* r->in.level is ignored */
9608
9609 result = getprintprocessordirectory_level_1(p->mem_ctx,
9610 r->in.server,
9611 r->in.environment,
9612 &r->out.info->info1);
9613 if (!W_ERROR_IS_OK(result)) {
9614 TALLOC_FREE(r->out.info);
9615 return result;
9616 }
9617
9618 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9619 r->out.info, r->in.level);
9620 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9621
9622 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9623 }
9624
9625 /*******************************************************************
9626 ********************************************************************/
9627
9628 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9629 const char *dllname)
9630 {
9631 enum ndr_err_code ndr_err;
9632 struct spoolss_MonitorUi ui;
9633
9634 ui.dll_name = dllname;
9635
9636 ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9637 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9638 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9639 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9640 }
9641 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9642 }
9643
9644 /*******************************************************************
9645 Streams the monitor UI DLL name in UNICODE
9646 *******************************************************************/
9647
9648 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9649 NT_USER_TOKEN *token, DATA_BLOB *in,
9650 DATA_BLOB *out, uint32_t *needed)
9651 {
9652 const char *dllname = "tcpmonui.dll";
9653
9654 *needed = (strlen(dllname)+1) * 2;
9655
9656 if (out->length < *needed) {
9657 return WERR_INSUFFICIENT_BUFFER;
9658 }
9659
9660 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9661 return WERR_NOMEM;
9662 }
9663
9664 return WERR_OK;
9665 }
9666
9667 /*******************************************************************
9668 ********************************************************************/
9669
9670 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9671 struct spoolss_PortData1 *port1,
9672 const DATA_BLOB *buf)
9673 {
9674 enum ndr_err_code ndr_err;
9675 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9676 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9677 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9678 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9679 }
9680 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9681 }
9682
9683 /*******************************************************************
9684 ********************************************************************/
9685
9686 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9687 struct spoolss_PortData2 *port2,
9688 const DATA_BLOB *buf)
9689 {
9690 enum ndr_err_code ndr_err;
9691 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9692 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9693 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9694 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9695 }
9696 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9697 }
9698
9699 /*******************************************************************
9700 Create a new TCP/IP port
9701 *******************************************************************/
9702
9703 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9704 NT_USER_TOKEN *token, DATA_BLOB *in,
9705 DATA_BLOB *out, uint32_t *needed)
9706 {
9707 struct spoolss_PortData1 port1;
9708 struct spoolss_PortData2 port2;
9709 char *device_uri = NULL;
9710 uint32_t version;
9711
9712 const char *portname;
9713 const char *hostaddress;
9714 const char *queue;
9715 uint32_t port_number;
9716 uint32_t protocol;
9717
9718 /* peek for spoolss_PortData version */
9719
9720 if (!in || (in->length < (128 + 4))) {
9721 return WERR_GENERAL_FAILURE;
9722 }
9723
9724 version = IVAL(in->data, 128);
9725
9726 switch (version) {
9727 case 1:
9728 ZERO_STRUCT(port1);
9729
9730 if (!pull_port_data_1(mem_ctx, &port1, in)) {
9731 return WERR_NOMEM;
9732 }
9733
9734 portname = port1.portname;
9735 hostaddress = port1.hostaddress;
9736 queue = port1.queue;
9737 protocol = port1.protocol;
9738 port_number = port1.port_number;
9739
9740 break;
9741 case 2:
9742 ZERO_STRUCT(port2);
9743
9744 if (!pull_port_data_2(mem_ctx, &port2, in)) {
9745 return WERR_NOMEM;
9746 }
9747
9748 portname = port2.portname;
9749 hostaddress = port2.hostaddress;
9750 queue = port2.queue;
9751 protocol = port2.protocol;
9752 port_number = port2.port_number;
9753
9754 break;
9755 default:
9756 DEBUG(1,("xcvtcp_addport: "
9757 "unknown version of port_data: %d\n", version));
9758 return WERR_UNKNOWN_PORT;
9759 }
9760
9761 /* create the device URI and call the add_port_hook() */
9762
9763 switch (protocol) {
9764 case PROTOCOL_RAWTCP_TYPE:
9765 device_uri = talloc_asprintf(mem_ctx,
9766 "socket://%s:%d/", hostaddress,
9767 port_number);
9768 break;
9769
9770 case PROTOCOL_LPR_TYPE:
9771 device_uri = talloc_asprintf(mem_ctx,
9772 "lpr://%s/%s", hostaddress, queue );
9773 break;
9774
9775 default:
9776 return WERR_UNKNOWN_PORT;
9777 }
9778
9779 if (!device_uri) {
9780 return WERR_NOMEM;
9781 }
9782
9783 return add_port_hook(mem_ctx, token, portname, device_uri);
9784 }
9785
9786 /*******************************************************************
9787 *******************************************************************/
9788
9789 struct xcv_api_table xcvtcp_cmds[] = {
9790 { "MonitorUI", xcvtcp_monitorui },
9791 { "AddPort", xcvtcp_addport},
9792 { NULL, NULL }
9793 };
9794
9795 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9796 NT_USER_TOKEN *token, const char *command,
9797 DATA_BLOB *inbuf,
9798 DATA_BLOB *outbuf,
9799 uint32_t *needed )
9800 {
9801 int i;
9802
9803 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9804
9805 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9806 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9807 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9808 }
9809
9810 return WERR_BADFUNC;
9811 }
9812
9813 /*******************************************************************
9814 *******************************************************************/
9815 #if 0 /* don't support management using the "Local Port" monitor */
9816
9817 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9818 NT_USER_TOKEN *token, DATA_BLOB *in,
9819 DATA_BLOB *out, uint32_t *needed)
9820 {
9821 const char *dllname = "localui.dll";
9822
9823 *needed = (strlen(dllname)+1) * 2;
9824
9825 if (out->length < *needed) {
9826 return WERR_INSUFFICIENT_BUFFER;
9827 }
9828
9829 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9830 return WERR_NOMEM;
9831 }
9832
9833 return WERR_OK;
9834 }
9835
9836 /*******************************************************************
9837 *******************************************************************/
9838
9839 struct xcv_api_table xcvlocal_cmds[] = {
9840 { "MonitorUI", xcvlocal_monitorui },
9841 { NULL, NULL }
9842 };
9843 #else
9844 struct xcv_api_table xcvlocal_cmds[] = {
9845 { NULL, NULL }
9846 };
9847 #endif
9848
9849
9850
9851 /*******************************************************************
9852 *******************************************************************/
9853
9854 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9855 NT_USER_TOKEN *token, const char *command,
9856 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9857 uint32_t *needed)
9858 {
9859 int i;
9860
9861 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9862
9863 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9864 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9865 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9866 }
9867 return WERR_BADFUNC;
9868 }
9869
9870 /****************************************************************
9871 _spoolss_XcvData
9872 ****************************************************************/
9873
9874 WERROR _spoolss_XcvData(pipes_struct *p,
9875 struct spoolss_XcvData *r)
9876 {
9877 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9878 DATA_BLOB out_data = data_blob_null;
9879 WERROR werror;
9880
9881 if (!Printer) {
9882 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9883 OUR_HANDLE(r->in.handle)));
9884 return WERR_BADFID;
9885 }
9886
9887 /* Has to be a handle to the TCP/IP port monitor */
9888
9889 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9890 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9891 return WERR_BADFID;
9892 }
9893
9894 /* requires administrative access to the server */
9895
9896 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9897 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9898 return WERR_ACCESS_DENIED;
9899 }
9900
9901 /* Allocate the outgoing buffer */
9902
9903 if (r->in.out_data_size) {
9904 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9905 if (out_data.data == NULL) {
9906 return WERR_NOMEM;
9907 }
9908 }
9909
9910 switch ( Printer->printer_type ) {
9911 case SPLHND_PORTMON_TCP:
9912 werror = process_xcvtcp_command(p->mem_ctx,
9913 p->server_info->ptok,
9914 r->in.function_name,
9915 &r->in.in_data, &out_data,
9916 r->out.needed);
9917 break;
9918 case SPLHND_PORTMON_LOCAL:
9919 werror = process_xcvlocal_command(p->mem_ctx,
9920 p->server_info->ptok,
9921 r->in.function_name,
9922 &r->in.in_data, &out_data,
9923 r->out.needed);
9924 break;
9925 default:
9926 werror = WERR_INVALID_PRINT_MONITOR;
9927 }
9928
9929 if (!W_ERROR_IS_OK(werror)) {
9930 return werror;
9931 }
9932
9933 *r->out.status_code = 0;
9934
9935 memcpy(r->out.out_data, out_data.data, out_data.length);
9936
9937 return WERR_OK;
9938 }
9939
9940 /****************************************************************
9941 _spoolss_AddPrintProcessor
9942 ****************************************************************/
9943
9944 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
9945 struct spoolss_AddPrintProcessor *r)
9946 {
9947 /* for now, just indicate success and ignore the add. We'll
9948 automatically set the winprint processor for printer
9949 entries later. Used to debug the LexMark Optra S 1855 PCL
9950 driver --jerry */
9951
9952 return WERR_OK;
9953 }
9954
9955 /****************************************************************
9956 _spoolss_AddPort
9957 ****************************************************************/
9958
9959 WERROR _spoolss_AddPort(pipes_struct *p,
9960 struct spoolss_AddPort *r)
9961 {
9962 /* do what w2k3 does */
9963
9964 return WERR_NOT_SUPPORTED;
9965 }
9966
9967 /****************************************************************
9968 _spoolss_AddPrinter
9969 ****************************************************************/
9970
9971 WERROR _spoolss_AddPrinter(pipes_struct *p,
9972 struct spoolss_AddPrinter *r)
9973 {
9974 p->rng_fault_state = true;
9975 return WERR_NOT_SUPPORTED;
9976 }
9977
9978 /****************************************************************
9979 _spoolss_GetPrinterDriver
9980 ****************************************************************/
9981
9982 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
9983 struct spoolss_GetPrinterDriver *r)
9984 {
9985 p->rng_fault_state = true;
9986 return WERR_NOT_SUPPORTED;
9987 }
9988
9989 /****************************************************************
9990 _spoolss_ReadPrinter
9991 ****************************************************************/
9992
9993 WERROR _spoolss_ReadPrinter(pipes_struct *p,
9994 struct spoolss_ReadPrinter *r)
9995 {
9996 p->rng_fault_state = true;
9997 return WERR_NOT_SUPPORTED;
9998 }
9999
10000 /****************************************************************
10001 _spoolss_WaitForPrinterChange
10002 ****************************************************************/
10003
10004 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
10005 struct spoolss_WaitForPrinterChange *r)
10006 {
10007 p->rng_fault_state = true;
10008 return WERR_NOT_SUPPORTED;
10009 }
10010
10011 /****************************************************************
10012 _spoolss_ConfigurePort
10013 ****************************************************************/
10014
10015 WERROR _spoolss_ConfigurePort(pipes_struct *p,
10016 struct spoolss_ConfigurePort *r)
10017 {
10018 p->rng_fault_state = true;
10019 return WERR_NOT_SUPPORTED;
10020 }
10021
10022 /****************************************************************
10023 _spoolss_DeletePort
10024 ****************************************************************/
10025
10026 WERROR _spoolss_DeletePort(pipes_struct *p,
10027 struct spoolss_DeletePort *r)
10028 {
10029 p->rng_fault_state = true;
10030 return WERR_NOT_SUPPORTED;
10031 }
10032
10033 /****************************************************************
10034 _spoolss_CreatePrinterIC
10035 ****************************************************************/
10036
10037 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
10038 struct spoolss_CreatePrinterIC *r)
10039 {
10040 p->rng_fault_state = true;
10041 return WERR_NOT_SUPPORTED;
10042 }
10043
10044 /****************************************************************
10045 _spoolss_PlayGDIScriptOnPrinterIC
10046 ****************************************************************/
10047
10048 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
10049 struct spoolss_PlayGDIScriptOnPrinterIC *r)
10050 {
10051 p->rng_fault_state = true;
10052 return WERR_NOT_SUPPORTED;
10053 }
10054
10055 /****************************************************************
10056 _spoolss_DeletePrinterIC
10057 ****************************************************************/
10058
10059 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
10060 struct spoolss_DeletePrinterIC *r)
10061 {
10062 p->rng_fault_state = true;
10063 return WERR_NOT_SUPPORTED;
10064 }
10065
10066 /****************************************************************
10067 _spoolss_AddPrinterConnection
10068 ****************************************************************/
10069
10070 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
10071 struct spoolss_AddPrinterConnection *r)
10072 {
10073 p->rng_fault_state = true;
10074 return WERR_NOT_SUPPORTED;
10075 }
10076
10077 /****************************************************************
10078 _spoolss_DeletePrinterConnection
10079 ****************************************************************/
10080
10081 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
10082 struct spoolss_DeletePrinterConnection *r)
10083 {
10084 p->rng_fault_state = true;
10085 return WERR_NOT_SUPPORTED;
10086 }
10087
10088 /****************************************************************
10089 _spoolss_PrinterMessageBox
10090 ****************************************************************/
10091
10092 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
10093 struct spoolss_PrinterMessageBox *r)
10094 {
10095 p->rng_fault_state = true;
10096 return WERR_NOT_SUPPORTED;
10097 }
10098
10099 /****************************************************************
10100 _spoolss_AddMonitor
10101 ****************************************************************/
10102
10103 WERROR _spoolss_AddMonitor(pipes_struct *p,
10104 struct spoolss_AddMonitor *r)
10105 {
10106 p->rng_fault_state = true;
10107 return WERR_NOT_SUPPORTED;
10108 }
10109
10110 /****************************************************************
10111 _spoolss_DeleteMonitor
10112 ****************************************************************/
10113
10114 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
10115 struct spoolss_DeleteMonitor *r)
10116 {
10117 p->rng_fault_state = true;
10118 return WERR_NOT_SUPPORTED;
10119 }
10120
10121 /****************************************************************
10122 _spoolss_DeletePrintProcessor
10123 ****************************************************************/
10124
10125 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
10126 struct spoolss_DeletePrintProcessor *r)
10127 {
10128 p->rng_fault_state = true;
10129 return WERR_NOT_SUPPORTED;
10130 }
10131
10132 /****************************************************************
10133 _spoolss_AddPrintProvidor
10134 ****************************************************************/
10135
10136 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
10137 struct spoolss_AddPrintProvidor *r)
10138 {
10139 p->rng_fault_state = true;
10140 return WERR_NOT_SUPPORTED;
10141 }
10142
10143 /****************************************************************
10144 _spoolss_DeletePrintProvidor
10145 ****************************************************************/
10146
10147 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
10148 struct spoolss_DeletePrintProvidor *r)
10149 {
10150 p->rng_fault_state = true;
10151 return WERR_NOT_SUPPORTED;
10152 }
10153
10154 /****************************************************************
10155 _spoolss_FindFirstPrinterChangeNotification
10156 ****************************************************************/
10157
10158 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
10159 struct spoolss_FindFirstPrinterChangeNotification *r)
10160 {
10161 p->rng_fault_state = true;
10162 return WERR_NOT_SUPPORTED;
10163 }
10164
10165 /****************************************************************
10166 _spoolss_FindNextPrinterChangeNotification
10167 ****************************************************************/
10168
10169 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
10170 struct spoolss_FindNextPrinterChangeNotification *r)
10171 {
10172 p->rng_fault_state = true;
10173 return WERR_NOT_SUPPORTED;
10174 }
10175
10176 /****************************************************************
10177 _spoolss_RouterFindFirstPrinterChangeNotificationOld
10178 ****************************************************************/
10179
10180 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
10181 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10182 {
10183 p->rng_fault_state = true;
10184 return WERR_NOT_SUPPORTED;
10185 }
10186
10187 /****************************************************************
10188 _spoolss_ReplyOpenPrinter
10189 ****************************************************************/
10190
10191 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
10192 struct spoolss_ReplyOpenPrinter *r)
10193 {
10194 p->rng_fault_state = true;
10195 return WERR_NOT_SUPPORTED;
10196 }
10197
10198 /****************************************************************
10199 _spoolss_RouterReplyPrinter
10200 ****************************************************************/
10201
10202 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
10203 struct spoolss_RouterReplyPrinter *r)
10204 {
10205 p->rng_fault_state = true;
10206 return WERR_NOT_SUPPORTED;
10207 }
10208
10209 /****************************************************************
10210 _spoolss_ReplyClosePrinter
10211 ****************************************************************/
10212
10213 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
10214 struct spoolss_ReplyClosePrinter *r)
10215 {
10216 p->rng_fault_state = true;
10217 return WERR_NOT_SUPPORTED;
10218 }
10219
10220 /****************************************************************
10221 _spoolss_AddPortEx
10222 ****************************************************************/
10223
10224 WERROR _spoolss_AddPortEx(pipes_struct *p,
10225 struct spoolss_AddPortEx *r)
10226 {
10227 p->rng_fault_state = true;
10228 return WERR_NOT_SUPPORTED;
10229 }
10230
10231 /****************************************************************
10232 _spoolss_RouterFindFirstPrinterChangeNotification
10233 ****************************************************************/
10234
10235 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
10236 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10237 {
10238 p->rng_fault_state = true;
10239 return WERR_NOT_SUPPORTED;
10240 }
10241
10242 /****************************************************************
10243 _spoolss_SpoolerInit
10244 ****************************************************************/
10245
10246 WERROR _spoolss_SpoolerInit(pipes_struct *p,
10247 struct spoolss_SpoolerInit *r)
10248 {
10249 p->rng_fault_state = true;
10250 return WERR_NOT_SUPPORTED;
10251 }
10252
10253 /****************************************************************
10254 _spoolss_ResetPrinterEx
10255 ****************************************************************/
10256
10257 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
10258 struct spoolss_ResetPrinterEx *r)
10259 {
10260 p->rng_fault_state = true;
10261 return WERR_NOT_SUPPORTED;
10262 }
10263
10264 /****************************************************************
10265 _spoolss_RouterReplyPrinterEx
10266 ****************************************************************/
10267
10268 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
10269 struct spoolss_RouterReplyPrinterEx *r)
10270 {
10271 p->rng_fault_state = true;
10272 return WERR_NOT_SUPPORTED;
10273 }
10274
10275 /****************************************************************
10276 _spoolss_44
10277 ****************************************************************/
10278
10279 WERROR _spoolss_44(pipes_struct *p,
10280 struct spoolss_44 *r)
10281 {
10282 p->rng_fault_state = true;
10283 return WERR_NOT_SUPPORTED;
10284 }
10285
10286 /****************************************************************
10287 _spoolss_47
10288 ****************************************************************/
10289
10290 WERROR _spoolss_47(pipes_struct *p,
10291 struct spoolss_47 *r)
10292 {
10293 p->rng_fault_state = true;
10294 return WERR_NOT_SUPPORTED;
10295 }
10296
10297 /****************************************************************
10298 _spoolss_4a
10299 ****************************************************************/
10300
10301 WERROR _spoolss_4a(pipes_struct *p,
10302 struct spoolss_4a *r)
10303 {
10304 p->rng_fault_state = true;
10305 return WERR_NOT_SUPPORTED;
10306 }
10307
10308 /****************************************************************
10309 _spoolss_4b
10310 ****************************************************************/
10311
10312 WERROR _spoolss_4b(pipes_struct *p,
10313 struct spoolss_4b *r)
10314 {
10315 p->rng_fault_state = true;
10316 return WERR_NOT_SUPPORTED;
10317 }
10318
10319 /****************************************************************
10320 _spoolss_4c
10321 ****************************************************************/
10322
10323 WERROR _spoolss_4c(pipes_struct *p,
10324 struct spoolss_4c *r)
10325 {
10326 p->rng_fault_state = true;
10327 return WERR_NOT_SUPPORTED;
10328 }
10329
10330 /****************************************************************
10331 _spoolss_53
10332 ****************************************************************/
10333
10334 WERROR _spoolss_53(pipes_struct *p,
10335 struct spoolss_53 *r)
10336 {
10337 p->rng_fault_state = true;
10338 return WERR_NOT_SUPPORTED;
10339 }
10340
10341 /****************************************************************
10342 _spoolss_55
10343 ****************************************************************/
10344
10345 WERROR _spoolss_55(pipes_struct *p,
10346 struct spoolss_55 *r)
10347 {
10348 p->rng_fault_state = true;
10349 return WERR_NOT_SUPPORTED;
10350 }
10351
10352 /****************************************************************
10353 _spoolss_56
10354 ****************************************************************/
10355
10356 WERROR _spoolss_56(pipes_struct *p,
10357 struct spoolss_56 *r)
10358 {
10359 p->rng_fault_state = true;
10360 return WERR_NOT_SUPPORTED;
10361 }
10362
10363 /****************************************************************
10364 _spoolss_57
10365 ****************************************************************/
10366
10367 WERROR _spoolss_57(pipes_struct *p,
10368 struct spoolss_57 *r)
10369 {
10370 p->rng_fault_state = true;
10371 return WERR_NOT_SUPPORTED;
10372 }
10373
10374 /****************************************************************
10375 _spoolss_5a
10376 ****************************************************************/
10377
10378 WERROR _spoolss_5a(pipes_struct *p,
10379 struct spoolss_5a *r)
10380 {
10381 p->rng_fault_state = true;
10382 return WERR_NOT_SUPPORTED;
10383 }
10384
10385 /****************************************************************
10386 _spoolss_5b
10387 ****************************************************************/
10388
10389 WERROR _spoolss_5b(pipes_struct *p,
10390 struct spoolss_5b *r)
10391 {
10392 p->rng_fault_state = true;
10393 return WERR_NOT_SUPPORTED;
10394 }
10395
10396 /****************************************************************
10397 _spoolss_5c
10398 ****************************************************************/
10399
10400 WERROR _spoolss_5c(pipes_struct *p,
10401 struct spoolss_5c *r)
10402 {
10403 p->rng_fault_state = true;
10404 return WERR_NOT_SUPPORTED;
10405 }
10406
10407 /****************************************************************
10408 _spoolss_5d
10409 ****************************************************************/
10410
10411 WERROR _spoolss_5d(pipes_struct *p,
10412 struct spoolss_5d *r)
10413 {
10414 p->rng_fault_state = true;
10415 return WERR_NOT_SUPPORTED;
10416 }
10417
10418 /****************************************************************
10419 _spoolss_5e
10420 ****************************************************************/
10421
10422 WERROR _spoolss_5e(pipes_struct *p,
10423 struct spoolss_5e *r)
10424 {
10425 p->rng_fault_state = true;
10426 return WERR_NOT_SUPPORTED;
10427 }
10428
10429 /****************************************************************
10430 _spoolss_5f
10431 ****************************************************************/
10432
10433 WERROR _spoolss_5f(pipes_struct *p,
10434 struct spoolss_5f *r)
10435 {
10436 p->rng_fault_state = true;
10437 return WERR_NOT_SUPPORTED;
10438 }
10439
Samba GIT mirror