?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-spoolss: add support for _spoolss_EnumPrinterDrivers() level 5.
[Samba.git] / source3 / rpc_server / srv_spoolss_nt.c
blobb181d81455a49625112536c94c1241b64166c9c8
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 != 0) &&
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 != 0)
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 != 0)
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->config_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 default:
6800 result = WERR_UNKNOWN_LEVEL;
6801 break;
6802 }
6803
6804 if (!W_ERROR_IS_OK(result)) {
6805 free_a_printer_driver(driver, 3);
6806 goto out;
6807 }
6808 free_a_printer_driver(driver, 3);
6809 }
6810
6811 count += ndrivers;
6812 SAFE_FREE(list);
6813 }
6814
6815 out:
6816 SAFE_FREE(list);
6817
6818 if (!W_ERROR_IS_OK(result)) {
6819 TALLOC_FREE(info);
6820 return result;
6821 }
6822
6823 *info_p = info;
6824 *count_p = count;
6825
6826 return WERR_OK;
6827 }
6828
6829 /****************************************************************************
6830 Enumerates all printer drivers at level 1.
6831 ****************************************************************************/
6832
6833 static WERROR enumprinterdrivers_level1(TALLOC_CTX *mem_ctx,
6834 const char *servername,
6835 const char *architecture,
6836 union spoolss_DriverInfo **info_p,
6837 uint32_t *count)
6838 {
6839 return enumprinterdrivers_level(mem_ctx, servername, architecture, 1,
6840 info_p, count);
6841 }
6842
6843 /****************************************************************************
6844 Enumerates all printer drivers at level 2.
6845 ****************************************************************************/
6846
6847 static WERROR enumprinterdrivers_level2(TALLOC_CTX *mem_ctx,
6848 const char *servername,
6849 const char *architecture,
6850 union spoolss_DriverInfo **info_p,
6851 uint32_t *count)
6852 {
6853 return enumprinterdrivers_level(mem_ctx, servername, architecture, 2,
6854 info_p, count);
6855 }
6856
6857 /****************************************************************************
6858 Enumerates all printer drivers at level 3.
6859 ****************************************************************************/
6860
6861 static WERROR enumprinterdrivers_level3(TALLOC_CTX *mem_ctx,
6862 const char *servername,
6863 const char *architecture,
6864 union spoolss_DriverInfo **info_p,
6865 uint32_t *count)
6866 {
6867 return enumprinterdrivers_level(mem_ctx, servername, architecture, 3,
6868 info_p, count);
6869 }
6870
6871 /****************************************************************************
6872 Enumerates all printer drivers at level 4.
6873 ****************************************************************************/
6874
6875 static WERROR enumprinterdrivers_level4(TALLOC_CTX *mem_ctx,
6876 const char *servername,
6877 const char *architecture,
6878 union spoolss_DriverInfo **info_p,
6879 uint32_t *count)
6880 {
6881 return enumprinterdrivers_level(mem_ctx, servername, architecture, 4,
6882 info_p, count);
6883 }
6884
6885 /****************************************************************************
6886 Enumerates all printer drivers at level 5.
6887 ****************************************************************************/
6888
6889 static WERROR enumprinterdrivers_level5(TALLOC_CTX *mem_ctx,
6890 const char *servername,
6891 const char *architecture,
6892 union spoolss_DriverInfo **info_p,
6893 uint32_t *count)
6894 {
6895 return enumprinterdrivers_level(mem_ctx, servername, architecture, 5,
6896 info_p, count);
6897 }
6898
6899 /****************************************************************
6900 _spoolss_EnumPrinterDrivers
6901 ****************************************************************/
6902
6903 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6904 struct spoolss_EnumPrinterDrivers *r)
6905 {
6906 const char *cservername;
6907 WERROR result;
6908
6909 /* that's an [in out] buffer */
6910
6911 if (!r->in.buffer && (r->in.offered != 0)) {
6912 return WERR_INVALID_PARAM;
6913 }
6914
6915 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6916
6917 *r->out.needed = 0;
6918 *r->out.count = 0;
6919 *r->out.info = NULL;
6920
6921 cservername = canon_servername(r->in.server);
6922
6923 if (!is_myname_or_ipaddr(cservername)) {
6924 return WERR_UNKNOWN_PRINTER_DRIVER;
6925 }
6926
6927 switch (r->in.level) {
6928 case 1:
6929 result = enumprinterdrivers_level1(p->mem_ctx, cservername,
6930 r->in.environment,
6931 r->out.info, r->out.count);
6932 break;
6933 case 2:
6934 result = enumprinterdrivers_level2(p->mem_ctx, cservername,
6935 r->in.environment,
6936 r->out.info, r->out.count);
6937 break;
6938 case 3:
6939 result = enumprinterdrivers_level3(p->mem_ctx, cservername,
6940 r->in.environment,
6941 r->out.info, r->out.count);
6942 break;
6943 case 4:
6944 result = enumprinterdrivers_level4(p->mem_ctx, cservername,
6945 r->in.environment,
6946 r->out.info, r->out.count);
6947 break;
6948 case 5:
6949 result = enumprinterdrivers_level5(p->mem_ctx, cservername,
6950 r->in.environment,
6951 r->out.info, r->out.count);
6952 break;
6953 default:
6954 return WERR_UNKNOWN_LEVEL;
6955 }
6956
6957 if (!W_ERROR_IS_OK(result)) {
6958 return result;
6959 }
6960
6961 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6962 spoolss_EnumPrinterDrivers, NULL,
6963 *r->out.info, r->in.level,
6964 *r->out.count);
6965 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6966 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6967
6968 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6969 }
6970
6971 /****************************************************************************
6972 ****************************************************************************/
6973
6974 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
6975 struct spoolss_FormInfo1 *r,
6976 const nt_forms_struct *form)
6977 {
6978 r->form_name = talloc_strdup(mem_ctx, form->name);
6979 W_ERROR_HAVE_NO_MEMORY(r->form_name);
6980
6981 r->flags = form->flag;
6982 r->size.width = form->width;
6983 r->size.height = form->length;
6984 r->area.left = form->left;
6985 r->area.top = form->top;
6986 r->area.right = form->right;
6987 r->area.bottom = form->bottom;
6988
6989 return WERR_OK;
6990 }
6991
6992 /****************************************************************
6993 spoolss_enumforms_level1
6994 ****************************************************************/
6995
6996 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
6997 const nt_forms_struct *builtin_forms,
6998 uint32_t num_builtin_forms,
6999 const nt_forms_struct *user_forms,
7000 uint32_t num_user_forms,
7001 union spoolss_FormInfo **info_p,
7002 uint32_t *count)
7003 {
7004 union spoolss_FormInfo *info;
7005 WERROR result = WERR_OK;
7006 int i;
7007
7008 *count = num_builtin_forms + num_user_forms;
7009
7010 info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
7011 W_ERROR_HAVE_NO_MEMORY(info);
7012
7013 /* construct the list of form structures */
7014 for (i=0; i<num_builtin_forms; i++) {
7015 DEBUGADD(6,("Filling form number [%d]\n",i));
7016 result = fill_form_info_1(info, &info[i].info1,
7017 &builtin_forms[i]);
7018 if (!W_ERROR_IS_OK(result)) {
7019 goto out;
7020 }
7021 }
7022
7023 for (; i<num_user_forms; i++) {
7024 DEBUGADD(6,("Filling form number [%d]\n",i));
7025 result = fill_form_info_1(info, &info[i].info1,
7026 &user_forms[i-num_builtin_forms]);
7027 if (!W_ERROR_IS_OK(result)) {
7028 goto out;
7029 }
7030 }
7031
7032 out:
7033 if (!W_ERROR_IS_OK(result)) {
7034 TALLOC_FREE(info);
7035 *count = 0;
7036 return result;
7037 }
7038
7039 *info_p = info;
7040
7041 return WERR_OK;
7042 }
7043
7044 /****************************************************************
7045 _spoolss_EnumForms
7046 ****************************************************************/
7047
7048 WERROR _spoolss_EnumForms(pipes_struct *p,
7049 struct spoolss_EnumForms *r)
7050 {
7051 WERROR result;
7052 nt_forms_struct *user_forms = NULL;
7053 nt_forms_struct *builtin_forms = NULL;
7054 uint32_t num_user_forms;
7055 uint32_t num_builtin_forms;
7056
7057 *r->out.count = 0;
7058 *r->out.needed = 0;
7059 *r->out.info = NULL;
7060
7061 /* that's an [in out] buffer */
7062
7063 if (!r->in.buffer && (r->in.offered != 0) ) {
7064 return WERR_INVALID_PARAM;
7065 }
7066
7067 DEBUG(4,("_spoolss_EnumForms\n"));
7068 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7069 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7070
7071 num_builtin_forms = get_builtin_ntforms(&builtin_forms);
7072 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
7073 num_user_forms = get_ntforms(&user_forms);
7074 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
7075
7076 if (num_user_forms + num_builtin_forms == 0) {
7077 SAFE_FREE(builtin_forms);
7078 SAFE_FREE(user_forms);
7079 return WERR_NO_MORE_ITEMS;
7080 }
7081
7082 switch (r->in.level) {
7083 case 1:
7084 result = spoolss_enumforms_level1(p->mem_ctx,
7085 builtin_forms,
7086 num_builtin_forms,
7087 user_forms,
7088 num_user_forms,
7089 r->out.info,
7090 r->out.count);
7091 break;
7092 default:
7093 result = WERR_UNKNOWN_LEVEL;
7094 break;
7095 }
7096
7097 SAFE_FREE(user_forms);
7098 SAFE_FREE(builtin_forms);
7099
7100 if (!W_ERROR_IS_OK(result)) {
7101 return result;
7102 }
7103
7104 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7105 spoolss_EnumForms, NULL,
7106 *r->out.info, r->in.level,
7107 *r->out.count);
7108 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7109 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7110
7111 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7112 }
7113
7114 /****************************************************************
7115 ****************************************************************/
7116
7117 static WERROR find_form_byname(const char *name,
7118 nt_forms_struct *form)
7119 {
7120 nt_forms_struct *list = NULL;
7121 int num_forms = 0, i = 0;
7122
7123 if (get_a_builtin_ntform_by_string(name, form)) {
7124 return WERR_OK;
7125 }
7126
7127 num_forms = get_ntforms(&list);
7128 DEBUGADD(5,("Number of forms [%d]\n", num_forms));
7129
7130 if (num_forms == 0) {
7131 return WERR_BADFID;
7132 }
7133
7134 /* Check if the requested name is in the list of form structures */
7135 for (i = 0; i < num_forms; i++) {
7136
7137 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
7138
7139 if (strequal(name, list[i].name)) {
7140 DEBUGADD(6,("Found form %s number [%d]\n", name, i));
7141 *form = list[i];
7142 SAFE_FREE(list);
7143 return WERR_OK;
7144 }
7145 }
7146
7147 SAFE_FREE(list);
7148
7149 return WERR_BADFID;
7150 }
7151
7152 /****************************************************************
7153 _spoolss_GetForm
7154 ****************************************************************/
7155
7156 WERROR _spoolss_GetForm(pipes_struct *p,
7157 struct spoolss_GetForm *r)
7158 {
7159 WERROR result;
7160 nt_forms_struct form;
7161
7162 /* that's an [in out] buffer */
7163
7164 if (!r->in.buffer && (r->in.offered != 0)) {
7165 return WERR_INVALID_PARAM;
7166 }
7167
7168 DEBUG(4,("_spoolss_GetForm\n"));
7169 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7170 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7171
7172 result = find_form_byname(r->in.form_name, &form);
7173 if (!W_ERROR_IS_OK(result)) {
7174 TALLOC_FREE(r->out.info);
7175 return result;
7176 }
7177
7178 switch (r->in.level) {
7179 case 1:
7180 result = fill_form_info_1(p->mem_ctx,
7181 &r->out.info->info1,
7182 &form);
7183 break;
7184
7185 default:
7186 result = WERR_UNKNOWN_LEVEL;
7187 break;
7188 }
7189
7190 if (!W_ERROR_IS_OK(result)) {
7191 TALLOC_FREE(r->out.info);
7192 return result;
7193 }
7194
7195 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
7196 r->out.info, r->in.level);
7197 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7198
7199 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7200 }
7201
7202 /****************************************************************************
7203 ****************************************************************************/
7204
7205 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7206 struct spoolss_PortInfo1 *r,
7207 const char *name)
7208 {
7209 r->port_name = talloc_strdup(mem_ctx, name);
7210 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7211
7212 return WERR_OK;
7213 }
7214
7215 /****************************************************************************
7216 TODO: This probably needs distinguish between TCP/IP and Local ports
7217 somehow.
7218 ****************************************************************************/
7219
7220 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7221 struct spoolss_PortInfo2 *r,
7222 const char *name)
7223 {
7224 r->port_name = talloc_strdup(mem_ctx, name);
7225 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7226
7227 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7228 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7229
7230 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7231 W_ERROR_HAVE_NO_MEMORY(r->description);
7232
7233 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7234 r->reserved = 0;
7235
7236 return WERR_OK;
7237 }
7238
7239
7240 /****************************************************************************
7241 wrapper around the enumer ports command
7242 ****************************************************************************/
7243
7244 WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines )
7245 {
7246 char *cmd = lp_enumports_cmd();
7247 char **qlines = NULL;
7248 char *command = NULL;
7249 int numlines;
7250 int ret;
7251 int fd;
7252
7253 *count = 0;
7254 *lines = NULL;
7255
7256 /* if no hook then just fill in the default port */
7257
7258 if ( !*cmd ) {
7259 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7260 return WERR_NOMEM;
7261 }
7262 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7263 TALLOC_FREE(qlines);
7264 return WERR_NOMEM;
7265 }
7266 qlines[1] = NULL;
7267 numlines = 1;
7268 }
7269 else {
7270 /* we have a valid enumport command */
7271
7272 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7273 if (!command) {
7274 return WERR_NOMEM;
7275 }
7276
7277 DEBUG(10,("Running [%s]\n", command));
7278 ret = smbrun(command, &fd);
7279 DEBUG(10,("Returned [%d]\n", ret));
7280 TALLOC_FREE(command);
7281 if (ret != 0) {
7282 if (fd != -1) {
7283 close(fd);
7284 }
7285 return WERR_ACCESS_DENIED;
7286 }
7287
7288 numlines = 0;
7289 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7290 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7291 close(fd);
7292 }
7293
7294 *count = numlines;
7295 *lines = qlines;
7296
7297 return WERR_OK;
7298 }
7299
7300 /****************************************************************************
7301 enumports level 1.
7302 ****************************************************************************/
7303
7304 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7305 union spoolss_PortInfo **info_p,
7306 uint32_t *count)
7307 {
7308 union spoolss_PortInfo *info = NULL;
7309 int i=0;
7310 WERROR result = WERR_OK;
7311 char **qlines = NULL;
7312 int numlines = 0;
7313
7314 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7315 if (!W_ERROR_IS_OK(result)) {
7316 goto out;
7317 }
7318
7319 if (numlines) {
7320 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7321 if (!info) {
7322 DEBUG(10,("Returning WERR_NOMEM\n"));
7323 result = WERR_NOMEM;
7324 goto out;
7325 }
7326
7327 for (i=0; i<numlines; i++) {
7328 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7329 result = fill_port_1(info, &info[i].info1, qlines[i]);
7330 if (!W_ERROR_IS_OK(result)) {
7331 goto out;
7332 }
7333 }
7334 }
7335 TALLOC_FREE(qlines);
7336
7337 out:
7338 if (!W_ERROR_IS_OK(result)) {
7339 TALLOC_FREE(info);
7340 TALLOC_FREE(qlines);
7341 *count = 0;
7342 *info_p = NULL;
7343 return result;
7344 }
7345
7346 *info_p = info;
7347 *count = numlines;
7348
7349 return WERR_OK;
7350 }
7351
7352 /****************************************************************************
7353 enumports level 2.
7354 ****************************************************************************/
7355
7356 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7357 union spoolss_PortInfo **info_p,
7358 uint32_t *count)
7359 {
7360 union spoolss_PortInfo *info = NULL;
7361 int i=0;
7362 WERROR result = WERR_OK;
7363 char **qlines = NULL;
7364 int numlines = 0;
7365
7366 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7367 if (!W_ERROR_IS_OK(result)) {
7368 goto out;
7369 }
7370
7371 if (numlines) {
7372 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7373 if (!info) {
7374 DEBUG(10,("Returning WERR_NOMEM\n"));
7375 result = WERR_NOMEM;
7376 goto out;
7377 }
7378
7379 for (i=0; i<numlines; i++) {
7380 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7381 result = fill_port_2(info, &info[i].info2, qlines[i]);
7382 if (!W_ERROR_IS_OK(result)) {
7383 goto out;
7384 }
7385 }
7386 }
7387 TALLOC_FREE(qlines);
7388
7389 out:
7390 if (!W_ERROR_IS_OK(result)) {
7391 TALLOC_FREE(info);
7392 TALLOC_FREE(qlines);
7393 *count = 0;
7394 *info_p = NULL;
7395 return result;
7396 }
7397
7398 *info_p = info;
7399 *count = numlines;
7400
7401 return WERR_OK;
7402 }
7403
7404 /****************************************************************
7405 _spoolss_EnumPorts
7406 ****************************************************************/
7407
7408 WERROR _spoolss_EnumPorts(pipes_struct *p,
7409 struct spoolss_EnumPorts *r)
7410 {
7411 WERROR result;
7412
7413 /* that's an [in out] buffer */
7414
7415 if (!r->in.buffer && (r->in.offered != 0)) {
7416 return WERR_INVALID_PARAM;
7417 }
7418
7419 DEBUG(4,("_spoolss_EnumPorts\n"));
7420
7421 *r->out.count = 0;
7422 *r->out.needed = 0;
7423 *r->out.info = NULL;
7424
7425 switch (r->in.level) {
7426 case 1:
7427 result = enumports_level_1(p->mem_ctx, r->out.info,
7428 r->out.count);
7429 break;
7430 case 2:
7431 result = enumports_level_2(p->mem_ctx, r->out.info,
7432 r->out.count);
7433 break;
7434 default:
7435 return WERR_UNKNOWN_LEVEL;
7436 }
7437
7438 if (!W_ERROR_IS_OK(result)) {
7439 return result;
7440 }
7441
7442 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7443 spoolss_EnumPorts, NULL,
7444 *r->out.info, r->in.level,
7445 *r->out.count);
7446 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7447 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7448
7449 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7450 }
7451
7452 /****************************************************************************
7453 ****************************************************************************/
7454
7455 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7456 const char *server,
7457 struct spoolss_SetPrinterInfoCtr *info_ctr,
7458 struct spoolss_DeviceMode *devmode,
7459 struct security_descriptor *sec_desc,
7460 struct spoolss_UserLevelCtr *user_ctr,
7461 struct policy_handle *handle)
7462 {
7463 NT_PRINTER_INFO_LEVEL *printer = NULL;
7464 fstring name;
7465 int snum;
7466 WERROR err = WERR_OK;
7467
7468 if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7469 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7470 return WERR_NOMEM;
7471 }
7472
7473 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7474 if (!convert_printer_info(info_ctr, printer)) {
7475 free_a_printer(&printer, 2);
7476 return WERR_NOMEM;
7477 }
7478
7479 /* check to see if the printer already exists */
7480
7481 if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7482 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7483 printer->info_2->sharename));
7484 free_a_printer(&printer, 2);
7485 return WERR_PRINTER_ALREADY_EXISTS;
7486 }
7487
7488 /* FIXME!!! smbd should check to see if the driver is installed before
7489 trying to add a printer like this --jerry */
7490
7491 if (*lp_addprinter_cmd() ) {
7492 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7493 printer) ) {
7494 free_a_printer(&printer,2);
7495 return WERR_ACCESS_DENIED;
7496 }
7497 } else {
7498 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7499 "smb.conf parameter \"addprinter command\" is defined. This"
7500 "parameter must exist for this call to succeed\n",
7501 printer->info_2->sharename ));
7502 }
7503
7504 /* use our primary netbios name since get_a_printer() will convert
7505 it to what the client expects on a case by case basis */
7506
7507 slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7508 printer->info_2->sharename);
7509
7510
7511 if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7512 free_a_printer(&printer,2);
7513 return WERR_ACCESS_DENIED;
7514 }
7515
7516 /* you must be a printer admin to add a new printer */
7517 if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
7518 free_a_printer(&printer,2);
7519 return WERR_ACCESS_DENIED;
7520 }
7521
7522 /*
7523 * Do sanity check on the requested changes for Samba.
7524 */
7525
7526 if (!check_printer_ok(printer->info_2, snum)) {
7527 free_a_printer(&printer,2);
7528 return WERR_INVALID_PARAM;
7529 }
7530
7531 /*
7532 * When a printer is created, the drivername bound to the printer is used
7533 * to lookup previously saved driver initialization info, which is then
7534 * bound to the new printer, simulating what happens in the Windows arch.
7535 */
7536
7537 if (!devmode)
7538 {
7539 set_driver_init(printer, 2);
7540 }
7541 else
7542 {
7543 /* A valid devmode was included, convert and link it
7544 */
7545 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7546
7547 if (!convert_devicemode(printer->info_2->printername, devmode,
7548 &printer->info_2->devmode)) {
7549 return WERR_NOMEM;
7550 }
7551 }
7552
7553 /* write the ASCII on disk */
7554 err = mod_a_printer(printer, 2);
7555 if (!W_ERROR_IS_OK(err)) {
7556 free_a_printer(&printer,2);
7557 return err;
7558 }
7559
7560 if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7561 /* Handle open failed - remove addition. */
7562 del_a_printer(printer->info_2->sharename);
7563 free_a_printer(&printer,2);
7564 ZERO_STRUCTP(handle);
7565 return WERR_ACCESS_DENIED;
7566 }
7567
7568 update_c_setprinter(false);
7569 free_a_printer(&printer,2);
7570
7571 return WERR_OK;
7572 }
7573
7574 /****************************************************************
7575 _spoolss_AddPrinterEx
7576 ****************************************************************/
7577
7578 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7579 struct spoolss_AddPrinterEx *r)
7580 {
7581 switch (r->in.info_ctr->level) {
7582 case 1:
7583 /* we don't handle yet */
7584 /* but I know what to do ... */
7585 return WERR_UNKNOWN_LEVEL;
7586 case 2:
7587 return spoolss_addprinterex_level_2(p, r->in.server,
7588 r->in.info_ctr,
7589 r->in.devmode_ctr->devmode,
7590 r->in.secdesc_ctr->sd,
7591 r->in.userlevel_ctr,
7592 r->out.handle);
7593 default:
7594 return WERR_UNKNOWN_LEVEL;
7595 }
7596 }
7597
7598 /****************************************************************
7599 _spoolss_AddPrinterDriver
7600 ****************************************************************/
7601
7602 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7603 struct spoolss_AddPrinterDriver *r)
7604 {
7605 uint32_t level = r->in.info_ctr->level;
7606 struct spoolss_AddDriverInfoCtr *info = r->in.info_ctr;
7607 WERROR err = WERR_OK;
7608 NT_PRINTER_DRIVER_INFO_LEVEL driver;
7609 const char *driver_name = NULL;
7610 uint32_t version;
7611 const char *fn;
7612
7613 switch (p->hdr_req.opnum) {
7614 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7615 fn = "_spoolss_AddPrinterDriver";
7616 break;
7617 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7618 fn = "_spoolss_AddPrinterDriverEx";
7619 break;
7620 default:
7621 return WERR_INVALID_PARAM;
7622 }
7623
7624
7625 /* FIXME */
7626 if (level != 3 && level != 6) {
7627 /* Clever hack from Martin Zielinski <mz@seh.de>
7628 * to allow downgrade from level 8 (Vista).
7629 */
7630 DEBUG(0,("%s: level %d not yet implemented\n", fn, level));
7631 return WERR_UNKNOWN_LEVEL;
7632 }
7633
7634 ZERO_STRUCT(driver);
7635
7636 if (!convert_printer_driver_info(info, &driver, level)) {
7637 err = WERR_NOMEM;
7638 goto done;
7639 }
7640
7641 DEBUG(5,("Cleaning driver's information\n"));
7642 err = clean_up_driver_struct(p, driver, level);
7643 if (!W_ERROR_IS_OK(err))
7644 goto done;
7645
7646 DEBUG(5,("Moving driver to final destination\n"));
7647 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, driver, level,
7648 &err)) ) {
7649 goto done;
7650 }
7651
7652 if (add_a_printer_driver(driver, level)!=0) {
7653 err = WERR_ACCESS_DENIED;
7654 goto done;
7655 }
7656
7657 switch(level) {
7658 case 3:
7659 driver_name = driver.info_3->name ? driver.info_3->name : "";
7660 break;
7661 case 6:
7662 driver_name = driver.info_6->name ? driver.info_6->name : "";
7663 break;
7664 }
7665
7666 /*
7667 * I think this is where he DrvUpgradePrinter() hook would be
7668 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7669 * server. Right now, we just need to send ourselves a message
7670 * to update each printer bound to this driver. --jerry
7671 */
7672
7673 if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7674 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7675 fn, driver_name));
7676 }
7677
7678 /*
7679 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7680 * decide if the driver init data should be deleted. The rules are:
7681 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7682 * 2) delete init data only if there is no 2k/Xp driver
7683 * 3) always delete init data
7684 * The generalized rule is always use init data from the highest order driver.
7685 * It is necessary to follow the driver install by an initialization step to
7686 * finish off this process.
7687 */
7688 if (level == 3)
7689 version = driver.info_3->cversion;
7690 else if (level == 6)
7691 version = driver.info_6->version;
7692 else
7693 version = -1;
7694 switch (version) {
7695 /*
7696 * 9x printer driver - never delete init data
7697 */
7698 case 0:
7699 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7700 fn, driver_name));
7701 break;
7702
7703 /*
7704 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7705 * there is no 2k/Xp driver init data for this driver name.
7706 */
7707 case 2:
7708 {
7709 NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7710
7711 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7712 /*
7713 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7714 */
7715 if (!del_driver_init(driver_name))
7716 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7717 fn, driver_name));
7718 } else {
7719 /*
7720 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7721 */
7722 free_a_printer_driver(driver1,3);
7723 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7724 fn, driver_name));
7725 }
7726 }
7727 break;
7728
7729 /*
7730 * 2k or Xp printer driver - always delete init data
7731 */
7732 case 3:
7733 if (!del_driver_init(driver_name))
7734 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7735 fn, driver_name));
7736 break;
7737
7738 default:
7739 DEBUG(0,("%s: invalid level=%d\n", fn, level));
7740 break;
7741 }
7742
7743
7744 done:
7745 free_a_printer_driver(driver, level);
7746 return err;
7747 }
7748
7749 /****************************************************************
7750 _spoolss_AddPrinterDriverEx
7751 ****************************************************************/
7752
7753 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7754 struct spoolss_AddPrinterDriverEx *r)
7755 {
7756 struct spoolss_AddPrinterDriver a;
7757
7758 /*
7759 * we only support the semantics of AddPrinterDriver()
7760 * i.e. only copy files that are newer than existing ones
7761 */
7762
7763 if (r->in.flags != APD_COPY_NEW_FILES) {
7764 return WERR_ACCESS_DENIED;
7765 }
7766
7767 a.in.servername = r->in.servername;
7768 a.in.info_ctr = r->in.info_ctr;
7769
7770 return _spoolss_AddPrinterDriver(p, &a);
7771 }
7772
7773 /****************************************************************************
7774 ****************************************************************************/
7775
7776 struct _spoolss_paths {
7777 int type;
7778 const char *share;
7779 const char *dir;
7780 };
7781
7782 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7783
7784 static const struct _spoolss_paths spoolss_paths[]= {
7785 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
7786 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
7787 };
7788
7789 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7790 const char *servername,
7791 const char *environment,
7792 int component,
7793 char **path)
7794 {
7795 const char *pservername = NULL;
7796 const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7797 const char *short_archi;
7798
7799 *path = NULL;
7800
7801 /* environment may be empty */
7802 if (environment && strlen(environment)) {
7803 long_archi = environment;
7804 }
7805
7806 /* servername may be empty */
7807 if (servername && strlen(servername)) {
7808 pservername = canon_servername(servername);
7809
7810 if (!is_myname_or_ipaddr(pservername)) {
7811 return WERR_INVALID_PARAM;
7812 }
7813 }
7814
7815 if (!(short_archi = get_short_archi(long_archi))) {
7816 return WERR_INVALID_ENVIRONMENT;
7817 }
7818
7819 switch (component) {
7820 case SPOOLSS_PRTPROCS_PATH:
7821 case SPOOLSS_DRIVER_PATH:
7822 if (pservername) {
7823 *path = talloc_asprintf(mem_ctx,
7824 "\\\\%s\\%s\\%s",
7825 pservername,
7826 spoolss_paths[component].share,
7827 short_archi);
7828 } else {
7829 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7830 SPOOLSS_DEFAULT_SERVER_PATH,
7831 spoolss_paths[component].dir,
7832 short_archi);
7833 }
7834 break;
7835 default:
7836 return WERR_INVALID_PARAM;
7837 }
7838
7839 if (!*path) {
7840 return WERR_NOMEM;
7841 }
7842
7843 return WERR_OK;
7844 }
7845
7846 /****************************************************************************
7847 ****************************************************************************/
7848
7849 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7850 const char *servername,
7851 const char *environment,
7852 struct spoolss_DriverDirectoryInfo1 *r)
7853 {
7854 WERROR werr;
7855 char *path = NULL;
7856
7857 werr = compose_spoolss_server_path(mem_ctx,
7858 servername,
7859 environment,
7860 SPOOLSS_DRIVER_PATH,
7861 &path);
7862 if (!W_ERROR_IS_OK(werr)) {
7863 return werr;
7864 }
7865
7866 DEBUG(4,("printer driver directory: [%s]\n", path));
7867
7868 r->directory_name = path;
7869
7870 return WERR_OK;
7871 }
7872
7873 /****************************************************************
7874 _spoolss_GetPrinterDriverDirectory
7875 ****************************************************************/
7876
7877 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7878 struct spoolss_GetPrinterDriverDirectory *r)
7879 {
7880 WERROR werror;
7881
7882 /* that's an [in out] buffer */
7883
7884 if (!r->in.buffer && (r->in.offered != 0)) {
7885 return WERR_INVALID_PARAM;
7886 }
7887
7888 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7889 r->in.level));
7890
7891 *r->out.needed = 0;
7892
7893 /* r->in.level is ignored */
7894
7895 werror = getprinterdriverdir_level_1(p->mem_ctx,
7896 r->in.server,
7897 r->in.environment,
7898 &r->out.info->info1);
7899 if (!W_ERROR_IS_OK(werror)) {
7900 TALLOC_FREE(r->out.info);
7901 return werror;
7902 }
7903
7904 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
7905 r->out.info, r->in.level);
7906 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7907
7908 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7909 }
7910
7911 /****************************************************************
7912 _spoolss_EnumPrinterData
7913 ****************************************************************/
7914
7915 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
7916 struct spoolss_EnumPrinterData *r)
7917 {
7918 NT_PRINTER_INFO_LEVEL *printer = NULL;
7919 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7920 int snum;
7921 WERROR result;
7922 REGISTRY_VALUE *val = NULL;
7923 NT_PRINTER_DATA *p_data;
7924 int i, key_index, num_values;
7925 int name_length;
7926
7927 *r->out.value_needed = 0;
7928 *r->out.type = REG_NONE;
7929 *r->out.data_needed = 0;
7930
7931 DEBUG(5,("_spoolss_EnumPrinterData\n"));
7932
7933 if (!Printer) {
7934 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
7935 OUR_HANDLE(r->in.handle)));
7936 return WERR_BADFID;
7937 }
7938
7939 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7940 return WERR_BADFID;
7941 }
7942
7943 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7944 if (!W_ERROR_IS_OK(result)) {
7945 return result;
7946 }
7947
7948 p_data = printer->info_2->data;
7949 key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
7950
7951 result = WERR_OK;
7952
7953 /*
7954 * The NT machine wants to know the biggest size of value and data
7955 *
7956 * cf: MSDN EnumPrinterData remark section
7957 */
7958
7959 if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
7960
7961 uint32_t biggest_valuesize = 0;
7962 uint32_t biggest_datasize = 0;
7963
7964 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7965
7966 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
7967
7968 for ( i=0; i<num_values; i++ )
7969 {
7970 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
7971
7972 name_length = strlen(val->valuename);
7973 if ( strlen(val->valuename) > biggest_valuesize )
7974 biggest_valuesize = name_length;
7975
7976 if ( val->size > biggest_datasize )
7977 biggest_datasize = val->size;
7978
7979 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
7980 biggest_datasize));
7981 }
7982
7983 /* the value is an UNICODE string but real_value_size is the length
7984 in bytes including the trailing 0 */
7985
7986 *r->out.value_needed = 2 * (1 + biggest_valuesize);
7987 *r->out.data_needed = biggest_datasize;
7988
7989 DEBUG(6,("final values: [%d], [%d]\n",
7990 *r->out.value_needed, *r->out.data_needed));
7991
7992 goto done;
7993 }
7994
7995 /*
7996 * the value len is wrong in NT sp3
7997 * that's the number of bytes not the number of unicode chars
7998 */
7999
8000 if (key_index != -1) {
8001 val = regval_ctr_specific_value(p_data->keys[key_index].values,
8002 r->in.enum_index);
8003 }
8004
8005 if (!val) {
8006
8007 /* out_value should default to "" or else NT4 has
8008 problems unmarshalling the response */
8009
8010 if (r->in.value_offered) {
8011 *r->out.value_needed = 1;
8012 r->out.value_name = talloc_strdup(r, "");
8013 if (!r->out.value_name) {
8014 result = WERR_NOMEM;
8015 goto done;
8016 }
8017 } else {
8018 r->out.value_name = NULL;
8019 *r->out.value_needed = 0;
8020 }
8021
8022 /* the data is counted in bytes */
8023
8024 *r->out.data_needed = r->in.data_offered;
8025
8026 result = WERR_NO_MORE_ITEMS;
8027 } else {
8028 /*
8029 * the value is:
8030 * - counted in bytes in the request
8031 * - counted in UNICODE chars in the max reply
8032 * - counted in bytes in the real size
8033 *
8034 * take a pause *before* coding not *during* coding
8035 */
8036
8037 /* name */
8038 if (r->in.value_offered) {
8039 r->out.value_name = talloc_strdup(r, regval_name(val));
8040 if (!r->out.value_name) {
8041 result = WERR_NOMEM;
8042 goto done;
8043 }
8044 *r->out.value_needed = strlen_m(regval_name(val));
8045 } else {
8046 r->out.value_name = NULL;
8047 *r->out.value_needed = 0;
8048 }
8049
8050 /* type */
8051
8052 *r->out.type = regval_type(val);
8053
8054 /* data - counted in bytes */
8055
8056 if (r->out.data && regval_size(val)) {
8057 memcpy(r->out.data, regval_data_p(val), regval_size(val));
8058 }
8059
8060 *r->out.data_needed = regval_size(val);
8061 }
8062
8063 done:
8064 free_a_printer(&printer, 2);
8065 return result;
8066 }
8067
8068 /****************************************************************
8069 _spoolss_SetPrinterData
8070 ****************************************************************/
8071
8072 WERROR _spoolss_SetPrinterData(pipes_struct *p,
8073 struct spoolss_SetPrinterData *r)
8074 {
8075 NT_PRINTER_INFO_LEVEL *printer = NULL;
8076 int snum=0;
8077 WERROR result = WERR_OK;
8078 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8079 DATA_BLOB blob;
8080
8081 DEBUG(5,("_spoolss_SetPrinterData\n"));
8082
8083 if (!Printer) {
8084 DEBUG(2,("_spoolss_SetPrinterData: Invalid handle (%s:%u:%u).\n",
8085 OUR_HANDLE(r->in.handle)));
8086 return WERR_BADFID;
8087 }
8088
8089 if (Printer->printer_type == SPLHND_SERVER) {
8090 DEBUG(10,("_spoolss_SetPrinterData: "
8091 "Not implemented for server handles yet\n"));
8092 return WERR_INVALID_PARAM;
8093 }
8094
8095 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8096 return WERR_BADFID;
8097 }
8098
8099 /*
8100 * Access check : NT returns "access denied" if you make a
8101 * SetPrinterData call without the necessary privildge.
8102 * we were originally returning OK if nothing changed
8103 * which made Win2k issue **a lot** of SetPrinterData
8104 * when connecting to a printer --jerry
8105 */
8106
8107 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8108 DEBUG(3,("_spoolss_SetPrinterData: "
8109 "change denied by handle access permissions\n"));
8110 result = WERR_ACCESS_DENIED;
8111 goto done;
8112 }
8113
8114 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8115 if (!W_ERROR_IS_OK(result)) {
8116 return result;
8117 }
8118
8119 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8120 r->in.type, &r->in.data);
8121 if (!W_ERROR_IS_OK(result)) {
8122 goto done;
8123 }
8124
8125 /*
8126 * When client side code sets a magic printer data key, detect it and save
8127 * the current printer data and the magic key's data (its the DEVMODE) for
8128 * future printer/driver initializations.
8129 */
8130 if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8131 /* Set devmode and printer initialization info */
8132 result = save_driver_init(printer, 2, blob.data, blob.length);
8133
8134 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8135
8136 goto done;
8137 }
8138
8139 result = set_printer_dataex(printer, SPOOL_PRINTERDATA_KEY,
8140 r->in.value_name, r->in.type,
8141 blob.data, blob.length);
8142 if (W_ERROR_IS_OK(result)) {
8143 result = mod_a_printer(printer, 2);
8144 }
8145
8146 done:
8147 free_a_printer(&printer, 2);
8148
8149 return result;
8150 }
8151
8152 /****************************************************************
8153 _spoolss_ResetPrinter
8154 ****************************************************************/
8155
8156 WERROR _spoolss_ResetPrinter(pipes_struct *p,
8157 struct spoolss_ResetPrinter *r)
8158 {
8159 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8160 int snum;
8161
8162 DEBUG(5,("_spoolss_ResetPrinter\n"));
8163
8164 /*
8165 * All we do is to check to see if the handle and queue is valid.
8166 * This call really doesn't mean anything to us because we only
8167 * support RAW printing. --jerry
8168 */
8169
8170 if (!Printer) {
8171 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8172 OUR_HANDLE(r->in.handle)));
8173 return WERR_BADFID;
8174 }
8175
8176 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8177 return WERR_BADFID;
8178
8179
8180 /* blindly return success */
8181 return WERR_OK;
8182 }
8183
8184 /****************************************************************
8185 _spoolss_DeletePrinterData
8186 ****************************************************************/
8187
8188 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
8189 struct spoolss_DeletePrinterData *r)
8190 {
8191 NT_PRINTER_INFO_LEVEL *printer = NULL;
8192 int snum=0;
8193 WERROR status = WERR_OK;
8194 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8195
8196 DEBUG(5,("_spoolss_DeletePrinterData\n"));
8197
8198 if (!Printer) {
8199 DEBUG(2,("_spoolss_DeletePrinterData: Invalid handle (%s:%u:%u).\n",
8200 OUR_HANDLE(r->in.handle)));
8201 return WERR_BADFID;
8202 }
8203
8204 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8205 return WERR_BADFID;
8206
8207 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8208 DEBUG(3, ("_spoolss_DeletePrinterData: "
8209 "printer properties change denied by handle\n"));
8210 return WERR_ACCESS_DENIED;
8211 }
8212
8213 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8214 if (!W_ERROR_IS_OK(status))
8215 return status;
8216
8217 if (!r->in.value_name) {
8218 free_a_printer(&printer, 2);
8219 return WERR_NOMEM;
8220 }
8221
8222 status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY,
8223 r->in.value_name );
8224
8225 if ( W_ERROR_IS_OK(status) )
8226 mod_a_printer( printer, 2 );
8227
8228 free_a_printer(&printer, 2);
8229
8230 return status;
8231 }
8232
8233 /****************************************************************
8234 _spoolss_AddForm
8235 ****************************************************************/
8236
8237 WERROR _spoolss_AddForm(pipes_struct *p,
8238 struct spoolss_AddForm *r)
8239 {
8240 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8241 nt_forms_struct tmpForm;
8242 int snum = -1;
8243 WERROR status = WERR_OK;
8244 NT_PRINTER_INFO_LEVEL *printer = NULL;
8245 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8246
8247 int count=0;
8248 nt_forms_struct *list=NULL;
8249 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8250
8251 DEBUG(5,("_spoolss_AddForm\n"));
8252
8253 if (!Printer) {
8254 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8255 OUR_HANDLE(r->in.handle)));
8256 return WERR_BADFID;
8257 }
8258
8259
8260 /* forms can be added on printer of on the print server handle */
8261
8262 if ( Printer->printer_type == SPLHND_PRINTER )
8263 {
8264 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8265 return WERR_BADFID;
8266
8267 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8268 if (!W_ERROR_IS_OK(status))
8269 goto done;
8270 }
8271
8272 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8273 and not a printer admin, then fail */
8274
8275 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8276 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8277 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8278 NULL, NULL,
8279 p->server_info->ptok,
8280 lp_printer_admin(snum))) {
8281 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8282 return WERR_ACCESS_DENIED;
8283 }
8284
8285 /* can't add if builtin */
8286
8287 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8288 status = WERR_FILE_EXISTS;
8289 goto done;
8290 }
8291
8292 count = get_ntforms(&list);
8293
8294 if(!add_a_form(&list, form, &count)) {
8295 status = WERR_NOMEM;
8296 goto done;
8297 }
8298
8299 become_root();
8300 write_ntforms(&list, count);
8301 unbecome_root();
8302
8303 /*
8304 * ChangeID must always be set if this is a printer
8305 */
8306
8307 if ( Printer->printer_type == SPLHND_PRINTER )
8308 status = mod_a_printer(printer, 2);
8309
8310 done:
8311 if ( printer )
8312 free_a_printer(&printer, 2);
8313 SAFE_FREE(list);
8314
8315 return status;
8316 }
8317
8318 /****************************************************************
8319 _spoolss_DeleteForm
8320 ****************************************************************/
8321
8322 WERROR _spoolss_DeleteForm(pipes_struct *p,
8323 struct spoolss_DeleteForm *r)
8324 {
8325 const char *form_name = r->in.form_name;
8326 nt_forms_struct tmpForm;
8327 int count=0;
8328 nt_forms_struct *list=NULL;
8329 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8330 int snum = -1;
8331 WERROR status = WERR_OK;
8332 NT_PRINTER_INFO_LEVEL *printer = NULL;
8333 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8334 bool ret = false;
8335
8336 DEBUG(5,("_spoolss_DeleteForm\n"));
8337
8338 if (!Printer) {
8339 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8340 OUR_HANDLE(r->in.handle)));
8341 return WERR_BADFID;
8342 }
8343
8344 /* forms can be deleted on printer of on the print server handle */
8345
8346 if ( Printer->printer_type == SPLHND_PRINTER )
8347 {
8348 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8349 return WERR_BADFID;
8350
8351 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8352 if (!W_ERROR_IS_OK(status))
8353 goto done;
8354 }
8355
8356 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8357 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8358 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8359 NULL, NULL,
8360 p->server_info->ptok,
8361 lp_printer_admin(snum))) {
8362 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8363 return WERR_ACCESS_DENIED;
8364 }
8365
8366
8367 /* can't delete if builtin */
8368
8369 if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8370 status = WERR_INVALID_PARAM;
8371 goto done;
8372 }
8373
8374 count = get_ntforms(&list);
8375
8376 become_root();
8377 ret = delete_a_form(&list, form_name, &count, &status);
8378 unbecome_root();
8379 if (ret == false) {
8380 goto done;
8381 }
8382
8383 /*
8384 * ChangeID must always be set if this is a printer
8385 */
8386
8387 if ( Printer->printer_type == SPLHND_PRINTER )
8388 status = mod_a_printer(printer, 2);
8389
8390 done:
8391 if ( printer )
8392 free_a_printer(&printer, 2);
8393 SAFE_FREE(list);
8394
8395 return status;
8396 }
8397
8398 /****************************************************************
8399 _spoolss_SetForm
8400 ****************************************************************/
8401
8402 WERROR _spoolss_SetForm(pipes_struct *p,
8403 struct spoolss_SetForm *r)
8404 {
8405 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8406 nt_forms_struct tmpForm;
8407 int snum = -1;
8408 WERROR status = WERR_OK;
8409 NT_PRINTER_INFO_LEVEL *printer = NULL;
8410 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8411
8412 int count=0;
8413 nt_forms_struct *list=NULL;
8414 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8415
8416 DEBUG(5,("_spoolss_SetForm\n"));
8417
8418 if (!Printer) {
8419 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8420 OUR_HANDLE(r->in.handle)));
8421 return WERR_BADFID;
8422 }
8423
8424 /* forms can be modified on printer of on the print server handle */
8425
8426 if ( Printer->printer_type == SPLHND_PRINTER )
8427 {
8428 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8429 return WERR_BADFID;
8430
8431 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8432 if (!W_ERROR_IS_OK(status))
8433 goto done;
8434 }
8435
8436 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8437 and not a printer admin, then fail */
8438
8439 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8440 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8441 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8442 NULL, NULL,
8443 p->server_info->ptok,
8444 lp_printer_admin(snum))) {
8445 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8446 return WERR_ACCESS_DENIED;
8447 }
8448
8449 /* can't set if builtin */
8450 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8451 status = WERR_INVALID_PARAM;
8452 goto done;
8453 }
8454
8455 count = get_ntforms(&list);
8456 update_a_form(&list, form, count);
8457 become_root();
8458 write_ntforms(&list, count);
8459 unbecome_root();
8460
8461 /*
8462 * ChangeID must always be set if this is a printer
8463 */
8464
8465 if ( Printer->printer_type == SPLHND_PRINTER )
8466 status = mod_a_printer(printer, 2);
8467
8468
8469 done:
8470 if ( printer )
8471 free_a_printer(&printer, 2);
8472 SAFE_FREE(list);
8473
8474 return status;
8475 }
8476
8477 /****************************************************************************
8478 fill_print_processor1
8479 ****************************************************************************/
8480
8481 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8482 struct spoolss_PrintProcessorInfo1 *r,
8483 const char *print_processor_name)
8484 {
8485 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8486 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8487
8488 return WERR_OK;
8489 }
8490
8491 /****************************************************************************
8492 enumprintprocessors level 1.
8493 ****************************************************************************/
8494
8495 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8496 union spoolss_PrintProcessorInfo **info_p,
8497 uint32_t *count)
8498 {
8499 union spoolss_PrintProcessorInfo *info;
8500 WERROR result;
8501
8502 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8503 W_ERROR_HAVE_NO_MEMORY(info);
8504
8505 *count = 1;
8506
8507 result = fill_print_processor1(info, &info[0].info1, "winprint");
8508 if (!W_ERROR_IS_OK(result)) {
8509 goto out;
8510 }
8511
8512 out:
8513 if (!W_ERROR_IS_OK(result)) {
8514 TALLOC_FREE(info);
8515 *count = 0;
8516 return result;
8517 }
8518
8519 *info_p = info;
8520
8521 return WERR_OK;
8522 }
8523
8524 /****************************************************************
8525 _spoolss_EnumPrintProcessors
8526 ****************************************************************/
8527
8528 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8529 struct spoolss_EnumPrintProcessors *r)
8530 {
8531 WERROR result;
8532
8533 /* that's an [in out] buffer */
8534
8535 if (!r->in.buffer && (r->in.offered != 0)) {
8536 return WERR_INVALID_PARAM;
8537 }
8538
8539 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8540
8541 /*
8542 * Enumerate the print processors ...
8543 *
8544 * Just reply with "winprint", to keep NT happy
8545 * and I can use my nice printer checker.
8546 */
8547
8548 *r->out.count = 0;
8549 *r->out.needed = 0;
8550 *r->out.info = NULL;
8551
8552 switch (r->in.level) {
8553 case 1:
8554 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8555 r->out.count);
8556 break;
8557 default:
8558 return WERR_UNKNOWN_LEVEL;
8559 }
8560
8561 if (!W_ERROR_IS_OK(result)) {
8562 return result;
8563 }
8564
8565 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8566 spoolss_EnumPrintProcessors, NULL,
8567 *r->out.info, r->in.level,
8568 *r->out.count);
8569 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8570 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8571
8572 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8573 }
8574
8575 /****************************************************************************
8576 fill_printprocdatatype1
8577 ****************************************************************************/
8578
8579 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8580 struct spoolss_PrintProcDataTypesInfo1 *r,
8581 const char *name_array)
8582 {
8583 r->name_array = talloc_strdup(mem_ctx, name_array);
8584 W_ERROR_HAVE_NO_MEMORY(r->name_array);
8585
8586 return WERR_OK;
8587 }
8588
8589 /****************************************************************************
8590 enumprintprocdatatypes level 1.
8591 ****************************************************************************/
8592
8593 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8594 union spoolss_PrintProcDataTypesInfo **info_p,
8595 uint32_t *count)
8596 {
8597 WERROR result;
8598 union spoolss_PrintProcDataTypesInfo *info;
8599
8600 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8601 W_ERROR_HAVE_NO_MEMORY(info);
8602
8603 *count = 1;
8604
8605 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8606 if (!W_ERROR_IS_OK(result)) {
8607 goto out;
8608 }
8609
8610 out:
8611 if (!W_ERROR_IS_OK(result)) {
8612 TALLOC_FREE(info);
8613 *count = 0;
8614 return result;
8615 }
8616
8617 *info_p = info;
8618
8619 return WERR_OK;
8620 }
8621
8622 /****************************************************************
8623 _spoolss_EnumPrintProcDataTypes
8624 ****************************************************************/
8625
8626 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8627 struct spoolss_EnumPrintProcDataTypes *r)
8628 {
8629 WERROR result;
8630
8631 /* that's an [in out] buffer */
8632
8633 if (!r->in.buffer && (r->in.offered != 0)) {
8634 return WERR_INVALID_PARAM;
8635 }
8636
8637 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8638
8639 *r->out.count = 0;
8640 *r->out.needed = 0;
8641 *r->out.info = NULL;
8642
8643 switch (r->in.level) {
8644 case 1:
8645 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8646 r->out.count);
8647 break;
8648 default:
8649 return WERR_UNKNOWN_LEVEL;
8650 }
8651
8652 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8653 spoolss_EnumPrintProcDataTypes, NULL,
8654 *r->out.info, r->in.level,
8655 *r->out.count);
8656 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8657 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8658
8659 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8660 }
8661
8662 /****************************************************************************
8663 fill_monitor_1
8664 ****************************************************************************/
8665
8666 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8667 struct spoolss_MonitorInfo1 *r,
8668 const char *monitor_name)
8669 {
8670 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8671 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8672
8673 return WERR_OK;
8674 }
8675
8676 /****************************************************************************
8677 fill_monitor_2
8678 ****************************************************************************/
8679
8680 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8681 struct spoolss_MonitorInfo2 *r,
8682 const char *monitor_name,
8683 const char *environment,
8684 const char *dll_name)
8685 {
8686 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8687 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8688 r->environment = talloc_strdup(mem_ctx, environment);
8689 W_ERROR_HAVE_NO_MEMORY(r->environment);
8690 r->dll_name = talloc_strdup(mem_ctx, dll_name);
8691 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8692
8693 return WERR_OK;
8694 }
8695
8696 /****************************************************************************
8697 enumprintmonitors level 1.
8698 ****************************************************************************/
8699
8700 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8701 union spoolss_MonitorInfo **info_p,
8702 uint32_t *count)
8703 {
8704 union spoolss_MonitorInfo *info;
8705 WERROR result = WERR_OK;
8706
8707 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8708 W_ERROR_HAVE_NO_MEMORY(info);
8709
8710 *count = 2;
8711
8712 result = fill_monitor_1(info, &info[0].info1,
8713 SPL_LOCAL_PORT);
8714 if (!W_ERROR_IS_OK(result)) {
8715 goto out;
8716 }
8717
8718 result = fill_monitor_1(info, &info[1].info1,
8719 SPL_TCPIP_PORT);
8720 if (!W_ERROR_IS_OK(result)) {
8721 goto out;
8722 }
8723
8724 out:
8725 if (!W_ERROR_IS_OK(result)) {
8726 TALLOC_FREE(info);
8727 *count = 0;
8728 return result;
8729 }
8730
8731 *info_p = info;
8732
8733 return WERR_OK;
8734 }
8735
8736 /****************************************************************************
8737 enumprintmonitors level 2.
8738 ****************************************************************************/
8739
8740 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8741 union spoolss_MonitorInfo **info_p,
8742 uint32_t *count)
8743 {
8744 union spoolss_MonitorInfo *info;
8745 WERROR result = WERR_OK;
8746
8747 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8748 W_ERROR_HAVE_NO_MEMORY(info);
8749
8750 *count = 2;
8751
8752 result = fill_monitor_2(info, &info[0].info2,
8753 SPL_LOCAL_PORT,
8754 "Windows NT X86", /* FIXME */
8755 "localmon.dll");
8756 if (!W_ERROR_IS_OK(result)) {
8757 goto out;
8758 }
8759
8760 result = fill_monitor_2(info, &info[1].info2,
8761 SPL_TCPIP_PORT,
8762 "Windows NT X86", /* FIXME */
8763 "tcpmon.dll");
8764 if (!W_ERROR_IS_OK(result)) {
8765 goto out;
8766 }
8767
8768 out:
8769 if (!W_ERROR_IS_OK(result)) {
8770 TALLOC_FREE(info);
8771 *count = 0;
8772 return result;
8773 }
8774
8775 *info_p = info;
8776
8777 return WERR_OK;
8778 }
8779
8780 /****************************************************************
8781 _spoolss_EnumMonitors
8782 ****************************************************************/
8783
8784 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8785 struct spoolss_EnumMonitors *r)
8786 {
8787 WERROR result;
8788
8789 /* that's an [in out] buffer */
8790
8791 if (!r->in.buffer && (r->in.offered != 0)) {
8792 return WERR_INVALID_PARAM;
8793 }
8794
8795 DEBUG(5,("_spoolss_EnumMonitors\n"));
8796
8797 /*
8798 * Enumerate the print monitors ...
8799 *
8800 * Just reply with "Local Port", to keep NT happy
8801 * and I can use my nice printer checker.
8802 */
8803
8804 *r->out.count = 0;
8805 *r->out.needed = 0;
8806 *r->out.info = NULL;
8807
8808 switch (r->in.level) {
8809 case 1:
8810 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8811 r->out.count);
8812 break;
8813 case 2:
8814 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8815 r->out.count);
8816 break;
8817 default:
8818 return WERR_UNKNOWN_LEVEL;
8819 }
8820
8821 if (!W_ERROR_IS_OK(result)) {
8822 return result;
8823 }
8824
8825 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8826 spoolss_EnumMonitors, NULL,
8827 *r->out.info, r->in.level,
8828 *r->out.count);
8829 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8830 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8831
8832 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8833 }
8834
8835 /****************************************************************************
8836 ****************************************************************************/
8837
8838 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8839 const print_queue_struct *queue,
8840 int count, int snum,
8841 const NT_PRINTER_INFO_LEVEL *ntprinter,
8842 uint32_t jobid,
8843 struct spoolss_JobInfo1 *r)
8844 {
8845 int i = 0;
8846 bool found = false;
8847
8848 for (i=0; i<count && found == false; i++) {
8849 if (queue[i].job == (int)jobid) {
8850 found = true;
8851 }
8852 }
8853
8854 if (found == false) {
8855 /* NT treats not found as bad param... yet another bad choice */
8856 return WERR_INVALID_PARAM;
8857 }
8858
8859 return fill_job_info1(mem_ctx,
8860 r,
8861 &queue[i-1],
8862 i,
8863 snum,
8864 ntprinter);
8865 }
8866
8867 /****************************************************************************
8868 ****************************************************************************/
8869
8870 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8871 const print_queue_struct *queue,
8872 int count, int snum,
8873 const NT_PRINTER_INFO_LEVEL *ntprinter,
8874 uint32_t jobid,
8875 struct spoolss_JobInfo2 *r)
8876 {
8877 int i = 0;
8878 bool found = false;
8879 struct spoolss_DeviceMode *devmode;
8880 NT_DEVICEMODE *nt_devmode;
8881 WERROR result;
8882
8883 for (i=0; i<count && found == false; i++) {
8884 if (queue[i].job == (int)jobid) {
8885 found = true;
8886 }
8887 }
8888
8889 if (found == false) {
8890 /* NT treats not found as bad param... yet another bad
8891 choice */
8892 return WERR_INVALID_PARAM;
8893 }
8894
8895 /*
8896 * if the print job does not have a DEVMODE associated with it,
8897 * just use the one for the printer. A NULL devicemode is not
8898 * a failure condition
8899 */
8900
8901 nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8902 if (nt_devmode) {
8903 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
8904 W_ERROR_HAVE_NO_MEMORY(devmode);
8905 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
8906 if (!W_ERROR_IS_OK(result)) {
8907 return result;
8908 }
8909 } else {
8910 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
8911 W_ERROR_HAVE_NO_MEMORY(devmode);
8912 }
8913
8914 return fill_job_info2(mem_ctx,
8915 r,
8916 &queue[i-1],
8917 i,
8918 snum,
8919 ntprinter,
8920 devmode);
8921 }
8922
8923 /****************************************************************
8924 _spoolss_GetJob
8925 ****************************************************************/
8926
8927 WERROR _spoolss_GetJob(pipes_struct *p,
8928 struct spoolss_GetJob *r)
8929 {
8930 WERROR result = WERR_OK;
8931 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
8932 int snum;
8933 int count;
8934 print_queue_struct *queue = NULL;
8935 print_status_struct prt_status;
8936
8937 /* that's an [in out] buffer */
8938
8939 if (!r->in.buffer && (r->in.offered != 0)) {
8940 return WERR_INVALID_PARAM;
8941 }
8942
8943 DEBUG(5,("_spoolss_GetJob\n"));
8944
8945 *r->out.needed = 0;
8946
8947 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8948 return WERR_BADFID;
8949 }
8950
8951 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
8952 if (!W_ERROR_IS_OK(result)) {
8953 return result;
8954 }
8955
8956 count = print_queue_status(snum, &queue, &prt_status);
8957
8958 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8959 count, prt_status.status, prt_status.message));
8960
8961 switch (r->in.level) {
8962 case 1:
8963 result = getjob_level_1(p->mem_ctx,
8964 queue, count, snum, ntprinter,
8965 r->in.job_id, &r->out.info->info1);
8966 break;
8967 case 2:
8968 result = getjob_level_2(p->mem_ctx,
8969 queue, count, snum, ntprinter,
8970 r->in.job_id, &r->out.info->info2);
8971 break;
8972 default:
8973 result = WERR_UNKNOWN_LEVEL;
8974 break;
8975 }
8976
8977 SAFE_FREE(queue);
8978 free_a_printer(&ntprinter, 2);
8979
8980 if (!W_ERROR_IS_OK(result)) {
8981 TALLOC_FREE(r->out.info);
8982 return result;
8983 }
8984
8985 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
8986 r->out.info, r->in.level);
8987 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8988
8989 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8990 }
8991
8992 /****************************************************************
8993 _spoolss_GetPrinterDataEx
8994
8995 From MSDN documentation of GetPrinterDataEx: pass request
8996 to GetPrinterData if key is "PrinterDriverData".
8997 ****************************************************************/
8998
8999 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
9000 struct spoolss_GetPrinterDataEx *r)
9001 {
9002
9003 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9004 REGISTRY_VALUE *val = NULL;
9005 NT_PRINTER_INFO_LEVEL *printer = NULL;
9006 int snum = 0;
9007 WERROR result = WERR_OK;
9008
9009 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9010
9011 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9012 r->in.key_name, r->in.value_name));
9013
9014 /* in case of problem, return some default values */
9015
9016 *r->out.needed = 0;
9017 *r->out.type = REG_NONE;
9018
9019 if (!Printer) {
9020 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9021 OUR_HANDLE(r->in.handle)));
9022 result = WERR_BADFID;
9023 goto done;
9024 }
9025
9026 /* Is the handle to a printer or to the server? */
9027
9028 if (Printer->printer_type == SPLHND_SERVER) {
9029 DEBUG(10,("_spoolss_GetPrinterDataEx: "
9030 "Not implemented for server handles yet\n"));
9031 result = WERR_INVALID_PARAM;
9032 goto done;
9033 }
9034
9035 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9036 return WERR_BADFID;
9037 }
9038
9039 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9040 if (!W_ERROR_IS_OK(result)) {
9041 goto done;
9042 }
9043
9044 /* check to see if the keyname is valid */
9045 if (!strlen(r->in.key_name)) {
9046 result = WERR_INVALID_PARAM;
9047 goto done;
9048 }
9049
9050 if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
9051 DEBUG(4,("_spoolss_GetPrinterDataEx: "
9052 "Invalid keyname [%s]\n", r->in.key_name ));
9053 result = WERR_BADFILE;
9054 goto done;
9055 }
9056
9057 /* When given a new keyname, we should just create it */
9058
9059 val = get_printer_data(printer->info_2,
9060 r->in.key_name, r->in.value_name);
9061 if (!val) {
9062 result = WERR_BADFILE;
9063 goto done;
9064 }
9065
9066 *r->out.needed = regval_size(val);
9067
9068 if (*r->out.needed > r->in.offered) {
9069 result = WERR_MORE_DATA;
9070 goto done;
9071 }
9072
9073 *r->out.type = regval_type(val);
9074
9075 memcpy(r->out.buffer, regval_data_p(val), regval_size(val));
9076
9077 done:
9078 if (printer) {
9079 free_a_printer(&printer, 2);
9080 }
9081
9082 return result;
9083 }
9084
9085 /****************************************************************
9086 _spoolss_SetPrinterDataEx
9087 ****************************************************************/
9088
9089 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
9090 struct spoolss_SetPrinterDataEx *r)
9091 {
9092 NT_PRINTER_INFO_LEVEL *printer = NULL;
9093 int snum = 0;
9094 WERROR result = WERR_OK;
9095 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9096 char *oid_string;
9097
9098 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9099
9100 /* From MSDN documentation of SetPrinterDataEx: pass request to
9101 SetPrinterData if key is "PrinterDriverData" */
9102
9103 if (!Printer) {
9104 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9105 OUR_HANDLE(r->in.handle)));
9106 return WERR_BADFID;
9107 }
9108
9109 if (Printer->printer_type == SPLHND_SERVER) {
9110 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9111 "Not implemented for server handles yet\n"));
9112 return WERR_INVALID_PARAM;
9113 }
9114
9115 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9116 return WERR_BADFID;
9117 }
9118
9119 /*
9120 * Access check : NT returns "access denied" if you make a
9121 * SetPrinterData call without the necessary privildge.
9122 * we were originally returning OK if nothing changed
9123 * which made Win2k issue **a lot** of SetPrinterData
9124 * when connecting to a printer --jerry
9125 */
9126
9127 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9128 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9129 "change denied by handle access permissions\n"));
9130 return WERR_ACCESS_DENIED;
9131 }
9132
9133 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9134 if (!W_ERROR_IS_OK(result)) {
9135 return result;
9136 }
9137
9138 /* check for OID in valuename */
9139
9140 oid_string = strchr(r->in.value_name, ',');
9141 if (oid_string) {
9142 *oid_string = '\0';
9143 oid_string++;
9144 }
9145
9146 /* save the registry data */
9147
9148 result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
9149 r->in.type, r->in.buffer, r->in.offered);
9150
9151 if (W_ERROR_IS_OK(result)) {
9152 /* save the OID if one was specified */
9153 if (oid_string) {
9154 char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
9155 r->in.key_name, SPOOL_OID_KEY);
9156 if (!str) {
9157 result = WERR_NOMEM;
9158 goto done;
9159 }
9160
9161 /*
9162 * I'm not checking the status here on purpose. Don't know
9163 * if this is right, but I'm returning the status from the
9164 * previous set_printer_dataex() call. I have no idea if
9165 * this is right. --jerry
9166 */
9167
9168 set_printer_dataex(printer, str, r->in.value_name,
9169 REG_SZ, (uint8_t *)oid_string,
9170 strlen(oid_string)+1);
9171 }
9172
9173 result = mod_a_printer(printer, 2);
9174 }
9175
9176 done:
9177 free_a_printer(&printer, 2);
9178
9179 return result;
9180 }
9181
9182 /****************************************************************
9183 _spoolss_DeletePrinterDataEx
9184 ****************************************************************/
9185
9186 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
9187 struct spoolss_DeletePrinterDataEx *r)
9188 {
9189 NT_PRINTER_INFO_LEVEL *printer = NULL;
9190 int snum=0;
9191 WERROR status = WERR_OK;
9192 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9193
9194 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9195
9196 if (!Printer) {
9197 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9198 "Invalid handle (%s:%u:%u).\n",
9199 OUR_HANDLE(r->in.handle)));
9200 return WERR_BADFID;
9201 }
9202
9203 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9204 return WERR_BADFID;
9205
9206 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9207 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9208 "printer properties change denied by handle\n"));
9209 return WERR_ACCESS_DENIED;
9210 }
9211
9212 if (!r->in.value_name || !r->in.key_name) {
9213 return WERR_NOMEM;
9214 }
9215
9216 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9217 if (!W_ERROR_IS_OK(status))
9218 return status;
9219
9220 status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
9221
9222 if ( W_ERROR_IS_OK(status) )
9223 mod_a_printer( printer, 2 );
9224
9225 free_a_printer(&printer, 2);
9226
9227 return status;
9228 }
9229
9230 /****************************************************************
9231 _spoolss_EnumPrinterKey
9232 ****************************************************************/
9233
9234 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
9235 struct spoolss_EnumPrinterKey *r)
9236 {
9237 fstring *keynames = NULL;
9238 int num_keys;
9239 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9240 NT_PRINTER_DATA *data;
9241 NT_PRINTER_INFO_LEVEL *printer = NULL;
9242 int snum = 0;
9243 WERROR result = WERR_BADFILE;
9244 int i;
9245 const char **array = NULL;
9246
9247
9248 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9249
9250 if (!Printer) {
9251 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9252 OUR_HANDLE(r->in.handle)));
9253 return WERR_BADFID;
9254 }
9255
9256 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9257 return WERR_BADFID;
9258 }
9259
9260 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9261 if (!W_ERROR_IS_OK(result)) {
9262 return result;
9263 }
9264
9265 /* get the list of subkey names */
9266
9267 data = printer->info_2->data;
9268
9269 num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
9270 if (num_keys == -1) {
9271 result = WERR_BADFILE;
9272 goto done;
9273 }
9274
9275 *r->out.needed = 4;
9276
9277 array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 1);
9278 if (!array) {
9279 result = WERR_NOMEM;
9280 goto done;
9281 }
9282
9283 for (i=0; i < num_keys; i++) {
9284 array[i] = talloc_strdup(array, keynames[i]);
9285 if (!array[i]) {
9286 result = WERR_NOMEM;
9287 goto done;
9288 }
9289
9290 *r->out.needed += strlen_m_term(keynames[i]) * 2;
9291 }
9292
9293 if (r->in.offered < *r->out.needed) {
9294 result = WERR_MORE_DATA;
9295 goto done;
9296 }
9297
9298 result = WERR_OK;
9299
9300 *r->out.key_buffer = array;
9301
9302 done:
9303 if (!W_ERROR_IS_OK(result)) {
9304 TALLOC_FREE(array);
9305 ZERO_STRUCTP(r->out.key_buffer);
9306 }
9307
9308 free_a_printer(&printer, 2);
9309 SAFE_FREE(keynames);
9310
9311 return result;
9312 }
9313
9314 /****************************************************************
9315 _spoolss_DeletePrinterKey
9316 ****************************************************************/
9317
9318 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9319 struct spoolss_DeletePrinterKey *r)
9320 {
9321 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9322 NT_PRINTER_INFO_LEVEL *printer = NULL;
9323 int snum=0;
9324 WERROR status;
9325
9326 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9327
9328 if (!Printer) {
9329 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9330 OUR_HANDLE(r->in.handle)));
9331 return WERR_BADFID;
9332 }
9333
9334 /* if keyname == NULL, return error */
9335
9336 if ( !r->in.key_name )
9337 return WERR_INVALID_PARAM;
9338
9339 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9340 return WERR_BADFID;
9341
9342 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9343 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9344 "printer properties change denied by handle\n"));
9345 return WERR_ACCESS_DENIED;
9346 }
9347
9348 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9349 if (!W_ERROR_IS_OK(status))
9350 return status;
9351
9352 /* delete the key and all subneys */
9353
9354 status = delete_all_printer_data( printer->info_2, r->in.key_name );
9355
9356 if ( W_ERROR_IS_OK(status) )
9357 status = mod_a_printer(printer, 2);
9358
9359 free_a_printer( &printer, 2 );
9360
9361 return status;
9362 }
9363
9364 /****************************************************************
9365 ****************************************************************/
9366
9367 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9368 REGISTRY_VALUE *v,
9369 struct spoolss_PrinterEnumValues *r)
9370 {
9371 WERROR result;
9372
9373 r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
9374 W_ERROR_HAVE_NO_MEMORY(r->data);
9375
9376 r->value_name = talloc_strdup(mem_ctx, regval_name(v));
9377 W_ERROR_HAVE_NO_MEMORY(r->value_name);
9378
9379 r->type = regval_type(v);
9380 r->data_length = regval_size(v);
9381
9382 if (r->data_length) {
9383 DATA_BLOB blob = data_blob_const(regval_data_p(v),
9384 regval_size(v));
9385 result = pull_spoolss_PrinterData(mem_ctx, &blob,
9386 r->data,
9387 r->type);
9388 if (!W_ERROR_IS_OK(result)) {
9389 return result;
9390 }
9391 }
9392
9393 return WERR_OK;
9394 }
9395
9396 /****************************************************************
9397 _spoolss_EnumPrinterDataEx
9398 ****************************************************************/
9399
9400 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9401 struct spoolss_EnumPrinterDataEx *r)
9402 {
9403 uint32_t count = 0;
9404 NT_PRINTER_INFO_LEVEL *printer = NULL;
9405 struct spoolss_PrinterEnumValues *info = NULL;
9406 NT_PRINTER_DATA *p_data;
9407 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9408 int snum;
9409 WERROR result;
9410 int key_index;
9411 int i;
9412
9413 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9414
9415 *r->out.count = 0;
9416 *r->out.needed = 0;
9417 *r->out.info = NULL;
9418
9419 if (!Printer) {
9420 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9421 OUR_HANDLE(r->in.handle)));
9422 return WERR_BADFID;
9423 }
9424
9425 /*
9426 * first check for a keyname of NULL or "". Win2k seems to send
9427 * this a lot and we should send back WERR_INVALID_PARAM
9428 * no need to spend time looking up the printer in this case.
9429 * --jerry
9430 */
9431
9432 if (!strlen(r->in.key_name)) {
9433 result = WERR_INVALID_PARAM;
9434 goto done;
9435 }
9436
9437 /* get the printer off of disk */
9438
9439 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9440 return WERR_BADFID;
9441 }
9442
9443 ZERO_STRUCT(printer);
9444 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9445 if (!W_ERROR_IS_OK(result)) {
9446 return result;
9447 }
9448
9449 /* now look for a match on the key name */
9450
9451 p_data = printer->info_2->data;
9452
9453 key_index = lookup_printerkey(p_data, r->in.key_name);
9454 if (key_index == -1) {
9455 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9456 r->in.key_name));
9457 result = WERR_INVALID_PARAM;
9458 goto done;
9459 }
9460
9461 /* allocate the memory for the array of pointers -- if necessary */
9462
9463 count = regval_ctr_numvals(p_data->keys[key_index].values);
9464 if (!count) {
9465 result = WERR_OK; /* ??? */
9466 goto done;
9467 }
9468
9469 info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9470 struct spoolss_PrinterEnumValues,
9471 count);
9472 if (!info) {
9473 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9474 result = WERR_NOMEM;
9475 goto done;
9476 }
9477
9478 /*
9479 * loop through all params and build the array to pass
9480 * back to the client
9481 */
9482
9483 for (i=0; i < count; i++) {
9484
9485 REGISTRY_VALUE *val;
9486
9487 /* lookup the registry value */
9488
9489 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9490
9491 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9492
9493 /* copy the data */
9494
9495 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9496 if (!W_ERROR_IS_OK(result)) {
9497 goto done;
9498 }
9499 }
9500
9501 #if 0 /* FIXME - gd */
9502 /* housekeeping information in the reply */
9503
9504 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9505 * the hand marshalled container size is a multiple
9506 * of 4 bytes for RPC alignment.
9507 */
9508
9509 if (needed % 4) {
9510 needed += 4-(needed % 4);
9511 }
9512 #endif
9513 *r->out.count = count;
9514 *r->out.info = info;
9515
9516 done:
9517
9518 if (printer) {
9519 free_a_printer(&printer, 2);
9520 }
9521
9522 if (!W_ERROR_IS_OK(result)) {
9523 return result;
9524 }
9525
9526 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9527 spoolss_EnumPrinterDataEx, NULL,
9528 *r->out.info,
9529 *r->out.count);
9530 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9531 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9532
9533 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9534 }
9535
9536 /****************************************************************************
9537 ****************************************************************************/
9538
9539 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9540 const char *servername,
9541 const char *environment,
9542 struct spoolss_PrintProcessorDirectoryInfo1 *r)
9543 {
9544 WERROR werr;
9545 char *path = NULL;
9546
9547 werr = compose_spoolss_server_path(mem_ctx,
9548 servername,
9549 environment,
9550 SPOOLSS_PRTPROCS_PATH,
9551 &path);
9552 if (!W_ERROR_IS_OK(werr)) {
9553 return werr;
9554 }
9555
9556 DEBUG(4,("print processor directory: [%s]\n", path));
9557
9558 r->directory_name = path;
9559
9560 return WERR_OK;
9561 }
9562
9563 /****************************************************************
9564 _spoolss_GetPrintProcessorDirectory
9565 ****************************************************************/
9566
9567 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9568 struct spoolss_GetPrintProcessorDirectory *r)
9569 {
9570 WERROR result;
9571
9572 /* that's an [in out] buffer */
9573
9574 if (!r->in.buffer && (r->in.offered != 0)) {
9575 return WERR_INVALID_PARAM;
9576 }
9577
9578 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9579 r->in.level));
9580
9581 *r->out.needed = 0;
9582
9583 /* r->in.level is ignored */
9584
9585 result = getprintprocessordirectory_level_1(p->mem_ctx,
9586 r->in.server,
9587 r->in.environment,
9588 &r->out.info->info1);
9589 if (!W_ERROR_IS_OK(result)) {
9590 TALLOC_FREE(r->out.info);
9591 return result;
9592 }
9593
9594 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9595 r->out.info, r->in.level);
9596 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9597
9598 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9599 }
9600
9601 /*******************************************************************
9602 ********************************************************************/
9603
9604 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9605 const char *dllname)
9606 {
9607 enum ndr_err_code ndr_err;
9608 struct spoolss_MonitorUi ui;
9609
9610 ui.dll_name = dllname;
9611
9612 ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9613 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9614 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9615 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9616 }
9617 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9618 }
9619
9620 /*******************************************************************
9621 Streams the monitor UI DLL name in UNICODE
9622 *******************************************************************/
9623
9624 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9625 NT_USER_TOKEN *token, DATA_BLOB *in,
9626 DATA_BLOB *out, uint32_t *needed)
9627 {
9628 const char *dllname = "tcpmonui.dll";
9629
9630 *needed = (strlen(dllname)+1) * 2;
9631
9632 if (out->length < *needed) {
9633 return WERR_INSUFFICIENT_BUFFER;
9634 }
9635
9636 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9637 return WERR_NOMEM;
9638 }
9639
9640 return WERR_OK;
9641 }
9642
9643 /*******************************************************************
9644 ********************************************************************/
9645
9646 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9647 struct spoolss_PortData1 *port1,
9648 const DATA_BLOB *buf)
9649 {
9650 enum ndr_err_code ndr_err;
9651 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9652 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9653 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9654 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9655 }
9656 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9657 }
9658
9659 /*******************************************************************
9660 ********************************************************************/
9661
9662 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9663 struct spoolss_PortData2 *port2,
9664 const DATA_BLOB *buf)
9665 {
9666 enum ndr_err_code ndr_err;
9667 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9668 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9669 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9670 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9671 }
9672 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9673 }
9674
9675 /*******************************************************************
9676 Create a new TCP/IP port
9677 *******************************************************************/
9678
9679 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9680 NT_USER_TOKEN *token, DATA_BLOB *in,
9681 DATA_BLOB *out, uint32_t *needed)
9682 {
9683 struct spoolss_PortData1 port1;
9684 struct spoolss_PortData2 port2;
9685 char *device_uri = NULL;
9686 uint32_t version;
9687
9688 const char *portname;
9689 const char *hostaddress;
9690 const char *queue;
9691 uint32_t port_number;
9692 uint32_t protocol;
9693
9694 /* peek for spoolss_PortData version */
9695
9696 if (!in || (in->length < (128 + 4))) {
9697 return WERR_GENERAL_FAILURE;
9698 }
9699
9700 version = IVAL(in->data, 128);
9701
9702 switch (version) {
9703 case 1:
9704 ZERO_STRUCT(port1);
9705
9706 if (!pull_port_data_1(mem_ctx, &port1, in)) {
9707 return WERR_NOMEM;
9708 }
9709
9710 portname = port1.portname;
9711 hostaddress = port1.hostaddress;
9712 queue = port1.queue;
9713 protocol = port1.protocol;
9714 port_number = port1.port_number;
9715
9716 break;
9717 case 2:
9718 ZERO_STRUCT(port2);
9719
9720 if (!pull_port_data_2(mem_ctx, &port2, in)) {
9721 return WERR_NOMEM;
9722 }
9723
9724 portname = port2.portname;
9725 hostaddress = port2.hostaddress;
9726 queue = port2.queue;
9727 protocol = port2.protocol;
9728 port_number = port2.port_number;
9729
9730 break;
9731 default:
9732 DEBUG(1,("xcvtcp_addport: "
9733 "unknown version of port_data: %d\n", version));
9734 return WERR_UNKNOWN_PORT;
9735 }
9736
9737 /* create the device URI and call the add_port_hook() */
9738
9739 switch (protocol) {
9740 case PROTOCOL_RAWTCP_TYPE:
9741 device_uri = talloc_asprintf(mem_ctx,
9742 "socket://%s:%d/", hostaddress,
9743 port_number);
9744 break;
9745
9746 case PROTOCOL_LPR_TYPE:
9747 device_uri = talloc_asprintf(mem_ctx,
9748 "lpr://%s/%s", hostaddress, queue );
9749 break;
9750
9751 default:
9752 return WERR_UNKNOWN_PORT;
9753 }
9754
9755 if (!device_uri) {
9756 return WERR_NOMEM;
9757 }
9758
9759 return add_port_hook(mem_ctx, token, portname, device_uri);
9760 }
9761
9762 /*******************************************************************
9763 *******************************************************************/
9764
9765 struct xcv_api_table xcvtcp_cmds[] = {
9766 { "MonitorUI", xcvtcp_monitorui },
9767 { "AddPort", xcvtcp_addport},
9768 { NULL, NULL }
9769 };
9770
9771 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9772 NT_USER_TOKEN *token, const char *command,
9773 DATA_BLOB *inbuf,
9774 DATA_BLOB *outbuf,
9775 uint32_t *needed )
9776 {
9777 int i;
9778
9779 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9780
9781 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9782 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9783 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9784 }
9785
9786 return WERR_BADFUNC;
9787 }
9788
9789 /*******************************************************************
9790 *******************************************************************/
9791 #if 0 /* don't support management using the "Local Port" monitor */
9792
9793 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9794 NT_USER_TOKEN *token, DATA_BLOB *in,
9795 DATA_BLOB *out, uint32_t *needed)
9796 {
9797 const char *dllname = "localui.dll";
9798
9799 *needed = (strlen(dllname)+1) * 2;
9800
9801 if (out->length < *needed) {
9802 return WERR_INSUFFICIENT_BUFFER;
9803 }
9804
9805 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9806 return WERR_NOMEM;
9807 }
9808
9809 return WERR_OK;
9810 }
9811
9812 /*******************************************************************
9813 *******************************************************************/
9814
9815 struct xcv_api_table xcvlocal_cmds[] = {
9816 { "MonitorUI", xcvlocal_monitorui },
9817 { NULL, NULL }
9818 };
9819 #else
9820 struct xcv_api_table xcvlocal_cmds[] = {
9821 { NULL, NULL }
9822 };
9823 #endif
9824
9825
9826
9827 /*******************************************************************
9828 *******************************************************************/
9829
9830 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9831 NT_USER_TOKEN *token, const char *command,
9832 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9833 uint32_t *needed)
9834 {
9835 int i;
9836
9837 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9838
9839 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9840 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9841 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9842 }
9843 return WERR_BADFUNC;
9844 }
9845
9846 /****************************************************************
9847 _spoolss_XcvData
9848 ****************************************************************/
9849
9850 WERROR _spoolss_XcvData(pipes_struct *p,
9851 struct spoolss_XcvData *r)
9852 {
9853 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9854 DATA_BLOB out_data = data_blob_null;
9855 WERROR werror;
9856
9857 if (!Printer) {
9858 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9859 OUR_HANDLE(r->in.handle)));
9860 return WERR_BADFID;
9861 }
9862
9863 /* Has to be a handle to the TCP/IP port monitor */
9864
9865 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9866 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9867 return WERR_BADFID;
9868 }
9869
9870 /* requires administrative access to the server */
9871
9872 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9873 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9874 return WERR_ACCESS_DENIED;
9875 }
9876
9877 /* Allocate the outgoing buffer */
9878
9879 if (r->in.out_data_size) {
9880 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9881 if (out_data.data == NULL) {
9882 return WERR_NOMEM;
9883 }
9884 }
9885
9886 switch ( Printer->printer_type ) {
9887 case SPLHND_PORTMON_TCP:
9888 werror = process_xcvtcp_command(p->mem_ctx,
9889 p->server_info->ptok,
9890 r->in.function_name,
9891 &r->in.in_data, &out_data,
9892 r->out.needed);
9893 break;
9894 case SPLHND_PORTMON_LOCAL:
9895 werror = process_xcvlocal_command(p->mem_ctx,
9896 p->server_info->ptok,
9897 r->in.function_name,
9898 &r->in.in_data, &out_data,
9899 r->out.needed);
9900 break;
9901 default:
9902 werror = WERR_INVALID_PRINT_MONITOR;
9903 }
9904
9905 if (!W_ERROR_IS_OK(werror)) {
9906 return werror;
9907 }
9908
9909 *r->out.status_code = 0;
9910
9911 memcpy(r->out.out_data, out_data.data, out_data.length);
9912
9913 return WERR_OK;
9914 }
9915
9916 /****************************************************************
9917 _spoolss_AddPrintProcessor
9918 ****************************************************************/
9919
9920 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
9921 struct spoolss_AddPrintProcessor *r)
9922 {
9923 /* for now, just indicate success and ignore the add. We'll
9924 automatically set the winprint processor for printer
9925 entries later. Used to debug the LexMark Optra S 1855 PCL
9926 driver --jerry */
9927
9928 return WERR_OK;
9929 }
9930
9931 /****************************************************************
9932 _spoolss_AddPort
9933 ****************************************************************/
9934
9935 WERROR _spoolss_AddPort(pipes_struct *p,
9936 struct spoolss_AddPort *r)
9937 {
9938 /* do what w2k3 does */
9939
9940 return WERR_NOT_SUPPORTED;
9941 }
9942
9943 /****************************************************************
9944 _spoolss_AddPrinter
9945 ****************************************************************/
9946
9947 WERROR _spoolss_AddPrinter(pipes_struct *p,
9948 struct spoolss_AddPrinter *r)
9949 {
9950 p->rng_fault_state = true;
9951 return WERR_NOT_SUPPORTED;
9952 }
9953
9954 /****************************************************************
9955 _spoolss_GetPrinterDriver
9956 ****************************************************************/
9957
9958 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
9959 struct spoolss_GetPrinterDriver *r)
9960 {
9961 p->rng_fault_state = true;
9962 return WERR_NOT_SUPPORTED;
9963 }
9964
9965 /****************************************************************
9966 _spoolss_ReadPrinter
9967 ****************************************************************/
9968
9969 WERROR _spoolss_ReadPrinter(pipes_struct *p,
9970 struct spoolss_ReadPrinter *r)
9971 {
9972 p->rng_fault_state = true;
9973 return WERR_NOT_SUPPORTED;
9974 }
9975
9976 /****************************************************************
9977 _spoolss_WaitForPrinterChange
9978 ****************************************************************/
9979
9980 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
9981 struct spoolss_WaitForPrinterChange *r)
9982 {
9983 p->rng_fault_state = true;
9984 return WERR_NOT_SUPPORTED;
9985 }
9986
9987 /****************************************************************
9988 _spoolss_ConfigurePort
9989 ****************************************************************/
9990
9991 WERROR _spoolss_ConfigurePort(pipes_struct *p,
9992 struct spoolss_ConfigurePort *r)
9993 {
9994 p->rng_fault_state = true;
9995 return WERR_NOT_SUPPORTED;
9996 }
9997
9998 /****************************************************************
9999 _spoolss_DeletePort
10000 ****************************************************************/
10001
10002 WERROR _spoolss_DeletePort(pipes_struct *p,
10003 struct spoolss_DeletePort *r)
10004 {
10005 p->rng_fault_state = true;
10006 return WERR_NOT_SUPPORTED;
10007 }
10008
10009 /****************************************************************
10010 _spoolss_CreatePrinterIC
10011 ****************************************************************/
10012
10013 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
10014 struct spoolss_CreatePrinterIC *r)
10015 {
10016 p->rng_fault_state = true;
10017 return WERR_NOT_SUPPORTED;
10018 }
10019
10020 /****************************************************************
10021 _spoolss_PlayGDIScriptOnPrinterIC
10022 ****************************************************************/
10023
10024 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
10025 struct spoolss_PlayGDIScriptOnPrinterIC *r)
10026 {
10027 p->rng_fault_state = true;
10028 return WERR_NOT_SUPPORTED;
10029 }
10030
10031 /****************************************************************
10032 _spoolss_DeletePrinterIC
10033 ****************************************************************/
10034
10035 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
10036 struct spoolss_DeletePrinterIC *r)
10037 {
10038 p->rng_fault_state = true;
10039 return WERR_NOT_SUPPORTED;
10040 }
10041
10042 /****************************************************************
10043 _spoolss_AddPrinterConnection
10044 ****************************************************************/
10045
10046 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
10047 struct spoolss_AddPrinterConnection *r)
10048 {
10049 p->rng_fault_state = true;
10050 return WERR_NOT_SUPPORTED;
10051 }
10052
10053 /****************************************************************
10054 _spoolss_DeletePrinterConnection
10055 ****************************************************************/
10056
10057 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
10058 struct spoolss_DeletePrinterConnection *r)
10059 {
10060 p->rng_fault_state = true;
10061 return WERR_NOT_SUPPORTED;
10062 }
10063
10064 /****************************************************************
10065 _spoolss_PrinterMessageBox
10066 ****************************************************************/
10067
10068 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
10069 struct spoolss_PrinterMessageBox *r)
10070 {
10071 p->rng_fault_state = true;
10072 return WERR_NOT_SUPPORTED;
10073 }
10074
10075 /****************************************************************
10076 _spoolss_AddMonitor
10077 ****************************************************************/
10078
10079 WERROR _spoolss_AddMonitor(pipes_struct *p,
10080 struct spoolss_AddMonitor *r)
10081 {
10082 p->rng_fault_state = true;
10083 return WERR_NOT_SUPPORTED;
10084 }
10085
10086 /****************************************************************
10087 _spoolss_DeleteMonitor
10088 ****************************************************************/
10089
10090 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
10091 struct spoolss_DeleteMonitor *r)
10092 {
10093 p->rng_fault_state = true;
10094 return WERR_NOT_SUPPORTED;
10095 }
10096
10097 /****************************************************************
10098 _spoolss_DeletePrintProcessor
10099 ****************************************************************/
10100
10101 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
10102 struct spoolss_DeletePrintProcessor *r)
10103 {
10104 p->rng_fault_state = true;
10105 return WERR_NOT_SUPPORTED;
10106 }
10107
10108 /****************************************************************
10109 _spoolss_AddPrintProvidor
10110 ****************************************************************/
10111
10112 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
10113 struct spoolss_AddPrintProvidor *r)
10114 {
10115 p->rng_fault_state = true;
10116 return WERR_NOT_SUPPORTED;
10117 }
10118
10119 /****************************************************************
10120 _spoolss_DeletePrintProvidor
10121 ****************************************************************/
10122
10123 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
10124 struct spoolss_DeletePrintProvidor *r)
10125 {
10126 p->rng_fault_state = true;
10127 return WERR_NOT_SUPPORTED;
10128 }
10129
10130 /****************************************************************
10131 _spoolss_FindFirstPrinterChangeNotification
10132 ****************************************************************/
10133
10134 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
10135 struct spoolss_FindFirstPrinterChangeNotification *r)
10136 {
10137 p->rng_fault_state = true;
10138 return WERR_NOT_SUPPORTED;
10139 }
10140
10141 /****************************************************************
10142 _spoolss_FindNextPrinterChangeNotification
10143 ****************************************************************/
10144
10145 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
10146 struct spoolss_FindNextPrinterChangeNotification *r)
10147 {
10148 p->rng_fault_state = true;
10149 return WERR_NOT_SUPPORTED;
10150 }
10151
10152 /****************************************************************
10153 _spoolss_RouterFindFirstPrinterChangeNotificationOld
10154 ****************************************************************/
10155
10156 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
10157 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10158 {
10159 p->rng_fault_state = true;
10160 return WERR_NOT_SUPPORTED;
10161 }
10162
10163 /****************************************************************
10164 _spoolss_ReplyOpenPrinter
10165 ****************************************************************/
10166
10167 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
10168 struct spoolss_ReplyOpenPrinter *r)
10169 {
10170 p->rng_fault_state = true;
10171 return WERR_NOT_SUPPORTED;
10172 }
10173
10174 /****************************************************************
10175 _spoolss_RouterReplyPrinter
10176 ****************************************************************/
10177
10178 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
10179 struct spoolss_RouterReplyPrinter *r)
10180 {
10181 p->rng_fault_state = true;
10182 return WERR_NOT_SUPPORTED;
10183 }
10184
10185 /****************************************************************
10186 _spoolss_ReplyClosePrinter
10187 ****************************************************************/
10188
10189 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
10190 struct spoolss_ReplyClosePrinter *r)
10191 {
10192 p->rng_fault_state = true;
10193 return WERR_NOT_SUPPORTED;
10194 }
10195
10196 /****************************************************************
10197 _spoolss_AddPortEx
10198 ****************************************************************/
10199
10200 WERROR _spoolss_AddPortEx(pipes_struct *p,
10201 struct spoolss_AddPortEx *r)
10202 {
10203 p->rng_fault_state = true;
10204 return WERR_NOT_SUPPORTED;
10205 }
10206
10207 /****************************************************************
10208 _spoolss_RouterFindFirstPrinterChangeNotification
10209 ****************************************************************/
10210
10211 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
10212 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10213 {
10214 p->rng_fault_state = true;
10215 return WERR_NOT_SUPPORTED;
10216 }
10217
10218 /****************************************************************
10219 _spoolss_SpoolerInit
10220 ****************************************************************/
10221
10222 WERROR _spoolss_SpoolerInit(pipes_struct *p,
10223 struct spoolss_SpoolerInit *r)
10224 {
10225 p->rng_fault_state = true;
10226 return WERR_NOT_SUPPORTED;
10227 }
10228
10229 /****************************************************************
10230 _spoolss_ResetPrinterEx
10231 ****************************************************************/
10232
10233 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
10234 struct spoolss_ResetPrinterEx *r)
10235 {
10236 p->rng_fault_state = true;
10237 return WERR_NOT_SUPPORTED;
10238 }
10239
10240 /****************************************************************
10241 _spoolss_RouterReplyPrinterEx
10242 ****************************************************************/
10243
10244 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
10245 struct spoolss_RouterReplyPrinterEx *r)
10246 {
10247 p->rng_fault_state = true;
10248 return WERR_NOT_SUPPORTED;
10249 }
10250
10251 /****************************************************************
10252 _spoolss_44
10253 ****************************************************************/
10254
10255 WERROR _spoolss_44(pipes_struct *p,
10256 struct spoolss_44 *r)
10257 {
10258 p->rng_fault_state = true;
10259 return WERR_NOT_SUPPORTED;
10260 }
10261
10262 /****************************************************************
10263 _spoolss_47
10264 ****************************************************************/
10265
10266 WERROR _spoolss_47(pipes_struct *p,
10267 struct spoolss_47 *r)
10268 {
10269 p->rng_fault_state = true;
10270 return WERR_NOT_SUPPORTED;
10271 }
10272
10273 /****************************************************************
10274 _spoolss_4a
10275 ****************************************************************/
10276
10277 WERROR _spoolss_4a(pipes_struct *p,
10278 struct spoolss_4a *r)
10279 {
10280 p->rng_fault_state = true;
10281 return WERR_NOT_SUPPORTED;
10282 }
10283
10284 /****************************************************************
10285 _spoolss_4b
10286 ****************************************************************/
10287
10288 WERROR _spoolss_4b(pipes_struct *p,
10289 struct spoolss_4b *r)
10290 {
10291 p->rng_fault_state = true;
10292 return WERR_NOT_SUPPORTED;
10293 }
10294
10295 /****************************************************************
10296 _spoolss_4c
10297 ****************************************************************/
10298
10299 WERROR _spoolss_4c(pipes_struct *p,
10300 struct spoolss_4c *r)
10301 {
10302 p->rng_fault_state = true;
10303 return WERR_NOT_SUPPORTED;
10304 }
10305
10306 /****************************************************************
10307 _spoolss_53
10308 ****************************************************************/
10309
10310 WERROR _spoolss_53(pipes_struct *p,
10311 struct spoolss_53 *r)
10312 {
10313 p->rng_fault_state = true;
10314 return WERR_NOT_SUPPORTED;
10315 }
10316
10317 /****************************************************************
10318 _spoolss_55
10319 ****************************************************************/
10320
10321 WERROR _spoolss_55(pipes_struct *p,
10322 struct spoolss_55 *r)
10323 {
10324 p->rng_fault_state = true;
10325 return WERR_NOT_SUPPORTED;
10326 }
10327
10328 /****************************************************************
10329 _spoolss_56
10330 ****************************************************************/
10331
10332 WERROR _spoolss_56(pipes_struct *p,
10333 struct spoolss_56 *r)
10334 {
10335 p->rng_fault_state = true;
10336 return WERR_NOT_SUPPORTED;
10337 }
10338
10339 /****************************************************************
10340 _spoolss_57
10341 ****************************************************************/
10342
10343 WERROR _spoolss_57(pipes_struct *p,
10344 struct spoolss_57 *r)
10345 {
10346 p->rng_fault_state = true;
10347 return WERR_NOT_SUPPORTED;
10348 }
10349
10350 /****************************************************************
10351 _spoolss_5a
10352 ****************************************************************/
10353
10354 WERROR _spoolss_5a(pipes_struct *p,
10355 struct spoolss_5a *r)
10356 {
10357 p->rng_fault_state = true;
10358 return WERR_NOT_SUPPORTED;
10359 }
10360
10361 /****************************************************************
10362 _spoolss_5b
10363 ****************************************************************/
10364
10365 WERROR _spoolss_5b(pipes_struct *p,
10366 struct spoolss_5b *r)
10367 {
10368 p->rng_fault_state = true;
10369 return WERR_NOT_SUPPORTED;
10370 }
10371
10372 /****************************************************************
10373 _spoolss_5c
10374 ****************************************************************/
10375
10376 WERROR _spoolss_5c(pipes_struct *p,
10377 struct spoolss_5c *r)
10378 {
10379 p->rng_fault_state = true;
10380 return WERR_NOT_SUPPORTED;
10381 }
10382
10383 /****************************************************************
10384 _spoolss_5d
10385 ****************************************************************/
10386
10387 WERROR _spoolss_5d(pipes_struct *p,
10388 struct spoolss_5d *r)
10389 {
10390 p->rng_fault_state = true;
10391 return WERR_NOT_SUPPORTED;
10392 }
10393
10394 /****************************************************************
10395 _spoolss_5e
10396 ****************************************************************/
10397
10398 WERROR _spoolss_5e(pipes_struct *p,
10399 struct spoolss_5e *r)
10400 {
10401 p->rng_fault_state = true;
10402 return WERR_NOT_SUPPORTED;
10403 }
10404
10405 /****************************************************************
10406 _spoolss_5f
10407 ****************************************************************/
10408
10409 WERROR _spoolss_5f(pipes_struct *p,
10410 struct spoolss_5f *r)
10411 {
10412 p->rng_fault_state = true;
10413 return WERR_NOT_SUPPORTED;
10414 }
10415
Samba GIT mirror