?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: Rename new parameter "ldap ref follow" to "ldap follow referral".
[Samba/gebeck_regimport.git] / source3 / rpc_server / srv_spoolss_nt.c
blob682a59b5a8e84d22ae06fcf3b73f31c700090b8a
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 static Printer_entry *printers_list;
57
58 typedef struct _counter_printer_0 {
59 struct _counter_printer_0 *next;
60 struct _counter_printer_0 *prev;
61
62 int snum;
63 uint32_t counter;
64 } counter_printer_0;
65
66 static counter_printer_0 *counter_list;
67
68 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
69 static uint32_t smb_connections = 0;
70
71
72 /* in printing/nt_printing.c */
73
74 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
75
76 /* API table for Xcv Monitor functions */
77
78 struct xcv_api_table {
79 const char *name;
80 WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
81 };
82
83 /********************************************************************
84 * Canonicalize servername.
85 ********************************************************************/
86
87 static const char *canon_servername(const char *servername)
88 {
89 const char *pservername = servername;
90 while (*pservername == '\\') {
91 pservername++;
92 }
93 return pservername;
94 }
95
96 /* translate between internal status numbers and NT status numbers */
97 static int nt_printj_status(int v)
98 {
99 switch (v) {
100 case LPQ_QUEUED:
101 return 0;
102 case LPQ_PAUSED:
103 return JOB_STATUS_PAUSED;
104 case LPQ_SPOOLING:
105 return JOB_STATUS_SPOOLING;
106 case LPQ_PRINTING:
107 return JOB_STATUS_PRINTING;
108 case LPQ_ERROR:
109 return JOB_STATUS_ERROR;
110 case LPQ_DELETING:
111 return JOB_STATUS_DELETING;
112 case LPQ_OFFLINE:
113 return JOB_STATUS_OFFLINE;
114 case LPQ_PAPEROUT:
115 return JOB_STATUS_PAPEROUT;
116 case LPQ_PRINTED:
117 return JOB_STATUS_PRINTED;
118 case LPQ_DELETED:
119 return JOB_STATUS_DELETED;
120 case LPQ_BLOCKED:
121 return JOB_STATUS_BLOCKED_DEVQ;
122 case LPQ_USER_INTERVENTION:
123 return JOB_STATUS_USER_INTERVENTION;
124 }
125 return 0;
126 }
127
128 static int nt_printq_status(int v)
129 {
130 switch (v) {
131 case LPQ_PAUSED:
132 return PRINTER_STATUS_PAUSED;
133 case LPQ_QUEUED:
134 case LPQ_SPOOLING:
135 case LPQ_PRINTING:
136 return 0;
137 }
138 return 0;
139 }
140
141 /***************************************************************************
142 Disconnect from the client
143 ****************************************************************************/
144
145 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
146 {
147 WERROR result;
148 NTSTATUS status;
149
150 /*
151 * Tell the specific printing tdb we no longer want messages for this printer
152 * by deregistering our PID.
153 */
154
155 if (!print_notify_deregister_pid(snum))
156 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
157
158 /* weird if the test succeds !!! */
159 if (smb_connections==0) {
160 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
161 return;
162 }
163
164 status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
165 handle,
166 &result);
167 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
168 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
169 win_errstr(result)));
170
171 /* if it's the last connection, deconnect the IPC$ share */
172 if (smb_connections==1) {
173
174 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
175 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
176
177 messaging_deregister(smbd_messaging_context(),
178 MSG_PRINTER_NOTIFY2, NULL);
179
180 /* Tell the connections db we're no longer interested in
181 * printer notify messages. */
182
183 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
184 }
185
186 smb_connections--;
187 }
188
189 /****************************************************************************
190 Functions to free a printer entry datastruct.
191 ****************************************************************************/
192
193 static int printer_entry_destructor(Printer_entry *Printer)
194 {
195 if (Printer->notify.client_connected == true) {
196 int snum = -1;
197
198 if ( Printer->printer_type == SPLHND_SERVER) {
199 snum = -1;
200 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
201 } else if (Printer->printer_type == SPLHND_PRINTER) {
202 snum = print_queue_snum(Printer->sharename);
203 if (snum != -1)
204 srv_spoolss_replycloseprinter(snum,
205 &Printer->notify.client_hnd);
206 }
207 }
208
209 Printer->notify.flags=0;
210 Printer->notify.options=0;
211 Printer->notify.localmachine[0]='\0';
212 Printer->notify.printerlocal=0;
213 TALLOC_FREE(Printer->notify.option);
214 Printer->notify.client_connected = false;
215
216 free_nt_devicemode( &Printer->nt_devmode );
217 free_a_printer( &Printer->printer_info, 2 );
218
219 /* Remove from the internal list. */
220 DLIST_REMOVE(printers_list, Printer);
221 return 0;
222 }
223
224 /****************************************************************************
225 find printer index by handle
226 ****************************************************************************/
227
228 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
229 struct policy_handle *hnd)
230 {
231 Printer_entry *find_printer = NULL;
232
233 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
234 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
235 return NULL;
236 }
237
238 return find_printer;
239 }
240
241 /****************************************************************************
242 Close printer index by handle.
243 ****************************************************************************/
244
245 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
246 {
247 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
248
249 if (!Printer) {
250 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
251 OUR_HANDLE(hnd)));
252 return false;
253 }
254
255 close_policy_hnd(p, hnd);
256
257 return true;
258 }
259
260 /****************************************************************************
261 Delete a printer given a handle.
262 ****************************************************************************/
263
264 static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename)
265 {
266 char *cmd = lp_deleteprinter_cmd();
267 char *command = NULL;
268 int ret;
269 SE_PRIV se_printop = SE_PRINT_OPERATOR;
270 bool is_print_op = false;
271
272 /* can't fail if we don't try */
273
274 if ( !*cmd )
275 return WERR_OK;
276
277 command = talloc_asprintf(ctx,
278 "%s \"%s\"",
279 cmd, sharename);
280 if (!command) {
281 return WERR_NOMEM;
282 }
283 if ( token )
284 is_print_op = user_has_privileges( token, &se_printop );
285
286 DEBUG(10,("Running [%s]\n", command));
287
288 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
289
290 if ( is_print_op )
291 become_root();
292
293 if ( (ret = smbrun(command, NULL)) == 0 ) {
294 /* Tell everyone we updated smb.conf. */
295 message_send_all(smbd_messaging_context(),
296 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
297 }
298
299 if ( is_print_op )
300 unbecome_root();
301
302 /********** END SePrintOperatorPrivlege BLOCK **********/
303
304 DEBUGADD(10,("returned [%d]\n", ret));
305
306 TALLOC_FREE(command);
307
308 if (ret != 0)
309 return WERR_BADFID; /* What to return here? */
310
311 /* go ahead and re-read the services immediately */
312 become_root();
313 reload_services(false);
314 unbecome_root();
315
316 if ( lp_servicenumber( sharename ) < 0 )
317 return WERR_ACCESS_DENIED;
318
319 return WERR_OK;
320 }
321
322 /****************************************************************************
323 Delete a printer given a handle.
324 ****************************************************************************/
325
326 static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
327 {
328 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
329
330 if (!Printer) {
331 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
332 OUR_HANDLE(hnd)));
333 return WERR_BADFID;
334 }
335
336 /*
337 * It turns out that Windows allows delete printer on a handle
338 * opened by an admin user, then used on a pipe handle created
339 * by an anonymous user..... but they're working on security.... riiight !
340 * JRA.
341 */
342
343 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
344 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
345 return WERR_ACCESS_DENIED;
346 }
347
348 /* this does not need a become root since the access check has been
349 done on the handle already */
350
351 if (del_a_printer( Printer->sharename ) != 0) {
352 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
353 return WERR_BADFID;
354 }
355
356 return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
357 Printer->sharename );
358 }
359
360 /****************************************************************************
361 Return the snum of a printer corresponding to an handle.
362 ****************************************************************************/
363
364 static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
365 int *number, struct share_params **params)
366 {
367 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
368
369 if (!Printer) {
370 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
371 OUR_HANDLE(hnd)));
372 return false;
373 }
374
375 switch (Printer->printer_type) {
376 case SPLHND_PRINTER:
377 DEBUG(4,("short name:%s\n", Printer->sharename));
378 *number = print_queue_snum(Printer->sharename);
379 return (*number != -1);
380 case SPLHND_SERVER:
381 return false;
382 default:
383 return false;
384 }
385 }
386
387 /****************************************************************************
388 Set printer handle type.
389 Check if it's \\server or \\server\printer
390 ****************************************************************************/
391
392 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
393 {
394 DEBUG(3,("Setting printer type=%s\n", handlename));
395
396 if ( strlen(handlename) < 3 ) {
397 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
398 return false;
399 }
400
401 /* it's a print server */
402 if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
403 DEBUGADD(4,("Printer is a print server\n"));
404 Printer->printer_type = SPLHND_SERVER;
405 }
406 /* it's a printer (set_printer_hnd_name() will handle port monitors */
407 else {
408 DEBUGADD(4,("Printer is a printer\n"));
409 Printer->printer_type = SPLHND_PRINTER;
410 }
411
412 return true;
413 }
414
415 /****************************************************************************
416 Set printer handle name.. Accept names like \\server, \\server\printer,
417 \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port" See
418 the MSDN docs regarding OpenPrinter() for details on the XcvData() and
419 XcvDataPort() interface.
420 ****************************************************************************/
421
422 static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
423 {
424 int snum;
425 int n_services=lp_numservices();
426 char *aprinter, *printername;
427 const char *servername;
428 fstring sname;
429 bool found = false;
430 NT_PRINTER_INFO_LEVEL *printer = NULL;
431 WERROR result;
432
433 DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
434 (unsigned long)strlen(handlename)));
435
436 aprinter = CONST_DISCARD(char *, handlename);
437 if ( *handlename == '\\' ) {
438 servername = canon_servername(handlename);
439 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
440 *aprinter = '\0';
441 aprinter++;
442 }
443 } else {
444 servername = global_myname();
445 }
446
447 /* save the servername to fill in replies on this handle */
448
449 if ( !is_myname_or_ipaddr( servername ) )
450 return false;
451
452 fstrcpy( Printer->servername, servername );
453
454 if ( Printer->printer_type == SPLHND_SERVER )
455 return true;
456
457 if ( Printer->printer_type != SPLHND_PRINTER )
458 return false;
459
460 DEBUGADD(5, ("searching for [%s]\n", aprinter ));
461
462 /* check for the Port Monitor Interface */
463
464 if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
465 Printer->printer_type = SPLHND_PORTMON_TCP;
466 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
467 found = true;
468 }
469 else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
470 Printer->printer_type = SPLHND_PORTMON_LOCAL;
471 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
472 found = true;
473 }
474
475 /* Search all sharenames first as this is easier than pulling
476 the printer_info_2 off of disk. Don't use find_service() since
477 that calls out to map_username() */
478
479 /* do another loop to look for printernames */
480
481 for (snum=0; !found && snum<n_services; snum++) {
482
483 /* no point going on if this is not a printer */
484
485 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
486 continue;
487
488 fstrcpy(sname, lp_servicename(snum));
489 if ( strequal( aprinter, sname ) ) {
490 found = true;
491 break;
492 }
493
494 /* no point looking up the printer object if
495 we aren't allowing printername != sharename */
496
497 if ( lp_force_printername(snum) )
498 continue;
499
500 fstrcpy(sname, lp_servicename(snum));
501
502 printer = NULL;
503
504 /* This call doesn't fill in the location or comment from
505 * a CUPS server for efficiency with large numbers of printers.
506 * JRA.
507 */
508
509 result = get_a_printer_search( NULL, &printer, 2, sname );
510 if ( !W_ERROR_IS_OK(result) ) {
511 DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
512 sname, win_errstr(result)));
513 continue;
514 }
515
516 /* printername is always returned as \\server\printername */
517 if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
518 DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
519 printer->info_2->printername));
520 free_a_printer( &printer, 2);
521 continue;
522 }
523
524 printername++;
525
526 if ( strequal(printername, aprinter) ) {
527 free_a_printer( &printer, 2);
528 found = true;
529 break;
530 }
531
532 DEBUGADD(10, ("printername: %s\n", printername));
533
534 free_a_printer( &printer, 2);
535 }
536
537 free_a_printer( &printer, 2);
538
539 if ( !found ) {
540 DEBUGADD(4,("Printer not found\n"));
541 return false;
542 }
543
544 DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
545
546 fstrcpy(Printer->sharename, sname);
547
548 return true;
549 }
550
551 /****************************************************************************
552 Find first available printer slot. creates a printer handle for you.
553 ****************************************************************************/
554
555 static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
556 const char *name, uint32_t access_granted)
557 {
558 Printer_entry *new_printer;
559
560 DEBUG(10,("open_printer_hnd: name [%s]\n", name));
561
562 new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
563 if (new_printer == NULL) {
564 return false;
565 }
566 talloc_set_destructor(new_printer, printer_entry_destructor);
567
568 if (!create_policy_hnd(p, hnd, new_printer)) {
569 TALLOC_FREE(new_printer);
570 return false;
571 }
572
573 /* Add to the internal list. */
574 DLIST_ADD(printers_list, new_printer);
575
576 new_printer->notify.option=NULL;
577
578 if (!set_printer_hnd_printertype(new_printer, name)) {
579 close_printer_handle(p, hnd);
580 return false;
581 }
582
583 if (!set_printer_hnd_name(new_printer, name)) {
584 close_printer_handle(p, hnd);
585 return false;
586 }
587
588 new_printer->access_granted = access_granted;
589
590 DEBUG(5, ("%d printer handles active\n",
591 (int)num_pipe_handles(p->pipe_handles)));
592
593 return true;
594 }
595
596 /***************************************************************************
597 check to see if the client motify handle is monitoring the notification
598 given by (notify_type, notify_field).
599 **************************************************************************/
600
601 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
602 uint16_t notify_field)
603 {
604 return true;
605 }
606
607 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
608 uint16_t notify_field)
609 {
610 struct spoolss_NotifyOption *option = p->notify.option;
611 uint32_t i, j;
612
613 /*
614 * Flags should always be zero when the change notify
615 * is registered by the client's spooler. A user Win32 app
616 * might use the flags though instead of the NOTIFY_OPTION_INFO
617 * --jerry
618 */
619
620 if (!option) {
621 return false;
622 }
623
624 if (p->notify.flags)
625 return is_monitoring_event_flags(
626 p->notify.flags, notify_type, notify_field);
627
628 for (i = 0; i < option->count; i++) {
629
630 /* Check match for notify_type */
631
632 if (option->types[i].type != notify_type)
633 continue;
634
635 /* Check match for field */
636
637 for (j = 0; j < option->types[i].count; j++) {
638 if (option->types[i].fields[j].field == notify_field) {
639 return true;
640 }
641 }
642 }
643
644 DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
645 p->servername, p->sharename, notify_type, notify_field));
646
647 return false;
648 }
649
650 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
651 _data->data.integer[0] = _integer; \
652 _data->data.integer[1] = 0;
653
654
655 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
656 _data->data.string.string = talloc_strdup(mem_ctx, _p); \
657 if (!_data->data.string.string) {\
658 _data->data.string.size = 0; \
659 } \
660 _data->data.string.size = strlen_m_term(_p) * 2;
661
662 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
663 _data->data.devmode.devmode = _devmode;
664
665 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
666 _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
667 if (!_data->data.sd.sd) { \
668 _data->data.sd.sd_size = 0; \
669 } \
670 _data->data.sd.sd_size = _size;
671
672 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
673 struct tm *t,
674 const char **pp,
675 uint32_t *plen)
676 {
677 struct spoolss_Time st;
678 uint32_t len = 16;
679 char *p;
680
681 if (!init_systemtime(&st, t)) {
682 return;
683 }
684
685 p = talloc_array(mem_ctx, char, len);
686 if (!p) {
687 return;
688 }
689
690 /*
691 * Systemtime must be linearized as a set of UINT16's.
692 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
693 */
694
695 SSVAL(p, 0, st.year);
696 SSVAL(p, 2, st.month);
697 SSVAL(p, 4, st.day_of_week);
698 SSVAL(p, 6, st.day);
699 SSVAL(p, 8, st.hour);
700 SSVAL(p, 10, st.minute);
701 SSVAL(p, 12, st.second);
702 SSVAL(p, 14, st.millisecond);
703
704 *pp = p;
705 *plen = len;
706 }
707
708 /* Convert a notification message to a struct spoolss_Notify */
709
710 static void notify_one_value(struct spoolss_notify_msg *msg,
711 struct spoolss_Notify *data,
712 TALLOC_CTX *mem_ctx)
713 {
714 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
715 }
716
717 static void notify_string(struct spoolss_notify_msg *msg,
718 struct spoolss_Notify *data,
719 TALLOC_CTX *mem_ctx)
720 {
721 /* The length of the message includes the trailing \0 */
722
723 data->data.string.size = msg->len * 2;
724 data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
725 if (!data->data.string.string) {
726 data->data.string.size = 0;
727 return;
728 }
729 }
730
731 static void notify_system_time(struct spoolss_notify_msg *msg,
732 struct spoolss_Notify *data,
733 TALLOC_CTX *mem_ctx)
734 {
735 data->data.string.string = NULL;
736 data->data.string.size = 0;
737
738 if (msg->len != sizeof(time_t)) {
739 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
740 msg->len));
741 return;
742 }
743
744 init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
745 &data->data.string.string,
746 &data->data.string.size);
747 }
748
749 struct notify2_message_table {
750 const char *name;
751 void (*fn)(struct spoolss_notify_msg *msg,
752 struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
753 };
754
755 static struct notify2_message_table printer_notify_table[] = {
756 /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
757 /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
758 /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
759 /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
760 /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
761 /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
762 /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
763 /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
764 /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
765 /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
766 /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
767 /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
768 /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
769 /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
770 /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
771 /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
772 /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
773 /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
774 /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
775 };
776
777 static struct notify2_message_table job_notify_table[] = {
778 /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
779 /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
780 /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
781 /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
782 /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
783 /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
784 /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
785 /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
786 /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
787 /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
788 /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
789 /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
790 /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
791 /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
792 /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
793 /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
794 /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
795 /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
796 /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
797 /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
798 /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
799 /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
800 /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
801 /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
802 };
803
804
805 /***********************************************************************
806 Allocate talloc context for container object
807 **********************************************************************/
808
809 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
810 {
811 if ( !ctr )
812 return;
813
814 ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
815
816 return;
817 }
818
819 /***********************************************************************
820 release all allocated memory and zero out structure
821 **********************************************************************/
822
823 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
824 {
825 if ( !ctr )
826 return;
827
828 if ( ctr->ctx )
829 talloc_destroy(ctr->ctx);
830
831 ZERO_STRUCTP(ctr);
832
833 return;
834 }
835
836 /***********************************************************************
837 **********************************************************************/
838
839 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
840 {
841 if ( !ctr )
842 return NULL;
843
844 return ctr->ctx;
845 }
846
847 /***********************************************************************
848 **********************************************************************/
849
850 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
851 {
852 if ( !ctr || !ctr->msg_groups )
853 return NULL;
854
855 if ( idx >= ctr->num_groups )
856 return NULL;
857
858 return &ctr->msg_groups[idx];
859
860 }
861
862 /***********************************************************************
863 How many groups of change messages do we have ?
864 **********************************************************************/
865
866 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
867 {
868 if ( !ctr )
869 return 0;
870
871 return ctr->num_groups;
872 }
873
874 /***********************************************************************
875 Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
876 **********************************************************************/
877
878 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
879 {
880 SPOOLSS_NOTIFY_MSG_GROUP *groups = NULL;
881 SPOOLSS_NOTIFY_MSG_GROUP *msg_grp = NULL;
882 SPOOLSS_NOTIFY_MSG *msg_list = NULL;
883 int i, new_slot;
884
885 if ( !ctr || !msg )
886 return 0;
887
888 /* loop over all groups looking for a matching printer name */
889
890 for ( i=0; i<ctr->num_groups; i++ ) {
891 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
892 break;
893 }
894
895 /* add a new group? */
896
897 if ( i == ctr->num_groups ) {
898 ctr->num_groups++;
899
900 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
901 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
902 return 0;
903 }
904 ctr->msg_groups = groups;
905
906 /* clear the new entry and set the printer name */
907
908 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
909 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
910 }
911
912 /* add the change messages; 'i' is the correct index now regardless */
913
914 msg_grp = &ctr->msg_groups[i];
915
916 msg_grp->num_msgs++;
917
918 if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
919 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
920 return 0;
921 }
922 msg_grp->msgs = msg_list;
923
924 new_slot = msg_grp->num_msgs-1;
925 memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
926
927 /* need to allocate own copy of data */
928
929 if ( msg->len != 0 )
930 msg_grp->msgs[new_slot].notify.data = (char *)
931 TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
932
933 return ctr->num_groups;
934 }
935
936 /***********************************************************************
937 Send a change notication message on all handles which have a call
938 back registered
939 **********************************************************************/
940
941 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
942 {
943 Printer_entry *p;
944 TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
945 SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
946 SPOOLSS_NOTIFY_MSG *messages;
947 int sending_msg_count;
948
949 if ( !msg_group ) {
950 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
951 return;
952 }
953
954 messages = msg_group->msgs;
955
956 if ( !messages ) {
957 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
958 return;
959 }
960
961 DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
962
963 /* loop over all printers */
964
965 for (p = printers_list; p; p = p->next) {
966 struct spoolss_Notify *notifies;
967 uint32_t count = 0;
968 uint32_t id;
969 int i;
970
971 /* Is there notification on this handle? */
972
973 if ( !p->notify.client_connected )
974 continue;
975
976 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
977
978 /* For this printer? Print servers always receive
979 notifications. */
980
981 if ( ( p->printer_type == SPLHND_PRINTER ) &&
982 ( !strequal(msg_group->printername, p->sharename) ) )
983 continue;
984
985 DEBUG(10,("Our printer\n"));
986
987 /* allocate the max entries possible */
988
989 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
990 if (!notifies) {
991 return;
992 }
993
994 /* build the array of change notifications */
995
996 sending_msg_count = 0;
997
998 for ( i=0; i<msg_group->num_msgs; i++ ) {
999 SPOOLSS_NOTIFY_MSG *msg = &messages[i];
1000
1001 /* Are we monitoring this event? */
1002
1003 if (!is_monitoring_event(p, msg->type, msg->field))
1004 continue;
1005
1006 sending_msg_count++;
1007
1008
1009 DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1010 msg->type, msg->field, p->sharename));
1011
1012 /*
1013 * if the is a printer notification handle and not a job notification
1014 * type, then set the id to 0. Other wise just use what was specified
1015 * in the message.
1016 *
1017 * When registering change notification on a print server handle
1018 * we always need to send back the id (snum) matching the printer
1019 * for which the change took place. For change notify registered
1020 * on a printer handle, this does not matter and the id should be 0.
1021 *
1022 * --jerry
1023 */
1024
1025 if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1026 id = 0;
1027 else
1028 id = msg->id;
1029
1030
1031 /* Convert unix jobid to smb jobid */
1032
1033 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1034 id = sysjob_to_jobid(msg->id);
1035
1036 if (id == -1) {
1037 DEBUG(3, ("no such unix jobid %d\n", msg->id));
1038 goto done;
1039 }
1040 }
1041
1042 construct_info_data( &notifies[count], msg->type, msg->field, id );
1043
1044 switch(msg->type) {
1045 case PRINTER_NOTIFY_TYPE:
1046 if ( printer_notify_table[msg->field].fn )
1047 printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1048 break;
1049
1050 case JOB_NOTIFY_TYPE:
1051 if ( job_notify_table[msg->field].fn )
1052 job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1053 break;
1054
1055 default:
1056 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1057 goto done;
1058 }
1059
1060 count++;
1061 }
1062
1063 if ( sending_msg_count ) {
1064 NTSTATUS status;
1065 WERROR werr;
1066 union spoolss_ReplyPrinterInfo info;
1067 struct spoolss_NotifyInfo info0;
1068 uint32_t reply_result;
1069
1070 info0.version = 0x2;
1071 info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1072 info0.count = count;
1073 info0.notifies = notifies;
1074
1075 info.info0 = &info0;
1076
1077 status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1078 &p->notify.client_hnd,
1079 p->notify.change, /* color */
1080 p->notify.flags,
1081 &reply_result,
1082 0, /* reply_type, must be 0 */
1083 info,
1084 &werr);
1085 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1086 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1087 notify_cli_pipe->srv_name_slash,
1088 win_errstr(werr)));
1089 }
1090 switch (reply_result) {
1091 case 0:
1092 break;
1093 case PRINTER_NOTIFY_INFO_DISCARDED:
1094 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1095 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1096 break;
1097 default:
1098 break;
1099 }
1100 }
1101 }
1102
1103 done:
1104 DEBUG(8,("send_notify2_changes: Exit...\n"));
1105 return;
1106 }
1107
1108 /***********************************************************************
1109 **********************************************************************/
1110
1111 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1112 {
1113
1114 uint32_t tv_sec, tv_usec;
1115 size_t offset = 0;
1116
1117 /* Unpack message */
1118
1119 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1120 msg->printer);
1121
1122 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1123 &tv_sec, &tv_usec,
1124 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1125
1126 if (msg->len == 0)
1127 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1128 &msg->notify.value[0], &msg->notify.value[1]);
1129 else
1130 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1131 &msg->len, &msg->notify.data);
1132
1133 DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1134 msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1135
1136 tv->tv_sec = tv_sec;
1137 tv->tv_usec = tv_usec;
1138
1139 if (msg->len == 0)
1140 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1141 msg->notify.value[1]));
1142 else
1143 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1144
1145 return true;
1146 }
1147
1148 /********************************************************************
1149 Receive a notify2 message list
1150 ********************************************************************/
1151
1152 static void receive_notify2_message_list(struct messaging_context *msg,
1153 void *private_data,
1154 uint32_t msg_type,
1155 struct server_id server_id,
1156 DATA_BLOB *data)
1157 {
1158 size_t msg_count, i;
1159 char *buf = (char *)data->data;
1160 char *msg_ptr;
1161 size_t msg_len;
1162 SPOOLSS_NOTIFY_MSG notify;
1163 SPOOLSS_NOTIFY_MSG_CTR messages;
1164 int num_groups;
1165
1166 if (data->length < 4) {
1167 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1168 return;
1169 }
1170
1171 msg_count = IVAL(buf, 0);
1172 msg_ptr = buf + 4;
1173
1174 DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1175
1176 if (msg_count == 0) {
1177 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1178 return;
1179 }
1180
1181 /* initialize the container */
1182
1183 ZERO_STRUCT( messages );
1184 notify_msg_ctr_init( &messages );
1185
1186 /*
1187 * build message groups for each printer identified
1188 * in a change_notify msg. Remember that a PCN message
1189 * includes the handle returned for the srv_spoolss_replyopenprinter()
1190 * call. Therefore messages are grouped according to printer handle.
1191 */
1192
1193 for ( i=0; i<msg_count; i++ ) {
1194 struct timeval msg_tv;
1195
1196 if (msg_ptr + 4 - buf > data->length) {
1197 DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1198 return;
1199 }
1200
1201 msg_len = IVAL(msg_ptr,0);
1202 msg_ptr += 4;
1203
1204 if (msg_ptr + msg_len - buf > data->length) {
1205 DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1206 return;
1207 }
1208
1209 /* unpack messages */
1210
1211 ZERO_STRUCT( notify );
1212 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1213 msg_ptr += msg_len;
1214
1215 /* add to correct list in container */
1216
1217 notify_msg_ctr_addmsg( &messages, &notify );
1218
1219 /* free memory that might have been allocated by notify2_unpack_msg() */
1220
1221 if ( notify.len != 0 )
1222 SAFE_FREE( notify.notify.data );
1223 }
1224
1225 /* process each group of messages */
1226
1227 num_groups = notify_msg_ctr_numgroups( &messages );
1228 for ( i=0; i<num_groups; i++ )
1229 send_notify2_changes( &messages, i );
1230
1231
1232 /* cleanup */
1233
1234 DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1235 (uint32_t)msg_count ));
1236
1237 notify_msg_ctr_destroy( &messages );
1238
1239 return;
1240 }
1241
1242 /********************************************************************
1243 Send a message to ourself about new driver being installed
1244 so we can upgrade the information for each printer bound to this
1245 driver
1246 ********************************************************************/
1247
1248 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1249 {
1250 int len = strlen(drivername);
1251
1252 if (!len)
1253 return false;
1254
1255 DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1256 drivername));
1257
1258 messaging_send_buf(smbd_messaging_context(), procid_self(),
1259 MSG_PRINTER_DRVUPGRADE,
1260 (uint8_t *)drivername, len+1);
1261
1262 return true;
1263 }
1264
1265 /**********************************************************************
1266 callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1267 over all printers, upgrading ones as necessary
1268 **********************************************************************/
1269
1270 void do_drv_upgrade_printer(struct messaging_context *msg,
1271 void *private_data,
1272 uint32_t msg_type,
1273 struct server_id server_id,
1274 DATA_BLOB *data)
1275 {
1276 fstring drivername;
1277 int snum;
1278 int n_services = lp_numservices();
1279 size_t len;
1280
1281 len = MIN(data->length,sizeof(drivername)-1);
1282 strncpy(drivername, (const char *)data->data, len);
1283
1284 DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1285
1286 /* Iterate the printer list */
1287
1288 for (snum=0; snum<n_services; snum++)
1289 {
1290 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1291 {
1292 WERROR result;
1293 NT_PRINTER_INFO_LEVEL *printer = NULL;
1294
1295 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1296 if (!W_ERROR_IS_OK(result))
1297 continue;
1298
1299 if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1300 {
1301 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1302
1303 /* all we care about currently is the change_id */
1304
1305 result = mod_a_printer(printer, 2);
1306 if (!W_ERROR_IS_OK(result)) {
1307 DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1308 win_errstr(result)));
1309 }
1310 }
1311
1312 free_a_printer(&printer, 2);
1313 }
1314 }
1315
1316 /* all done */
1317 }
1318
1319 /********************************************************************
1320 Update the cache for all printq's with a registered client
1321 connection
1322 ********************************************************************/
1323
1324 void update_monitored_printq_cache( void )
1325 {
1326 Printer_entry *printer = printers_list;
1327 int snum;
1328
1329 /* loop through all printers and update the cache where
1330 client_connected == true */
1331 while ( printer )
1332 {
1333 if ( (printer->printer_type == SPLHND_PRINTER)
1334 && printer->notify.client_connected )
1335 {
1336 snum = print_queue_snum(printer->sharename);
1337 print_queue_status( snum, NULL, NULL );
1338 }
1339
1340 printer = printer->next;
1341 }
1342
1343 return;
1344 }
1345 /********************************************************************
1346 Send a message to ourself about new driver being installed
1347 so we can upgrade the information for each printer bound to this
1348 driver
1349 ********************************************************************/
1350
1351 static bool srv_spoolss_reset_printerdata(char* drivername)
1352 {
1353 int len = strlen(drivername);
1354
1355 if (!len)
1356 return false;
1357
1358 DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1359 drivername));
1360
1361 messaging_send_buf(smbd_messaging_context(), procid_self(),
1362 MSG_PRINTERDATA_INIT_RESET,
1363 (uint8_t *)drivername, len+1);
1364
1365 return true;
1366 }
1367
1368 /**********************************************************************
1369 callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1370 over all printers, resetting printer data as neessary
1371 **********************************************************************/
1372
1373 void reset_all_printerdata(struct messaging_context *msg,
1374 void *private_data,
1375 uint32_t msg_type,
1376 struct server_id server_id,
1377 DATA_BLOB *data)
1378 {
1379 fstring drivername;
1380 int snum;
1381 int n_services = lp_numservices();
1382 size_t len;
1383
1384 len = MIN( data->length, sizeof(drivername)-1 );
1385 strncpy( drivername, (const char *)data->data, len );
1386
1387 DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1388
1389 /* Iterate the printer list */
1390
1391 for ( snum=0; snum<n_services; snum++ )
1392 {
1393 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1394 {
1395 WERROR result;
1396 NT_PRINTER_INFO_LEVEL *printer = NULL;
1397
1398 result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1399 if ( !W_ERROR_IS_OK(result) )
1400 continue;
1401
1402 /*
1403 * if the printer is bound to the driver,
1404 * then reset to the new driver initdata
1405 */
1406
1407 if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1408 {
1409 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1410
1411 if ( !set_driver_init(printer, 2) ) {
1412 DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1413 printer->info_2->printername, printer->info_2->drivername));
1414 }
1415
1416 result = mod_a_printer( printer, 2 );
1417 if ( !W_ERROR_IS_OK(result) ) {
1418 DEBUG(3,("reset_all_printerdata: mod_a_printer() failed! (%s)\n",
1419 get_dos_error_msg(result)));
1420 }
1421 }
1422
1423 free_a_printer( &printer, 2 );
1424 }
1425 }
1426
1427 /* all done */
1428
1429 return;
1430 }
1431
1432 /****************************************************************
1433 _spoolss_OpenPrinter
1434 ****************************************************************/
1435
1436 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1437 struct spoolss_OpenPrinter *r)
1438 {
1439 struct spoolss_OpenPrinterEx e;
1440 WERROR werr;
1441
1442 ZERO_STRUCT(e.in.userlevel);
1443
1444 e.in.printername = r->in.printername;
1445 e.in.datatype = r->in.datatype;
1446 e.in.devmode_ctr = r->in.devmode_ctr;
1447 e.in.access_mask = r->in.access_mask;
1448 e.in.level = 0;
1449
1450 e.out.handle = r->out.handle;
1451
1452 werr = _spoolss_OpenPrinterEx(p, &e);
1453
1454 if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1455 /* OpenPrinterEx returns this for a bad
1456 * printer name. We must return WERR_INVALID_PRINTER_NAME
1457 * instead.
1458 */
1459 werr = WERR_INVALID_PRINTER_NAME;
1460 }
1461
1462 return werr;
1463 }
1464
1465 /********************************************************************
1466 ********************************************************************/
1467
1468 bool convert_devicemode(const char *printername,
1469 const struct spoolss_DeviceMode *devmode,
1470 NT_DEVICEMODE **pp_nt_devmode)
1471 {
1472 NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1473
1474 /*
1475 * Ensure nt_devmode is a valid pointer
1476 * as we will be overwriting it.
1477 */
1478
1479 if (nt_devmode == NULL) {
1480 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1481 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1482 return false;
1483 }
1484
1485 rpcstr_push(nt_devmode->devicename, devmode->devicename, 31, 0);
1486 rpcstr_push(nt_devmode->formname, devmode->formname, 31, 0);
1487
1488 nt_devmode->specversion = devmode->specversion;
1489 nt_devmode->driverversion = devmode->driverversion;
1490 nt_devmode->size = devmode->size;
1491 nt_devmode->fields = devmode->fields;
1492 nt_devmode->orientation = devmode->orientation;
1493 nt_devmode->papersize = devmode->papersize;
1494 nt_devmode->paperlength = devmode->paperlength;
1495 nt_devmode->paperwidth = devmode->paperwidth;
1496 nt_devmode->scale = devmode->scale;
1497 nt_devmode->copies = devmode->copies;
1498 nt_devmode->defaultsource = devmode->defaultsource;
1499 nt_devmode->printquality = devmode->printquality;
1500 nt_devmode->color = devmode->color;
1501 nt_devmode->duplex = devmode->duplex;
1502 nt_devmode->yresolution = devmode->yresolution;
1503 nt_devmode->ttoption = devmode->ttoption;
1504 nt_devmode->collate = devmode->collate;
1505
1506 nt_devmode->logpixels = devmode->logpixels;
1507 nt_devmode->bitsperpel = devmode->bitsperpel;
1508 nt_devmode->pelswidth = devmode->pelswidth;
1509 nt_devmode->pelsheight = devmode->pelsheight;
1510 nt_devmode->displayflags = devmode->displayflags;
1511 nt_devmode->displayfrequency = devmode->displayfrequency;
1512 nt_devmode->icmmethod = devmode->icmmethod;
1513 nt_devmode->icmintent = devmode->icmintent;
1514 nt_devmode->mediatype = devmode->mediatype;
1515 nt_devmode->dithertype = devmode->dithertype;
1516 nt_devmode->reserved1 = devmode->reserved1;
1517 nt_devmode->reserved2 = devmode->reserved2;
1518 nt_devmode->panningwidth = devmode->panningwidth;
1519 nt_devmode->panningheight = devmode->panningheight;
1520
1521 /*
1522 * Only change private and driverextra if the incoming devmode
1523 * has a new one. JRA.
1524 */
1525
1526 if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1527 SAFE_FREE(nt_devmode->nt_dev_private);
1528 nt_devmode->driverextra = devmode->__driverextra_length;
1529 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1530 return false;
1531 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1532 }
1533
1534 *pp_nt_devmode = nt_devmode;
1535
1536 return true;
1537 }
1538
1539 /****************************************************************
1540 _spoolss_OpenPrinterEx
1541 ****************************************************************/
1542
1543 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1544 struct spoolss_OpenPrinterEx *r)
1545 {
1546 int snum;
1547 Printer_entry *Printer=NULL;
1548
1549 if (!r->in.printername) {
1550 return WERR_INVALID_PARAM;
1551 }
1552
1553 /* some sanity check because you can open a printer or a print server */
1554 /* aka: \\server\printer or \\server */
1555
1556 DEBUGADD(3,("checking name: %s\n", r->in.printername));
1557
1558 if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1559 ZERO_STRUCTP(r->out.handle);
1560 return WERR_INVALID_PARAM;
1561 }
1562
1563 Printer = find_printer_index_by_hnd(p, r->out.handle);
1564 if ( !Printer ) {
1565 DEBUG(0,("_spoolss_OpenPrinterEx: logic error. Can't find printer "
1566 "handle we created for printer %s\n", r->in.printername));
1567 close_printer_handle(p, r->out.handle);
1568 ZERO_STRUCTP(r->out.handle);
1569 return WERR_INVALID_PARAM;
1570 }
1571
1572 /*
1573 * First case: the user is opening the print server:
1574 *
1575 * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1576 * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1577 *
1578 * Then both Win2k and WinNT clients try an OpenPrinterEx with
1579 * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1580 * or if the user is listed in the smb.conf printer admin parameter.
1581 *
1582 * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1583 * client view printer folder, but does not show the MSAPW.
1584 *
1585 * Note: this test needs code to check access rights here too. Jeremy
1586 * could you look at this?
1587 *
1588 * Second case: the user is opening a printer:
1589 * NT doesn't let us connect to a printer if the connecting user
1590 * doesn't have print permission.
1591 *
1592 * Third case: user is opening a Port Monitor
1593 * access checks same as opening a handle to the print server.
1594 */
1595
1596 switch (Printer->printer_type )
1597 {
1598 case SPLHND_SERVER:
1599 case SPLHND_PORTMON_TCP:
1600 case SPLHND_PORTMON_LOCAL:
1601 /* Printserver handles use global struct... */
1602
1603 snum = -1;
1604
1605 /* Map standard access rights to object specific access rights */
1606
1607 se_map_standard(&r->in.access_mask,
1608 &printserver_std_mapping);
1609
1610 /* Deny any object specific bits that don't apply to print
1611 servers (i.e printer and job specific bits) */
1612
1613 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1614
1615 if (r->in.access_mask &
1616 ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1617 DEBUG(3, ("access DENIED for non-printserver bits\n"));
1618 close_printer_handle(p, r->out.handle);
1619 ZERO_STRUCTP(r->out.handle);
1620 return WERR_ACCESS_DENIED;
1621 }
1622
1623 /* Allow admin access */
1624
1625 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1626 {
1627 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1628
1629 if (!lp_ms_add_printer_wizard()) {
1630 close_printer_handle(p, r->out.handle);
1631 ZERO_STRUCTP(r->out.handle);
1632 return WERR_ACCESS_DENIED;
1633 }
1634
1635 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1636 and not a printer admin, then fail */
1637
1638 if ((p->server_info->utok.uid != sec_initial_uid()) &&
1639 !user_has_privileges(p->server_info->ptok,
1640 &se_printop ) &&
1641 !token_contains_name_in_list(
1642 uidtoname(p->server_info->utok.uid),
1643 NULL, NULL,
1644 p->server_info->ptok,
1645 lp_printer_admin(snum))) {
1646 close_printer_handle(p, r->out.handle);
1647 ZERO_STRUCTP(r->out.handle);
1648 return WERR_ACCESS_DENIED;
1649 }
1650
1651 r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1652 }
1653 else
1654 {
1655 r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1656 }
1657
1658 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1659 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1660
1661 /* We fall through to return WERR_OK */
1662 break;
1663
1664 case SPLHND_PRINTER:
1665 /* NT doesn't let us connect to a printer if the connecting user
1666 doesn't have print permission. */
1667
1668 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1669 close_printer_handle(p, r->out.handle);
1670 ZERO_STRUCTP(r->out.handle);
1671 return WERR_BADFID;
1672 }
1673
1674 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1675
1676 /* map an empty access mask to the minimum access mask */
1677 if (r->in.access_mask == 0x0)
1678 r->in.access_mask = PRINTER_ACCESS_USE;
1679
1680 /*
1681 * If we are not serving the printer driver for this printer,
1682 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1683 * will keep NT clients happy --jerry
1684 */
1685
1686 if (lp_use_client_driver(snum)
1687 && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1688 {
1689 r->in.access_mask = PRINTER_ACCESS_USE;
1690 }
1691
1692 /* check smb.conf parameters and the the sec_desc */
1693
1694 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1695 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1696 ZERO_STRUCTP(r->out.handle);
1697 return WERR_ACCESS_DENIED;
1698 }
1699
1700 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1701 p->server_info->ptok, snum) ||
1702 !print_access_check(p->server_info, snum,
1703 r->in.access_mask)) {
1704 DEBUG(3, ("access DENIED for printer open\n"));
1705 close_printer_handle(p, r->out.handle);
1706 ZERO_STRUCTP(r->out.handle);
1707 return WERR_ACCESS_DENIED;
1708 }
1709
1710 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1711 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1712 close_printer_handle(p, r->out.handle);
1713 ZERO_STRUCTP(r->out.handle);
1714 return WERR_ACCESS_DENIED;
1715 }
1716
1717 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1718 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1719 else
1720 r->in.access_mask = PRINTER_ACCESS_USE;
1721
1722 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1723 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1724
1725 break;
1726
1727 default:
1728 /* sanity check to prevent programmer error */
1729 ZERO_STRUCTP(r->out.handle);
1730 return WERR_BADFID;
1731 }
1732
1733 Printer->access_granted = r->in.access_mask;
1734
1735 /*
1736 * If the client sent a devmode in the OpenPrinter() call, then
1737 * save it here in case we get a job submission on this handle
1738 */
1739
1740 if ((Printer->printer_type != SPLHND_SERVER) &&
1741 r->in.devmode_ctr.devmode) {
1742 convert_devicemode(Printer->sharename,
1743 r->in.devmode_ctr.devmode,
1744 &Printer->nt_devmode);
1745 }
1746
1747 #if 0 /* JERRY -- I'm doubtful this is really effective */
1748 /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1749 optimization in Windows 2000 clients --jerry */
1750
1751 if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1752 && (RA_WIN2K == get_remote_arch()) )
1753 {
1754 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1755 sys_usleep( 500000 );
1756 }
1757 #endif
1758
1759 return WERR_OK;
1760 }
1761
1762 /****************************************************************************
1763 ****************************************************************************/
1764
1765 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1766 NT_PRINTER_INFO_LEVEL_2 *d)
1767 {
1768 DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1769
1770 if (!r || !d) {
1771 return false;
1772 }
1773
1774 d->attributes = r->attributes;
1775 d->priority = r->priority;
1776 d->default_priority = r->defaultpriority;
1777 d->starttime = r->starttime;
1778 d->untiltime = r->untiltime;
1779 d->status = r->status;
1780 d->cjobs = r->cjobs;
1781
1782 fstrcpy(d->servername, r->servername);
1783 fstrcpy(d->printername, r->printername);
1784 fstrcpy(d->sharename, r->sharename);
1785 fstrcpy(d->portname, r->portname);
1786 fstrcpy(d->drivername, r->drivername);
1787 slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1788 fstrcpy(d->location, r->location);
1789 fstrcpy(d->sepfile, r->sepfile);
1790 fstrcpy(d->printprocessor, r->printprocessor);
1791 fstrcpy(d->datatype, r->datatype);
1792 fstrcpy(d->parameters, r->parameters);
1793
1794 return true;
1795 }
1796
1797 /****************************************************************************
1798 ****************************************************************************/
1799
1800 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1801 NT_PRINTER_INFO_LEVEL *printer)
1802 {
1803 bool ret;
1804
1805 switch (info_ctr->level) {
1806 case 2:
1807 /* allocate memory if needed. Messy because
1808 convert_printer_info is used to update an existing
1809 printer or build a new one */
1810
1811 if (!printer->info_2) {
1812 printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1813 if (!printer->info_2) {
1814 DEBUG(0,("convert_printer_info: "
1815 "talloc() failed!\n"));
1816 return false;
1817 }
1818 }
1819
1820 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1821 printer->info_2);
1822 printer->info_2->setuptime = time(NULL);
1823 return ret;
1824 }
1825
1826 return false;
1827 }
1828
1829 /*******************************************************************
1830 ********************************************************************/
1831
1832 static bool string_array_to_fstring_array(const char **sarray, fstring **farray)
1833 {
1834 int i;
1835
1836 if (!sarray) {
1837 *farray = NULL;
1838 return true;
1839 }
1840
1841 *farray = SMB_MALLOC_ARRAY(fstring, 1);
1842 if (!*farray) {
1843 return false;
1844 }
1845
1846 for (i=0; sarray[i] != NULL; i++) {
1847 *farray = SMB_REALLOC_ARRAY(*farray, fstring, i+2);
1848 if (!*farray) {
1849 return false;
1850 }
1851 fstrcpy((*farray)[i], sarray[i]);
1852 }
1853
1854 fstrcpy((*farray)[i], "");
1855
1856 return true;
1857 }
1858
1859 /*******************************************************************
1860 ********************************************************************/
1861
1862 static bool driver_info3_to_nt_driver_info3(struct spoolss_AddDriverInfo3 *r,
1863 NT_PRINTER_DRIVER_INFO_LEVEL_3 **p)
1864 {
1865 NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
1866
1867 DEBUG(7,("driver_info3_to_nt_driver_info3: Converting from UNICODE to ASCII\n"));
1868
1869 if (*p == NULL) {
1870 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
1871 if (*p == NULL) {
1872 return false;
1873 }
1874 ZERO_STRUCTP(*p);
1875 }
1876
1877 d = *p;
1878
1879 d->cversion = r->version;
1880
1881 fstrcpy(d->name, r->driver_name);
1882 fstrcpy(d->environment, r->architecture);
1883 fstrcpy(d->driverpath, r->driver_path);
1884 fstrcpy(d->datafile, r->data_file);
1885 fstrcpy(d->configfile, r->config_file);
1886 fstrcpy(d->helpfile, r->help_file);
1887 fstrcpy(d->monitorname, r->monitor_name);
1888 fstrcpy(d->defaultdatatype, r->default_datatype);
1889
1890 DEBUGADD(8,( "version: %d\n", d->cversion));
1891 DEBUGADD(8,( "name: %s\n", d->name));
1892 DEBUGADD(8,( "environment: %s\n", d->environment));
1893 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
1894 DEBUGADD(8,( "datafile: %s\n", d->datafile));
1895 DEBUGADD(8,( "configfile: %s\n", d->configfile));
1896 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
1897 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
1898 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1899
1900 if (r->dependent_files) {
1901 if (!string_array_to_fstring_array(r->dependent_files->string,
1902 &d->dependentfiles)) {
1903 SAFE_FREE(*p);
1904 return false;
1905 }
1906 }
1907
1908 return true;
1909 }
1910
1911 /*******************************************************************
1912 ********************************************************************/
1913
1914 static bool driver_info6_to_nt_driver_info6(struct spoolss_AddDriverInfo6 *r,
1915 NT_PRINTER_DRIVER_INFO_LEVEL_6 **p)
1916 {
1917 NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
1918
1919 DEBUG(7,("driver_info6_to_nt_driver_info6: Converting from UNICODE to ASCII\n"));
1920
1921 if (*p == NULL) {
1922 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
1923 if (*p == NULL) {
1924 return false;
1925 }
1926 ZERO_STRUCTP(*p);
1927 }
1928
1929 d = *p;
1930
1931 d->version = r->version;
1932
1933 fstrcpy(d->name, r->driver_name);
1934 fstrcpy(d->environment, r->architecture);
1935 fstrcpy(d->driverpath, r->driver_path);
1936 fstrcpy(d->datafile, r->data_file);
1937 fstrcpy(d->configfile, r->config_file);
1938 fstrcpy(d->helpfile, r->help_file);
1939 fstrcpy(d->monitorname, r->monitor_name);
1940 fstrcpy(d->defaultdatatype, r->default_datatype);
1941
1942 DEBUGADD(8,( "version: %d\n", d->version));
1943 DEBUGADD(8,( "name: %s\n", d->name));
1944 DEBUGADD(8,( "environment: %s\n", d->environment));
1945 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
1946 DEBUGADD(8,( "datafile: %s\n", d->datafile));
1947 DEBUGADD(8,( "configfile: %s\n", d->configfile));
1948 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
1949 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
1950 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1951
1952 if (r->dependent_files) {
1953 if (!string_array_to_fstring_array(r->dependent_files->string,
1954 &d->dependentfiles)) {
1955 goto error;
1956 }
1957 }
1958
1959 if (r->previous_names) {
1960 if (!string_array_to_fstring_array(r->previous_names->string,
1961 &d->previousnames)) {
1962 goto error;
1963 }
1964 }
1965
1966 return true;
1967
1968 error:
1969 SAFE_FREE(*p);
1970 return false;
1971 }
1972
1973 /********************************************************************
1974 ********************************************************************/
1975
1976 static bool convert_printer_driver_info(const struct spoolss_AddDriverInfoCtr *r,
1977 NT_PRINTER_DRIVER_INFO_LEVEL *printer,
1978 uint32_t level)
1979 {
1980 switch (level) {
1981 case 3:
1982 printer->info_3 = NULL;
1983 if (!driver_info3_to_nt_driver_info3(r->info.info3, &printer->info_3)) {
1984 return false;
1985 }
1986 break;
1987 case 6:
1988 printer->info_6 = NULL;
1989 if (!driver_info6_to_nt_driver_info6(r->info.info6, &printer->info_6)) {
1990 return false;
1991 }
1992 break;
1993 default:
1994 return false;
1995 }
1996
1997 return true;
1998 }
1999
2000 /****************************************************************
2001 _spoolss_ClosePrinter
2002 ****************************************************************/
2003
2004 WERROR _spoolss_ClosePrinter(pipes_struct *p,
2005 struct spoolss_ClosePrinter *r)
2006 {
2007 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2008
2009 if (Printer && Printer->document_started) {
2010 struct spoolss_EndDocPrinter e;
2011
2012 e.in.handle = r->in.handle;
2013
2014 _spoolss_EndDocPrinter(p, &e);
2015 }
2016
2017 if (!close_printer_handle(p, r->in.handle))
2018 return WERR_BADFID;
2019
2020 /* clear the returned printer handle. Observed behavior
2021 from Win2k server. Don't think this really matters.
2022 Previous code just copied the value of the closed
2023 handle. --jerry */
2024
2025 ZERO_STRUCTP(r->out.handle);
2026
2027 return WERR_OK;
2028 }
2029
2030 /****************************************************************
2031 _spoolss_DeletePrinter
2032 ****************************************************************/
2033
2034 WERROR _spoolss_DeletePrinter(pipes_struct *p,
2035 struct spoolss_DeletePrinter *r)
2036 {
2037 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2038 WERROR result;
2039
2040 if (Printer && Printer->document_started) {
2041 struct spoolss_EndDocPrinter e;
2042
2043 e.in.handle = r->in.handle;
2044
2045 _spoolss_EndDocPrinter(p, &e);
2046 }
2047
2048 result = delete_printer_handle(p, r->in.handle);
2049
2050 update_c_setprinter(false);
2051
2052 return result;
2053 }
2054
2055 /*******************************************************************
2056 * static function to lookup the version id corresponding to an
2057 * long architecture string
2058 ******************************************************************/
2059
2060 static const struct print_architecture_table_node archi_table[]= {
2061
2062 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
2063 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
2064 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
2065 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
2066 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
2067 {"Windows IA64", SPL_ARCH_IA64, 3 },
2068 {"Windows x64", SPL_ARCH_X64, 3 },
2069 {NULL, "", -1 }
2070 };
2071
2072 static int get_version_id(const char *arch)
2073 {
2074 int i;
2075
2076 for (i=0; archi_table[i].long_archi != NULL; i++)
2077 {
2078 if (strcmp(arch, archi_table[i].long_archi) == 0)
2079 return (archi_table[i].version);
2080 }
2081
2082 return -1;
2083 }
2084
2085 /****************************************************************
2086 _spoolss_DeletePrinterDriver
2087 ****************************************************************/
2088
2089 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
2090 struct spoolss_DeletePrinterDriver *r)
2091 {
2092 NT_PRINTER_DRIVER_INFO_LEVEL info;
2093 NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
2094 int version;
2095 WERROR status;
2096 WERROR status_win2k = WERR_ACCESS_DENIED;
2097 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2098
2099 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2100 and not a printer admin, then fail */
2101
2102 if ( (p->server_info->utok.uid != sec_initial_uid())
2103 && !user_has_privileges(p->server_info->ptok, &se_printop )
2104 && !token_contains_name_in_list(
2105 uidtoname(p->server_info->utok.uid), NULL,
2106 NULL, p->server_info->ptok,
2107 lp_printer_admin(-1)) )
2108 {
2109 return WERR_ACCESS_DENIED;
2110 }
2111
2112 /* check that we have a valid driver name first */
2113
2114 if ((version = get_version_id(r->in.architecture)) == -1)
2115 return WERR_INVALID_ENVIRONMENT;
2116
2117 ZERO_STRUCT(info);
2118 ZERO_STRUCT(info_win2k);
2119
2120 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2121 r->in.architecture,
2122 version)))
2123 {
2124 /* try for Win2k driver if "Windows NT x86" */
2125
2126 if ( version == 2 ) {
2127 version = 3;
2128 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3,
2129 r->in.driver,
2130 r->in.architecture,
2131 version))) {
2132 status = WERR_UNKNOWN_PRINTER_DRIVER;
2133 goto done;
2134 }
2135 }
2136 /* otherwise it was a failure */
2137 else {
2138 status = WERR_UNKNOWN_PRINTER_DRIVER;
2139 goto done;
2140 }
2141
2142 }
2143
2144 if (printer_driver_in_use(info.info_3)) {
2145 status = WERR_PRINTER_DRIVER_IN_USE;
2146 goto done;
2147 }
2148
2149 if ( version == 2 )
2150 {
2151 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2152 r->in.driver,
2153 r->in.architecture, 3)))
2154 {
2155 /* if we get to here, we now have 2 driver info structures to remove */
2156 /* remove the Win2k driver first*/
2157
2158 status_win2k = delete_printer_driver(
2159 p, info_win2k.info_3, 3, false);
2160 free_a_printer_driver( info_win2k, 3 );
2161
2162 /* this should not have failed---if it did, report to client */
2163 if ( !W_ERROR_IS_OK(status_win2k) )
2164 {
2165 status = status_win2k;
2166 goto done;
2167 }
2168 }
2169 }
2170
2171 status = delete_printer_driver(p, info.info_3, version, false);
2172
2173 /* if at least one of the deletes succeeded return OK */
2174
2175 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2176 status = WERR_OK;
2177
2178 done:
2179 free_a_printer_driver( info, 3 );
2180
2181 return status;
2182 }
2183
2184 /****************************************************************
2185 _spoolss_DeletePrinterDriverEx
2186 ****************************************************************/
2187
2188 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2189 struct spoolss_DeletePrinterDriverEx *r)
2190 {
2191 NT_PRINTER_DRIVER_INFO_LEVEL info;
2192 NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
2193 int version;
2194 bool delete_files;
2195 WERROR status;
2196 WERROR status_win2k = WERR_ACCESS_DENIED;
2197 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2198
2199 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2200 and not a printer admin, then fail */
2201
2202 if ( (p->server_info->utok.uid != sec_initial_uid())
2203 && !user_has_privileges(p->server_info->ptok, &se_printop )
2204 && !token_contains_name_in_list(
2205 uidtoname(p->server_info->utok.uid), NULL, NULL,
2206 p->server_info->ptok, lp_printer_admin(-1)) )
2207 {
2208 return WERR_ACCESS_DENIED;
2209 }
2210
2211 /* check that we have a valid driver name first */
2212 if ((version = get_version_id(r->in.architecture)) == -1) {
2213 /* this is what NT returns */
2214 return WERR_INVALID_ENVIRONMENT;
2215 }
2216
2217 if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2218 version = r->in.version;
2219
2220 ZERO_STRUCT(info);
2221 ZERO_STRUCT(info_win2k);
2222
2223 status = get_a_printer_driver(&info, 3, r->in.driver,
2224 r->in.architecture, version);
2225
2226 if ( !W_ERROR_IS_OK(status) )
2227 {
2228 /*
2229 * if the client asked for a specific version,
2230 * or this is something other than Windows NT x86,
2231 * then we've failed
2232 */
2233
2234 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2235 goto done;
2236
2237 /* try for Win2k driver if "Windows NT x86" */
2238
2239 version = 3;
2240 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2241 r->in.architecture,
2242 version))) {
2243 status = WERR_UNKNOWN_PRINTER_DRIVER;
2244 goto done;
2245 }
2246 }
2247
2248 if ( printer_driver_in_use(info.info_3) ) {
2249 status = WERR_PRINTER_DRIVER_IN_USE;
2250 goto done;
2251 }
2252
2253 /*
2254 * we have a couple of cases to consider.
2255 * (1) Are any files in use? If so and DPD_DELTE_ALL_FILE is set,
2256 * then the delete should fail if **any** files overlap with
2257 * other drivers
2258 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2259 * non-overlapping files
2260 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2261 * is set, the do not delete any files
2262 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2263 */
2264
2265 delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2266
2267 /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2268
2269 if ( delete_files && printer_driver_files_in_use(info.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2270 /* no idea of the correct error here */
2271 status = WERR_ACCESS_DENIED;
2272 goto done;
2273 }
2274
2275
2276 /* also check for W32X86/3 if necessary; maybe we already have? */
2277
2278 if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
2279 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2280 r->in.driver,
2281 r->in.architecture, 3)))
2282 {
2283
2284 if ( delete_files && printer_driver_files_in_use(info_win2k.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2285 /* no idea of the correct error here */
2286 free_a_printer_driver( info_win2k, 3 );
2287 status = WERR_ACCESS_DENIED;
2288 goto done;
2289 }
2290
2291 /* if we get to here, we now have 2 driver info structures to remove */
2292 /* remove the Win2k driver first*/
2293
2294 status_win2k = delete_printer_driver(
2295 p, info_win2k.info_3, 3, delete_files);
2296 free_a_printer_driver( info_win2k, 3 );
2297
2298 /* this should not have failed---if it did, report to client */
2299
2300 if ( !W_ERROR_IS_OK(status_win2k) )
2301 goto done;
2302 }
2303 }
2304
2305 status = delete_printer_driver(p, info.info_3, version, delete_files);
2306
2307 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2308 status = WERR_OK;
2309 done:
2310 free_a_printer_driver( info, 3 );
2311
2312 return status;
2313 }
2314
2315
2316 /****************************************************************************
2317 Internal routine for removing printerdata
2318 ***************************************************************************/
2319
2320 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2321 {
2322 return delete_printer_data( printer->info_2, key, value );
2323 }
2324
2325 /****************************************************************************
2326 Internal routine for storing printerdata
2327 ***************************************************************************/
2328
2329 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2330 const char *key, const char *value,
2331 uint32_t type, uint8_t *data, int real_len)
2332 {
2333 /* the registry objects enforce uniqueness based on value name */
2334
2335 return add_printer_data( printer->info_2, key, value, type, data, real_len );
2336 }
2337
2338 /********************************************************************
2339 GetPrinterData on a printer server Handle.
2340 ********************************************************************/
2341
2342 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2343 const char *value,
2344 enum winreg_Type *type,
2345 union spoolss_PrinterData *data)
2346 {
2347 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2348
2349 if (!StrCaseCmp(value, "W3SvcInstalled")) {
2350 *type = REG_DWORD;
2351 data->value = 0x00;
2352 return WERR_OK;
2353 }
2354
2355 if (!StrCaseCmp(value, "BeepEnabled")) {
2356 *type = REG_DWORD;
2357 data->value = 0x00;
2358 return WERR_OK;
2359 }
2360
2361 if (!StrCaseCmp(value, "EventLog")) {
2362 *type = REG_DWORD;
2363 /* formally was 0x1b */
2364 data->value = 0x00;
2365 return WERR_OK;
2366 }
2367
2368 if (!StrCaseCmp(value, "NetPopup")) {
2369 *type = REG_DWORD;
2370 data->value = 0x00;
2371 return WERR_OK;
2372 }
2373
2374 if (!StrCaseCmp(value, "MajorVersion")) {
2375 *type = REG_DWORD;
2376
2377 /* Windows NT 4.0 seems to not allow uploading of drivers
2378 to a server that reports 0x3 as the MajorVersion.
2379 need to investigate more how Win2k gets around this .
2380 -- jerry */
2381
2382 if (RA_WINNT == get_remote_arch()) {
2383 data->value = 0x02;
2384 } else {
2385 data->value = 0x03;
2386 }
2387
2388 return WERR_OK;
2389 }
2390
2391 if (!StrCaseCmp(value, "MinorVersion")) {
2392 *type = REG_DWORD;
2393 data->value = 0x00;
2394 return WERR_OK;
2395 }
2396
2397 /* REG_BINARY
2398 * uint32_t size = 0x114
2399 * uint32_t major = 5
2400 * uint32_t minor = [0|1]
2401 * uint32_t build = [2195|2600]
2402 * extra unicode string = e.g. "Service Pack 3"
2403 */
2404 if (!StrCaseCmp(value, "OSVersion")) {
2405 DATA_BLOB blob;
2406 enum ndr_err_code ndr_err;
2407 struct spoolss_OSVersion os;
2408
2409 os.major = 5; /* Windows 2000 == 5.0 */
2410 os.minor = 0;
2411 os.build = 2195; /* build */
2412 os.extra_string = ""; /* leave extra string empty */
2413
2414 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2415 (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2416 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2417 return WERR_GENERAL_FAILURE;
2418 }
2419
2420 *type = REG_BINARY;
2421 data->binary = blob;
2422
2423 return WERR_OK;
2424 }
2425
2426
2427 if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2428 *type = REG_SZ;
2429
2430 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2431 W_ERROR_HAVE_NO_MEMORY(data->string);
2432
2433 return WERR_OK;
2434 }
2435
2436 if (!StrCaseCmp(value, "Architecture")) {
2437 *type = REG_SZ;
2438
2439 data->string = talloc_strdup(mem_ctx, "Windows NT x86");
2440 W_ERROR_HAVE_NO_MEMORY(data->string);
2441
2442 return WERR_OK;
2443 }
2444
2445 if (!StrCaseCmp(value, "DsPresent")) {
2446 *type = REG_DWORD;
2447
2448 /* only show the publish check box if we are a
2449 member of a AD domain */
2450
2451 if (lp_security() == SEC_ADS) {
2452 data->value = 0x01;
2453 } else {
2454 data->value = 0x00;
2455 }
2456 return WERR_OK;
2457 }
2458
2459 if (!StrCaseCmp(value, "DNSMachineName")) {
2460 const char *hostname = get_mydnsfullname();
2461
2462 if (!hostname) {
2463 return WERR_BADFILE;
2464 }
2465
2466 *type = REG_SZ;
2467 data->string = talloc_strdup(mem_ctx, hostname);
2468 W_ERROR_HAVE_NO_MEMORY(data->string);
2469
2470 return WERR_OK;
2471 }
2472
2473 return WERR_INVALID_PARAM;
2474 }
2475
2476 /****************************************************************
2477 _spoolss_GetPrinterData
2478 ****************************************************************/
2479
2480 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2481 struct spoolss_GetPrinterData *r)
2482 {
2483 WERROR result;
2484 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2485 NT_PRINTER_INFO_LEVEL *printer = NULL;
2486 int snum = 0;
2487
2488 /*
2489 * Reminder: when it's a string, the length is in BYTES
2490 * even if UNICODE is negociated.
2491 *
2492 * JFM, 4/19/1999
2493 */
2494
2495 /* in case of problem, return some default values */
2496
2497 *r->out.needed = 0;
2498 *r->out.type = 0;
2499
2500 DEBUG(4,("_spoolss_GetPrinterData\n"));
2501
2502 if (!Printer) {
2503 DEBUG(2,("_spoolss_GetPrinterData: Invalid handle (%s:%u:%u).\n",
2504 OUR_HANDLE(r->in.handle)));
2505 result = WERR_BADFID;
2506 goto done;
2507 }
2508
2509 if (Printer->printer_type == SPLHND_SERVER) {
2510 result = getprinterdata_printer_server(p->mem_ctx,
2511 r->in.value_name,
2512 r->out.type,
2513 r->out.data);
2514 } else {
2515 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
2516 result = WERR_BADFID;
2517 goto done;
2518 }
2519
2520 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
2521 if (!W_ERROR_IS_OK(result)) {
2522 goto done;
2523 }
2524
2525 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
2526
2527 if (strequal(r->in.value_name, "ChangeId")) {
2528 *r->out.type = REG_DWORD;
2529 r->out.data->value = printer->info_2->changeid;
2530 result = WERR_OK;
2531 } else {
2532 struct regval_blob *v;
2533 DATA_BLOB blob;
2534
2535 v = get_printer_data(printer->info_2,
2536 SPOOL_PRINTERDATA_KEY,
2537 r->in.value_name);
2538 if (!v) {
2539 result = WERR_BADFILE;
2540 goto done;
2541 }
2542
2543 *r->out.type = v->type;
2544
2545 blob = data_blob_const(v->data_p, v->size);
2546
2547 result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
2548 r->out.data,
2549 *r->out.type);
2550 }
2551 }
2552
2553 done:
2554 /* cleanup & exit */
2555
2556 if (printer) {
2557 free_a_printer(&printer, 2);
2558 }
2559
2560 if (!W_ERROR_IS_OK(result)) {
2561 return result;
2562 }
2563
2564 *r->out.needed = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
2565 *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
2566 r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
2567
2568 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
2569 }
2570
2571 /*********************************************************
2572 Connect to the client machine.
2573 **********************************************************/
2574
2575 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2576 struct sockaddr_storage *client_ss, const char *remote_machine)
2577 {
2578 NTSTATUS ret;
2579 struct cli_state *the_cli;
2580 struct sockaddr_storage rm_addr;
2581
2582 if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2583 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2584 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2585 return false;
2586 }
2587
2588 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2589 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
2590 return false;
2591 }
2592 } else {
2593 char addr[INET6_ADDRSTRLEN];
2594 rm_addr = *client_ss;
2595 print_sockaddr(addr, sizeof(addr), &rm_addr);
2596 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2597 addr));
2598 }
2599
2600 /* setup the connection */
2601
2602 ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2603 &rm_addr, 0, "IPC$", "IPC",
2604 "", /* username */
2605 "", /* domain */
2606 "", /* password */
2607 0, lp_client_signing(), NULL );
2608
2609 if ( !NT_STATUS_IS_OK( ret ) ) {
2610 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2611 remote_machine ));
2612 return false;
2613 }
2614
2615 if ( the_cli->protocol != PROTOCOL_NT1 ) {
2616 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2617 cli_shutdown(the_cli);
2618 return false;
2619 }
2620
2621 /*
2622 * Ok - we have an anonymous connection to the IPC$ share.
2623 * Now start the NT Domain stuff :-).
2624 */
2625
2626 ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2627 if (!NT_STATUS_IS_OK(ret)) {
2628 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2629 remote_machine, nt_errstr(ret)));
2630 cli_shutdown(the_cli);
2631 return false;
2632 }
2633
2634 return true;
2635 }
2636
2637 /***************************************************************************
2638 Connect to the client.
2639 ****************************************************************************/
2640
2641 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2642 uint32_t localprinter, uint32_t type,
2643 struct policy_handle *handle,
2644 struct sockaddr_storage *client_ss)
2645 {
2646 WERROR result;
2647 NTSTATUS status;
2648
2649 /*
2650 * If it's the first connection, contact the client
2651 * and connect to the IPC$ share anonymously
2652 */
2653 if (smb_connections==0) {
2654 fstring unix_printer;
2655
2656 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2657
2658 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2659 return false;
2660
2661 messaging_register(smbd_messaging_context(), NULL,
2662 MSG_PRINTER_NOTIFY2,
2663 receive_notify2_message_list);
2664 /* Tell the connections db we're now interested in printer
2665 * notify messages. */
2666 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2667 }
2668
2669 /*
2670 * Tell the specific printing tdb we want messages for this printer
2671 * by registering our PID.
2672 */
2673
2674 if (!print_notify_register_pid(snum))
2675 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2676
2677 smb_connections++;
2678
2679 status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2680 printer,
2681 localprinter,
2682 type,
2683 0,
2684 NULL,
2685 handle,
2686 &result);
2687 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2688 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2689 win_errstr(result)));
2690
2691 return (W_ERROR_IS_OK(result));
2692 }
2693
2694 /****************************************************************
2695 ****************************************************************/
2696
2697 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2698 const struct spoolss_NotifyOption *r)
2699 {
2700 struct spoolss_NotifyOption *option;
2701 uint32_t i,k;
2702
2703 if (!r) {
2704 return NULL;
2705 }
2706
2707 option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2708 if (!option) {
2709 return NULL;
2710 }
2711
2712 *option = *r;
2713
2714 if (!option->count) {
2715 return option;
2716 }
2717
2718 option->types = talloc_zero_array(option,
2719 struct spoolss_NotifyOptionType, option->count);
2720 if (!option->types) {
2721 talloc_free(option);
2722 return NULL;
2723 }
2724
2725 for (i=0; i < option->count; i++) {
2726 option->types[i] = r->types[i];
2727
2728 if (option->types[i].count) {
2729 option->types[i].fields = talloc_zero_array(option,
2730 union spoolss_Field, option->types[i].count);
2731 if (!option->types[i].fields) {
2732 talloc_free(option);
2733 return NULL;
2734 }
2735 for (k=0; k<option->types[i].count; k++) {
2736 option->types[i].fields[k] =
2737 r->types[i].fields[k];
2738 }
2739 }
2740 }
2741
2742 return option;
2743 }
2744
2745 /****************************************************************
2746 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2747 *
2748 * before replying OK: status=0 a rpc call is made to the workstation
2749 * asking ReplyOpenPrinter
2750 *
2751 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2752 * called from api_spoolss_rffpcnex
2753 ****************************************************************/
2754
2755 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2756 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2757 {
2758 int snum = -1;
2759 struct spoolss_NotifyOption *option = r->in.notify_options;
2760 struct sockaddr_storage client_ss;
2761
2762 /* store the notify value in the printer struct */
2763
2764 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2765
2766 if (!Printer) {
2767 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2768 "Invalid handle (%s:%u:%u).\n",
2769 OUR_HANDLE(r->in.handle)));
2770 return WERR_BADFID;
2771 }
2772
2773 Printer->notify.flags = r->in.flags;
2774 Printer->notify.options = r->in.options;
2775 Printer->notify.printerlocal = r->in.printer_local;
2776
2777 TALLOC_FREE(Printer->notify.option);
2778 Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2779
2780 fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2781
2782 /* Connect to the client machine and send a ReplyOpenPrinter */
2783
2784 if ( Printer->printer_type == SPLHND_SERVER)
2785 snum = -1;
2786 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2787 !get_printer_snum(p, r->in.handle, &snum, NULL) )
2788 return WERR_BADFID;
2789
2790 if (!interpret_string_addr(&client_ss, p->client_address,
2791 AI_NUMERICHOST)) {
2792 return WERR_SERVER_UNAVAILABLE;
2793 }
2794
2795 if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2796 Printer->notify.printerlocal, 1,
2797 &Printer->notify.client_hnd, &client_ss))
2798 return WERR_SERVER_UNAVAILABLE;
2799
2800 Printer->notify.client_connected = true;
2801
2802 return WERR_OK;
2803 }
2804
2805 /*******************************************************************
2806 * fill a notify_info_data with the servername
2807 ********************************************************************/
2808
2809 void spoolss_notify_server_name(int snum,
2810 struct spoolss_Notify *data,
2811 print_queue_struct *queue,
2812 NT_PRINTER_INFO_LEVEL *printer,
2813 TALLOC_CTX *mem_ctx)
2814 {
2815 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2816 }
2817
2818 /*******************************************************************
2819 * fill a notify_info_data with the printername (not including the servername).
2820 ********************************************************************/
2821
2822 void spoolss_notify_printer_name(int snum,
2823 struct spoolss_Notify *data,
2824 print_queue_struct *queue,
2825 NT_PRINTER_INFO_LEVEL *printer,
2826 TALLOC_CTX *mem_ctx)
2827 {
2828 /* the notify name should not contain the \\server\ part */
2829 char *p = strrchr(printer->info_2->printername, '\\');
2830
2831 if (!p) {
2832 p = printer->info_2->printername;
2833 } else {
2834 p++;
2835 }
2836
2837 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2838 }
2839
2840 /*******************************************************************
2841 * fill a notify_info_data with the servicename
2842 ********************************************************************/
2843
2844 void spoolss_notify_share_name(int snum,
2845 struct spoolss_Notify *data,
2846 print_queue_struct *queue,
2847 NT_PRINTER_INFO_LEVEL *printer,
2848 TALLOC_CTX *mem_ctx)
2849 {
2850 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2851 }
2852
2853 /*******************************************************************
2854 * fill a notify_info_data with the port name
2855 ********************************************************************/
2856
2857 void spoolss_notify_port_name(int snum,
2858 struct spoolss_Notify *data,
2859 print_queue_struct *queue,
2860 NT_PRINTER_INFO_LEVEL *printer,
2861 TALLOC_CTX *mem_ctx)
2862 {
2863 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2864 }
2865
2866 /*******************************************************************
2867 * fill a notify_info_data with the printername
2868 * but it doesn't exist, have to see what to do
2869 ********************************************************************/
2870
2871 void spoolss_notify_driver_name(int snum,
2872 struct spoolss_Notify *data,
2873 print_queue_struct *queue,
2874 NT_PRINTER_INFO_LEVEL *printer,
2875 TALLOC_CTX *mem_ctx)
2876 {
2877 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2878 }
2879
2880 /*******************************************************************
2881 * fill a notify_info_data with the comment
2882 ********************************************************************/
2883
2884 void spoolss_notify_comment(int snum,
2885 struct spoolss_Notify *data,
2886 print_queue_struct *queue,
2887 NT_PRINTER_INFO_LEVEL *printer,
2888 TALLOC_CTX *mem_ctx)
2889 {
2890 char *p;
2891
2892 if (*printer->info_2->comment == '\0') {
2893 p = lp_comment(snum);
2894 } else {
2895 p = printer->info_2->comment;
2896 }
2897
2898 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2899 }
2900
2901 /*******************************************************************
2902 * fill a notify_info_data with the comment
2903 * location = "Room 1, floor 2, building 3"
2904 ********************************************************************/
2905
2906 void spoolss_notify_location(int snum,
2907 struct spoolss_Notify *data,
2908 print_queue_struct *queue,
2909 NT_PRINTER_INFO_LEVEL *printer,
2910 TALLOC_CTX *mem_ctx)
2911 {
2912 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2913 }
2914
2915 /*******************************************************************
2916 * fill a notify_info_data with the device mode
2917 * jfm:xxxx don't to it for know but that's a real problem !!!
2918 ********************************************************************/
2919
2920 static void spoolss_notify_devmode(int snum,
2921 struct spoolss_Notify *data,
2922 print_queue_struct *queue,
2923 NT_PRINTER_INFO_LEVEL *printer,
2924 TALLOC_CTX *mem_ctx)
2925 {
2926 /* for a dummy implementation we have to zero the fields */
2927 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2928 }
2929
2930 /*******************************************************************
2931 * fill a notify_info_data with the separator file name
2932 ********************************************************************/
2933
2934 void spoolss_notify_sepfile(int snum,
2935 struct spoolss_Notify *data,
2936 print_queue_struct *queue,
2937 NT_PRINTER_INFO_LEVEL *printer,
2938 TALLOC_CTX *mem_ctx)
2939 {
2940 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2941 }
2942
2943 /*******************************************************************
2944 * fill a notify_info_data with the print processor
2945 * jfm:xxxx return always winprint to indicate we don't do anything to it
2946 ********************************************************************/
2947
2948 void spoolss_notify_print_processor(int snum,
2949 struct spoolss_Notify *data,
2950 print_queue_struct *queue,
2951 NT_PRINTER_INFO_LEVEL *printer,
2952 TALLOC_CTX *mem_ctx)
2953 {
2954 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2955 }
2956
2957 /*******************************************************************
2958 * fill a notify_info_data with the print processor options
2959 * jfm:xxxx send an empty string
2960 ********************************************************************/
2961
2962 void spoolss_notify_parameters(int snum,
2963 struct spoolss_Notify *data,
2964 print_queue_struct *queue,
2965 NT_PRINTER_INFO_LEVEL *printer,
2966 TALLOC_CTX *mem_ctx)
2967 {
2968 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2969 }
2970
2971 /*******************************************************************
2972 * fill a notify_info_data with the data type
2973 * jfm:xxxx always send RAW as data type
2974 ********************************************************************/
2975
2976 void spoolss_notify_datatype(int snum,
2977 struct spoolss_Notify *data,
2978 print_queue_struct *queue,
2979 NT_PRINTER_INFO_LEVEL *printer,
2980 TALLOC_CTX *mem_ctx)
2981 {
2982 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
2983 }
2984
2985 /*******************************************************************
2986 * fill a notify_info_data with the security descriptor
2987 * jfm:xxxx send an null pointer to say no security desc
2988 * have to implement security before !
2989 ********************************************************************/
2990
2991 static void spoolss_notify_security_desc(int snum,
2992 struct spoolss_Notify *data,
2993 print_queue_struct *queue,
2994 NT_PRINTER_INFO_LEVEL *printer,
2995 TALLOC_CTX *mem_ctx)
2996 {
2997 SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
2998 printer->info_2->secdesc_buf->sd_size,
2999 printer->info_2->secdesc_buf->sd);
3000 }
3001
3002 /*******************************************************************
3003 * fill a notify_info_data with the attributes
3004 * jfm:xxxx a samba printer is always shared
3005 ********************************************************************/
3006
3007 void spoolss_notify_attributes(int snum,
3008 struct spoolss_Notify *data,
3009 print_queue_struct *queue,
3010 NT_PRINTER_INFO_LEVEL *printer,
3011 TALLOC_CTX *mem_ctx)
3012 {
3013 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
3014 }
3015
3016 /*******************************************************************
3017 * fill a notify_info_data with the priority
3018 ********************************************************************/
3019
3020 static void spoolss_notify_priority(int snum,
3021 struct spoolss_Notify *data,
3022 print_queue_struct *queue,
3023 NT_PRINTER_INFO_LEVEL *printer,
3024 TALLOC_CTX *mem_ctx)
3025 {
3026 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
3027 }
3028
3029 /*******************************************************************
3030 * fill a notify_info_data with the default priority
3031 ********************************************************************/
3032
3033 static void spoolss_notify_default_priority(int snum,
3034 struct spoolss_Notify *data,
3035 print_queue_struct *queue,
3036 NT_PRINTER_INFO_LEVEL *printer,
3037 TALLOC_CTX *mem_ctx)
3038 {
3039 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
3040 }
3041
3042 /*******************************************************************
3043 * fill a notify_info_data with the start time
3044 ********************************************************************/
3045
3046 static void spoolss_notify_start_time(int snum,
3047 struct spoolss_Notify *data,
3048 print_queue_struct *queue,
3049 NT_PRINTER_INFO_LEVEL *printer,
3050 TALLOC_CTX *mem_ctx)
3051 {
3052 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
3053 }
3054
3055 /*******************************************************************
3056 * fill a notify_info_data with the until time
3057 ********************************************************************/
3058
3059 static void spoolss_notify_until_time(int snum,
3060 struct spoolss_Notify *data,
3061 print_queue_struct *queue,
3062 NT_PRINTER_INFO_LEVEL *printer,
3063 TALLOC_CTX *mem_ctx)
3064 {
3065 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
3066 }
3067
3068 /*******************************************************************
3069 * fill a notify_info_data with the status
3070 ********************************************************************/
3071
3072 static void spoolss_notify_status(int snum,
3073 struct spoolss_Notify *data,
3074 print_queue_struct *queue,
3075 NT_PRINTER_INFO_LEVEL *printer,
3076 TALLOC_CTX *mem_ctx)
3077 {
3078 print_status_struct status;
3079
3080 print_queue_length(snum, &status);
3081 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3082 }
3083
3084 /*******************************************************************
3085 * fill a notify_info_data with the number of jobs queued
3086 ********************************************************************/
3087
3088 void spoolss_notify_cjobs(int snum,
3089 struct spoolss_Notify *data,
3090 print_queue_struct *queue,
3091 NT_PRINTER_INFO_LEVEL *printer,
3092 TALLOC_CTX *mem_ctx)
3093 {
3094 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
3095 }
3096
3097 /*******************************************************************
3098 * fill a notify_info_data with the average ppm
3099 ********************************************************************/
3100
3101 static void spoolss_notify_average_ppm(int snum,
3102 struct spoolss_Notify *data,
3103 print_queue_struct *queue,
3104 NT_PRINTER_INFO_LEVEL *printer,
3105 TALLOC_CTX *mem_ctx)
3106 {
3107 /* always respond 8 pages per minutes */
3108 /* a little hard ! */
3109 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
3110 }
3111
3112 /*******************************************************************
3113 * fill a notify_info_data with username
3114 ********************************************************************/
3115
3116 static void spoolss_notify_username(int snum,
3117 struct spoolss_Notify *data,
3118 print_queue_struct *queue,
3119 NT_PRINTER_INFO_LEVEL *printer,
3120 TALLOC_CTX *mem_ctx)
3121 {
3122 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3123 }
3124
3125 /*******************************************************************
3126 * fill a notify_info_data with job status
3127 ********************************************************************/
3128
3129 static void spoolss_notify_job_status(int snum,
3130 struct spoolss_Notify *data,
3131 print_queue_struct *queue,
3132 NT_PRINTER_INFO_LEVEL *printer,
3133 TALLOC_CTX *mem_ctx)
3134 {
3135 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3136 }
3137
3138 /*******************************************************************
3139 * fill a notify_info_data with job name
3140 ********************************************************************/
3141
3142 static void spoolss_notify_job_name(int snum,
3143 struct spoolss_Notify *data,
3144 print_queue_struct *queue,
3145 NT_PRINTER_INFO_LEVEL *printer,
3146 TALLOC_CTX *mem_ctx)
3147 {
3148 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3149 }
3150
3151 /*******************************************************************
3152 * fill a notify_info_data with job status
3153 ********************************************************************/
3154
3155 static void spoolss_notify_job_status_string(int snum,
3156 struct spoolss_Notify *data,
3157 print_queue_struct *queue,
3158 NT_PRINTER_INFO_LEVEL *printer,
3159 TALLOC_CTX *mem_ctx)
3160 {
3161 /*
3162 * Now we're returning job status codes we just return a "" here. JRA.
3163 */
3164
3165 const char *p = "";
3166
3167 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3168 p = "unknown";
3169
3170 switch (queue->status) {
3171 case LPQ_QUEUED:
3172 p = "Queued";
3173 break;
3174 case LPQ_PAUSED:
3175 p = ""; /* NT provides the paused string */
3176 break;
3177 case LPQ_SPOOLING:
3178 p = "Spooling";
3179 break;
3180 case LPQ_PRINTING:
3181 p = "Printing";
3182 break;
3183 }
3184 #endif /* NO LONGER NEEDED. */
3185
3186 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3187 }
3188
3189 /*******************************************************************
3190 * fill a notify_info_data with job time
3191 ********************************************************************/
3192
3193 static void spoolss_notify_job_time(int snum,
3194 struct spoolss_Notify *data,
3195 print_queue_struct *queue,
3196 NT_PRINTER_INFO_LEVEL *printer,
3197 TALLOC_CTX *mem_ctx)
3198 {
3199 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3200 }
3201
3202 /*******************************************************************
3203 * fill a notify_info_data with job size
3204 ********************************************************************/
3205
3206 static void spoolss_notify_job_size(int snum,
3207 struct spoolss_Notify *data,
3208 print_queue_struct *queue,
3209 NT_PRINTER_INFO_LEVEL *printer,
3210 TALLOC_CTX *mem_ctx)
3211 {
3212 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3213 }
3214
3215 /*******************************************************************
3216 * fill a notify_info_data with page info
3217 ********************************************************************/
3218 static void spoolss_notify_total_pages(int snum,
3219 struct spoolss_Notify *data,
3220 print_queue_struct *queue,
3221 NT_PRINTER_INFO_LEVEL *printer,
3222 TALLOC_CTX *mem_ctx)
3223 {
3224 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3225 }
3226
3227 /*******************************************************************
3228 * fill a notify_info_data with pages printed info.
3229 ********************************************************************/
3230 static void spoolss_notify_pages_printed(int snum,
3231 struct spoolss_Notify *data,
3232 print_queue_struct *queue,
3233 NT_PRINTER_INFO_LEVEL *printer,
3234 TALLOC_CTX *mem_ctx)
3235 {
3236 /* Add code when back-end tracks this */
3237 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3238 }
3239
3240 /*******************************************************************
3241 Fill a notify_info_data with job position.
3242 ********************************************************************/
3243
3244 static void spoolss_notify_job_position(int snum,
3245 struct spoolss_Notify *data,
3246 print_queue_struct *queue,
3247 NT_PRINTER_INFO_LEVEL *printer,
3248 TALLOC_CTX *mem_ctx)
3249 {
3250 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3251 }
3252
3253 /*******************************************************************
3254 Fill a notify_info_data with submitted time.
3255 ********************************************************************/
3256
3257 static void spoolss_notify_submitted_time(int snum,
3258 struct spoolss_Notify *data,
3259 print_queue_struct *queue,
3260 NT_PRINTER_INFO_LEVEL *printer,
3261 TALLOC_CTX *mem_ctx)
3262 {
3263 data->data.string.string = NULL;
3264 data->data.string.size = 0;
3265
3266 init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3267 &data->data.string.string,
3268 &data->data.string.size);
3269
3270 }
3271
3272 struct s_notify_info_data_table
3273 {
3274 enum spoolss_NotifyType type;
3275 uint16_t field;
3276 const char *name;
3277 enum spoolss_NotifyTable variable_type;
3278 void (*fn) (int snum, struct spoolss_Notify *data,
3279 print_queue_struct *queue,
3280 NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3281 };
3282
3283 /* A table describing the various print notification constants and
3284 whether the notification data is a pointer to a variable sized
3285 buffer, a one value uint32_t or a two value uint32_t. */
3286
3287 static const struct s_notify_info_data_table notify_info_data_table[] =
3288 {
3289 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3290 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3291 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_share_name },
3292 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3293 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3294 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING, spoolss_notify_comment },
3295 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING, spoolss_notify_location },
3296 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3297 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING, spoolss_notify_sepfile },
3298 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3299 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3300 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3301 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, spoolss_notify_security_desc },
3302 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD, spoolss_notify_attributes },
3303 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3304 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_default_priority },
3305 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3306 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3307 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_status },
3308 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, NULL },
3309 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD, spoolss_notify_cjobs },
3310 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD, spoolss_notify_average_ppm },
3311 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, NULL },
3312 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3313 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, NULL },
3314 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3315 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINTER_NAME, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3316 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_MACHINE_NAME, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3317 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PORT_NAME, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3318 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3319 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_NOTIFY_NAME, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3320 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DATATYPE, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3321 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINT_PROCESSOR, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3322 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PARAMETERS, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3323 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DRIVER_NAME, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3324 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DEVMODE, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3325 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_job_status },
3326 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS_STRING, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, spoolss_notify_job_status_string },
3327 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, NULL },
3328 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING, spoolss_notify_job_name },
3329 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRIORITY, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3330 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_POSITION, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD, spoolss_notify_job_position },
3331 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME, spoolss_notify_submitted_time },
3332 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_START_TIME, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3333 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_UNTIL_TIME, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3334 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TIME, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_job_time },
3335 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_PAGES, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, spoolss_notify_total_pages },
3336 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PAGES_PRINTED, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, spoolss_notify_pages_printed },
3337 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_BYTES, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, spoolss_notify_job_size },
3338 };
3339
3340 /*******************************************************************
3341 Return the variable_type of info_data structure.
3342 ********************************************************************/
3343
3344 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3345 uint16_t field)
3346 {
3347 int i=0;
3348
3349 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3350 if ( (notify_info_data_table[i].type == type) &&
3351 (notify_info_data_table[i].field == field) ) {
3352 return notify_info_data_table[i].variable_type;
3353 }
3354 }
3355
3356 DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3357
3358 return 0;
3359 }
3360
3361 /****************************************************************************
3362 ****************************************************************************/
3363
3364 static bool search_notify(enum spoolss_NotifyType type,
3365 uint16_t field,
3366 int *value)
3367 {
3368 int i;
3369
3370 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3371 if (notify_info_data_table[i].type == type &&
3372 notify_info_data_table[i].field == field &&
3373 notify_info_data_table[i].fn != NULL) {
3374 *value = i;
3375 return true;
3376 }
3377 }
3378
3379 return false;
3380 }
3381
3382 /****************************************************************************
3383 ****************************************************************************/
3384
3385 void construct_info_data(struct spoolss_Notify *info_data,
3386 enum spoolss_NotifyType type,
3387 uint16_t field,
3388 int id)
3389 {
3390 info_data->type = type;
3391 info_data->field.field = field;
3392 info_data->variable_type = variable_type_of_notify_info_data(type, field);
3393 info_data->job_id = id;
3394 }
3395
3396 /*******************************************************************
3397 *
3398 * fill a notify_info struct with info asked
3399 *
3400 ********************************************************************/
3401
3402 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3403 struct spoolss_NotifyInfo *info,
3404 int snum,
3405 const struct spoolss_NotifyOptionType *option_type,
3406 uint32_t id,
3407 TALLOC_CTX *mem_ctx)
3408 {
3409 int field_num,j;
3410 enum spoolss_NotifyType type;
3411 uint16_t field;
3412
3413 struct spoolss_Notify *current_data;
3414 NT_PRINTER_INFO_LEVEL *printer = NULL;
3415 print_queue_struct *queue=NULL;
3416
3417 type = option_type->type;
3418
3419 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3420 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3421 option_type->count, lp_servicename(snum)));
3422
3423 if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3424 return false;
3425
3426 for(field_num=0; field_num < option_type->count; field_num++) {
3427 field = option_type->fields[field_num].field;
3428
3429 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3430
3431 if (!search_notify(type, field, &j) )
3432 continue;
3433
3434 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3435 struct spoolss_Notify,
3436 info->count + 1);
3437 if (info->notifies == NULL) {
3438 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3439 free_a_printer(&printer, 2);
3440 return false;
3441 }
3442
3443 current_data = &info->notifies[info->count];
3444
3445 construct_info_data(current_data, type, field, id);
3446
3447 DEBUG(10,("construct_notify_printer_info: calling [%s] snum=%d printername=[%s])\n",
3448 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3449
3450 notify_info_data_table[j].fn(snum, current_data, queue,
3451 printer, mem_ctx);
3452
3453 info->count++;
3454 }
3455
3456 free_a_printer(&printer, 2);
3457 return true;
3458 }
3459
3460 /*******************************************************************
3461 *
3462 * fill a notify_info struct with info asked
3463 *
3464 ********************************************************************/
3465
3466 static bool construct_notify_jobs_info(print_queue_struct *queue,
3467 struct spoolss_NotifyInfo *info,
3468 NT_PRINTER_INFO_LEVEL *printer,
3469 int snum,
3470 const struct spoolss_NotifyOptionType *option_type,
3471 uint32_t id,
3472 TALLOC_CTX *mem_ctx)
3473 {
3474 int field_num,j;
3475 enum spoolss_NotifyType type;
3476 uint16_t field;
3477 struct spoolss_Notify *current_data;
3478
3479 DEBUG(4,("construct_notify_jobs_info\n"));
3480
3481 type = option_type->type;
3482
3483 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3484 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3485 option_type->count));
3486
3487 for(field_num=0; field_num<option_type->count; field_num++) {
3488 field = option_type->fields[field_num].field;
3489
3490 if (!search_notify(type, field, &j) )
3491 continue;
3492
3493 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3494 struct spoolss_Notify,
3495 info->count + 1);
3496 if (info->notifies == NULL) {
3497 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3498 return false;
3499 }
3500
3501 current_data=&(info->notifies[info->count]);
3502
3503 construct_info_data(current_data, type, field, id);
3504 notify_info_data_table[j].fn(snum, current_data, queue,
3505 printer, mem_ctx);
3506 info->count++;
3507 }
3508
3509 return true;
3510 }
3511
3512 /*
3513 * JFM: The enumeration is not that simple, it's even non obvious.
3514 *
3515 * let's take an example: I want to monitor the PRINTER SERVER for
3516 * the printer's name and the number of jobs currently queued.
3517 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3518 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3519 *
3520 * I have 3 printers on the back of my server.
3521 *
3522 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3523 * structures.
3524 * Number Data Id
3525 * 1 printer 1 name 1
3526 * 2 printer 1 cjob 1
3527 * 3 printer 2 name 2
3528 * 4 printer 2 cjob 2
3529 * 5 printer 3 name 3
3530 * 6 printer 3 name 3
3531 *
3532 * that's the print server case, the printer case is even worse.
3533 */
3534
3535 /*******************************************************************
3536 *
3537 * enumerate all printers on the printserver
3538 * fill a notify_info struct with info asked
3539 *
3540 ********************************************************************/
3541
3542 static WERROR printserver_notify_info(pipes_struct *p,
3543 struct policy_handle *hnd,
3544 struct spoolss_NotifyInfo *info,
3545 TALLOC_CTX *mem_ctx)
3546 {
3547 int snum;
3548 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3549 int n_services=lp_numservices();
3550 int i;
3551 struct spoolss_NotifyOption *option;
3552 struct spoolss_NotifyOptionType option_type;
3553
3554 DEBUG(4,("printserver_notify_info\n"));
3555
3556 if (!Printer)
3557 return WERR_BADFID;
3558
3559 option = Printer->notify.option;
3560
3561 info->version = 2;
3562 info->notifies = NULL;
3563 info->count = 0;
3564
3565 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3566 sending a ffpcn() request first */
3567
3568 if ( !option )
3569 return WERR_BADFID;
3570
3571 for (i=0; i<option->count; i++) {
3572 option_type = option->types[i];
3573
3574 if (option_type.type != PRINTER_NOTIFY_TYPE)
3575 continue;
3576
3577 for (snum=0; snum<n_services; snum++)
3578 {
3579 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3580 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3581 }
3582 }
3583
3584 #if 0
3585 /*
3586 * Debugging information, don't delete.
3587 */
3588
3589 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3590 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3591 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3592
3593 for (i=0; i<info->count; i++) {
3594 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3595 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3596 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3597 }
3598 #endif
3599
3600 return WERR_OK;
3601 }
3602
3603 /*******************************************************************
3604 *
3605 * fill a notify_info struct with info asked
3606 *
3607 ********************************************************************/
3608
3609 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3610 struct spoolss_NotifyInfo *info,
3611 TALLOC_CTX *mem_ctx)
3612 {
3613 int snum;
3614 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3615 int i;
3616 uint32_t id;
3617 struct spoolss_NotifyOption *option;
3618 struct spoolss_NotifyOptionType option_type;
3619 int count,j;
3620 print_queue_struct *queue=NULL;
3621 print_status_struct status;
3622
3623 DEBUG(4,("printer_notify_info\n"));
3624
3625 if (!Printer)
3626 return WERR_BADFID;
3627
3628 option = Printer->notify.option;
3629 id = 0x0;
3630
3631 info->version = 2;
3632 info->notifies = NULL;
3633 info->count = 0;
3634
3635 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3636 sending a ffpcn() request first */
3637
3638 if ( !option )
3639 return WERR_BADFID;
3640
3641 get_printer_snum(p, hnd, &snum, NULL);
3642
3643 for (i=0; i<option->count; i++) {
3644 option_type = option->types[i];
3645
3646 switch (option_type.type) {
3647 case PRINTER_NOTIFY_TYPE:
3648 if(construct_notify_printer_info(Printer, info, snum,
3649 &option_type, id,
3650 mem_ctx))
3651 id--;
3652 break;
3653
3654 case JOB_NOTIFY_TYPE: {
3655 NT_PRINTER_INFO_LEVEL *printer = NULL;
3656
3657 count = print_queue_status(snum, &queue, &status);
3658
3659 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3660 goto done;
3661
3662 for (j=0; j<count; j++) {
3663 construct_notify_jobs_info(&queue[j], info,
3664 printer, snum,
3665 &option_type,
3666 queue[j].job,
3667 mem_ctx);
3668 }
3669
3670 free_a_printer(&printer, 2);
3671
3672 done:
3673 SAFE_FREE(queue);
3674 break;
3675 }
3676 }
3677 }
3678
3679 /*
3680 * Debugging information, don't delete.
3681 */
3682 /*
3683 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3684 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3685 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3686
3687 for (i=0; i<info->count; i++) {
3688 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3689 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3690 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3691 }
3692 */
3693 return WERR_OK;
3694 }
3695
3696 /****************************************************************
3697 _spoolss_RouterRefreshPrinterChangeNotify
3698 ****************************************************************/
3699
3700 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3701 struct spoolss_RouterRefreshPrinterChangeNotify *r)
3702 {
3703 struct spoolss_NotifyInfo *info;
3704
3705 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3706 WERROR result = WERR_BADFID;
3707
3708 /* we always have a spoolss_NotifyInfo struct */
3709 info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3710 if (!info) {
3711 result = WERR_NOMEM;
3712 goto done;
3713 }
3714
3715 *r->out.info = info;
3716
3717 if (!Printer) {
3718 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3719 "Invalid handle (%s:%u:%u).\n",
3720 OUR_HANDLE(r->in.handle)));
3721 goto done;
3722 }
3723
3724 DEBUG(4,("Printer type %x\n",Printer->printer_type));
3725
3726 /*
3727 * We are now using the change value, and
3728 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3729 * I don't have a global notification system, I'm sending back all the
3730 * informations even when _NOTHING_ has changed.
3731 */
3732
3733 /* We need to keep track of the change value to send back in
3734 RRPCN replies otherwise our updates are ignored. */
3735
3736 Printer->notify.fnpcn = true;
3737
3738 if (Printer->notify.client_connected) {
3739 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3740 "Saving change value in request [%x]\n",
3741 r->in.change_low));
3742 Printer->notify.change = r->in.change_low;
3743 }
3744
3745 /* just ignore the spoolss_NotifyOption */
3746
3747 switch (Printer->printer_type) {
3748 case SPLHND_SERVER:
3749 result = printserver_notify_info(p, r->in.handle,
3750 info, p->mem_ctx);
3751 break;
3752
3753 case SPLHND_PRINTER:
3754 result = printer_notify_info(p, r->in.handle,
3755 info, p->mem_ctx);
3756 break;
3757 }
3758
3759 Printer->notify.fnpcn = false;
3760
3761 done:
3762 return result;
3763 }
3764
3765 /********************************************************************
3766 * construct_printer_info_0
3767 * fill a printer_info_0 struct
3768 ********************************************************************/
3769
3770 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3771 const NT_PRINTER_INFO_LEVEL *ntprinter,
3772 struct spoolss_PrinterInfo0 *r,
3773 int snum)
3774 {
3775 int count;
3776 counter_printer_0 *session_counter;
3777 time_t setuptime;
3778 print_status_struct status;
3779
3780 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3781 W_ERROR_HAVE_NO_MEMORY(r->printername);
3782
3783 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3784 W_ERROR_HAVE_NO_MEMORY(r->servername);
3785
3786 count = print_queue_length(snum, &status);
3787
3788 /* check if we already have a counter for this printer */
3789 for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3790 if (session_counter->snum == snum)
3791 break;
3792 }
3793
3794 /* it's the first time, add it to the list */
3795 if (session_counter == NULL) {
3796 session_counter = SMB_MALLOC_P(counter_printer_0);
3797 W_ERROR_HAVE_NO_MEMORY(session_counter);
3798 ZERO_STRUCTP(session_counter);
3799 session_counter->snum = snum;
3800 session_counter->counter = 0;
3801 DLIST_ADD(counter_list, session_counter);
3802 }
3803
3804 /* increment it */
3805 session_counter->counter++;
3806
3807 r->cjobs = count;
3808 r->total_jobs = 0;
3809 r->total_bytes = 0;
3810
3811 setuptime = (time_t)ntprinter->info_2->setuptime;
3812
3813 init_systemtime(&r->time, gmtime(&setuptime));
3814
3815 /* JFM:
3816 * the global_counter should be stored in a TDB as it's common to all the clients
3817 * and should be zeroed on samba startup
3818 */
3819 r->global_counter = session_counter->counter;
3820 r->total_pages = 0;
3821 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3822 r->version = 0x0005; /* NT 5 */
3823 r->free_build = 0x0893; /* build 2195 */
3824 r->spooling = 0;
3825 r->max_spooling = 0;
3826 r->session_counter = session_counter->counter;
3827 r->num_error_out_of_paper = 0x0;
3828 r->num_error_not_ready = 0x0; /* number of print failure */
3829 r->job_error = 0x0;
3830 r->number_of_processors = 0x1;
3831 r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3832 r->high_part_total_bytes = 0x0;
3833 r->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3834 r->last_error = WERR_OK;
3835 r->status = nt_printq_status(status.status);
3836 r->enumerate_network_printers = 0x0;
3837 r->c_setprinter = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3838 r->processor_architecture = 0x0;
3839 r->processor_level = 0x6; /* 6 ???*/
3840 r->ref_ic = 0;
3841 r->reserved2 = 0;
3842 r->reserved3 = 0;
3843
3844 return WERR_OK;
3845 }
3846
3847 /****************************************************************************
3848 Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure. Both pointers
3849 should be valid upon entry
3850 ****************************************************************************/
3851
3852 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3853 struct spoolss_DeviceMode *r,
3854 const NT_DEVICEMODE *ntdevmode)
3855 {
3856 if (!r || !ntdevmode) {
3857 return WERR_INVALID_PARAM;
3858 }
3859
3860 r->devicename = talloc_strdup(mem_ctx, ntdevmode->devicename);
3861 W_ERROR_HAVE_NO_MEMORY(r->devicename);
3862
3863 r->specversion = ntdevmode->specversion;
3864 r->driverversion = ntdevmode->driverversion;
3865 r->size = ntdevmode->size;
3866 r->__driverextra_length = ntdevmode->driverextra;
3867 r->fields = ntdevmode->fields;
3868
3869 r->orientation = ntdevmode->orientation;
3870 r->papersize = ntdevmode->papersize;
3871 r->paperlength = ntdevmode->paperlength;
3872 r->paperwidth = ntdevmode->paperwidth;
3873 r->scale = ntdevmode->scale;
3874 r->copies = ntdevmode->copies;
3875 r->defaultsource = ntdevmode->defaultsource;
3876 r->printquality = ntdevmode->printquality;
3877 r->color = ntdevmode->color;
3878 r->duplex = ntdevmode->duplex;
3879 r->yresolution = ntdevmode->yresolution;
3880 r->ttoption = ntdevmode->ttoption;
3881 r->collate = ntdevmode->collate;
3882
3883 r->formname = talloc_strdup(mem_ctx, ntdevmode->formname);
3884 W_ERROR_HAVE_NO_MEMORY(r->formname);
3885
3886 /* all 0 below are values that have not been set in the old parsing/copy
3887 * function, maybe they should... - gd */
3888
3889 r->logpixels = 0;
3890 r->bitsperpel = 0;
3891 r->pelswidth = 0;
3892 r->pelsheight = 0;
3893 r->displayflags = 0;
3894 r->displayfrequency = 0;
3895 r->icmmethod = ntdevmode->icmmethod;
3896 r->icmintent = ntdevmode->icmintent;
3897 r->mediatype = ntdevmode->mediatype;
3898 r->dithertype = ntdevmode->dithertype;
3899 r->reserved1 = 0;
3900 r->reserved2 = 0;
3901 r->panningwidth = 0;
3902 r->panningheight = 0;
3903
3904 if (ntdevmode->nt_dev_private != NULL) {
3905 r->driverextra_data = data_blob_talloc(mem_ctx,
3906 ntdevmode->nt_dev_private,
3907 ntdevmode->driverextra);
3908 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3909 }
3910
3911 return WERR_OK;
3912 }
3913
3914
3915 /****************************************************************************
3916 Create a spoolss_DeviceMode struct. Returns talloced memory.
3917 ****************************************************************************/
3918
3919 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3920 const char *servicename)
3921 {
3922 WERROR result;
3923 NT_PRINTER_INFO_LEVEL *printer = NULL;
3924 struct spoolss_DeviceMode *devmode = NULL;
3925
3926 DEBUG(7,("construct_dev_mode\n"));
3927
3928 DEBUGADD(8,("getting printer characteristics\n"));
3929
3930 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3931 return NULL;
3932
3933 if (!printer->info_2->devmode) {
3934 DEBUG(5, ("BONG! There was no device mode!\n"));
3935 goto done;
3936 }
3937
3938 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3939 if (!devmode) {
3940 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3941 goto done;
3942 }
3943
3944 DEBUGADD(8,("loading DEVICEMODE\n"));
3945
3946 result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3947 if (!W_ERROR_IS_OK(result)) {
3948 TALLOC_FREE(devmode);
3949 }
3950
3951 done:
3952 free_a_printer(&printer,2);
3953
3954 return devmode;
3955 }
3956
3957 /********************************************************************
3958 * construct_printer_info3
3959 * fill a spoolss_PrinterInfo3 struct
3960 ********************************************************************/
3961
3962 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3963 const NT_PRINTER_INFO_LEVEL *ntprinter,
3964 struct spoolss_PrinterInfo3 *r,
3965 int snum)
3966 {
3967 /* These are the components of the SD we are returning. */
3968
3969 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3970 /* don't use talloc_steal() here unless you do a deep steal of all
3971 the SEC_DESC members */
3972
3973 r->secdesc = dup_sec_desc(mem_ctx,
3974 ntprinter->info_2->secdesc_buf->sd);
3975 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3976 }
3977
3978 return WERR_OK;
3979 }
3980
3981 /********************************************************************
3982 * construct_printer_info4
3983 * fill a spoolss_PrinterInfo4 struct
3984 ********************************************************************/
3985
3986 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
3987 const NT_PRINTER_INFO_LEVEL *ntprinter,
3988 struct spoolss_PrinterInfo4 *r,
3989 int snum)
3990 {
3991 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3992 W_ERROR_HAVE_NO_MEMORY(r->printername);
3993 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3994 W_ERROR_HAVE_NO_MEMORY(r->servername);
3995
3996 r->attributes = ntprinter->info_2->attributes;
3997
3998 return WERR_OK;
3999 }
4000
4001 /********************************************************************
4002 * construct_printer_info5
4003 * fill a spoolss_PrinterInfo5 struct
4004 ********************************************************************/
4005
4006 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
4007 const NT_PRINTER_INFO_LEVEL *ntprinter,
4008 struct spoolss_PrinterInfo5 *r,
4009 int snum)
4010 {
4011 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4012 W_ERROR_HAVE_NO_MEMORY(r->printername);
4013 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4014 W_ERROR_HAVE_NO_MEMORY(r->portname);
4015
4016 r->attributes = ntprinter->info_2->attributes;
4017
4018 /* these two are not used by NT+ according to MSDN */
4019
4020 r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
4021 r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
4022
4023 return WERR_OK;
4024 }
4025
4026 /********************************************************************
4027 * construct_printer_info_6
4028 * fill a spoolss_PrinterInfo6 struct
4029 ********************************************************************/
4030
4031 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
4032 const NT_PRINTER_INFO_LEVEL *ntprinter,
4033 struct spoolss_PrinterInfo6 *r,
4034 int snum)
4035 {
4036 int count;
4037 print_status_struct status;
4038
4039 count = print_queue_length(snum, &status);
4040
4041 r->status = nt_printq_status(status.status);
4042
4043 return WERR_OK;
4044 }
4045
4046 /********************************************************************
4047 * construct_printer_info7
4048 * fill a spoolss_PrinterInfo7 struct
4049 ********************************************************************/
4050
4051 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4052 Printer_entry *print_hnd,
4053 struct spoolss_PrinterInfo7 *r,
4054 int snum)
4055 {
4056 struct GUID guid;
4057
4058 if (is_printer_published(print_hnd, snum, &guid)) {
4059 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
4060 r->action = DSPRINT_PUBLISH;
4061 } else {
4062 r->guid = talloc_strdup(mem_ctx, "");
4063 r->action = DSPRINT_UNPUBLISH;
4064 }
4065 W_ERROR_HAVE_NO_MEMORY(r->guid);
4066
4067 return WERR_OK;
4068 }
4069
4070 /********************************************************************
4071 * construct_printer_info8
4072 * fill a spoolss_PrinterInfo8 struct
4073 ********************************************************************/
4074
4075 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4076 const NT_PRINTER_INFO_LEVEL *ntprinter,
4077 struct spoolss_DeviceModeInfo *r,
4078 int snum)
4079 {
4080 struct spoolss_DeviceMode *devmode;
4081 WERROR result;
4082
4083 if (!ntprinter->info_2->devmode) {
4084 r->devmode = NULL;
4085 return WERR_OK;
4086 }
4087
4088 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
4089 W_ERROR_HAVE_NO_MEMORY(devmode);
4090
4091 result = convert_nt_devicemode(mem_ctx, devmode, ntprinter->info_2->devmode);
4092 if (!W_ERROR_IS_OK(result)) {
4093 TALLOC_FREE(devmode);
4094 return result;
4095 }
4096
4097 r->devmode = devmode;
4098
4099 return WERR_OK;
4100 }
4101
4102
4103 /********************************************************************
4104 * construct_printer_info1
4105 * fill a spoolss_PrinterInfo1 struct
4106 ********************************************************************/
4107
4108 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
4109 const NT_PRINTER_INFO_LEVEL *ntprinter,
4110 uint32_t flags,
4111 struct spoolss_PrinterInfo1 *r,
4112 int snum)
4113 {
4114 r->flags = flags;
4115
4116 r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
4117 ntprinter->info_2->printername,
4118 ntprinter->info_2->drivername,
4119 ntprinter->info_2->location);
4120 W_ERROR_HAVE_NO_MEMORY(r->description);
4121
4122 if (*ntprinter->info_2->comment == '\0') {
4123 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
4124 } else {
4125 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
4126 }
4127 W_ERROR_HAVE_NO_MEMORY(r->comment);
4128
4129 r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4130 W_ERROR_HAVE_NO_MEMORY(r->name);
4131
4132 return WERR_OK;
4133 }
4134
4135 /********************************************************************
4136 * construct_printer_info2
4137 * fill a spoolss_PrinterInfo2 struct
4138 ********************************************************************/
4139
4140 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
4141 const NT_PRINTER_INFO_LEVEL *ntprinter,
4142 struct spoolss_PrinterInfo2 *r,
4143 int snum)
4144 {
4145 int count;
4146
4147 print_status_struct status;
4148
4149 count = print_queue_length(snum, &status);
4150
4151 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
4152 W_ERROR_HAVE_NO_MEMORY(r->servername);
4153 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4154 W_ERROR_HAVE_NO_MEMORY(r->printername);
4155 r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
4156 W_ERROR_HAVE_NO_MEMORY(r->sharename);
4157 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4158 W_ERROR_HAVE_NO_MEMORY(r->portname);
4159 r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
4160 W_ERROR_HAVE_NO_MEMORY(r->drivername);
4161
4162 if (*ntprinter->info_2->comment == '\0') {
4163 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
4164 } else {
4165 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
4166 }
4167 W_ERROR_HAVE_NO_MEMORY(r->comment);
4168
4169 r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
4170 W_ERROR_HAVE_NO_MEMORY(r->location);
4171 r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
4172 W_ERROR_HAVE_NO_MEMORY(r->sepfile);
4173 r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
4174 W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
4175 r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
4176 W_ERROR_HAVE_NO_MEMORY(r->datatype);
4177 r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
4178 W_ERROR_HAVE_NO_MEMORY(r->parameters);
4179
4180 r->attributes = ntprinter->info_2->attributes;
4181
4182 r->priority = ntprinter->info_2->priority;
4183 r->defaultpriority = ntprinter->info_2->default_priority;
4184 r->starttime = ntprinter->info_2->starttime;
4185 r->untiltime = ntprinter->info_2->untiltime;
4186 r->status = nt_printq_status(status.status);
4187 r->cjobs = count;
4188 r->averageppm = ntprinter->info_2->averageppm;
4189
4190 r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
4191 if (!r->devmode) {
4192 DEBUG(8,("Returning NULL Devicemode!\n"));
4193 }
4194
4195 r->secdesc = NULL;
4196
4197 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
4198 /* don't use talloc_steal() here unless you do a deep steal of all
4199 the SEC_DESC members */
4200
4201 r->secdesc = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
4202 }
4203
4204 return WERR_OK;
4205 }
4206
4207 /********************************************************************
4208 ********************************************************************/
4209
4210 static bool snum_is_shared_printer(int snum)
4211 {
4212 return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
4213 }
4214
4215 /********************************************************************
4216 Spoolss_enumprinters.
4217 ********************************************************************/
4218
4219 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4220 uint32_t level,
4221 uint32_t flags,
4222 union spoolss_PrinterInfo **info_p,
4223 uint32_t *count_p)
4224 {
4225 int snum;
4226 int n_services = lp_numservices();
4227 union spoolss_PrinterInfo *info = NULL;
4228 uint32_t count = 0;
4229 WERROR result = WERR_OK;
4230
4231 *count_p = 0;
4232 *info_p = NULL;
4233
4234 for (snum = 0; snum < n_services; snum++) {
4235
4236 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4237
4238 if (!snum_is_shared_printer(snum)) {
4239 continue;
4240 }
4241
4242 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4243 lp_servicename(snum), snum));
4244
4245 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4246 union spoolss_PrinterInfo,
4247 count + 1);
4248 if (!info) {
4249 result = WERR_NOMEM;
4250 goto out;
4251 }
4252
4253 result = get_a_printer(NULL, &ntprinter, 2,
4254 lp_const_servicename(snum));
4255 if (!W_ERROR_IS_OK(result)) {
4256 goto out;
4257 }
4258
4259 switch (level) {
4260 case 0:
4261 result = construct_printer_info0(info, ntprinter,
4262 &info[count].info0, snum);
4263 break;
4264 case 1:
4265 result = construct_printer_info1(info, ntprinter, flags,
4266 &info[count].info1, snum);
4267 break;
4268 case 2:
4269 result = construct_printer_info2(info, ntprinter,
4270 &info[count].info2, snum);
4271 break;
4272 case 4:
4273 result = construct_printer_info4(info, ntprinter,
4274 &info[count].info4, snum);
4275 break;
4276 case 5:
4277 result = construct_printer_info5(info, ntprinter,
4278 &info[count].info5, snum);
4279 break;
4280
4281 default:
4282 result = WERR_UNKNOWN_LEVEL;
4283 free_a_printer(&ntprinter, 2);
4284 goto out;
4285 }
4286
4287 free_a_printer(&ntprinter, 2);
4288 if (!W_ERROR_IS_OK(result)) {
4289 goto out;
4290 }
4291
4292 count++;
4293 }
4294
4295 *count_p = count;
4296 *info_p = info;
4297
4298 out:
4299 if (!W_ERROR_IS_OK(result)) {
4300 TALLOC_FREE(info);
4301 return result;
4302 }
4303
4304 *info_p = info;
4305
4306 return WERR_OK;
4307 }
4308
4309 /********************************************************************
4310 * handle enumeration of printers at level 0
4311 ********************************************************************/
4312
4313 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4314 uint32_t flags,
4315 const char *servername,
4316 union spoolss_PrinterInfo **info,
4317 uint32_t *count)
4318 {
4319 DEBUG(4,("enum_all_printers_info_0\n"));
4320
4321 return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4322 }
4323
4324
4325 /********************************************************************
4326 ********************************************************************/
4327
4328 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4329 uint32_t flags,
4330 union spoolss_PrinterInfo **info,
4331 uint32_t *count)
4332 {
4333 DEBUG(4,("enum_all_printers_info_1\n"));
4334
4335 return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4336 }
4337
4338 /********************************************************************
4339 enum_all_printers_info_1_local.
4340 *********************************************************************/
4341
4342 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4343 union spoolss_PrinterInfo **info,
4344 uint32_t *count)
4345 {
4346 DEBUG(4,("enum_all_printers_info_1_local\n"));
4347
4348 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4349 }
4350
4351 /********************************************************************
4352 enum_all_printers_info_1_name.
4353 *********************************************************************/
4354
4355 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4356 const char *name,
4357 union spoolss_PrinterInfo **info,
4358 uint32_t *count)
4359 {
4360 const char *s = name;
4361
4362 DEBUG(4,("enum_all_printers_info_1_name\n"));
4363
4364 if ((name[0] == '\\') && (name[1] == '\\')) {
4365 s = name + 2;
4366 }
4367
4368 if (!is_myname_or_ipaddr(s)) {
4369 return WERR_INVALID_NAME;
4370 }
4371
4372 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4373 }
4374
4375 /********************************************************************
4376 enum_all_printers_info_1_network.
4377 *********************************************************************/
4378
4379 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4380 const char *name,
4381 union spoolss_PrinterInfo **info,
4382 uint32_t *count)
4383 {
4384 const char *s = name;
4385
4386 DEBUG(4,("enum_all_printers_info_1_network\n"));
4387
4388 /* If we respond to a enum_printers level 1 on our name with flags
4389 set to PRINTER_ENUM_REMOTE with a list of printers then these
4390 printers incorrectly appear in the APW browse list.
4391 Specifically the printers for the server appear at the workgroup
4392 level where all the other servers in the domain are
4393 listed. Windows responds to this call with a
4394 WERR_CAN_NOT_COMPLETE so we should do the same. */
4395
4396 if (name[0] == '\\' && name[1] == '\\') {
4397 s = name + 2;
4398 }
4399
4400 if (is_myname_or_ipaddr(s)) {
4401 return WERR_CAN_NOT_COMPLETE;
4402 }
4403
4404 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4405 }
4406
4407 /********************************************************************
4408 * api_spoolss_enumprinters
4409 *
4410 * called from api_spoolss_enumprinters (see this to understand)
4411 ********************************************************************/
4412
4413 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4414 union spoolss_PrinterInfo **info,
4415 uint32_t *count)
4416 {
4417 DEBUG(4,("enum_all_printers_info_2\n"));
4418
4419 return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4420 }
4421
4422 /********************************************************************
4423 * handle enumeration of printers at level 1
4424 ********************************************************************/
4425
4426 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4427 uint32_t flags,
4428 const char *name,
4429 union spoolss_PrinterInfo **info,
4430 uint32_t *count)
4431 {
4432 /* Not all the flags are equals */
4433
4434 if (flags & PRINTER_ENUM_LOCAL) {
4435 return enum_all_printers_info_1_local(mem_ctx, info, count);
4436 }
4437
4438 if (flags & PRINTER_ENUM_NAME) {
4439 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4440 }
4441
4442 if (flags & PRINTER_ENUM_NETWORK) {
4443 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4444 }
4445
4446 return WERR_OK; /* NT4sp5 does that */
4447 }
4448
4449 /********************************************************************
4450 * handle enumeration of printers at level 2
4451 ********************************************************************/
4452
4453 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4454 uint32_t flags,
4455 const char *servername,
4456 union spoolss_PrinterInfo **info,
4457 uint32_t *count)
4458 {
4459 if (flags & PRINTER_ENUM_LOCAL) {
4460 return enum_all_printers_info_2(mem_ctx, info, count);
4461 }
4462
4463 if (flags & PRINTER_ENUM_NAME) {
4464 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4465 return WERR_INVALID_NAME;
4466 }
4467
4468 return enum_all_printers_info_2(mem_ctx, info, count);
4469 }
4470
4471 if (flags & PRINTER_ENUM_REMOTE) {
4472 return WERR_UNKNOWN_LEVEL;
4473 }
4474
4475 return WERR_OK;
4476 }
4477
4478 /********************************************************************
4479 * handle enumeration of printers at level 4
4480 ********************************************************************/
4481
4482 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4483 uint32_t flags,
4484 const char *servername,
4485 union spoolss_PrinterInfo **info,
4486 uint32_t *count)
4487 {
4488 DEBUG(4,("enum_all_printers_info_4\n"));
4489
4490 return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4491 }
4492
4493
4494 /********************************************************************
4495 * handle enumeration of printers at level 5
4496 ********************************************************************/
4497
4498 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4499 uint32_t flags,
4500 const char *servername,
4501 union spoolss_PrinterInfo **info,
4502 uint32_t *count)
4503 {
4504 DEBUG(4,("enum_all_printers_info_5\n"));
4505
4506 return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4507 }
4508
4509 /****************************************************************
4510 _spoolss_EnumPrinters
4511 ****************************************************************/
4512
4513 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4514 struct spoolss_EnumPrinters *r)
4515 {
4516 const char *name;
4517 WERROR result;
4518
4519 /* that's an [in out] buffer */
4520
4521 if (!r->in.buffer && (r->in.offered != 0)) {
4522 return WERR_INVALID_PARAM;
4523 }
4524
4525 DEBUG(4,("_spoolss_EnumPrinters\n"));
4526
4527 *r->out.needed = 0;
4528 *r->out.count = 0;
4529 *r->out.info = NULL;
4530
4531 /*
4532 * Level 1:
4533 * flags==PRINTER_ENUM_NAME
4534 * if name=="" then enumerates all printers
4535 * if name!="" then enumerate the printer
4536 * flags==PRINTER_ENUM_REMOTE
4537 * name is NULL, enumerate printers
4538 * Level 2: name!="" enumerates printers, name can't be NULL
4539 * Level 3: doesn't exist
4540 * Level 4: does a local registry lookup
4541 * Level 5: same as Level 2
4542 */
4543
4544 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4545 W_ERROR_HAVE_NO_MEMORY(name);
4546
4547 switch (r->in.level) {
4548 case 0:
4549 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4550 r->out.info, r->out.count);
4551 break;
4552 case 1:
4553 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4554 r->out.info, r->out.count);
4555 break;
4556 case 2:
4557 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4558 r->out.info, r->out.count);
4559 break;
4560 case 4:
4561 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4562 r->out.info, r->out.count);
4563 break;
4564 case 5:
4565 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4566 r->out.info, r->out.count);
4567 break;
4568 default:
4569 return WERR_UNKNOWN_LEVEL;
4570 }
4571
4572 if (!W_ERROR_IS_OK(result)) {
4573 return result;
4574 }
4575
4576 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4577 spoolss_EnumPrinters, NULL,
4578 *r->out.info, r->in.level,
4579 *r->out.count);
4580 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4581 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4582
4583 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4584 }
4585
4586 /****************************************************************
4587 _spoolss_GetPrinter
4588 ****************************************************************/
4589
4590 WERROR _spoolss_GetPrinter(pipes_struct *p,
4591 struct spoolss_GetPrinter *r)
4592 {
4593 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4594 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4595 WERROR result = WERR_OK;
4596
4597 int snum;
4598
4599 /* that's an [in out] buffer */
4600
4601 if (!r->in.buffer && (r->in.offered != 0)) {
4602 return WERR_INVALID_PARAM;
4603 }
4604
4605 *r->out.needed = 0;
4606
4607 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4608 return WERR_BADFID;
4609 }
4610
4611 result = get_a_printer(Printer, &ntprinter, 2,
4612 lp_const_servicename(snum));
4613 if (!W_ERROR_IS_OK(result)) {
4614 return result;
4615 }
4616
4617 switch (r->in.level) {
4618 case 0:
4619 result = construct_printer_info0(p->mem_ctx, ntprinter,
4620 &r->out.info->info0, snum);
4621 break;
4622 case 1:
4623 result = construct_printer_info1(p->mem_ctx, ntprinter,
4624 PRINTER_ENUM_ICON8,
4625 &r->out.info->info1, snum);
4626 break;
4627 case 2:
4628 result = construct_printer_info2(p->mem_ctx, ntprinter,
4629 &r->out.info->info2, snum);
4630 break;
4631 case 3:
4632 result = construct_printer_info3(p->mem_ctx, ntprinter,
4633 &r->out.info->info3, snum);
4634 break;
4635 case 4:
4636 result = construct_printer_info4(p->mem_ctx, ntprinter,
4637 &r->out.info->info4, snum);
4638 break;
4639 case 5:
4640 result = construct_printer_info5(p->mem_ctx, ntprinter,
4641 &r->out.info->info5, snum);
4642 break;
4643 case 6:
4644 result = construct_printer_info6(p->mem_ctx, ntprinter,
4645 &r->out.info->info6, snum);
4646 break;
4647 case 7:
4648 result = construct_printer_info7(p->mem_ctx, Printer,
4649 &r->out.info->info7, snum);
4650 break;
4651 case 8:
4652 result = construct_printer_info8(p->mem_ctx, ntprinter,
4653 &r->out.info->info8, snum);
4654 break;
4655 default:
4656 result = WERR_UNKNOWN_LEVEL;
4657 break;
4658 }
4659
4660 free_a_printer(&ntprinter, 2);
4661
4662 if (!W_ERROR_IS_OK(result)) {
4663 TALLOC_FREE(r->out.info);
4664 return result;
4665 }
4666
4667 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4668 r->out.info, r->in.level);
4669 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4670
4671 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4672 }
4673
4674 /********************************************************************
4675 ********************************************************************/
4676
4677 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4678 fstring *fstring_array,
4679 const char *cservername)
4680 {
4681 int i, num_strings = 0;
4682 const char **array = NULL;
4683
4684 for (i=0; fstring_array && fstring_array[i][0] != '\0'; i++) {
4685
4686 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4687 cservername, fstring_array[i]);
4688 if (!str) {
4689 TALLOC_FREE(array);
4690 return NULL;
4691 }
4692
4693
4694 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4695 TALLOC_FREE(array);
4696 return NULL;
4697 }
4698 }
4699
4700 if (i > 0) {
4701 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4702 &array, &num_strings);
4703 }
4704
4705 return array;
4706 }
4707
4708 /********************************************************************
4709 * fill a spoolss_DriverInfo1 struct
4710 ********************************************************************/
4711
4712 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4713 struct spoolss_DriverInfo1 *r,
4714 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4715 const char *servername,
4716 const char *architecture)
4717 {
4718 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4719 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4720
4721 return WERR_OK;
4722 }
4723
4724 /********************************************************************
4725 * fill a spoolss_DriverInfo2 struct
4726 ********************************************************************/
4727
4728 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4729 struct spoolss_DriverInfo2 *r,
4730 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4731 const char *servername)
4732
4733 {
4734 const char *cservername = canon_servername(servername);
4735
4736 r->version = driver->info_3->cversion;
4737
4738 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4739 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4740 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4741 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4742
4743 if (strlen(driver->info_3->driverpath)) {
4744 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4745 cservername, driver->info_3->driverpath);
4746 } else {
4747 r->driver_path = talloc_strdup(mem_ctx, "");
4748 }
4749 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4750
4751 if (strlen(driver->info_3->datafile)) {
4752 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4753 cservername, driver->info_3->datafile);
4754 } else {
4755 r->data_file = talloc_strdup(mem_ctx, "");
4756 }
4757 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4758
4759 if (strlen(driver->info_3->configfile)) {
4760 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4761 cservername, driver->info_3->configfile);
4762 } else {
4763 r->config_file = talloc_strdup(mem_ctx, "");
4764 }
4765 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4766
4767 return WERR_OK;
4768 }
4769
4770 /********************************************************************
4771 * fill a spoolss_DriverInfo3 struct
4772 ********************************************************************/
4773
4774 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4775 struct spoolss_DriverInfo3 *r,
4776 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4777 const char *servername)
4778 {
4779 const char *cservername = canon_servername(servername);
4780
4781 r->version = driver->info_3->cversion;
4782
4783 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4784 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4785 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4786 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4787
4788 if (strlen(driver->info_3->driverpath)) {
4789 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4790 cservername, driver->info_3->driverpath);
4791 } else {
4792 r->driver_path = talloc_strdup(mem_ctx, "");
4793 }
4794 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4795
4796 if (strlen(driver->info_3->datafile)) {
4797 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4798 cservername, driver->info_3->datafile);
4799 } else {
4800 r->data_file = talloc_strdup(mem_ctx, "");
4801 }
4802 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4803
4804 if (strlen(driver->info_3->configfile)) {
4805 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4806 cservername, driver->info_3->configfile);
4807 } else {
4808 r->config_file = talloc_strdup(mem_ctx, "");
4809 }
4810 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4811
4812 if (strlen(driver->info_3->helpfile)) {
4813 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4814 cservername, driver->info_3->helpfile);
4815 } else {
4816 r->help_file = talloc_strdup(mem_ctx, "");
4817 }
4818 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4819
4820 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4821 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4822 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4823 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4824
4825 r->dependent_files = string_array_from_driver_info(mem_ctx,
4826 driver->info_3->dependentfiles,
4827 cservername);
4828 return WERR_OK;
4829 }
4830
4831 /********************************************************************
4832 * fill a spoolss_DriverInfo4 struct
4833 ********************************************************************/
4834
4835 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4836 struct spoolss_DriverInfo4 *r,
4837 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4838 const char *servername)
4839 {
4840 const char *cservername = canon_servername(servername);
4841
4842 r->version = driver->info_3->cversion;
4843
4844 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4845 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4846 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4847 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4848
4849 if (strlen(driver->info_3->driverpath)) {
4850 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4851 cservername, driver->info_3->driverpath);
4852 } else {
4853 r->driver_path = talloc_strdup(mem_ctx, "");
4854 }
4855 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4856
4857 if (strlen(driver->info_3->datafile)) {
4858 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4859 cservername, driver->info_3->datafile);
4860 } else {
4861 r->data_file = talloc_strdup(mem_ctx, "");
4862 }
4863 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4864
4865 if (strlen(driver->info_3->configfile)) {
4866 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4867 cservername, driver->info_3->configfile);
4868 } else {
4869 r->config_file = talloc_strdup(mem_ctx, "");
4870 }
4871 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4872
4873 if (strlen(driver->info_3->helpfile)) {
4874 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4875 cservername, driver->info_3->helpfile);
4876 } else {
4877 r->help_file = talloc_strdup(mem_ctx, "");
4878 }
4879 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4880
4881 r->dependent_files = string_array_from_driver_info(mem_ctx,
4882 driver->info_3->dependentfiles,
4883 cservername);
4884
4885
4886 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4887 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4888 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4889 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4890
4891 r->previous_names = string_array_from_driver_info(mem_ctx,
4892 NULL,
4893 cservername);
4894
4895 return WERR_OK;
4896 }
4897
4898 /********************************************************************
4899 * fill a spoolss_DriverInfo5 struct
4900 ********************************************************************/
4901
4902 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4903 struct spoolss_DriverInfo5 *r,
4904 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4905 const char *servername)
4906 {
4907 const char *cservername = canon_servername(servername);
4908
4909 r->version = driver->info_3->cversion;
4910
4911 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4912 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4913 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4914 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4915
4916 if (strlen(driver->info_3->driverpath)) {
4917 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4918 cservername, driver->info_3->driverpath);
4919 } else {
4920 r->driver_path = talloc_strdup(mem_ctx, "");
4921 }
4922 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4923
4924 if (strlen(driver->info_3->datafile)) {
4925 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4926 cservername, driver->info_3->datafile);
4927 } else {
4928 r->data_file = talloc_strdup(mem_ctx, "");
4929 }
4930 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4931
4932 if (strlen(driver->info_3->configfile)) {
4933 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4934 cservername, driver->info_3->configfile);
4935 } else {
4936 r->config_file = talloc_strdup(mem_ctx, "");
4937 }
4938 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4939
4940 r->driver_attributes = 0;
4941 r->config_version = 0;
4942 r->driver_version = 0;
4943
4944 return WERR_OK;
4945 }
4946 /********************************************************************
4947 * fill a spoolss_DriverInfo6 struct
4948 ********************************************************************/
4949
4950 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4951 struct spoolss_DriverInfo6 *r,
4952 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4953 const char *servername)
4954 {
4955 const char *cservername = canon_servername(servername);
4956
4957 r->version = driver->info_3->cversion;
4958
4959 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4960 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4961 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4962 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4963
4964 if (strlen(driver->info_3->driverpath)) {
4965 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4966 cservername, driver->info_3->driverpath);
4967 } else {
4968 r->driver_path = talloc_strdup(mem_ctx, "");
4969 }
4970 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4971
4972 if (strlen(driver->info_3->datafile)) {
4973 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4974 cservername, driver->info_3->datafile);
4975 } else {
4976 r->data_file = talloc_strdup(mem_ctx, "");
4977 }
4978 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4979
4980 if (strlen(driver->info_3->configfile)) {
4981 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4982 cservername, driver->info_3->configfile);
4983 } else {
4984 r->config_file = talloc_strdup(mem_ctx, "");
4985 }
4986 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4987
4988 if (strlen(driver->info_3->helpfile)) {
4989 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4990 cservername, driver->info_3->helpfile);
4991 } else {
4992 r->help_file = talloc_strdup(mem_ctx, "");
4993 }
4994 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4995
4996 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4997 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4998 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4999 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
5000
5001 r->dependent_files = string_array_from_driver_info(mem_ctx,
5002 driver->info_3->dependentfiles,
5003 cservername);
5004 r->previous_names = string_array_from_driver_info(mem_ctx,
5005 NULL,
5006 cservername);
5007
5008 r->driver_date = 0;
5009 r->driver_version = 0;
5010
5011 r->manufacturer_name = talloc_strdup(mem_ctx, "");
5012 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5013 r->manufacturer_url = talloc_strdup(mem_ctx, "");
5014 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5015 r->hardware_id = talloc_strdup(mem_ctx, "");
5016 W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5017 r->provider = talloc_strdup(mem_ctx, "");
5018 W_ERROR_HAVE_NO_MEMORY(r->provider);
5019
5020 return WERR_OK;
5021 }
5022
5023 /********************************************************************
5024 ********************************************************************/
5025
5026 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5027 struct spoolss_DriverFileInfo *r,
5028 const char *cservername,
5029 const char *file_name,
5030 enum spoolss_DriverFileType file_type,
5031 uint32_t file_version)
5032 {
5033 r->file_name = talloc_asprintf(mem_ctx, "\\\\%s%s",
5034 cservername, file_name);
5035 W_ERROR_HAVE_NO_MEMORY(r->file_name);
5036 r->file_type = file_type;
5037 r->file_version = file_version;
5038
5039 return WERR_OK;
5040 }
5041
5042 /********************************************************************
5043 ********************************************************************/
5044
5045 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5046 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5047 const char *cservername,
5048 struct spoolss_DriverFileInfo **info_p,
5049 uint32_t *count_p)
5050 {
5051 struct spoolss_DriverFileInfo *info = NULL;
5052 uint32_t count = 0;
5053 WERROR result;
5054 uint32_t i;
5055
5056 *info_p = NULL;
5057 *count_p = 0;
5058
5059 if (strlen(driver->info_3->driverpath)) {
5060 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5061 struct spoolss_DriverFileInfo,
5062 count + 1);
5063 W_ERROR_HAVE_NO_MEMORY(info);
5064 result = fill_spoolss_DriverFileInfo(info,
5065 &info[count],
5066 cservername,
5067 driver->info_3->driverpath,
5068 SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5069 0);
5070 W_ERROR_NOT_OK_RETURN(result);
5071 count++;
5072 }
5073
5074 if (strlen(driver->info_3->configfile)) {
5075 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5076 struct spoolss_DriverFileInfo,
5077 count + 1);
5078 W_ERROR_HAVE_NO_MEMORY(info);
5079 result = fill_spoolss_DriverFileInfo(info,
5080 &info[count],
5081 cservername,
5082 driver->info_3->configfile,
5083 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5084 0);
5085 W_ERROR_NOT_OK_RETURN(result);
5086 count++;
5087 }
5088
5089 if (strlen(driver->info_3->datafile)) {
5090 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5091 struct spoolss_DriverFileInfo,
5092 count + 1);
5093 W_ERROR_HAVE_NO_MEMORY(info);
5094 result = fill_spoolss_DriverFileInfo(info,
5095 &info[count],
5096 cservername,
5097 driver->info_3->datafile,
5098 SPOOLSS_DRIVER_FILE_TYPE_DATA,
5099 0);
5100 W_ERROR_NOT_OK_RETURN(result);
5101 count++;
5102 }
5103
5104 if (strlen(driver->info_3->helpfile)) {
5105 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5106 struct spoolss_DriverFileInfo,
5107 count + 1);
5108 W_ERROR_HAVE_NO_MEMORY(info);
5109 result = fill_spoolss_DriverFileInfo(info,
5110 &info[count],
5111 cservername,
5112 driver->info_3->helpfile,
5113 SPOOLSS_DRIVER_FILE_TYPE_HELP,
5114 0);
5115 W_ERROR_NOT_OK_RETURN(result);
5116 count++;
5117 }
5118
5119 for (i=0; driver->info_3->dependentfiles[i][0] != '\0'; i++) {
5120 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5121 struct spoolss_DriverFileInfo,
5122 count + 1);
5123 W_ERROR_HAVE_NO_MEMORY(info);
5124 result = fill_spoolss_DriverFileInfo(info,
5125 &info[count],
5126 cservername,
5127 driver->info_3->dependentfiles[i],
5128 SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5129 0);
5130 W_ERROR_NOT_OK_RETURN(result);
5131 count++;
5132 }
5133
5134 *info_p = info;
5135 *count_p = count;
5136
5137 return WERR_OK;
5138 }
5139
5140 /********************************************************************
5141 * fill a spoolss_DriverInfo101 sttruct
5142 ********************************************************************/
5143
5144 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5145 struct spoolss_DriverInfo101 *r,
5146 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5147 const char *servername)
5148 {
5149 const char *cservername = canon_servername(servername);
5150 WERROR result;
5151
5152 r->version = driver->info_3->cversion;
5153
5154 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
5155 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5156 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
5157 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5158
5159 result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5160 cservername,
5161 &r->file_info,
5162 &r->file_count);
5163 if (!W_ERROR_IS_OK(result)) {
5164 return result;
5165 }
5166
5167 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
5168 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
5169
5170 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
5171 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
5172
5173 r->previous_names = string_array_from_driver_info(mem_ctx,
5174 NULL,
5175 cservername);
5176 r->driver_date = 0;
5177 r->driver_version = 0;
5178
5179 r->manufacturer_name = talloc_strdup(mem_ctx, "");
5180 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5181 r->manufacturer_url = talloc_strdup(mem_ctx, "");
5182 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5183 r->hardware_id = talloc_strdup(mem_ctx, "");
5184 W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5185 r->provider = talloc_strdup(mem_ctx, "");
5186 W_ERROR_HAVE_NO_MEMORY(r->provider);
5187
5188 return WERR_OK;
5189 }
5190
5191 /********************************************************************
5192 * construct_printer_driver_info_1
5193 ********************************************************************/
5194
5195 static WERROR construct_printer_driver_info_1(TALLOC_CTX *mem_ctx,
5196 struct spoolss_DriverInfo1 *r,
5197 int snum,
5198 const char *servername,
5199 const char *architecture,
5200 uint32_t version)
5201 {
5202 NT_PRINTER_INFO_LEVEL *printer = NULL;
5203 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5204 WERROR result;
5205
5206 ZERO_STRUCT(driver);
5207
5208 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5209 return WERR_INVALID_PRINTER_NAME;
5210
5211 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5212 free_a_printer(&printer, 2);
5213 return WERR_UNKNOWN_PRINTER_DRIVER;
5214 }
5215
5216 result = fill_printer_driver_info1(mem_ctx, r, &driver, servername, architecture);
5217
5218 free_a_printer(&printer,2);
5219
5220 return result;
5221 }
5222
5223 /********************************************************************
5224 * construct_printer_driver_info_2
5225 * fill a printer_info_2 struct
5226 ********************************************************************/
5227
5228 static WERROR construct_printer_driver_info_2(TALLOC_CTX *mem_ctx,
5229 struct spoolss_DriverInfo2 *r,
5230 int snum,
5231 const char *servername,
5232 const char *architecture,
5233 uint32_t version)
5234 {
5235 NT_PRINTER_INFO_LEVEL *printer = NULL;
5236 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5237 WERROR result;
5238
5239 ZERO_STRUCT(printer);
5240 ZERO_STRUCT(driver);
5241
5242 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5243 return WERR_INVALID_PRINTER_NAME;
5244
5245 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5246 free_a_printer(&printer, 2);
5247 return WERR_UNKNOWN_PRINTER_DRIVER;
5248 }
5249
5250 result = fill_printer_driver_info2(mem_ctx, r, &driver, servername);
5251
5252 free_a_printer(&printer,2);
5253
5254 return result;
5255 }
5256
5257 /********************************************************************
5258 * construct_printer_info_3
5259 * fill a printer_info_3 struct
5260 ********************************************************************/
5261
5262 static WERROR construct_printer_driver_info_3(TALLOC_CTX *mem_ctx,
5263 struct spoolss_DriverInfo3 *r,
5264 int snum,
5265 const char *servername,
5266 const char *architecture,
5267 uint32_t version)
5268 {
5269 NT_PRINTER_INFO_LEVEL *printer = NULL;
5270 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5271 WERROR status;
5272 ZERO_STRUCT(driver);
5273
5274 status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5275 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5276 if (!W_ERROR_IS_OK(status))
5277 return WERR_INVALID_PRINTER_NAME;
5278
5279 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5280 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5281
5282 #if 0 /* JERRY */
5283
5284 /*
5285 * I put this code in during testing. Helpful when commenting out the
5286 * support for DRIVER_INFO_6 in regards to win2k. Not needed in general
5287 * as win2k always queries the driver using an infor level of 6.
5288 * I've left it in (but ifdef'd out) because I'll probably
5289 * use it in experimentation again in the future. --jerry 22/01/2002
5290 */
5291
5292 if (!W_ERROR_IS_OK(status)) {
5293 /*
5294 * Is this a W2k client ?
5295 */
5296 if (version == 3) {
5297 /* Yes - try again with a WinNT driver. */
5298 version = 2;
5299 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5300 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5301 }
5302 #endif
5303
5304 if (!W_ERROR_IS_OK(status)) {
5305 free_a_printer(&printer,2);
5306 return WERR_UNKNOWN_PRINTER_DRIVER;
5307 }
5308
5309 #if 0 /* JERRY */
5310 }
5311 #endif
5312
5313
5314 status = fill_printer_driver_info3(mem_ctx, r, &driver, servername);
5315
5316 free_a_printer(&printer,2);
5317
5318 return status;
5319 }
5320
5321 /********************************************************************
5322 * construct_printer_info_6
5323 * fill a printer_info_6 struct
5324 ********************************************************************/
5325
5326 static WERROR construct_printer_driver_info_6(TALLOC_CTX *mem_ctx,
5327 struct spoolss_DriverInfo6 *r,
5328 int snum,
5329 const char *servername,
5330 const char *architecture,
5331 uint32_t version)
5332 {
5333 NT_PRINTER_INFO_LEVEL *printer = NULL;
5334 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5335 WERROR status;
5336
5337 ZERO_STRUCT(driver);
5338
5339 status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5340
5341 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5342
5343 if (!W_ERROR_IS_OK(status))
5344 return WERR_INVALID_PRINTER_NAME;
5345
5346 status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5347
5348 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5349
5350 if (!W_ERROR_IS_OK(status))
5351 {
5352 /*
5353 * Is this a W2k client ?
5354 */
5355
5356 if (version < 3) {
5357 free_a_printer(&printer,2);
5358 return WERR_UNKNOWN_PRINTER_DRIVER;
5359 }
5360
5361 /* Yes - try again with a WinNT driver. */
5362 version = 2;
5363 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5364 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5365 if (!W_ERROR_IS_OK(status)) {
5366 free_a_printer(&printer,2);
5367 return WERR_UNKNOWN_PRINTER_DRIVER;
5368 }
5369 }
5370
5371 status = fill_printer_driver_info6(mem_ctx, r, &driver, servername);
5372
5373 free_a_printer(&printer,2);
5374 free_a_printer_driver(driver, 3);
5375
5376 return status;
5377 }
5378
5379 /********************************************************************
5380 * construct_printer_info_101
5381 * fill a printer_info_101 struct
5382 ********************************************************************/
5383
5384 static WERROR construct_printer_driver_info_101(TALLOC_CTX *mem_ctx,
5385 struct spoolss_DriverInfo101 *r,
5386 int snum,
5387 const char *servername,
5388 const char *architecture,
5389 uint32_t version)
5390 {
5391 NT_PRINTER_INFO_LEVEL *printer = NULL;
5392 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5393 WERROR result;
5394
5395 ZERO_STRUCT(driver);
5396
5397 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5398
5399 DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5400 win_errstr(result)));
5401
5402 if (!W_ERROR_IS_OK(result)) {
5403 return WERR_INVALID_PRINTER_NAME;
5404 }
5405
5406 result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5407 architecture, version);
5408
5409 DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5410 win_errstr(result)));
5411
5412 if (!W_ERROR_IS_OK(result)) {
5413 /*
5414 * Is this a W2k client ?
5415 */
5416
5417 if (version < 3) {
5418 free_a_printer(&printer, 2);
5419 return WERR_UNKNOWN_PRINTER_DRIVER;
5420 }
5421
5422 /* Yes - try again with a WinNT driver. */
5423 version = 2;
5424 result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5425 architecture, version);
5426 DEBUG(8,("construct_printer_driver_info_6: status: %s\n",
5427 win_errstr(result)));
5428 if (!W_ERROR_IS_OK(result)) {
5429 free_a_printer(&printer, 2);
5430 return WERR_UNKNOWN_PRINTER_DRIVER;
5431 }
5432 }
5433
5434 result = fill_printer_driver_info101(mem_ctx, r, &driver, servername);
5435
5436 free_a_printer(&printer, 2);
5437 free_a_printer_driver(driver, 3);
5438
5439 return result;
5440 }
5441
5442 /****************************************************************
5443 _spoolss_GetPrinterDriver2
5444 ****************************************************************/
5445
5446 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5447 struct spoolss_GetPrinterDriver2 *r)
5448 {
5449 Printer_entry *printer;
5450 WERROR result;
5451
5452 const char *servername;
5453 int snum;
5454
5455 /* that's an [in out] buffer */
5456
5457 if (!r->in.buffer && (r->in.offered != 0)) {
5458 return WERR_INVALID_PARAM;
5459 }
5460
5461 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5462
5463 if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5464 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5465 return WERR_INVALID_PRINTER_NAME;
5466 }
5467
5468 *r->out.needed = 0;
5469 *r->out.server_major_version = 0;
5470 *r->out.server_minor_version = 0;
5471
5472 servername = get_server_name(printer);
5473
5474 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5475 return WERR_BADFID;
5476 }
5477
5478 switch (r->in.level) {
5479 case 1:
5480 result = construct_printer_driver_info_1(p->mem_ctx,
5481 &r->out.info->info1,
5482 snum,
5483 servername,
5484 r->in.architecture,
5485 r->in.client_major_version);
5486 break;
5487 case 2:
5488 result = construct_printer_driver_info_2(p->mem_ctx,
5489 &r->out.info->info2,
5490 snum,
5491 servername,
5492 r->in.architecture,
5493 r->in.client_major_version);
5494 break;
5495 case 3:
5496 result = construct_printer_driver_info_3(p->mem_ctx,
5497 &r->out.info->info3,
5498 snum,
5499 servername,
5500 r->in.architecture,
5501 r->in.client_major_version);
5502 break;
5503 case 6:
5504 result = construct_printer_driver_info_6(p->mem_ctx,
5505 &r->out.info->info6,
5506 snum,
5507 servername,
5508 r->in.architecture,
5509 r->in.client_major_version);
5510 break;
5511 case 101:
5512 result = construct_printer_driver_info_101(p->mem_ctx,
5513 &r->out.info->info101,
5514 snum,
5515 servername,
5516 r->in.architecture,
5517 r->in.client_major_version);
5518 break;
5519 default:
5520 result = WERR_UNKNOWN_LEVEL;
5521 break;
5522 }
5523
5524 if (!W_ERROR_IS_OK(result)) {
5525 TALLOC_FREE(r->out.info);
5526 return result;
5527 }
5528
5529 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5530 r->out.info, r->in.level);
5531 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5532
5533 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5534 }
5535
5536
5537 /****************************************************************
5538 _spoolss_StartPagePrinter
5539 ****************************************************************/
5540
5541 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5542 struct spoolss_StartPagePrinter *r)
5543 {
5544 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5545
5546 if (!Printer) {
5547 DEBUG(3,("_spoolss_StartPagePrinter: "
5548 "Error in startpageprinter printer handle\n"));
5549 return WERR_BADFID;
5550 }
5551
5552 Printer->page_started = true;
5553 return WERR_OK;
5554 }
5555
5556 /****************************************************************
5557 _spoolss_EndPagePrinter
5558 ****************************************************************/
5559
5560 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5561 struct spoolss_EndPagePrinter *r)
5562 {
5563 int snum;
5564
5565 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5566
5567 if (!Printer) {
5568 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5569 OUR_HANDLE(r->in.handle)));
5570 return WERR_BADFID;
5571 }
5572
5573 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5574 return WERR_BADFID;
5575
5576 Printer->page_started = false;
5577 print_job_endpage(snum, Printer->jobid);
5578
5579 return WERR_OK;
5580 }
5581
5582 /****************************************************************
5583 _spoolss_StartDocPrinter
5584 ****************************************************************/
5585
5586 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5587 struct spoolss_StartDocPrinter *r)
5588 {
5589 struct spoolss_DocumentInfo1 *info_1;
5590 int snum;
5591 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5592
5593 if (!Printer) {
5594 DEBUG(2,("_spoolss_StartDocPrinter: "
5595 "Invalid handle (%s:%u:%u)\n",
5596 OUR_HANDLE(r->in.handle)));
5597 return WERR_BADFID;
5598 }
5599
5600 if (r->in.level != 1) {
5601 return WERR_UNKNOWN_LEVEL;
5602 }
5603
5604 info_1 = r->in.info.info1;
5605
5606 /*
5607 * a nice thing with NT is it doesn't listen to what you tell it.
5608 * when asked to send _only_ RAW datas, it tries to send datas
5609 * in EMF format.
5610 *
5611 * So I add checks like in NT Server ...
5612 */
5613
5614 if (info_1->datatype) {
5615 if (strcmp(info_1->datatype, "RAW") != 0) {
5616 *r->out.job_id = 0;
5617 return WERR_INVALID_DATATYPE;
5618 }
5619 }
5620
5621 /* get the share number of the printer */
5622 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5623 return WERR_BADFID;
5624 }
5625
5626 Printer->jobid = print_job_start(p->server_info, snum,
5627 info_1->document_name,
5628 Printer->nt_devmode);
5629
5630 /* An error occured in print_job_start() so return an appropriate
5631 NT error code. */
5632
5633 if (Printer->jobid == -1) {
5634 return map_werror_from_unix(errno);
5635 }
5636
5637 Printer->document_started = true;
5638 *r->out.job_id = Printer->jobid;
5639
5640 return WERR_OK;
5641 }
5642
5643 /****************************************************************
5644 _spoolss_EndDocPrinter
5645 ****************************************************************/
5646
5647 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5648 struct spoolss_EndDocPrinter *r)
5649 {
5650 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5651 int snum;
5652
5653 if (!Printer) {
5654 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5655 OUR_HANDLE(r->in.handle)));
5656 return WERR_BADFID;
5657 }
5658
5659 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5660 return WERR_BADFID;
5661 }
5662
5663 Printer->document_started = false;
5664 print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
5665 /* error codes unhandled so far ... */
5666
5667 return WERR_OK;
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 errcode = print_queue_pause(p->server_info, snum);
5733 break;
5734 case SPOOLSS_PRINTER_CONTROL_RESUME:
5735 case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5736 errcode = print_queue_resume(p->server_info, snum);
5737 break;
5738 case SPOOLSS_PRINTER_CONTROL_PURGE:
5739 errcode = print_queue_purge(p->server_info, snum);
5740 break;
5741 default:
5742 return WERR_UNKNOWN_LEVEL;
5743 }
5744
5745 return errcode;
5746 }
5747
5748
5749 /****************************************************************
5750 _spoolss_AbortPrinter
5751 * From MSDN: "Deletes printer's spool file if printer is configured
5752 * for spooling"
5753 ****************************************************************/
5754
5755 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5756 struct spoolss_AbortPrinter *r)
5757 {
5758 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5759 int snum;
5760 WERROR errcode = WERR_OK;
5761
5762 if (!Printer) {
5763 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5764 OUR_HANDLE(r->in.handle)));
5765 return WERR_BADFID;
5766 }
5767
5768 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5769 return WERR_BADFID;
5770
5771 print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5772
5773 return errcode;
5774 }
5775
5776 /********************************************************************
5777 * called by spoolss_api_setprinter
5778 * when updating a printer description
5779 ********************************************************************/
5780
5781 static WERROR update_printer_sec(struct policy_handle *handle,
5782 pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5783 {
5784 SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5785 WERROR result;
5786 int snum;
5787
5788 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5789
5790 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5791 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5792 OUR_HANDLE(handle)));
5793
5794 result = WERR_BADFID;
5795 goto done;
5796 }
5797
5798 if (!secdesc_ctr) {
5799 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5800 result = WERR_INVALID_PARAM;
5801 goto done;
5802 }
5803
5804 /* Check the user has permissions to change the security
5805 descriptor. By experimentation with two NT machines, the user
5806 requires Full Access to the printer to change security
5807 information. */
5808
5809 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5810 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5811 result = WERR_ACCESS_DENIED;
5812 goto done;
5813 }
5814
5815 /* NT seems to like setting the security descriptor even though
5816 nothing may have actually changed. */
5817
5818 if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5819 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5820 result = WERR_BADFID;
5821 goto done;
5822 }
5823
5824 if (DEBUGLEVEL >= 10) {
5825 SEC_ACL *the_acl;
5826 int i;
5827
5828 the_acl = old_secdesc_ctr->sd->dacl;
5829 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5830 PRINTERNAME(snum), the_acl->num_aces));
5831
5832 for (i = 0; i < the_acl->num_aces; i++) {
5833 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5834 &the_acl->aces[i].trustee),
5835 the_acl->aces[i].access_mask));
5836 }
5837
5838 the_acl = secdesc_ctr->sd->dacl;
5839
5840 if (the_acl) {
5841 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5842 PRINTERNAME(snum), the_acl->num_aces));
5843
5844 for (i = 0; i < the_acl->num_aces; i++) {
5845 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5846 &the_acl->aces[i].trustee),
5847 the_acl->aces[i].access_mask));
5848 }
5849 } else {
5850 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5851 }
5852 }
5853
5854 new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5855 if (!new_secdesc_ctr) {
5856 result = WERR_NOMEM;
5857 goto done;
5858 }
5859
5860 if (security_descriptor_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5861 result = WERR_OK;
5862 goto done;
5863 }
5864
5865 result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5866
5867 done:
5868
5869 return result;
5870 }
5871
5872 /********************************************************************
5873 Canonicalize printer info from a client
5874
5875 ATTN: It does not matter what we set the servername to hear
5876 since we do the necessary work in get_a_printer() to set it to
5877 the correct value based on what the client sent in the
5878 _spoolss_open_printer_ex().
5879 ********************************************************************/
5880
5881 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5882 {
5883 fstring printername;
5884 const char *p;
5885
5886 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5887 "portname=%s drivername=%s comment=%s location=%s\n",
5888 info->servername, info->printername, info->sharename,
5889 info->portname, info->drivername, info->comment, info->location));
5890
5891 /* we force some elements to "correct" values */
5892 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5893 fstrcpy(info->sharename, lp_servicename(snum));
5894
5895 /* check to see if we allow printername != sharename */
5896
5897 if ( lp_force_printername(snum) ) {
5898 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5899 global_myname(), info->sharename );
5900 } else {
5901
5902 /* make sure printername is in \\server\printername format */
5903
5904 fstrcpy( printername, info->printername );
5905 p = printername;
5906 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5907 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5908 p++;
5909 }
5910
5911 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5912 global_myname(), p );
5913 }
5914
5915 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5916 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5917
5918
5919
5920 return true;
5921 }
5922
5923 /****************************************************************************
5924 ****************************************************************************/
5925
5926 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5927 {
5928 char *cmd = lp_addport_cmd();
5929 char *command = NULL;
5930 int ret;
5931 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5932 bool is_print_op = false;
5933
5934 if ( !*cmd ) {
5935 return WERR_ACCESS_DENIED;
5936 }
5937
5938 command = talloc_asprintf(ctx,
5939 "%s \"%s\" \"%s\"", cmd, portname, uri );
5940 if (!command) {
5941 return WERR_NOMEM;
5942 }
5943
5944 if ( token )
5945 is_print_op = user_has_privileges( token, &se_printop );
5946
5947 DEBUG(10,("Running [%s]\n", command));
5948
5949 /********* BEGIN SePrintOperatorPrivilege **********/
5950
5951 if ( is_print_op )
5952 become_root();
5953
5954 ret = smbrun(command, NULL);
5955
5956 if ( is_print_op )
5957 unbecome_root();
5958
5959 /********* END SePrintOperatorPrivilege **********/
5960
5961 DEBUGADD(10,("returned [%d]\n", ret));
5962
5963 TALLOC_FREE(command);
5964
5965 if ( ret != 0 ) {
5966 return WERR_ACCESS_DENIED;
5967 }
5968
5969 return WERR_OK;
5970 }
5971
5972 /****************************************************************************
5973 ****************************************************************************/
5974
5975 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5976 {
5977 char *cmd = lp_addprinter_cmd();
5978 char **qlines;
5979 char *command = NULL;
5980 int numlines;
5981 int ret;
5982 int fd;
5983 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5984 bool is_print_op = false;
5985 char *remote_machine = talloc_strdup(ctx, "%m");
5986
5987 if (!remote_machine) {
5988 return false;
5989 }
5990 remote_machine = talloc_sub_basic(ctx,
5991 current_user_info.smb_name,
5992 current_user_info.domain,
5993 remote_machine);
5994 if (!remote_machine) {
5995 return false;
5996 }
5997
5998 command = talloc_asprintf(ctx,
5999 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
6000 cmd, printer->info_2->printername, printer->info_2->sharename,
6001 printer->info_2->portname, printer->info_2->drivername,
6002 printer->info_2->location, printer->info_2->comment, remote_machine);
6003 if (!command) {
6004 return false;
6005 }
6006
6007 if ( token )
6008 is_print_op = user_has_privileges( token, &se_printop );
6009
6010 DEBUG(10,("Running [%s]\n", command));
6011
6012 /********* BEGIN SePrintOperatorPrivilege **********/
6013
6014 if ( is_print_op )
6015 become_root();
6016
6017 if ( (ret = smbrun(command, &fd)) == 0 ) {
6018 /* Tell everyone we updated smb.conf. */
6019 message_send_all(smbd_messaging_context(),
6020 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6021 }
6022
6023 if ( is_print_op )
6024 unbecome_root();
6025
6026 /********* END SePrintOperatorPrivilege **********/
6027
6028 DEBUGADD(10,("returned [%d]\n", ret));
6029
6030 TALLOC_FREE(command);
6031 TALLOC_FREE(remote_machine);
6032
6033 if ( ret != 0 ) {
6034 if (fd != -1)
6035 close(fd);
6036 return false;
6037 }
6038
6039 /* reload our services immediately */
6040 become_root();
6041 reload_services(false);
6042 unbecome_root();
6043
6044 numlines = 0;
6045 /* Get lines and convert them back to dos-codepage */
6046 qlines = fd_lines_load(fd, &numlines, 0, NULL);
6047 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6048 close(fd);
6049
6050 /* Set the portname to what the script says the portname should be. */
6051 /* but don't require anything to be return from the script exit a good error code */
6052
6053 if (numlines) {
6054 /* Set the portname to what the script says the portname should be. */
6055 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
6056 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6057 }
6058
6059 TALLOC_FREE(qlines);
6060 return true;
6061 }
6062
6063
6064 /********************************************************************
6065 * Called by spoolss_api_setprinter
6066 * when updating a printer description.
6067 ********************************************************************/
6068
6069 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
6070 struct spoolss_SetPrinterInfoCtr *info_ctr,
6071 struct spoolss_DeviceMode *devmode)
6072 {
6073 int snum;
6074 NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
6075 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6076 WERROR result;
6077 DATA_BLOB buffer;
6078 fstring asc_buffer;
6079
6080 DEBUG(8,("update_printer\n"));
6081
6082 result = WERR_OK;
6083
6084 if (!Printer) {
6085 result = WERR_BADFID;
6086 goto done;
6087 }
6088
6089 if (!get_printer_snum(p, handle, &snum, NULL)) {
6090 result = WERR_BADFID;
6091 goto done;
6092 }
6093
6094 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
6095 (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
6096 result = WERR_BADFID;
6097 goto done;
6098 }
6099
6100 DEBUGADD(8,("Converting info_2 struct\n"));
6101
6102 /*
6103 * convert_printer_info converts the incoming
6104 * info from the client and overwrites the info
6105 * just read from the tdb in the pointer 'printer'.
6106 */
6107
6108 if (!convert_printer_info(info_ctr, printer)) {
6109 result = WERR_NOMEM;
6110 goto done;
6111 }
6112
6113 if (devmode) {
6114 /* we have a valid devmode
6115 convert it and link it*/
6116
6117 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
6118 if (!convert_devicemode(printer->info_2->printername, devmode,
6119 &printer->info_2->devmode)) {
6120 result = WERR_NOMEM;
6121 goto done;
6122 }
6123 }
6124
6125 /* Do sanity check on the requested changes for Samba */
6126
6127 if (!check_printer_ok(printer->info_2, snum)) {
6128 result = WERR_INVALID_PARAM;
6129 goto done;
6130 }
6131
6132 /* FIXME!!! If the driver has changed we really should verify that
6133 it is installed before doing much else --jerry */
6134
6135 /* Check calling user has permission to update printer description */
6136
6137 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6138 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6139 result = WERR_ACCESS_DENIED;
6140 goto done;
6141 }
6142
6143 /* Call addprinter hook */
6144 /* Check changes to see if this is really needed */
6145
6146 if ( *lp_addprinter_cmd()
6147 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
6148 || !strequal(printer->info_2->comment, old_printer->info_2->comment)
6149 || !strequal(printer->info_2->portname, old_printer->info_2->portname)
6150 || !strequal(printer->info_2->location, old_printer->info_2->location)) )
6151 {
6152 /* add_printer_hook() will call reload_services() */
6153
6154 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
6155 printer) ) {
6156 result = WERR_ACCESS_DENIED;
6157 goto done;
6158 }
6159 }
6160
6161 /*
6162 * When a *new* driver is bound to a printer, the drivername is used to
6163 * lookup previously saved driver initialization info, which is then
6164 * bound to the printer, simulating what happens in the Windows arch.
6165 */
6166 if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
6167 {
6168 if (!set_driver_init(printer, 2))
6169 {
6170 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
6171 printer->info_2->drivername));
6172 }
6173
6174 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
6175 printer->info_2->drivername));
6176
6177 notify_printer_driver(snum, printer->info_2->drivername);
6178 }
6179
6180 /*
6181 * flag which changes actually occured. This is a small subset of
6182 * all the possible changes. We also have to update things in the
6183 * DsSpooler key.
6184 */
6185
6186 if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
6187 push_reg_sz(talloc_tos(), &buffer, printer->info_2->comment);
6188 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
6189 REG_SZ, buffer.data, buffer.length);
6190
6191 notify_printer_comment(snum, printer->info_2->comment);
6192 }
6193
6194 if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
6195 push_reg_sz(talloc_tos(), &buffer, printer->info_2->sharename);
6196 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
6197 REG_SZ, buffer.data, buffer.length);
6198
6199 notify_printer_sharename(snum, printer->info_2->sharename);
6200 }
6201
6202 if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
6203 char *pname;
6204
6205 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
6206 pname++;
6207 else
6208 pname = printer->info_2->printername;
6209
6210
6211 push_reg_sz(talloc_tos(), &buffer, pname);
6212 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
6213 REG_SZ, buffer.data, buffer.length);
6214
6215 notify_printer_printername( snum, pname );
6216 }
6217
6218 if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
6219 push_reg_sz(talloc_tos(), &buffer, printer->info_2->portname);
6220 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
6221 REG_SZ, buffer.data, buffer.length);
6222
6223 notify_printer_port(snum, printer->info_2->portname);
6224 }
6225
6226 if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
6227 push_reg_sz(talloc_tos(), &buffer, printer->info_2->location);
6228 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
6229 REG_SZ, buffer.data, buffer.length);
6230
6231 notify_printer_location(snum, printer->info_2->location);
6232 }
6233
6234 /* here we need to update some more DsSpooler keys */
6235 /* uNCName, serverName, shortServerName */
6236
6237 push_reg_sz(talloc_tos(), &buffer, global_myname());
6238 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
6239 REG_SZ, buffer.data, buffer.length);
6240 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
6241 REG_SZ, buffer.data, buffer.length);
6242
6243 slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
6244 global_myname(), printer->info_2->sharename );
6245 push_reg_sz(talloc_tos(), &buffer, asc_buffer);
6246 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
6247 REG_SZ, buffer.data, buffer.length);
6248
6249 /* Update printer info */
6250 result = mod_a_printer(printer, 2);
6251
6252 done:
6253 free_a_printer(&printer, 2);
6254 free_a_printer(&old_printer, 2);
6255
6256
6257 return result;
6258 }
6259
6260 /****************************************************************************
6261 ****************************************************************************/
6262 static WERROR publish_or_unpublish_printer(pipes_struct *p,
6263 struct policy_handle *handle,
6264 struct spoolss_SetPrinterInfo7 *info7)
6265 {
6266 #ifdef HAVE_ADS
6267 int snum;
6268 Printer_entry *Printer;
6269
6270 if ( lp_security() != SEC_ADS ) {
6271 return WERR_UNKNOWN_LEVEL;
6272 }
6273
6274 Printer = find_printer_index_by_hnd(p, handle);
6275
6276 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6277
6278 if (!Printer)
6279 return WERR_BADFID;
6280
6281 if (!get_printer_snum(p, handle, &snum, NULL))
6282 return WERR_BADFID;
6283
6284 nt_printer_publish(Printer, snum, info7->action);
6285
6286 return WERR_OK;
6287 #else
6288 return WERR_UNKNOWN_LEVEL;
6289 #endif
6290 }
6291
6292 /****************************************************************
6293 _spoolss_SetPrinter
6294 ****************************************************************/
6295
6296 WERROR _spoolss_SetPrinter(pipes_struct *p,
6297 struct spoolss_SetPrinter *r)
6298 {
6299 WERROR result;
6300
6301 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6302
6303 if (!Printer) {
6304 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6305 OUR_HANDLE(r->in.handle)));
6306 return WERR_BADFID;
6307 }
6308
6309 /* check the level */
6310 switch (r->in.info_ctr->level) {
6311 case 0:
6312 return control_printer(r->in.handle, r->in.command, p);
6313 case 2:
6314 result = update_printer(p, r->in.handle,
6315 r->in.info_ctr,
6316 r->in.devmode_ctr->devmode);
6317 if (!W_ERROR_IS_OK(result))
6318 return result;
6319 if (r->in.secdesc_ctr->sd)
6320 result = update_printer_sec(r->in.handle, p,
6321 r->in.secdesc_ctr);
6322 return result;
6323 case 3:
6324 return update_printer_sec(r->in.handle, p,
6325 r->in.secdesc_ctr);
6326 case 7:
6327 return publish_or_unpublish_printer(p, r->in.handle,
6328 r->in.info_ctr->info.info7);
6329 default:
6330 return WERR_UNKNOWN_LEVEL;
6331 }
6332 }
6333
6334 /****************************************************************
6335 _spoolss_FindClosePrinterNotify
6336 ****************************************************************/
6337
6338 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
6339 struct spoolss_FindClosePrinterNotify *r)
6340 {
6341 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6342
6343 if (!Printer) {
6344 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6345 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6346 return WERR_BADFID;
6347 }
6348
6349 if (Printer->notify.client_connected == true) {
6350 int snum = -1;
6351
6352 if ( Printer->printer_type == SPLHND_SERVER)
6353 snum = -1;
6354 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6355 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6356 return WERR_BADFID;
6357
6358 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6359 }
6360
6361 Printer->notify.flags=0;
6362 Printer->notify.options=0;
6363 Printer->notify.localmachine[0]='\0';
6364 Printer->notify.printerlocal=0;
6365 TALLOC_FREE(Printer->notify.option);
6366 Printer->notify.client_connected = false;
6367
6368 return WERR_OK;
6369 }
6370
6371 /****************************************************************
6372 _spoolss_AddJob
6373 ****************************************************************/
6374
6375 WERROR _spoolss_AddJob(pipes_struct *p,
6376 struct spoolss_AddJob *r)
6377 {
6378 if (!r->in.buffer && (r->in.offered != 0)) {
6379 return WERR_INVALID_PARAM;
6380 }
6381
6382 /* this is what a NT server returns for AddJob. AddJob must fail on
6383 * non-local printers */
6384
6385 if (r->in.level != 1) {
6386 return WERR_UNKNOWN_LEVEL;
6387 }
6388
6389 return WERR_INVALID_PARAM;
6390 }
6391
6392 /****************************************************************************
6393 fill_job_info1
6394 ****************************************************************************/
6395
6396 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6397 struct spoolss_JobInfo1 *r,
6398 const print_queue_struct *queue,
6399 int position, int snum,
6400 const NT_PRINTER_INFO_LEVEL *ntprinter)
6401 {
6402 struct tm *t;
6403
6404 t = gmtime(&queue->time);
6405
6406 r->job_id = queue->job;
6407
6408 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6409 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6410 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6411 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6412 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6413 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6414 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6415 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6416 r->data_type = talloc_strdup(mem_ctx, "RAW");
6417 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6418 r->text_status = talloc_strdup(mem_ctx, "");
6419 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6420
6421 r->status = nt_printj_status(queue->status);
6422 r->priority = queue->priority;
6423 r->position = position;
6424 r->total_pages = queue->page_count;
6425 r->pages_printed = 0; /* ??? */
6426
6427 init_systemtime(&r->submitted, t);
6428
6429 return WERR_OK;
6430 }
6431
6432 /****************************************************************************
6433 fill_job_info2
6434 ****************************************************************************/
6435
6436 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6437 struct spoolss_JobInfo2 *r,
6438 const print_queue_struct *queue,
6439 int position, int snum,
6440 const NT_PRINTER_INFO_LEVEL *ntprinter,
6441 struct spoolss_DeviceMode *devmode)
6442 {
6443 struct tm *t;
6444
6445 t = gmtime(&queue->time);
6446
6447 r->job_id = queue->job;
6448
6449 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6450 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6451 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6452 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6453 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6454 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6455 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6456 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6457 r->notify_name = talloc_strdup(mem_ctx, queue->fs_user);
6458 W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6459 r->data_type = talloc_strdup(mem_ctx, "RAW");
6460 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6461 r->print_processor = talloc_strdup(mem_ctx, "winprint");
6462 W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6463 r->parameters = talloc_strdup(mem_ctx, "");
6464 W_ERROR_HAVE_NO_MEMORY(r->parameters);
6465 r->driver_name = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6466 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6467
6468 r->devmode = devmode;
6469
6470 r->text_status = talloc_strdup(mem_ctx, "");
6471 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6472
6473 r->secdesc = NULL;
6474
6475 r->status = nt_printj_status(queue->status);
6476 r->priority = queue->priority;
6477 r->position = position;
6478 r->start_time = 0;
6479 r->until_time = 0;
6480 r->total_pages = queue->page_count;
6481 r->size = queue->size;
6482 init_systemtime(&r->submitted, t);
6483 r->time = 0;
6484 r->pages_printed = 0; /* ??? */
6485
6486 return WERR_OK;
6487 }
6488
6489 /****************************************************************************
6490 Enumjobs at level 1.
6491 ****************************************************************************/
6492
6493 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6494 const print_queue_struct *queue,
6495 uint32_t num_queues, int snum,
6496 const NT_PRINTER_INFO_LEVEL *ntprinter,
6497 union spoolss_JobInfo **info_p,
6498 uint32_t *count)
6499 {
6500 union spoolss_JobInfo *info;
6501 int i;
6502 WERROR result = WERR_OK;
6503
6504 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6505 W_ERROR_HAVE_NO_MEMORY(info);
6506
6507 *count = num_queues;
6508
6509 for (i=0; i<*count; i++) {
6510 result = fill_job_info1(info,
6511 &info[i].info1,
6512 &queue[i],
6513 i,
6514 snum,
6515 ntprinter);
6516 if (!W_ERROR_IS_OK(result)) {
6517 goto out;
6518 }
6519 }
6520
6521 out:
6522 if (!W_ERROR_IS_OK(result)) {
6523 TALLOC_FREE(info);
6524 *count = 0;
6525 return result;
6526 }
6527
6528 *info_p = info;
6529
6530 return WERR_OK;
6531 }
6532
6533 /****************************************************************************
6534 Enumjobs at level 2.
6535 ****************************************************************************/
6536
6537 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6538 const print_queue_struct *queue,
6539 uint32_t num_queues, int snum,
6540 const NT_PRINTER_INFO_LEVEL *ntprinter,
6541 union spoolss_JobInfo **info_p,
6542 uint32_t *count)
6543 {
6544 union spoolss_JobInfo *info;
6545 int i;
6546 WERROR result = WERR_OK;
6547
6548 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6549 W_ERROR_HAVE_NO_MEMORY(info);
6550
6551 *count = num_queues;
6552
6553 for (i=0; i<*count; i++) {
6554
6555 struct spoolss_DeviceMode *devmode;
6556
6557 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6558 if (!devmode) {
6559 result = WERR_NOMEM;
6560 goto out;
6561 }
6562
6563 result = fill_job_info2(info,
6564 &info[i].info2,
6565 &queue[i],
6566 i,
6567 snum,
6568 ntprinter,
6569 devmode);
6570 if (!W_ERROR_IS_OK(result)) {
6571 goto out;
6572 }
6573 }
6574
6575 out:
6576 if (!W_ERROR_IS_OK(result)) {
6577 TALLOC_FREE(info);
6578 *count = 0;
6579 return result;
6580 }
6581
6582 *info_p = info;
6583
6584 return WERR_OK;
6585 }
6586
6587 /****************************************************************
6588 _spoolss_EnumJobs
6589 ****************************************************************/
6590
6591 WERROR _spoolss_EnumJobs(pipes_struct *p,
6592 struct spoolss_EnumJobs *r)
6593 {
6594 WERROR result;
6595 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6596 int snum;
6597 print_status_struct prt_status;
6598 print_queue_struct *queue = NULL;
6599 uint32_t count;
6600
6601 /* that's an [in out] buffer */
6602
6603 if (!r->in.buffer && (r->in.offered != 0)) {
6604 return WERR_INVALID_PARAM;
6605 }
6606
6607 DEBUG(4,("_spoolss_EnumJobs\n"));
6608
6609 *r->out.needed = 0;
6610 *r->out.count = 0;
6611 *r->out.info = NULL;
6612
6613 /* lookup the printer snum and tdb entry */
6614
6615 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6616 return WERR_BADFID;
6617 }
6618
6619 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6620 if (!W_ERROR_IS_OK(result)) {
6621 return result;
6622 }
6623
6624 count = print_queue_status(snum, &queue, &prt_status);
6625 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6626 count, prt_status.status, prt_status.message));
6627
6628 if (count == 0) {
6629 SAFE_FREE(queue);
6630 free_a_printer(&ntprinter, 2);
6631 return WERR_OK;
6632 }
6633
6634 switch (r->in.level) {
6635 case 1:
6636 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6637 ntprinter, r->out.info, r->out.count);
6638 break;
6639 case 2:
6640 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6641 ntprinter, r->out.info, r->out.count);
6642 break;
6643 default:
6644 result = WERR_UNKNOWN_LEVEL;
6645 break;
6646 }
6647
6648 SAFE_FREE(queue);
6649 free_a_printer(&ntprinter, 2);
6650
6651 if (!W_ERROR_IS_OK(result)) {
6652 return result;
6653 }
6654
6655 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6656 spoolss_EnumJobs, NULL,
6657 *r->out.info, r->in.level,
6658 *r->out.count);
6659 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6660 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6661
6662 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6663 }
6664
6665 /****************************************************************
6666 _spoolss_ScheduleJob
6667 ****************************************************************/
6668
6669 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6670 struct spoolss_ScheduleJob *r)
6671 {
6672 return WERR_OK;
6673 }
6674
6675 /****************************************************************
6676 _spoolss_SetJob
6677 ****************************************************************/
6678
6679 WERROR _spoolss_SetJob(pipes_struct *p,
6680 struct spoolss_SetJob *r)
6681 {
6682 int snum;
6683 WERROR errcode = WERR_BADFUNC;
6684
6685 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6686 return WERR_BADFID;
6687 }
6688
6689 if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6690 return WERR_INVALID_PRINTER_NAME;
6691 }
6692
6693 switch (r->in.command) {
6694 case SPOOLSS_JOB_CONTROL_CANCEL:
6695 case SPOOLSS_JOB_CONTROL_DELETE:
6696 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6697 errcode = WERR_OK;
6698 }
6699 break;
6700 case SPOOLSS_JOB_CONTROL_PAUSE:
6701 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6702 errcode = WERR_OK;
6703 }
6704 break;
6705 case SPOOLSS_JOB_CONTROL_RESTART:
6706 case SPOOLSS_JOB_CONTROL_RESUME:
6707 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6708 errcode = WERR_OK;
6709 }
6710 break;
6711 default:
6712 return WERR_UNKNOWN_LEVEL;
6713 }
6714
6715 return errcode;
6716 }
6717
6718 /****************************************************************************
6719 Enumerates all printer drivers by level and architecture.
6720 ****************************************************************************/
6721
6722 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
6723 const char *servername,
6724 const char *architecture,
6725 uint32_t level,
6726 union spoolss_DriverInfo **info_p,
6727 uint32_t *count_p)
6728 {
6729 int i;
6730 int ndrivers;
6731 uint32_t version;
6732 fstring *list = NULL;
6733 NT_PRINTER_DRIVER_INFO_LEVEL driver;
6734 union spoolss_DriverInfo *info = NULL;
6735 uint32_t count = 0;
6736 WERROR result = WERR_OK;
6737
6738 *count_p = 0;
6739 *info_p = NULL;
6740
6741 for (version=0; version<DRIVER_MAX_VERSION; version++) {
6742 list = NULL;
6743 ndrivers = get_ntdrivers(&list, architecture, version);
6744 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6745 ndrivers, architecture, version));
6746
6747 if (ndrivers == -1) {
6748 result = WERR_NOMEM;
6749 goto out;
6750 }
6751
6752 if (ndrivers != 0) {
6753 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6754 union spoolss_DriverInfo,
6755 count + ndrivers);
6756 if (!info) {
6757 DEBUG(0,("enumprinterdrivers_level1: "
6758 "failed to enlarge driver info buffer!\n"));
6759 result = WERR_NOMEM;
6760 goto out;
6761 }
6762 }
6763
6764 for (i=0; i<ndrivers; i++) {
6765 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6766 ZERO_STRUCT(driver);
6767 result = get_a_printer_driver(&driver, 3, list[i],
6768 architecture, version);
6769 if (!W_ERROR_IS_OK(result)) {
6770 goto out;
6771 }
6772
6773 switch (level) {
6774 case 1:
6775 result = fill_printer_driver_info1(info, &info[count+i].info1,
6776 &driver, servername,
6777 architecture);
6778 break;
6779 case 2:
6780 result = fill_printer_driver_info2(info, &info[count+i].info2,
6781 &driver, servername);
6782 break;
6783 case 3:
6784 result = fill_printer_driver_info3(info, &info[count+i].info3,
6785 &driver, servername);
6786 break;
6787 case 4:
6788 result = fill_printer_driver_info4(info, &info[count+i].info4,
6789 &driver, servername);
6790 break;
6791 case 5:
6792 result = fill_printer_driver_info5(info, &info[count+i].info5,
6793 &driver, servername);
6794 break;
6795 case 6:
6796 result = fill_printer_driver_info6(info, &info[count+i].info6,
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 by level.
6831 ****************************************************************************/
6832
6833 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6834 const char *servername,
6835 const char *architecture,
6836 uint32_t level,
6837 union spoolss_DriverInfo **info_p,
6838 uint32_t *count_p)
6839 {
6840 uint32_t a,i;
6841 WERROR result = WERR_OK;
6842
6843 if (strequal(architecture, "all")) {
6844
6845 for (a=0; archi_table[a].long_archi != NULL; a++) {
6846
6847 union spoolss_DriverInfo *info = NULL;
6848 uint32_t count = 0;
6849
6850 result = enumprinterdrivers_level_by_architecture(mem_ctx,
6851 servername,
6852 archi_table[a].long_archi,
6853 level,
6854 &info,
6855 &count);
6856 if (!W_ERROR_IS_OK(result)) {
6857 continue;
6858 }
6859
6860 for (i=0; i < count; i++) {
6861 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
6862 info[i], info_p, count_p);
6863 }
6864 }
6865
6866 return result;
6867 }
6868
6869 return enumprinterdrivers_level_by_architecture(mem_ctx,
6870 servername,
6871 architecture,
6872 level,
6873 info_p,
6874 count_p);
6875 }
6876
6877 /****************************************************************************
6878 Enumerates all printer drivers at level 1.
6879 ****************************************************************************/
6880
6881 static WERROR enumprinterdrivers_level1(TALLOC_CTX *mem_ctx,
6882 const char *servername,
6883 const char *architecture,
6884 union spoolss_DriverInfo **info_p,
6885 uint32_t *count)
6886 {
6887 return enumprinterdrivers_level(mem_ctx, servername, architecture, 1,
6888 info_p, count);
6889 }
6890
6891 /****************************************************************************
6892 Enumerates all printer drivers at level 2.
6893 ****************************************************************************/
6894
6895 static WERROR enumprinterdrivers_level2(TALLOC_CTX *mem_ctx,
6896 const char *servername,
6897 const char *architecture,
6898 union spoolss_DriverInfo **info_p,
6899 uint32_t *count)
6900 {
6901 return enumprinterdrivers_level(mem_ctx, servername, architecture, 2,
6902 info_p, count);
6903 }
6904
6905 /****************************************************************************
6906 Enumerates all printer drivers at level 3.
6907 ****************************************************************************/
6908
6909 static WERROR enumprinterdrivers_level3(TALLOC_CTX *mem_ctx,
6910 const char *servername,
6911 const char *architecture,
6912 union spoolss_DriverInfo **info_p,
6913 uint32_t *count)
6914 {
6915 return enumprinterdrivers_level(mem_ctx, servername, architecture, 3,
6916 info_p, count);
6917 }
6918
6919 /****************************************************************************
6920 Enumerates all printer drivers at level 4.
6921 ****************************************************************************/
6922
6923 static WERROR enumprinterdrivers_level4(TALLOC_CTX *mem_ctx,
6924 const char *servername,
6925 const char *architecture,
6926 union spoolss_DriverInfo **info_p,
6927 uint32_t *count)
6928 {
6929 return enumprinterdrivers_level(mem_ctx, servername, architecture, 4,
6930 info_p, count);
6931 }
6932
6933 /****************************************************************************
6934 Enumerates all printer drivers at level 5.
6935 ****************************************************************************/
6936
6937 static WERROR enumprinterdrivers_level5(TALLOC_CTX *mem_ctx,
6938 const char *servername,
6939 const char *architecture,
6940 union spoolss_DriverInfo **info_p,
6941 uint32_t *count)
6942 {
6943 return enumprinterdrivers_level(mem_ctx, servername, architecture, 5,
6944 info_p, count);
6945 }
6946
6947 /****************************************************************************
6948 Enumerates all printer drivers at level 6.
6949 ****************************************************************************/
6950
6951 static WERROR enumprinterdrivers_level6(TALLOC_CTX *mem_ctx,
6952 const char *servername,
6953 const char *architecture,
6954 union spoolss_DriverInfo **info_p,
6955 uint32_t *count)
6956 {
6957 return enumprinterdrivers_level(mem_ctx, servername, architecture, 6,
6958 info_p, count);
6959 }
6960
6961
6962 /****************************************************************
6963 _spoolss_EnumPrinterDrivers
6964 ****************************************************************/
6965
6966 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6967 struct spoolss_EnumPrinterDrivers *r)
6968 {
6969 const char *cservername;
6970 WERROR result;
6971
6972 /* that's an [in out] buffer */
6973
6974 if (!r->in.buffer && (r->in.offered != 0)) {
6975 return WERR_INVALID_PARAM;
6976 }
6977
6978 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6979
6980 *r->out.needed = 0;
6981 *r->out.count = 0;
6982 *r->out.info = NULL;
6983
6984 cservername = canon_servername(r->in.server);
6985
6986 if (!is_myname_or_ipaddr(cservername)) {
6987 return WERR_UNKNOWN_PRINTER_DRIVER;
6988 }
6989
6990 switch (r->in.level) {
6991 case 1:
6992 result = enumprinterdrivers_level1(p->mem_ctx, cservername,
6993 r->in.environment,
6994 r->out.info, r->out.count);
6995 break;
6996 case 2:
6997 result = enumprinterdrivers_level2(p->mem_ctx, cservername,
6998 r->in.environment,
6999 r->out.info, r->out.count);
7000 break;
7001 case 3:
7002 result = enumprinterdrivers_level3(p->mem_ctx, cservername,
7003 r->in.environment,
7004 r->out.info, r->out.count);
7005 break;
7006 case 4:
7007 result = enumprinterdrivers_level4(p->mem_ctx, cservername,
7008 r->in.environment,
7009 r->out.info, r->out.count);
7010 break;
7011 case 5:
7012 result = enumprinterdrivers_level5(p->mem_ctx, cservername,
7013 r->in.environment,
7014 r->out.info, r->out.count);
7015 break;
7016 case 6:
7017 result = enumprinterdrivers_level6(p->mem_ctx, cservername,
7018 r->in.environment,
7019 r->out.info, r->out.count);
7020 break;
7021 default:
7022 return WERR_UNKNOWN_LEVEL;
7023 }
7024
7025 if (!W_ERROR_IS_OK(result)) {
7026 return result;
7027 }
7028
7029 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7030 spoolss_EnumPrinterDrivers, NULL,
7031 *r->out.info, r->in.level,
7032 *r->out.count);
7033 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7034 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7035
7036 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7037 }
7038
7039 /****************************************************************************
7040 ****************************************************************************/
7041
7042 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
7043 struct spoolss_FormInfo1 *r,
7044 const nt_forms_struct *form)
7045 {
7046 r->form_name = talloc_strdup(mem_ctx, form->name);
7047 W_ERROR_HAVE_NO_MEMORY(r->form_name);
7048
7049 r->flags = form->flag;
7050 r->size.width = form->width;
7051 r->size.height = form->length;
7052 r->area.left = form->left;
7053 r->area.top = form->top;
7054 r->area.right = form->right;
7055 r->area.bottom = form->bottom;
7056
7057 return WERR_OK;
7058 }
7059
7060 /****************************************************************
7061 spoolss_enumforms_level1
7062 ****************************************************************/
7063
7064 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
7065 const nt_forms_struct *builtin_forms,
7066 uint32_t num_builtin_forms,
7067 const nt_forms_struct *user_forms,
7068 uint32_t num_user_forms,
7069 union spoolss_FormInfo **info_p,
7070 uint32_t *count)
7071 {
7072 union spoolss_FormInfo *info;
7073 WERROR result = WERR_OK;
7074 int i;
7075
7076 *count = num_builtin_forms + num_user_forms;
7077
7078 info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
7079 W_ERROR_HAVE_NO_MEMORY(info);
7080
7081 /* construct the list of form structures */
7082 for (i=0; i<num_builtin_forms; i++) {
7083 DEBUGADD(6,("Filling builtin form number [%d]\n",i));
7084 result = fill_form_info_1(info, &info[i].info1,
7085 &builtin_forms[i]);
7086 if (!W_ERROR_IS_OK(result)) {
7087 goto out;
7088 }
7089 }
7090
7091 for (i=0; i<num_user_forms; i++) {
7092 DEBUGADD(6,("Filling user form number [%d]\n",i));
7093 result = fill_form_info_1(info, &info[i+num_builtin_forms].info1,
7094 &user_forms[i]);
7095 if (!W_ERROR_IS_OK(result)) {
7096 goto out;
7097 }
7098 }
7099
7100 out:
7101 if (!W_ERROR_IS_OK(result)) {
7102 TALLOC_FREE(info);
7103 *count = 0;
7104 return result;
7105 }
7106
7107 *info_p = info;
7108
7109 return WERR_OK;
7110 }
7111
7112 /****************************************************************
7113 _spoolss_EnumForms
7114 ****************************************************************/
7115
7116 WERROR _spoolss_EnumForms(pipes_struct *p,
7117 struct spoolss_EnumForms *r)
7118 {
7119 WERROR result;
7120 nt_forms_struct *user_forms = NULL;
7121 nt_forms_struct *builtin_forms = NULL;
7122 uint32_t num_user_forms;
7123 uint32_t num_builtin_forms;
7124
7125 *r->out.count = 0;
7126 *r->out.needed = 0;
7127 *r->out.info = NULL;
7128
7129 /* that's an [in out] buffer */
7130
7131 if (!r->in.buffer && (r->in.offered != 0) ) {
7132 return WERR_INVALID_PARAM;
7133 }
7134
7135 DEBUG(4,("_spoolss_EnumForms\n"));
7136 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7137 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7138
7139 num_builtin_forms = get_builtin_ntforms(&builtin_forms);
7140 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
7141 num_user_forms = get_ntforms(&user_forms);
7142 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
7143
7144 if (num_user_forms + num_builtin_forms == 0) {
7145 SAFE_FREE(builtin_forms);
7146 SAFE_FREE(user_forms);
7147 return WERR_NO_MORE_ITEMS;
7148 }
7149
7150 switch (r->in.level) {
7151 case 1:
7152 result = spoolss_enumforms_level1(p->mem_ctx,
7153 builtin_forms,
7154 num_builtin_forms,
7155 user_forms,
7156 num_user_forms,
7157 r->out.info,
7158 r->out.count);
7159 break;
7160 default:
7161 result = WERR_UNKNOWN_LEVEL;
7162 break;
7163 }
7164
7165 SAFE_FREE(user_forms);
7166 SAFE_FREE(builtin_forms);
7167
7168 if (!W_ERROR_IS_OK(result)) {
7169 return result;
7170 }
7171
7172 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7173 spoolss_EnumForms, NULL,
7174 *r->out.info, r->in.level,
7175 *r->out.count);
7176 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7177 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7178
7179 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7180 }
7181
7182 /****************************************************************
7183 ****************************************************************/
7184
7185 static WERROR find_form_byname(const char *name,
7186 nt_forms_struct *form)
7187 {
7188 nt_forms_struct *list = NULL;
7189 int num_forms = 0, i = 0;
7190
7191 if (get_a_builtin_ntform_by_string(name, form)) {
7192 return WERR_OK;
7193 }
7194
7195 num_forms = get_ntforms(&list);
7196 DEBUGADD(5,("Number of forms [%d]\n", num_forms));
7197
7198 if (num_forms == 0) {
7199 return WERR_BADFID;
7200 }
7201
7202 /* Check if the requested name is in the list of form structures */
7203 for (i = 0; i < num_forms; i++) {
7204
7205 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
7206
7207 if (strequal(name, list[i].name)) {
7208 DEBUGADD(6,("Found form %s number [%d]\n", name, i));
7209 *form = list[i];
7210 SAFE_FREE(list);
7211 return WERR_OK;
7212 }
7213 }
7214
7215 SAFE_FREE(list);
7216
7217 return WERR_BADFID;
7218 }
7219
7220 /****************************************************************
7221 _spoolss_GetForm
7222 ****************************************************************/
7223
7224 WERROR _spoolss_GetForm(pipes_struct *p,
7225 struct spoolss_GetForm *r)
7226 {
7227 WERROR result;
7228 nt_forms_struct form;
7229
7230 /* that's an [in out] buffer */
7231
7232 if (!r->in.buffer && (r->in.offered != 0)) {
7233 return WERR_INVALID_PARAM;
7234 }
7235
7236 DEBUG(4,("_spoolss_GetForm\n"));
7237 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7238 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7239
7240 result = find_form_byname(r->in.form_name, &form);
7241 if (!W_ERROR_IS_OK(result)) {
7242 TALLOC_FREE(r->out.info);
7243 return result;
7244 }
7245
7246 switch (r->in.level) {
7247 case 1:
7248 result = fill_form_info_1(p->mem_ctx,
7249 &r->out.info->info1,
7250 &form);
7251 break;
7252
7253 default:
7254 result = WERR_UNKNOWN_LEVEL;
7255 break;
7256 }
7257
7258 if (!W_ERROR_IS_OK(result)) {
7259 TALLOC_FREE(r->out.info);
7260 return result;
7261 }
7262
7263 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
7264 r->out.info, r->in.level);
7265 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7266
7267 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7268 }
7269
7270 /****************************************************************************
7271 ****************************************************************************/
7272
7273 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7274 struct spoolss_PortInfo1 *r,
7275 const char *name)
7276 {
7277 r->port_name = talloc_strdup(mem_ctx, name);
7278 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7279
7280 return WERR_OK;
7281 }
7282
7283 /****************************************************************************
7284 TODO: This probably needs distinguish between TCP/IP and Local ports
7285 somehow.
7286 ****************************************************************************/
7287
7288 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7289 struct spoolss_PortInfo2 *r,
7290 const char *name)
7291 {
7292 r->port_name = talloc_strdup(mem_ctx, name);
7293 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7294
7295 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7296 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7297
7298 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7299 W_ERROR_HAVE_NO_MEMORY(r->description);
7300
7301 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7302 r->reserved = 0;
7303
7304 return WERR_OK;
7305 }
7306
7307
7308 /****************************************************************************
7309 wrapper around the enumer ports command
7310 ****************************************************************************/
7311
7312 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7313 {
7314 char *cmd = lp_enumports_cmd();
7315 char **qlines = NULL;
7316 char *command = NULL;
7317 int numlines;
7318 int ret;
7319 int fd;
7320
7321 *count = 0;
7322 *lines = NULL;
7323
7324 /* if no hook then just fill in the default port */
7325
7326 if ( !*cmd ) {
7327 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7328 return WERR_NOMEM;
7329 }
7330 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7331 TALLOC_FREE(qlines);
7332 return WERR_NOMEM;
7333 }
7334 qlines[1] = NULL;
7335 numlines = 1;
7336 }
7337 else {
7338 /* we have a valid enumport command */
7339
7340 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7341 if (!command) {
7342 return WERR_NOMEM;
7343 }
7344
7345 DEBUG(10,("Running [%s]\n", command));
7346 ret = smbrun(command, &fd);
7347 DEBUG(10,("Returned [%d]\n", ret));
7348 TALLOC_FREE(command);
7349 if (ret != 0) {
7350 if (fd != -1) {
7351 close(fd);
7352 }
7353 return WERR_ACCESS_DENIED;
7354 }
7355
7356 numlines = 0;
7357 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7358 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7359 close(fd);
7360 }
7361
7362 *count = numlines;
7363 *lines = qlines;
7364
7365 return WERR_OK;
7366 }
7367
7368 /****************************************************************************
7369 enumports level 1.
7370 ****************************************************************************/
7371
7372 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7373 union spoolss_PortInfo **info_p,
7374 uint32_t *count)
7375 {
7376 union spoolss_PortInfo *info = NULL;
7377 int i=0;
7378 WERROR result = WERR_OK;
7379 char **qlines = NULL;
7380 int numlines = 0;
7381
7382 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7383 if (!W_ERROR_IS_OK(result)) {
7384 goto out;
7385 }
7386
7387 if (numlines) {
7388 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7389 if (!info) {
7390 DEBUG(10,("Returning WERR_NOMEM\n"));
7391 result = WERR_NOMEM;
7392 goto out;
7393 }
7394
7395 for (i=0; i<numlines; i++) {
7396 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7397 result = fill_port_1(info, &info[i].info1, qlines[i]);
7398 if (!W_ERROR_IS_OK(result)) {
7399 goto out;
7400 }
7401 }
7402 }
7403 TALLOC_FREE(qlines);
7404
7405 out:
7406 if (!W_ERROR_IS_OK(result)) {
7407 TALLOC_FREE(info);
7408 TALLOC_FREE(qlines);
7409 *count = 0;
7410 *info_p = NULL;
7411 return result;
7412 }
7413
7414 *info_p = info;
7415 *count = numlines;
7416
7417 return WERR_OK;
7418 }
7419
7420 /****************************************************************************
7421 enumports level 2.
7422 ****************************************************************************/
7423
7424 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7425 union spoolss_PortInfo **info_p,
7426 uint32_t *count)
7427 {
7428 union spoolss_PortInfo *info = NULL;
7429 int i=0;
7430 WERROR result = WERR_OK;
7431 char **qlines = NULL;
7432 int numlines = 0;
7433
7434 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7435 if (!W_ERROR_IS_OK(result)) {
7436 goto out;
7437 }
7438
7439 if (numlines) {
7440 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7441 if (!info) {
7442 DEBUG(10,("Returning WERR_NOMEM\n"));
7443 result = WERR_NOMEM;
7444 goto out;
7445 }
7446
7447 for (i=0; i<numlines; i++) {
7448 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7449 result = fill_port_2(info, &info[i].info2, qlines[i]);
7450 if (!W_ERROR_IS_OK(result)) {
7451 goto out;
7452 }
7453 }
7454 }
7455 TALLOC_FREE(qlines);
7456
7457 out:
7458 if (!W_ERROR_IS_OK(result)) {
7459 TALLOC_FREE(info);
7460 TALLOC_FREE(qlines);
7461 *count = 0;
7462 *info_p = NULL;
7463 return result;
7464 }
7465
7466 *info_p = info;
7467 *count = numlines;
7468
7469 return WERR_OK;
7470 }
7471
7472 /****************************************************************
7473 _spoolss_EnumPorts
7474 ****************************************************************/
7475
7476 WERROR _spoolss_EnumPorts(pipes_struct *p,
7477 struct spoolss_EnumPorts *r)
7478 {
7479 WERROR result;
7480
7481 /* that's an [in out] buffer */
7482
7483 if (!r->in.buffer && (r->in.offered != 0)) {
7484 return WERR_INVALID_PARAM;
7485 }
7486
7487 DEBUG(4,("_spoolss_EnumPorts\n"));
7488
7489 *r->out.count = 0;
7490 *r->out.needed = 0;
7491 *r->out.info = NULL;
7492
7493 switch (r->in.level) {
7494 case 1:
7495 result = enumports_level_1(p->mem_ctx, r->out.info,
7496 r->out.count);
7497 break;
7498 case 2:
7499 result = enumports_level_2(p->mem_ctx, r->out.info,
7500 r->out.count);
7501 break;
7502 default:
7503 return WERR_UNKNOWN_LEVEL;
7504 }
7505
7506 if (!W_ERROR_IS_OK(result)) {
7507 return result;
7508 }
7509
7510 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7511 spoolss_EnumPorts, NULL,
7512 *r->out.info, r->in.level,
7513 *r->out.count);
7514 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7515 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7516
7517 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7518 }
7519
7520 /****************************************************************************
7521 ****************************************************************************/
7522
7523 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7524 const char *server,
7525 struct spoolss_SetPrinterInfoCtr *info_ctr,
7526 struct spoolss_DeviceMode *devmode,
7527 struct security_descriptor *sec_desc,
7528 struct spoolss_UserLevelCtr *user_ctr,
7529 struct policy_handle *handle)
7530 {
7531 NT_PRINTER_INFO_LEVEL *printer = NULL;
7532 fstring name;
7533 int snum;
7534 WERROR err = WERR_OK;
7535
7536 if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7537 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7538 return WERR_NOMEM;
7539 }
7540
7541 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7542 if (!convert_printer_info(info_ctr, printer)) {
7543 free_a_printer(&printer, 2);
7544 return WERR_NOMEM;
7545 }
7546
7547 /* check to see if the printer already exists */
7548
7549 if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7550 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7551 printer->info_2->sharename));
7552 free_a_printer(&printer, 2);
7553 return WERR_PRINTER_ALREADY_EXISTS;
7554 }
7555
7556 /* FIXME!!! smbd should check to see if the driver is installed before
7557 trying to add a printer like this --jerry */
7558
7559 if (*lp_addprinter_cmd() ) {
7560 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7561 printer) ) {
7562 free_a_printer(&printer,2);
7563 return WERR_ACCESS_DENIED;
7564 }
7565 } else {
7566 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7567 "smb.conf parameter \"addprinter command\" is defined. This"
7568 "parameter must exist for this call to succeed\n",
7569 printer->info_2->sharename ));
7570 }
7571
7572 /* use our primary netbios name since get_a_printer() will convert
7573 it to what the client expects on a case by case basis */
7574
7575 slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7576 printer->info_2->sharename);
7577
7578
7579 if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7580 free_a_printer(&printer,2);
7581 return WERR_ACCESS_DENIED;
7582 }
7583
7584 /* you must be a printer admin to add a new printer */
7585 if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
7586 free_a_printer(&printer,2);
7587 return WERR_ACCESS_DENIED;
7588 }
7589
7590 /*
7591 * Do sanity check on the requested changes for Samba.
7592 */
7593
7594 if (!check_printer_ok(printer->info_2, snum)) {
7595 free_a_printer(&printer,2);
7596 return WERR_INVALID_PARAM;
7597 }
7598
7599 /*
7600 * When a printer is created, the drivername bound to the printer is used
7601 * to lookup previously saved driver initialization info, which is then
7602 * bound to the new printer, simulating what happens in the Windows arch.
7603 */
7604
7605 if (!devmode)
7606 {
7607 set_driver_init(printer, 2);
7608 }
7609 else
7610 {
7611 /* A valid devmode was included, convert and link it
7612 */
7613 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7614
7615 if (!convert_devicemode(printer->info_2->printername, devmode,
7616 &printer->info_2->devmode)) {
7617 return WERR_NOMEM;
7618 }
7619 }
7620
7621 /* write the ASCII on disk */
7622 err = mod_a_printer(printer, 2);
7623 if (!W_ERROR_IS_OK(err)) {
7624 free_a_printer(&printer,2);
7625 return err;
7626 }
7627
7628 if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7629 /* Handle open failed - remove addition. */
7630 del_a_printer(printer->info_2->sharename);
7631 free_a_printer(&printer,2);
7632 ZERO_STRUCTP(handle);
7633 return WERR_ACCESS_DENIED;
7634 }
7635
7636 update_c_setprinter(false);
7637 free_a_printer(&printer,2);
7638
7639 return WERR_OK;
7640 }
7641
7642 /****************************************************************
7643 _spoolss_AddPrinterEx
7644 ****************************************************************/
7645
7646 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7647 struct spoolss_AddPrinterEx *r)
7648 {
7649 switch (r->in.info_ctr->level) {
7650 case 1:
7651 /* we don't handle yet */
7652 /* but I know what to do ... */
7653 return WERR_UNKNOWN_LEVEL;
7654 case 2:
7655 return spoolss_addprinterex_level_2(p, r->in.server,
7656 r->in.info_ctr,
7657 r->in.devmode_ctr->devmode,
7658 r->in.secdesc_ctr->sd,
7659 r->in.userlevel_ctr,
7660 r->out.handle);
7661 default:
7662 return WERR_UNKNOWN_LEVEL;
7663 }
7664 }
7665
7666 /****************************************************************
7667 _spoolss_AddPrinter
7668 ****************************************************************/
7669
7670 WERROR _spoolss_AddPrinter(pipes_struct *p,
7671 struct spoolss_AddPrinter *r)
7672 {
7673 struct spoolss_AddPrinterEx a;
7674 struct spoolss_UserLevelCtr userlevel_ctr;
7675
7676 ZERO_STRUCT(userlevel_ctr);
7677
7678 userlevel_ctr.level = 1;
7679
7680 a.in.server = r->in.server;
7681 a.in.info_ctr = r->in.info_ctr;
7682 a.in.devmode_ctr = r->in.devmode_ctr;
7683 a.in.secdesc_ctr = r->in.secdesc_ctr;
7684 a.in.userlevel_ctr = &userlevel_ctr;
7685 a.out.handle = r->out.handle;
7686
7687 return _spoolss_AddPrinterEx(p, &a);
7688 }
7689
7690 /****************************************************************
7691 _spoolss_AddPrinterDriver
7692 ****************************************************************/
7693
7694 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7695 struct spoolss_AddPrinterDriver *r)
7696 {
7697 uint32_t level = r->in.info_ctr->level;
7698 struct spoolss_AddDriverInfoCtr *info = r->in.info_ctr;
7699 WERROR err = WERR_OK;
7700 NT_PRINTER_DRIVER_INFO_LEVEL driver;
7701 const char *driver_name = NULL;
7702 uint32_t version;
7703 const char *fn;
7704
7705 switch (p->hdr_req.opnum) {
7706 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7707 fn = "_spoolss_AddPrinterDriver";
7708 break;
7709 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7710 fn = "_spoolss_AddPrinterDriverEx";
7711 break;
7712 default:
7713 return WERR_INVALID_PARAM;
7714 }
7715
7716
7717 /* FIXME */
7718 if (level != 3 && level != 6) {
7719 /* Clever hack from Martin Zielinski <mz@seh.de>
7720 * to allow downgrade from level 8 (Vista).
7721 */
7722 DEBUG(0,("%s: level %d not yet implemented\n", fn, level));
7723 return WERR_UNKNOWN_LEVEL;
7724 }
7725
7726 ZERO_STRUCT(driver);
7727
7728 if (!convert_printer_driver_info(info, &driver, level)) {
7729 err = WERR_NOMEM;
7730 goto done;
7731 }
7732
7733 DEBUG(5,("Cleaning driver's information\n"));
7734 err = clean_up_driver_struct(p, driver, level);
7735 if (!W_ERROR_IS_OK(err))
7736 goto done;
7737
7738 DEBUG(5,("Moving driver to final destination\n"));
7739 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, driver, level,
7740 &err)) ) {
7741 goto done;
7742 }
7743
7744 if (add_a_printer_driver(driver, level)!=0) {
7745 err = WERR_ACCESS_DENIED;
7746 goto done;
7747 }
7748
7749 switch(level) {
7750 case 3:
7751 driver_name = driver.info_3->name ? driver.info_3->name : "";
7752 break;
7753 case 6:
7754 driver_name = driver.info_6->name ? driver.info_6->name : "";
7755 break;
7756 }
7757
7758 /*
7759 * I think this is where he DrvUpgradePrinter() hook would be
7760 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7761 * server. Right now, we just need to send ourselves a message
7762 * to update each printer bound to this driver. --jerry
7763 */
7764
7765 if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7766 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7767 fn, driver_name));
7768 }
7769
7770 /*
7771 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7772 * decide if the driver init data should be deleted. The rules are:
7773 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7774 * 2) delete init data only if there is no 2k/Xp driver
7775 * 3) always delete init data
7776 * The generalized rule is always use init data from the highest order driver.
7777 * It is necessary to follow the driver install by an initialization step to
7778 * finish off this process.
7779 */
7780 if (level == 3)
7781 version = driver.info_3->cversion;
7782 else if (level == 6)
7783 version = driver.info_6->version;
7784 else
7785 version = -1;
7786 switch (version) {
7787 /*
7788 * 9x printer driver - never delete init data
7789 */
7790 case 0:
7791 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7792 fn, driver_name));
7793 break;
7794
7795 /*
7796 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7797 * there is no 2k/Xp driver init data for this driver name.
7798 */
7799 case 2:
7800 {
7801 NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7802
7803 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7804 /*
7805 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7806 */
7807 if (!del_driver_init(driver_name))
7808 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7809 fn, driver_name));
7810 } else {
7811 /*
7812 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7813 */
7814 free_a_printer_driver(driver1,3);
7815 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7816 fn, driver_name));
7817 }
7818 }
7819 break;
7820
7821 /*
7822 * 2k or Xp printer driver - always delete init data
7823 */
7824 case 3:
7825 if (!del_driver_init(driver_name))
7826 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7827 fn, driver_name));
7828 break;
7829
7830 default:
7831 DEBUG(0,("%s: invalid level=%d\n", fn, level));
7832 break;
7833 }
7834
7835
7836 done:
7837 free_a_printer_driver(driver, level);
7838 return err;
7839 }
7840
7841 /****************************************************************
7842 _spoolss_AddPrinterDriverEx
7843 ****************************************************************/
7844
7845 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7846 struct spoolss_AddPrinterDriverEx *r)
7847 {
7848 struct spoolss_AddPrinterDriver a;
7849
7850 /*
7851 * we only support the semantics of AddPrinterDriver()
7852 * i.e. only copy files that are newer than existing ones
7853 */
7854
7855 if (r->in.flags != APD_COPY_NEW_FILES) {
7856 return WERR_ACCESS_DENIED;
7857 }
7858
7859 a.in.servername = r->in.servername;
7860 a.in.info_ctr = r->in.info_ctr;
7861
7862 return _spoolss_AddPrinterDriver(p, &a);
7863 }
7864
7865 /****************************************************************************
7866 ****************************************************************************/
7867
7868 struct _spoolss_paths {
7869 int type;
7870 const char *share;
7871 const char *dir;
7872 };
7873
7874 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7875
7876 static const struct _spoolss_paths spoolss_paths[]= {
7877 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
7878 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
7879 };
7880
7881 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7882 const char *servername,
7883 const char *environment,
7884 int component,
7885 char **path)
7886 {
7887 const char *pservername = NULL;
7888 const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7889 const char *short_archi;
7890
7891 *path = NULL;
7892
7893 /* environment may be empty */
7894 if (environment && strlen(environment)) {
7895 long_archi = environment;
7896 }
7897
7898 /* servername may be empty */
7899 if (servername && strlen(servername)) {
7900 pservername = canon_servername(servername);
7901
7902 if (!is_myname_or_ipaddr(pservername)) {
7903 return WERR_INVALID_PARAM;
7904 }
7905 }
7906
7907 if (!(short_archi = get_short_archi(long_archi))) {
7908 return WERR_INVALID_ENVIRONMENT;
7909 }
7910
7911 switch (component) {
7912 case SPOOLSS_PRTPROCS_PATH:
7913 case SPOOLSS_DRIVER_PATH:
7914 if (pservername) {
7915 *path = talloc_asprintf(mem_ctx,
7916 "\\\\%s\\%s\\%s",
7917 pservername,
7918 spoolss_paths[component].share,
7919 short_archi);
7920 } else {
7921 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7922 SPOOLSS_DEFAULT_SERVER_PATH,
7923 spoolss_paths[component].dir,
7924 short_archi);
7925 }
7926 break;
7927 default:
7928 return WERR_INVALID_PARAM;
7929 }
7930
7931 if (!*path) {
7932 return WERR_NOMEM;
7933 }
7934
7935 return WERR_OK;
7936 }
7937
7938 /****************************************************************************
7939 ****************************************************************************/
7940
7941 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7942 const char *servername,
7943 const char *environment,
7944 struct spoolss_DriverDirectoryInfo1 *r)
7945 {
7946 WERROR werr;
7947 char *path = NULL;
7948
7949 werr = compose_spoolss_server_path(mem_ctx,
7950 servername,
7951 environment,
7952 SPOOLSS_DRIVER_PATH,
7953 &path);
7954 if (!W_ERROR_IS_OK(werr)) {
7955 return werr;
7956 }
7957
7958 DEBUG(4,("printer driver directory: [%s]\n", path));
7959
7960 r->directory_name = path;
7961
7962 return WERR_OK;
7963 }
7964
7965 /****************************************************************
7966 _spoolss_GetPrinterDriverDirectory
7967 ****************************************************************/
7968
7969 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7970 struct spoolss_GetPrinterDriverDirectory *r)
7971 {
7972 WERROR werror;
7973
7974 /* that's an [in out] buffer */
7975
7976 if (!r->in.buffer && (r->in.offered != 0)) {
7977 return WERR_INVALID_PARAM;
7978 }
7979
7980 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7981 r->in.level));
7982
7983 *r->out.needed = 0;
7984
7985 /* r->in.level is ignored */
7986
7987 werror = getprinterdriverdir_level_1(p->mem_ctx,
7988 r->in.server,
7989 r->in.environment,
7990 &r->out.info->info1);
7991 if (!W_ERROR_IS_OK(werror)) {
7992 TALLOC_FREE(r->out.info);
7993 return werror;
7994 }
7995
7996 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
7997 r->out.info, r->in.level);
7998 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7999
8000 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8001 }
8002
8003 /****************************************************************
8004 _spoolss_EnumPrinterData
8005 ****************************************************************/
8006
8007 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
8008 struct spoolss_EnumPrinterData *r)
8009 {
8010 NT_PRINTER_INFO_LEVEL *printer = NULL;
8011 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8012 int snum;
8013 WERROR result;
8014 struct regval_blob *val = NULL;
8015 NT_PRINTER_DATA *p_data;
8016 int i, key_index, num_values;
8017 int name_length;
8018
8019 *r->out.value_needed = 0;
8020 *r->out.type = REG_NONE;
8021 *r->out.data_needed = 0;
8022
8023 DEBUG(5,("_spoolss_EnumPrinterData\n"));
8024
8025 if (!Printer) {
8026 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
8027 OUR_HANDLE(r->in.handle)));
8028 return WERR_BADFID;
8029 }
8030
8031 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8032 return WERR_BADFID;
8033 }
8034
8035 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8036 if (!W_ERROR_IS_OK(result)) {
8037 return result;
8038 }
8039
8040 p_data = printer->info_2->data;
8041 key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
8042
8043 result = WERR_OK;
8044
8045 /*
8046 * The NT machine wants to know the biggest size of value and data
8047 *
8048 * cf: MSDN EnumPrinterData remark section
8049 */
8050
8051 if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
8052
8053 uint32_t biggest_valuesize = 0;
8054 uint32_t biggest_datasize = 0;
8055
8056 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8057
8058 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
8059
8060 for ( i=0; i<num_values; i++ )
8061 {
8062 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
8063
8064 name_length = strlen(val->valuename);
8065 if ( strlen(val->valuename) > biggest_valuesize )
8066 biggest_valuesize = name_length;
8067
8068 if ( val->size > biggest_datasize )
8069 biggest_datasize = val->size;
8070
8071 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8072 biggest_datasize));
8073 }
8074
8075 /* the value is an UNICODE string but real_value_size is the length
8076 in bytes including the trailing 0 */
8077
8078 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8079 *r->out.data_needed = biggest_datasize;
8080
8081 DEBUG(6,("final values: [%d], [%d]\n",
8082 *r->out.value_needed, *r->out.data_needed));
8083
8084 goto done;
8085 }
8086
8087 /*
8088 * the value len is wrong in NT sp3
8089 * that's the number of bytes not the number of unicode chars
8090 */
8091
8092 if (key_index != -1) {
8093 val = regval_ctr_specific_value(p_data->keys[key_index].values,
8094 r->in.enum_index);
8095 }
8096
8097 if (!val) {
8098
8099 /* out_value should default to "" or else NT4 has
8100 problems unmarshalling the response */
8101
8102 if (r->in.value_offered) {
8103 *r->out.value_needed = 1;
8104 r->out.value_name = talloc_strdup(r, "");
8105 if (!r->out.value_name) {
8106 result = WERR_NOMEM;
8107 goto done;
8108 }
8109 } else {
8110 r->out.value_name = NULL;
8111 *r->out.value_needed = 0;
8112 }
8113
8114 /* the data is counted in bytes */
8115
8116 *r->out.data_needed = r->in.data_offered;
8117
8118 result = WERR_NO_MORE_ITEMS;
8119 } else {
8120 /*
8121 * the value is:
8122 * - counted in bytes in the request
8123 * - counted in UNICODE chars in the max reply
8124 * - counted in bytes in the real size
8125 *
8126 * take a pause *before* coding not *during* coding
8127 */
8128
8129 /* name */
8130 if (r->in.value_offered) {
8131 r->out.value_name = talloc_strdup(r, regval_name(val));
8132 if (!r->out.value_name) {
8133 result = WERR_NOMEM;
8134 goto done;
8135 }
8136 *r->out.value_needed = strlen_m(regval_name(val));
8137 } else {
8138 r->out.value_name = NULL;
8139 *r->out.value_needed = 0;
8140 }
8141
8142 /* type */
8143
8144 *r->out.type = regval_type(val);
8145
8146 /* data - counted in bytes */
8147
8148 if (r->out.data && regval_size(val)) {
8149 memcpy(r->out.data, regval_data_p(val), regval_size(val));
8150 }
8151
8152 *r->out.data_needed = regval_size(val);
8153 }
8154
8155 done:
8156 free_a_printer(&printer, 2);
8157 return result;
8158 }
8159
8160 /****************************************************************
8161 _spoolss_SetPrinterData
8162 ****************************************************************/
8163
8164 WERROR _spoolss_SetPrinterData(pipes_struct *p,
8165 struct spoolss_SetPrinterData *r)
8166 {
8167 NT_PRINTER_INFO_LEVEL *printer = NULL;
8168 int snum=0;
8169 WERROR result = WERR_OK;
8170 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8171 DATA_BLOB blob;
8172
8173 DEBUG(5,("_spoolss_SetPrinterData\n"));
8174
8175 if (!Printer) {
8176 DEBUG(2,("_spoolss_SetPrinterData: Invalid handle (%s:%u:%u).\n",
8177 OUR_HANDLE(r->in.handle)));
8178 return WERR_BADFID;
8179 }
8180
8181 if (Printer->printer_type == SPLHND_SERVER) {
8182 DEBUG(10,("_spoolss_SetPrinterData: "
8183 "Not implemented for server handles yet\n"));
8184 return WERR_INVALID_PARAM;
8185 }
8186
8187 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8188 return WERR_BADFID;
8189 }
8190
8191 /*
8192 * Access check : NT returns "access denied" if you make a
8193 * SetPrinterData call without the necessary privildge.
8194 * we were originally returning OK if nothing changed
8195 * which made Win2k issue **a lot** of SetPrinterData
8196 * when connecting to a printer --jerry
8197 */
8198
8199 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8200 DEBUG(3,("_spoolss_SetPrinterData: "
8201 "change denied by handle access permissions\n"));
8202 result = WERR_ACCESS_DENIED;
8203 goto done;
8204 }
8205
8206 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8207 if (!W_ERROR_IS_OK(result)) {
8208 return result;
8209 }
8210
8211 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8212 r->in.type, &r->in.data);
8213 if (!W_ERROR_IS_OK(result)) {
8214 goto done;
8215 }
8216
8217 /*
8218 * When client side code sets a magic printer data key, detect it and save
8219 * the current printer data and the magic key's data (its the DEVMODE) for
8220 * future printer/driver initializations.
8221 */
8222 if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8223 /* Set devmode and printer initialization info */
8224 result = save_driver_init(printer, 2, blob.data, blob.length);
8225
8226 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8227
8228 goto done;
8229 }
8230
8231 result = set_printer_dataex(printer, SPOOL_PRINTERDATA_KEY,
8232 r->in.value_name, r->in.type,
8233 blob.data, blob.length);
8234 if (W_ERROR_IS_OK(result)) {
8235 result = mod_a_printer(printer, 2);
8236 }
8237
8238 done:
8239 free_a_printer(&printer, 2);
8240
8241 return result;
8242 }
8243
8244 /****************************************************************
8245 _spoolss_ResetPrinter
8246 ****************************************************************/
8247
8248 WERROR _spoolss_ResetPrinter(pipes_struct *p,
8249 struct spoolss_ResetPrinter *r)
8250 {
8251 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8252 int snum;
8253
8254 DEBUG(5,("_spoolss_ResetPrinter\n"));
8255
8256 /*
8257 * All we do is to check to see if the handle and queue is valid.
8258 * This call really doesn't mean anything to us because we only
8259 * support RAW printing. --jerry
8260 */
8261
8262 if (!Printer) {
8263 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8264 OUR_HANDLE(r->in.handle)));
8265 return WERR_BADFID;
8266 }
8267
8268 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8269 return WERR_BADFID;
8270
8271
8272 /* blindly return success */
8273 return WERR_OK;
8274 }
8275
8276 /****************************************************************
8277 _spoolss_DeletePrinterData
8278 ****************************************************************/
8279
8280 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
8281 struct spoolss_DeletePrinterData *r)
8282 {
8283 NT_PRINTER_INFO_LEVEL *printer = NULL;
8284 int snum=0;
8285 WERROR status = WERR_OK;
8286 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8287
8288 DEBUG(5,("_spoolss_DeletePrinterData\n"));
8289
8290 if (!Printer) {
8291 DEBUG(2,("_spoolss_DeletePrinterData: Invalid handle (%s:%u:%u).\n",
8292 OUR_HANDLE(r->in.handle)));
8293 return WERR_BADFID;
8294 }
8295
8296 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8297 return WERR_BADFID;
8298
8299 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8300 DEBUG(3, ("_spoolss_DeletePrinterData: "
8301 "printer properties change denied by handle\n"));
8302 return WERR_ACCESS_DENIED;
8303 }
8304
8305 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8306 if (!W_ERROR_IS_OK(status))
8307 return status;
8308
8309 if (!r->in.value_name) {
8310 free_a_printer(&printer, 2);
8311 return WERR_NOMEM;
8312 }
8313
8314 status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY,
8315 r->in.value_name );
8316
8317 if ( W_ERROR_IS_OK(status) )
8318 mod_a_printer( printer, 2 );
8319
8320 free_a_printer(&printer, 2);
8321
8322 return status;
8323 }
8324
8325 /****************************************************************
8326 _spoolss_AddForm
8327 ****************************************************************/
8328
8329 WERROR _spoolss_AddForm(pipes_struct *p,
8330 struct spoolss_AddForm *r)
8331 {
8332 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8333 nt_forms_struct tmpForm;
8334 int snum = -1;
8335 WERROR status = WERR_OK;
8336 NT_PRINTER_INFO_LEVEL *printer = NULL;
8337 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8338
8339 int count=0;
8340 nt_forms_struct *list=NULL;
8341 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8342
8343 DEBUG(5,("_spoolss_AddForm\n"));
8344
8345 if (!Printer) {
8346 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8347 OUR_HANDLE(r->in.handle)));
8348 return WERR_BADFID;
8349 }
8350
8351
8352 /* forms can be added on printer of on the print server handle */
8353
8354 if ( Printer->printer_type == SPLHND_PRINTER )
8355 {
8356 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8357 return WERR_BADFID;
8358
8359 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8360 if (!W_ERROR_IS_OK(status))
8361 goto done;
8362 }
8363
8364 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8365 and not a printer admin, then fail */
8366
8367 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8368 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8369 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8370 NULL, NULL,
8371 p->server_info->ptok,
8372 lp_printer_admin(snum))) {
8373 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8374 return WERR_ACCESS_DENIED;
8375 }
8376
8377 /* can't add if builtin */
8378
8379 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8380 status = WERR_FILE_EXISTS;
8381 goto done;
8382 }
8383
8384 count = get_ntforms(&list);
8385
8386 if(!add_a_form(&list, form, &count)) {
8387 status = WERR_NOMEM;
8388 goto done;
8389 }
8390
8391 become_root();
8392 write_ntforms(&list, count);
8393 unbecome_root();
8394
8395 /*
8396 * ChangeID must always be set if this is a printer
8397 */
8398
8399 if ( Printer->printer_type == SPLHND_PRINTER )
8400 status = mod_a_printer(printer, 2);
8401
8402 done:
8403 if ( printer )
8404 free_a_printer(&printer, 2);
8405 SAFE_FREE(list);
8406
8407 return status;
8408 }
8409
8410 /****************************************************************
8411 _spoolss_DeleteForm
8412 ****************************************************************/
8413
8414 WERROR _spoolss_DeleteForm(pipes_struct *p,
8415 struct spoolss_DeleteForm *r)
8416 {
8417 const char *form_name = r->in.form_name;
8418 nt_forms_struct tmpForm;
8419 int count=0;
8420 nt_forms_struct *list=NULL;
8421 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8422 int snum = -1;
8423 WERROR status = WERR_OK;
8424 NT_PRINTER_INFO_LEVEL *printer = NULL;
8425 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8426 bool ret = false;
8427
8428 DEBUG(5,("_spoolss_DeleteForm\n"));
8429
8430 if (!Printer) {
8431 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8432 OUR_HANDLE(r->in.handle)));
8433 return WERR_BADFID;
8434 }
8435
8436 /* forms can be deleted on printer of on the print server handle */
8437
8438 if ( Printer->printer_type == SPLHND_PRINTER )
8439 {
8440 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8441 return WERR_BADFID;
8442
8443 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8444 if (!W_ERROR_IS_OK(status))
8445 goto done;
8446 }
8447
8448 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8449 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8450 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8451 NULL, NULL,
8452 p->server_info->ptok,
8453 lp_printer_admin(snum))) {
8454 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8455 return WERR_ACCESS_DENIED;
8456 }
8457
8458
8459 /* can't delete if builtin */
8460
8461 if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8462 status = WERR_INVALID_PARAM;
8463 goto done;
8464 }
8465
8466 count = get_ntforms(&list);
8467
8468 become_root();
8469 ret = delete_a_form(&list, form_name, &count, &status);
8470 unbecome_root();
8471 if (ret == false) {
8472 goto done;
8473 }
8474
8475 /*
8476 * ChangeID must always be set if this is a printer
8477 */
8478
8479 if ( Printer->printer_type == SPLHND_PRINTER )
8480 status = mod_a_printer(printer, 2);
8481
8482 done:
8483 if ( printer )
8484 free_a_printer(&printer, 2);
8485 SAFE_FREE(list);
8486
8487 return status;
8488 }
8489
8490 /****************************************************************
8491 _spoolss_SetForm
8492 ****************************************************************/
8493
8494 WERROR _spoolss_SetForm(pipes_struct *p,
8495 struct spoolss_SetForm *r)
8496 {
8497 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8498 nt_forms_struct tmpForm;
8499 int snum = -1;
8500 WERROR status = WERR_OK;
8501 NT_PRINTER_INFO_LEVEL *printer = NULL;
8502 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8503
8504 int count=0;
8505 nt_forms_struct *list=NULL;
8506 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8507
8508 DEBUG(5,("_spoolss_SetForm\n"));
8509
8510 if (!Printer) {
8511 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8512 OUR_HANDLE(r->in.handle)));
8513 return WERR_BADFID;
8514 }
8515
8516 /* forms can be modified on printer of on the print server handle */
8517
8518 if ( Printer->printer_type == SPLHND_PRINTER )
8519 {
8520 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8521 return WERR_BADFID;
8522
8523 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8524 if (!W_ERROR_IS_OK(status))
8525 goto done;
8526 }
8527
8528 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8529 and not a printer admin, then fail */
8530
8531 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8532 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8533 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8534 NULL, NULL,
8535 p->server_info->ptok,
8536 lp_printer_admin(snum))) {
8537 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8538 return WERR_ACCESS_DENIED;
8539 }
8540
8541 /* can't set if builtin */
8542 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8543 status = WERR_INVALID_PARAM;
8544 goto done;
8545 }
8546
8547 count = get_ntforms(&list);
8548 update_a_form(&list, form, count);
8549 become_root();
8550 write_ntforms(&list, count);
8551 unbecome_root();
8552
8553 /*
8554 * ChangeID must always be set if this is a printer
8555 */
8556
8557 if ( Printer->printer_type == SPLHND_PRINTER )
8558 status = mod_a_printer(printer, 2);
8559
8560
8561 done:
8562 if ( printer )
8563 free_a_printer(&printer, 2);
8564 SAFE_FREE(list);
8565
8566 return status;
8567 }
8568
8569 /****************************************************************************
8570 fill_print_processor1
8571 ****************************************************************************/
8572
8573 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8574 struct spoolss_PrintProcessorInfo1 *r,
8575 const char *print_processor_name)
8576 {
8577 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8578 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8579
8580 return WERR_OK;
8581 }
8582
8583 /****************************************************************************
8584 enumprintprocessors level 1.
8585 ****************************************************************************/
8586
8587 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8588 union spoolss_PrintProcessorInfo **info_p,
8589 uint32_t *count)
8590 {
8591 union spoolss_PrintProcessorInfo *info;
8592 WERROR result;
8593
8594 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8595 W_ERROR_HAVE_NO_MEMORY(info);
8596
8597 *count = 1;
8598
8599 result = fill_print_processor1(info, &info[0].info1, "winprint");
8600 if (!W_ERROR_IS_OK(result)) {
8601 goto out;
8602 }
8603
8604 out:
8605 if (!W_ERROR_IS_OK(result)) {
8606 TALLOC_FREE(info);
8607 *count = 0;
8608 return result;
8609 }
8610
8611 *info_p = info;
8612
8613 return WERR_OK;
8614 }
8615
8616 /****************************************************************
8617 _spoolss_EnumPrintProcessors
8618 ****************************************************************/
8619
8620 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8621 struct spoolss_EnumPrintProcessors *r)
8622 {
8623 WERROR result;
8624
8625 /* that's an [in out] buffer */
8626
8627 if (!r->in.buffer && (r->in.offered != 0)) {
8628 return WERR_INVALID_PARAM;
8629 }
8630
8631 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8632
8633 /*
8634 * Enumerate the print processors ...
8635 *
8636 * Just reply with "winprint", to keep NT happy
8637 * and I can use my nice printer checker.
8638 */
8639
8640 *r->out.count = 0;
8641 *r->out.needed = 0;
8642 *r->out.info = NULL;
8643
8644 switch (r->in.level) {
8645 case 1:
8646 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8647 r->out.count);
8648 break;
8649 default:
8650 return WERR_UNKNOWN_LEVEL;
8651 }
8652
8653 if (!W_ERROR_IS_OK(result)) {
8654 return result;
8655 }
8656
8657 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8658 spoolss_EnumPrintProcessors, NULL,
8659 *r->out.info, r->in.level,
8660 *r->out.count);
8661 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8662 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8663
8664 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8665 }
8666
8667 /****************************************************************************
8668 fill_printprocdatatype1
8669 ****************************************************************************/
8670
8671 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8672 struct spoolss_PrintProcDataTypesInfo1 *r,
8673 const char *name_array)
8674 {
8675 r->name_array = talloc_strdup(mem_ctx, name_array);
8676 W_ERROR_HAVE_NO_MEMORY(r->name_array);
8677
8678 return WERR_OK;
8679 }
8680
8681 /****************************************************************************
8682 enumprintprocdatatypes level 1.
8683 ****************************************************************************/
8684
8685 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8686 union spoolss_PrintProcDataTypesInfo **info_p,
8687 uint32_t *count)
8688 {
8689 WERROR result;
8690 union spoolss_PrintProcDataTypesInfo *info;
8691
8692 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8693 W_ERROR_HAVE_NO_MEMORY(info);
8694
8695 *count = 1;
8696
8697 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8698 if (!W_ERROR_IS_OK(result)) {
8699 goto out;
8700 }
8701
8702 out:
8703 if (!W_ERROR_IS_OK(result)) {
8704 TALLOC_FREE(info);
8705 *count = 0;
8706 return result;
8707 }
8708
8709 *info_p = info;
8710
8711 return WERR_OK;
8712 }
8713
8714 /****************************************************************
8715 _spoolss_EnumPrintProcDataTypes
8716 ****************************************************************/
8717
8718 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8719 struct spoolss_EnumPrintProcDataTypes *r)
8720 {
8721 WERROR result;
8722
8723 /* that's an [in out] buffer */
8724
8725 if (!r->in.buffer && (r->in.offered != 0)) {
8726 return WERR_INVALID_PARAM;
8727 }
8728
8729 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8730
8731 *r->out.count = 0;
8732 *r->out.needed = 0;
8733 *r->out.info = NULL;
8734
8735 switch (r->in.level) {
8736 case 1:
8737 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8738 r->out.count);
8739 break;
8740 default:
8741 return WERR_UNKNOWN_LEVEL;
8742 }
8743
8744 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8745 spoolss_EnumPrintProcDataTypes, NULL,
8746 *r->out.info, r->in.level,
8747 *r->out.count);
8748 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8749 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8750
8751 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8752 }
8753
8754 /****************************************************************************
8755 fill_monitor_1
8756 ****************************************************************************/
8757
8758 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8759 struct spoolss_MonitorInfo1 *r,
8760 const char *monitor_name)
8761 {
8762 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8763 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8764
8765 return WERR_OK;
8766 }
8767
8768 /****************************************************************************
8769 fill_monitor_2
8770 ****************************************************************************/
8771
8772 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8773 struct spoolss_MonitorInfo2 *r,
8774 const char *monitor_name,
8775 const char *environment,
8776 const char *dll_name)
8777 {
8778 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8779 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8780 r->environment = talloc_strdup(mem_ctx, environment);
8781 W_ERROR_HAVE_NO_MEMORY(r->environment);
8782 r->dll_name = talloc_strdup(mem_ctx, dll_name);
8783 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8784
8785 return WERR_OK;
8786 }
8787
8788 /****************************************************************************
8789 enumprintmonitors level 1.
8790 ****************************************************************************/
8791
8792 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8793 union spoolss_MonitorInfo **info_p,
8794 uint32_t *count)
8795 {
8796 union spoolss_MonitorInfo *info;
8797 WERROR result = WERR_OK;
8798
8799 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8800 W_ERROR_HAVE_NO_MEMORY(info);
8801
8802 *count = 2;
8803
8804 result = fill_monitor_1(info, &info[0].info1,
8805 SPL_LOCAL_PORT);
8806 if (!W_ERROR_IS_OK(result)) {
8807 goto out;
8808 }
8809
8810 result = fill_monitor_1(info, &info[1].info1,
8811 SPL_TCPIP_PORT);
8812 if (!W_ERROR_IS_OK(result)) {
8813 goto out;
8814 }
8815
8816 out:
8817 if (!W_ERROR_IS_OK(result)) {
8818 TALLOC_FREE(info);
8819 *count = 0;
8820 return result;
8821 }
8822
8823 *info_p = info;
8824
8825 return WERR_OK;
8826 }
8827
8828 /****************************************************************************
8829 enumprintmonitors level 2.
8830 ****************************************************************************/
8831
8832 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8833 union spoolss_MonitorInfo **info_p,
8834 uint32_t *count)
8835 {
8836 union spoolss_MonitorInfo *info;
8837 WERROR result = WERR_OK;
8838
8839 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8840 W_ERROR_HAVE_NO_MEMORY(info);
8841
8842 *count = 2;
8843
8844 result = fill_monitor_2(info, &info[0].info2,
8845 SPL_LOCAL_PORT,
8846 "Windows NT X86", /* FIXME */
8847 "localmon.dll");
8848 if (!W_ERROR_IS_OK(result)) {
8849 goto out;
8850 }
8851
8852 result = fill_monitor_2(info, &info[1].info2,
8853 SPL_TCPIP_PORT,
8854 "Windows NT X86", /* FIXME */
8855 "tcpmon.dll");
8856 if (!W_ERROR_IS_OK(result)) {
8857 goto out;
8858 }
8859
8860 out:
8861 if (!W_ERROR_IS_OK(result)) {
8862 TALLOC_FREE(info);
8863 *count = 0;
8864 return result;
8865 }
8866
8867 *info_p = info;
8868
8869 return WERR_OK;
8870 }
8871
8872 /****************************************************************
8873 _spoolss_EnumMonitors
8874 ****************************************************************/
8875
8876 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8877 struct spoolss_EnumMonitors *r)
8878 {
8879 WERROR result;
8880
8881 /* that's an [in out] buffer */
8882
8883 if (!r->in.buffer && (r->in.offered != 0)) {
8884 return WERR_INVALID_PARAM;
8885 }
8886
8887 DEBUG(5,("_spoolss_EnumMonitors\n"));
8888
8889 /*
8890 * Enumerate the print monitors ...
8891 *
8892 * Just reply with "Local Port", to keep NT happy
8893 * and I can use my nice printer checker.
8894 */
8895
8896 *r->out.count = 0;
8897 *r->out.needed = 0;
8898 *r->out.info = NULL;
8899
8900 switch (r->in.level) {
8901 case 1:
8902 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8903 r->out.count);
8904 break;
8905 case 2:
8906 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8907 r->out.count);
8908 break;
8909 default:
8910 return WERR_UNKNOWN_LEVEL;
8911 }
8912
8913 if (!W_ERROR_IS_OK(result)) {
8914 return result;
8915 }
8916
8917 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8918 spoolss_EnumMonitors, NULL,
8919 *r->out.info, r->in.level,
8920 *r->out.count);
8921 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8922 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8923
8924 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8925 }
8926
8927 /****************************************************************************
8928 ****************************************************************************/
8929
8930 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8931 const print_queue_struct *queue,
8932 int count, int snum,
8933 const NT_PRINTER_INFO_LEVEL *ntprinter,
8934 uint32_t jobid,
8935 struct spoolss_JobInfo1 *r)
8936 {
8937 int i = 0;
8938 bool found = false;
8939
8940 for (i=0; i<count && found == false; i++) {
8941 if (queue[i].job == (int)jobid) {
8942 found = true;
8943 }
8944 }
8945
8946 if (found == false) {
8947 /* NT treats not found as bad param... yet another bad choice */
8948 return WERR_INVALID_PARAM;
8949 }
8950
8951 return fill_job_info1(mem_ctx,
8952 r,
8953 &queue[i-1],
8954 i,
8955 snum,
8956 ntprinter);
8957 }
8958
8959 /****************************************************************************
8960 ****************************************************************************/
8961
8962 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8963 const print_queue_struct *queue,
8964 int count, int snum,
8965 const NT_PRINTER_INFO_LEVEL *ntprinter,
8966 uint32_t jobid,
8967 struct spoolss_JobInfo2 *r)
8968 {
8969 int i = 0;
8970 bool found = false;
8971 struct spoolss_DeviceMode *devmode;
8972 NT_DEVICEMODE *nt_devmode;
8973 WERROR result;
8974
8975 for (i=0; i<count && found == false; i++) {
8976 if (queue[i].job == (int)jobid) {
8977 found = true;
8978 }
8979 }
8980
8981 if (found == false) {
8982 /* NT treats not found as bad param... yet another bad
8983 choice */
8984 return WERR_INVALID_PARAM;
8985 }
8986
8987 /*
8988 * if the print job does not have a DEVMODE associated with it,
8989 * just use the one for the printer. A NULL devicemode is not
8990 * a failure condition
8991 */
8992
8993 nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8994 if (nt_devmode) {
8995 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
8996 W_ERROR_HAVE_NO_MEMORY(devmode);
8997 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
8998 if (!W_ERROR_IS_OK(result)) {
8999 return result;
9000 }
9001 } else {
9002 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
9003 W_ERROR_HAVE_NO_MEMORY(devmode);
9004 }
9005
9006 return fill_job_info2(mem_ctx,
9007 r,
9008 &queue[i-1],
9009 i,
9010 snum,
9011 ntprinter,
9012 devmode);
9013 }
9014
9015 /****************************************************************
9016 _spoolss_GetJob
9017 ****************************************************************/
9018
9019 WERROR _spoolss_GetJob(pipes_struct *p,
9020 struct spoolss_GetJob *r)
9021 {
9022 WERROR result = WERR_OK;
9023 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
9024 int snum;
9025 int count;
9026 print_queue_struct *queue = NULL;
9027 print_status_struct prt_status;
9028
9029 /* that's an [in out] buffer */
9030
9031 if (!r->in.buffer && (r->in.offered != 0)) {
9032 return WERR_INVALID_PARAM;
9033 }
9034
9035 DEBUG(5,("_spoolss_GetJob\n"));
9036
9037 *r->out.needed = 0;
9038
9039 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9040 return WERR_BADFID;
9041 }
9042
9043 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
9044 if (!W_ERROR_IS_OK(result)) {
9045 return result;
9046 }
9047
9048 count = print_queue_status(snum, &queue, &prt_status);
9049
9050 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
9051 count, prt_status.status, prt_status.message));
9052
9053 switch (r->in.level) {
9054 case 1:
9055 result = getjob_level_1(p->mem_ctx,
9056 queue, count, snum, ntprinter,
9057 r->in.job_id, &r->out.info->info1);
9058 break;
9059 case 2:
9060 result = getjob_level_2(p->mem_ctx,
9061 queue, count, snum, ntprinter,
9062 r->in.job_id, &r->out.info->info2);
9063 break;
9064 default:
9065 result = WERR_UNKNOWN_LEVEL;
9066 break;
9067 }
9068
9069 SAFE_FREE(queue);
9070 free_a_printer(&ntprinter, 2);
9071
9072 if (!W_ERROR_IS_OK(result)) {
9073 TALLOC_FREE(r->out.info);
9074 return result;
9075 }
9076
9077 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
9078 r->out.info, r->in.level);
9079 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9080
9081 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9082 }
9083
9084 /****************************************************************
9085 _spoolss_GetPrinterDataEx
9086
9087 From MSDN documentation of GetPrinterDataEx: pass request
9088 to GetPrinterData if key is "PrinterDriverData".
9089 ****************************************************************/
9090
9091 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
9092 struct spoolss_GetPrinterDataEx *r)
9093 {
9094
9095 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9096 struct regval_blob *val = NULL;
9097 NT_PRINTER_INFO_LEVEL *printer = NULL;
9098 int snum = 0;
9099 WERROR result = WERR_OK;
9100
9101 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9102
9103 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9104 r->in.key_name, r->in.value_name));
9105
9106 /* in case of problem, return some default values */
9107
9108 *r->out.needed = 0;
9109 *r->out.type = REG_NONE;
9110
9111 if (!Printer) {
9112 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9113 OUR_HANDLE(r->in.handle)));
9114 result = WERR_BADFID;
9115 goto done;
9116 }
9117
9118 /* Is the handle to a printer or to the server? */
9119
9120 if (Printer->printer_type == SPLHND_SERVER) {
9121 DEBUG(10,("_spoolss_GetPrinterDataEx: "
9122 "Not implemented for server handles yet\n"));
9123 result = WERR_INVALID_PARAM;
9124 goto done;
9125 }
9126
9127 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9128 return WERR_BADFID;
9129 }
9130
9131 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9132 if (!W_ERROR_IS_OK(result)) {
9133 goto done;
9134 }
9135
9136 /* check to see if the keyname is valid */
9137 if (!strlen(r->in.key_name)) {
9138 result = WERR_INVALID_PARAM;
9139 goto done;
9140 }
9141
9142 if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
9143 DEBUG(4,("_spoolss_GetPrinterDataEx: "
9144 "Invalid keyname [%s]\n", r->in.key_name ));
9145 result = WERR_BADFILE;
9146 goto done;
9147 }
9148
9149 /* When given a new keyname, we should just create it */
9150
9151 val = get_printer_data(printer->info_2,
9152 r->in.key_name, r->in.value_name);
9153 if (!val) {
9154 result = WERR_BADFILE;
9155 goto done;
9156 }
9157
9158 *r->out.needed = regval_size(val);
9159
9160 if (*r->out.needed > r->in.offered) {
9161 result = WERR_MORE_DATA;
9162 goto done;
9163 }
9164
9165 *r->out.type = regval_type(val);
9166
9167 memcpy(r->out.buffer, regval_data_p(val), regval_size(val));
9168
9169 done:
9170 if (printer) {
9171 free_a_printer(&printer, 2);
9172 }
9173
9174 return result;
9175 }
9176
9177 /****************************************************************
9178 _spoolss_SetPrinterDataEx
9179 ****************************************************************/
9180
9181 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
9182 struct spoolss_SetPrinterDataEx *r)
9183 {
9184 NT_PRINTER_INFO_LEVEL *printer = NULL;
9185 int snum = 0;
9186 WERROR result = WERR_OK;
9187 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9188 char *oid_string;
9189
9190 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9191
9192 /* From MSDN documentation of SetPrinterDataEx: pass request to
9193 SetPrinterData if key is "PrinterDriverData" */
9194
9195 if (!Printer) {
9196 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9197 OUR_HANDLE(r->in.handle)));
9198 return WERR_BADFID;
9199 }
9200
9201 if (Printer->printer_type == SPLHND_SERVER) {
9202 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9203 "Not implemented for server handles yet\n"));
9204 return WERR_INVALID_PARAM;
9205 }
9206
9207 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9208 return WERR_BADFID;
9209 }
9210
9211 /*
9212 * Access check : NT returns "access denied" if you make a
9213 * SetPrinterData call without the necessary privildge.
9214 * we were originally returning OK if nothing changed
9215 * which made Win2k issue **a lot** of SetPrinterData
9216 * when connecting to a printer --jerry
9217 */
9218
9219 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9220 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9221 "change denied by handle access permissions\n"));
9222 return WERR_ACCESS_DENIED;
9223 }
9224
9225 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9226 if (!W_ERROR_IS_OK(result)) {
9227 return result;
9228 }
9229
9230 /* check for OID in valuename */
9231
9232 oid_string = strchr(r->in.value_name, ',');
9233 if (oid_string) {
9234 *oid_string = '\0';
9235 oid_string++;
9236 }
9237
9238 /* save the registry data */
9239
9240 result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
9241 r->in.type, r->in.buffer, r->in.offered);
9242
9243 if (W_ERROR_IS_OK(result)) {
9244 /* save the OID if one was specified */
9245 if (oid_string) {
9246 char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
9247 r->in.key_name, SPOOL_OID_KEY);
9248 if (!str) {
9249 result = WERR_NOMEM;
9250 goto done;
9251 }
9252
9253 /*
9254 * I'm not checking the status here on purpose. Don't know
9255 * if this is right, but I'm returning the status from the
9256 * previous set_printer_dataex() call. I have no idea if
9257 * this is right. --jerry
9258 */
9259
9260 set_printer_dataex(printer, str, r->in.value_name,
9261 REG_SZ, (uint8_t *)oid_string,
9262 strlen(oid_string)+1);
9263 }
9264
9265 result = mod_a_printer(printer, 2);
9266 }
9267
9268 done:
9269 free_a_printer(&printer, 2);
9270
9271 return result;
9272 }
9273
9274 /****************************************************************
9275 _spoolss_DeletePrinterDataEx
9276 ****************************************************************/
9277
9278 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
9279 struct spoolss_DeletePrinterDataEx *r)
9280 {
9281 NT_PRINTER_INFO_LEVEL *printer = NULL;
9282 int snum=0;
9283 WERROR status = WERR_OK;
9284 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9285
9286 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9287
9288 if (!Printer) {
9289 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9290 "Invalid handle (%s:%u:%u).\n",
9291 OUR_HANDLE(r->in.handle)));
9292 return WERR_BADFID;
9293 }
9294
9295 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9296 return WERR_BADFID;
9297
9298 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9299 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9300 "printer properties change denied by handle\n"));
9301 return WERR_ACCESS_DENIED;
9302 }
9303
9304 if (!r->in.value_name || !r->in.key_name) {
9305 return WERR_NOMEM;
9306 }
9307
9308 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9309 if (!W_ERROR_IS_OK(status))
9310 return status;
9311
9312 status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
9313
9314 if ( W_ERROR_IS_OK(status) )
9315 mod_a_printer( printer, 2 );
9316
9317 free_a_printer(&printer, 2);
9318
9319 return status;
9320 }
9321
9322 /****************************************************************
9323 _spoolss_EnumPrinterKey
9324 ****************************************************************/
9325
9326 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
9327 struct spoolss_EnumPrinterKey *r)
9328 {
9329 fstring *keynames = NULL;
9330 int num_keys;
9331 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9332 NT_PRINTER_DATA *data;
9333 NT_PRINTER_INFO_LEVEL *printer = NULL;
9334 int snum = 0;
9335 WERROR result = WERR_BADFILE;
9336 int i;
9337 const char **array = NULL;
9338
9339
9340 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9341
9342 if (!Printer) {
9343 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9344 OUR_HANDLE(r->in.handle)));
9345 return WERR_BADFID;
9346 }
9347
9348 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9349 return WERR_BADFID;
9350 }
9351
9352 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9353 if (!W_ERROR_IS_OK(result)) {
9354 return result;
9355 }
9356
9357 /* get the list of subkey names */
9358
9359 data = printer->info_2->data;
9360
9361 num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
9362 if (num_keys == -1) {
9363 result = WERR_BADFILE;
9364 goto done;
9365 }
9366
9367 *r->out.needed = 4;
9368
9369 array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 1);
9370 if (!array) {
9371 result = WERR_NOMEM;
9372 goto done;
9373 }
9374
9375 for (i=0; i < num_keys; i++) {
9376 array[i] = talloc_strdup(array, keynames[i]);
9377 if (!array[i]) {
9378 result = WERR_NOMEM;
9379 goto done;
9380 }
9381
9382 *r->out.needed += strlen_m_term(keynames[i]) * 2;
9383 }
9384
9385 if (r->in.offered < *r->out.needed) {
9386 result = WERR_MORE_DATA;
9387 goto done;
9388 }
9389
9390 result = WERR_OK;
9391
9392 *r->out.key_buffer = array;
9393
9394 done:
9395 if (!W_ERROR_IS_OK(result)) {
9396 TALLOC_FREE(array);
9397 ZERO_STRUCTP(r->out.key_buffer);
9398 }
9399
9400 free_a_printer(&printer, 2);
9401 SAFE_FREE(keynames);
9402
9403 return result;
9404 }
9405
9406 /****************************************************************
9407 _spoolss_DeletePrinterKey
9408 ****************************************************************/
9409
9410 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9411 struct spoolss_DeletePrinterKey *r)
9412 {
9413 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9414 NT_PRINTER_INFO_LEVEL *printer = NULL;
9415 int snum=0;
9416 WERROR status;
9417
9418 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9419
9420 if (!Printer) {
9421 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9422 OUR_HANDLE(r->in.handle)));
9423 return WERR_BADFID;
9424 }
9425
9426 /* if keyname == NULL, return error */
9427
9428 if ( !r->in.key_name )
9429 return WERR_INVALID_PARAM;
9430
9431 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9432 return WERR_BADFID;
9433
9434 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9435 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9436 "printer properties change denied by handle\n"));
9437 return WERR_ACCESS_DENIED;
9438 }
9439
9440 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9441 if (!W_ERROR_IS_OK(status))
9442 return status;
9443
9444 /* delete the key and all subneys */
9445
9446 status = delete_all_printer_data( printer->info_2, r->in.key_name );
9447
9448 if ( W_ERROR_IS_OK(status) )
9449 status = mod_a_printer(printer, 2);
9450
9451 free_a_printer( &printer, 2 );
9452
9453 return status;
9454 }
9455
9456 /****************************************************************
9457 ****************************************************************/
9458
9459 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9460 struct regval_blob *v,
9461 struct spoolss_PrinterEnumValues *r)
9462 {
9463 WERROR result;
9464
9465 r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
9466 W_ERROR_HAVE_NO_MEMORY(r->data);
9467
9468 r->value_name = talloc_strdup(mem_ctx, regval_name(v));
9469 W_ERROR_HAVE_NO_MEMORY(r->value_name);
9470
9471 r->type = regval_type(v);
9472 r->data_length = regval_size(v);
9473
9474 if (r->data_length) {
9475 DATA_BLOB blob = data_blob_const(regval_data_p(v),
9476 regval_size(v));
9477 result = pull_spoolss_PrinterData(mem_ctx, &blob,
9478 r->data,
9479 r->type);
9480 if (!W_ERROR_IS_OK(result)) {
9481 return result;
9482 }
9483 }
9484
9485 return WERR_OK;
9486 }
9487
9488 /****************************************************************
9489 _spoolss_EnumPrinterDataEx
9490 ****************************************************************/
9491
9492 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9493 struct spoolss_EnumPrinterDataEx *r)
9494 {
9495 uint32_t count = 0;
9496 NT_PRINTER_INFO_LEVEL *printer = NULL;
9497 struct spoolss_PrinterEnumValues *info = NULL;
9498 NT_PRINTER_DATA *p_data;
9499 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9500 int snum;
9501 WERROR result;
9502 int key_index;
9503 int i;
9504
9505 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9506
9507 *r->out.count = 0;
9508 *r->out.needed = 0;
9509 *r->out.info = NULL;
9510
9511 if (!Printer) {
9512 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9513 OUR_HANDLE(r->in.handle)));
9514 return WERR_BADFID;
9515 }
9516
9517 /*
9518 * first check for a keyname of NULL or "". Win2k seems to send
9519 * this a lot and we should send back WERR_INVALID_PARAM
9520 * no need to spend time looking up the printer in this case.
9521 * --jerry
9522 */
9523
9524 if (!strlen(r->in.key_name)) {
9525 result = WERR_INVALID_PARAM;
9526 goto done;
9527 }
9528
9529 /* get the printer off of disk */
9530
9531 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9532 return WERR_BADFID;
9533 }
9534
9535 ZERO_STRUCT(printer);
9536 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9537 if (!W_ERROR_IS_OK(result)) {
9538 return result;
9539 }
9540
9541 /* now look for a match on the key name */
9542
9543 p_data = printer->info_2->data;
9544
9545 key_index = lookup_printerkey(p_data, r->in.key_name);
9546 if (key_index == -1) {
9547 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9548 r->in.key_name));
9549 result = WERR_INVALID_PARAM;
9550 goto done;
9551 }
9552
9553 /* allocate the memory for the array of pointers -- if necessary */
9554
9555 count = regval_ctr_numvals(p_data->keys[key_index].values);
9556 if (!count) {
9557 result = WERR_OK; /* ??? */
9558 goto done;
9559 }
9560
9561 info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9562 struct spoolss_PrinterEnumValues,
9563 count);
9564 if (!info) {
9565 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9566 result = WERR_NOMEM;
9567 goto done;
9568 }
9569
9570 /*
9571 * loop through all params and build the array to pass
9572 * back to the client
9573 */
9574
9575 for (i=0; i < count; i++) {
9576
9577 struct regval_blob *val;
9578
9579 /* lookup the registry value */
9580
9581 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9582
9583 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9584
9585 /* copy the data */
9586
9587 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9588 if (!W_ERROR_IS_OK(result)) {
9589 goto done;
9590 }
9591 }
9592
9593 #if 0 /* FIXME - gd */
9594 /* housekeeping information in the reply */
9595
9596 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9597 * the hand marshalled container size is a multiple
9598 * of 4 bytes for RPC alignment.
9599 */
9600
9601 if (needed % 4) {
9602 needed += 4-(needed % 4);
9603 }
9604 #endif
9605 *r->out.count = count;
9606 *r->out.info = info;
9607
9608 done:
9609
9610 if (printer) {
9611 free_a_printer(&printer, 2);
9612 }
9613
9614 if (!W_ERROR_IS_OK(result)) {
9615 return result;
9616 }
9617
9618 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9619 spoolss_EnumPrinterDataEx, NULL,
9620 *r->out.info,
9621 *r->out.count);
9622 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9623 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9624
9625 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9626 }
9627
9628 /****************************************************************************
9629 ****************************************************************************/
9630
9631 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9632 const char *servername,
9633 const char *environment,
9634 struct spoolss_PrintProcessorDirectoryInfo1 *r)
9635 {
9636 WERROR werr;
9637 char *path = NULL;
9638
9639 werr = compose_spoolss_server_path(mem_ctx,
9640 servername,
9641 environment,
9642 SPOOLSS_PRTPROCS_PATH,
9643 &path);
9644 if (!W_ERROR_IS_OK(werr)) {
9645 return werr;
9646 }
9647
9648 DEBUG(4,("print processor directory: [%s]\n", path));
9649
9650 r->directory_name = path;
9651
9652 return WERR_OK;
9653 }
9654
9655 /****************************************************************
9656 _spoolss_GetPrintProcessorDirectory
9657 ****************************************************************/
9658
9659 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9660 struct spoolss_GetPrintProcessorDirectory *r)
9661 {
9662 WERROR result;
9663
9664 /* that's an [in out] buffer */
9665
9666 if (!r->in.buffer && (r->in.offered != 0)) {
9667 return WERR_INVALID_PARAM;
9668 }
9669
9670 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9671 r->in.level));
9672
9673 *r->out.needed = 0;
9674
9675 /* r->in.level is ignored */
9676
9677 /* We always should reply with a local print processor directory so that
9678 * users are not forced to have a [prnproc$] share on the Samba spoolss
9679 * server - Guenther */
9680
9681 result = getprintprocessordirectory_level_1(p->mem_ctx,
9682 NULL, /* r->in.server */
9683 r->in.environment,
9684 &r->out.info->info1);
9685 if (!W_ERROR_IS_OK(result)) {
9686 TALLOC_FREE(r->out.info);
9687 return result;
9688 }
9689
9690 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9691 r->out.info, r->in.level);
9692 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9693
9694 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9695 }
9696
9697 /*******************************************************************
9698 ********************************************************************/
9699
9700 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9701 const char *dllname)
9702 {
9703 enum ndr_err_code ndr_err;
9704 struct spoolss_MonitorUi ui;
9705
9706 ui.dll_name = dllname;
9707
9708 ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9709 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9710 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9711 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9712 }
9713 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9714 }
9715
9716 /*******************************************************************
9717 Streams the monitor UI DLL name in UNICODE
9718 *******************************************************************/
9719
9720 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9721 NT_USER_TOKEN *token, DATA_BLOB *in,
9722 DATA_BLOB *out, uint32_t *needed)
9723 {
9724 const char *dllname = "tcpmonui.dll";
9725
9726 *needed = (strlen(dllname)+1) * 2;
9727
9728 if (out->length < *needed) {
9729 return WERR_INSUFFICIENT_BUFFER;
9730 }
9731
9732 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9733 return WERR_NOMEM;
9734 }
9735
9736 return WERR_OK;
9737 }
9738
9739 /*******************************************************************
9740 ********************************************************************/
9741
9742 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9743 struct spoolss_PortData1 *port1,
9744 const DATA_BLOB *buf)
9745 {
9746 enum ndr_err_code ndr_err;
9747 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9748 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9749 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9750 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9751 }
9752 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9753 }
9754
9755 /*******************************************************************
9756 ********************************************************************/
9757
9758 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9759 struct spoolss_PortData2 *port2,
9760 const DATA_BLOB *buf)
9761 {
9762 enum ndr_err_code ndr_err;
9763 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9764 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9765 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9766 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9767 }
9768 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9769 }
9770
9771 /*******************************************************************
9772 Create a new TCP/IP port
9773 *******************************************************************/
9774
9775 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9776 NT_USER_TOKEN *token, DATA_BLOB *in,
9777 DATA_BLOB *out, uint32_t *needed)
9778 {
9779 struct spoolss_PortData1 port1;
9780 struct spoolss_PortData2 port2;
9781 char *device_uri = NULL;
9782 uint32_t version;
9783
9784 const char *portname;
9785 const char *hostaddress;
9786 const char *queue;
9787 uint32_t port_number;
9788 uint32_t protocol;
9789
9790 /* peek for spoolss_PortData version */
9791
9792 if (!in || (in->length < (128 + 4))) {
9793 return WERR_GENERAL_FAILURE;
9794 }
9795
9796 version = IVAL(in->data, 128);
9797
9798 switch (version) {
9799 case 1:
9800 ZERO_STRUCT(port1);
9801
9802 if (!pull_port_data_1(mem_ctx, &port1, in)) {
9803 return WERR_NOMEM;
9804 }
9805
9806 portname = port1.portname;
9807 hostaddress = port1.hostaddress;
9808 queue = port1.queue;
9809 protocol = port1.protocol;
9810 port_number = port1.port_number;
9811
9812 break;
9813 case 2:
9814 ZERO_STRUCT(port2);
9815
9816 if (!pull_port_data_2(mem_ctx, &port2, in)) {
9817 return WERR_NOMEM;
9818 }
9819
9820 portname = port2.portname;
9821 hostaddress = port2.hostaddress;
9822 queue = port2.queue;
9823 protocol = port2.protocol;
9824 port_number = port2.port_number;
9825
9826 break;
9827 default:
9828 DEBUG(1,("xcvtcp_addport: "
9829 "unknown version of port_data: %d\n", version));
9830 return WERR_UNKNOWN_PORT;
9831 }
9832
9833 /* create the device URI and call the add_port_hook() */
9834
9835 switch (protocol) {
9836 case PROTOCOL_RAWTCP_TYPE:
9837 device_uri = talloc_asprintf(mem_ctx,
9838 "socket://%s:%d/", hostaddress,
9839 port_number);
9840 break;
9841
9842 case PROTOCOL_LPR_TYPE:
9843 device_uri = talloc_asprintf(mem_ctx,
9844 "lpr://%s/%s", hostaddress, queue );
9845 break;
9846
9847 default:
9848 return WERR_UNKNOWN_PORT;
9849 }
9850
9851 if (!device_uri) {
9852 return WERR_NOMEM;
9853 }
9854
9855 return add_port_hook(mem_ctx, token, portname, device_uri);
9856 }
9857
9858 /*******************************************************************
9859 *******************************************************************/
9860
9861 struct xcv_api_table xcvtcp_cmds[] = {
9862 { "MonitorUI", xcvtcp_monitorui },
9863 { "AddPort", xcvtcp_addport},
9864 { NULL, NULL }
9865 };
9866
9867 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9868 NT_USER_TOKEN *token, const char *command,
9869 DATA_BLOB *inbuf,
9870 DATA_BLOB *outbuf,
9871 uint32_t *needed )
9872 {
9873 int i;
9874
9875 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9876
9877 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9878 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9879 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9880 }
9881
9882 return WERR_BADFUNC;
9883 }
9884
9885 /*******************************************************************
9886 *******************************************************************/
9887 #if 0 /* don't support management using the "Local Port" monitor */
9888
9889 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9890 NT_USER_TOKEN *token, DATA_BLOB *in,
9891 DATA_BLOB *out, uint32_t *needed)
9892 {
9893 const char *dllname = "localui.dll";
9894
9895 *needed = (strlen(dllname)+1) * 2;
9896
9897 if (out->length < *needed) {
9898 return WERR_INSUFFICIENT_BUFFER;
9899 }
9900
9901 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9902 return WERR_NOMEM;
9903 }
9904
9905 return WERR_OK;
9906 }
9907
9908 /*******************************************************************
9909 *******************************************************************/
9910
9911 struct xcv_api_table xcvlocal_cmds[] = {
9912 { "MonitorUI", xcvlocal_monitorui },
9913 { NULL, NULL }
9914 };
9915 #else
9916 struct xcv_api_table xcvlocal_cmds[] = {
9917 { NULL, NULL }
9918 };
9919 #endif
9920
9921
9922
9923 /*******************************************************************
9924 *******************************************************************/
9925
9926 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9927 NT_USER_TOKEN *token, const char *command,
9928 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9929 uint32_t *needed)
9930 {
9931 int i;
9932
9933 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9934
9935 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9936 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9937 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9938 }
9939 return WERR_BADFUNC;
9940 }
9941
9942 /****************************************************************
9943 _spoolss_XcvData
9944 ****************************************************************/
9945
9946 WERROR _spoolss_XcvData(pipes_struct *p,
9947 struct spoolss_XcvData *r)
9948 {
9949 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9950 DATA_BLOB out_data = data_blob_null;
9951 WERROR werror;
9952
9953 if (!Printer) {
9954 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9955 OUR_HANDLE(r->in.handle)));
9956 return WERR_BADFID;
9957 }
9958
9959 /* Has to be a handle to the TCP/IP port monitor */
9960
9961 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9962 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9963 return WERR_BADFID;
9964 }
9965
9966 /* requires administrative access to the server */
9967
9968 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9969 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9970 return WERR_ACCESS_DENIED;
9971 }
9972
9973 /* Allocate the outgoing buffer */
9974
9975 if (r->in.out_data_size) {
9976 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9977 if (out_data.data == NULL) {
9978 return WERR_NOMEM;
9979 }
9980 }
9981
9982 switch ( Printer->printer_type ) {
9983 case SPLHND_PORTMON_TCP:
9984 werror = process_xcvtcp_command(p->mem_ctx,
9985 p->server_info->ptok,
9986 r->in.function_name,
9987 &r->in.in_data, &out_data,
9988 r->out.needed);
9989 break;
9990 case SPLHND_PORTMON_LOCAL:
9991 werror = process_xcvlocal_command(p->mem_ctx,
9992 p->server_info->ptok,
9993 r->in.function_name,
9994 &r->in.in_data, &out_data,
9995 r->out.needed);
9996 break;
9997 default:
9998 werror = WERR_INVALID_PRINT_MONITOR;
9999 }
10000
10001 if (!W_ERROR_IS_OK(werror)) {
10002 return werror;
10003 }
10004
10005 *r->out.status_code = 0;
10006
10007 memcpy(r->out.out_data, out_data.data, out_data.length);
10008
10009 return WERR_OK;
10010 }
10011
10012 /****************************************************************
10013 _spoolss_AddPrintProcessor
10014 ****************************************************************/
10015
10016 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
10017 struct spoolss_AddPrintProcessor *r)
10018 {
10019 /* for now, just indicate success and ignore the add. We'll
10020 automatically set the winprint processor for printer
10021 entries later. Used to debug the LexMark Optra S 1855 PCL
10022 driver --jerry */
10023
10024 return WERR_OK;
10025 }
10026
10027 /****************************************************************
10028 _spoolss_AddPort
10029 ****************************************************************/
10030
10031 WERROR _spoolss_AddPort(pipes_struct *p,
10032 struct spoolss_AddPort *r)
10033 {
10034 /* do what w2k3 does */
10035
10036 return WERR_NOT_SUPPORTED;
10037 }
10038
10039 /****************************************************************
10040 _spoolss_GetPrinterDriver
10041 ****************************************************************/
10042
10043 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
10044 struct spoolss_GetPrinterDriver *r)
10045 {
10046 p->rng_fault_state = true;
10047 return WERR_NOT_SUPPORTED;
10048 }
10049
10050 /****************************************************************
10051 _spoolss_ReadPrinter
10052 ****************************************************************/
10053
10054 WERROR _spoolss_ReadPrinter(pipes_struct *p,
10055 struct spoolss_ReadPrinter *r)
10056 {
10057 p->rng_fault_state = true;
10058 return WERR_NOT_SUPPORTED;
10059 }
10060
10061 /****************************************************************
10062 _spoolss_WaitForPrinterChange
10063 ****************************************************************/
10064
10065 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
10066 struct spoolss_WaitForPrinterChange *r)
10067 {
10068 p->rng_fault_state = true;
10069 return WERR_NOT_SUPPORTED;
10070 }
10071
10072 /****************************************************************
10073 _spoolss_ConfigurePort
10074 ****************************************************************/
10075
10076 WERROR _spoolss_ConfigurePort(pipes_struct *p,
10077 struct spoolss_ConfigurePort *r)
10078 {
10079 p->rng_fault_state = true;
10080 return WERR_NOT_SUPPORTED;
10081 }
10082
10083 /****************************************************************
10084 _spoolss_DeletePort
10085 ****************************************************************/
10086
10087 WERROR _spoolss_DeletePort(pipes_struct *p,
10088 struct spoolss_DeletePort *r)
10089 {
10090 p->rng_fault_state = true;
10091 return WERR_NOT_SUPPORTED;
10092 }
10093
10094 /****************************************************************
10095 _spoolss_CreatePrinterIC
10096 ****************************************************************/
10097
10098 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
10099 struct spoolss_CreatePrinterIC *r)
10100 {
10101 p->rng_fault_state = true;
10102 return WERR_NOT_SUPPORTED;
10103 }
10104
10105 /****************************************************************
10106 _spoolss_PlayGDIScriptOnPrinterIC
10107 ****************************************************************/
10108
10109 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
10110 struct spoolss_PlayGDIScriptOnPrinterIC *r)
10111 {
10112 p->rng_fault_state = true;
10113 return WERR_NOT_SUPPORTED;
10114 }
10115
10116 /****************************************************************
10117 _spoolss_DeletePrinterIC
10118 ****************************************************************/
10119
10120 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
10121 struct spoolss_DeletePrinterIC *r)
10122 {
10123 p->rng_fault_state = true;
10124 return WERR_NOT_SUPPORTED;
10125 }
10126
10127 /****************************************************************
10128 _spoolss_AddPrinterConnection
10129 ****************************************************************/
10130
10131 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
10132 struct spoolss_AddPrinterConnection *r)
10133 {
10134 p->rng_fault_state = true;
10135 return WERR_NOT_SUPPORTED;
10136 }
10137
10138 /****************************************************************
10139 _spoolss_DeletePrinterConnection
10140 ****************************************************************/
10141
10142 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
10143 struct spoolss_DeletePrinterConnection *r)
10144 {
10145 p->rng_fault_state = true;
10146 return WERR_NOT_SUPPORTED;
10147 }
10148
10149 /****************************************************************
10150 _spoolss_PrinterMessageBox
10151 ****************************************************************/
10152
10153 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
10154 struct spoolss_PrinterMessageBox *r)
10155 {
10156 p->rng_fault_state = true;
10157 return WERR_NOT_SUPPORTED;
10158 }
10159
10160 /****************************************************************
10161 _spoolss_AddMonitor
10162 ****************************************************************/
10163
10164 WERROR _spoolss_AddMonitor(pipes_struct *p,
10165 struct spoolss_AddMonitor *r)
10166 {
10167 p->rng_fault_state = true;
10168 return WERR_NOT_SUPPORTED;
10169 }
10170
10171 /****************************************************************
10172 _spoolss_DeleteMonitor
10173 ****************************************************************/
10174
10175 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
10176 struct spoolss_DeleteMonitor *r)
10177 {
10178 p->rng_fault_state = true;
10179 return WERR_NOT_SUPPORTED;
10180 }
10181
10182 /****************************************************************
10183 _spoolss_DeletePrintProcessor
10184 ****************************************************************/
10185
10186 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
10187 struct spoolss_DeletePrintProcessor *r)
10188 {
10189 p->rng_fault_state = true;
10190 return WERR_NOT_SUPPORTED;
10191 }
10192
10193 /****************************************************************
10194 _spoolss_AddPrintProvidor
10195 ****************************************************************/
10196
10197 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
10198 struct spoolss_AddPrintProvidor *r)
10199 {
10200 p->rng_fault_state = true;
10201 return WERR_NOT_SUPPORTED;
10202 }
10203
10204 /****************************************************************
10205 _spoolss_DeletePrintProvidor
10206 ****************************************************************/
10207
10208 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
10209 struct spoolss_DeletePrintProvidor *r)
10210 {
10211 p->rng_fault_state = true;
10212 return WERR_NOT_SUPPORTED;
10213 }
10214
10215 /****************************************************************
10216 _spoolss_FindFirstPrinterChangeNotification
10217 ****************************************************************/
10218
10219 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
10220 struct spoolss_FindFirstPrinterChangeNotification *r)
10221 {
10222 p->rng_fault_state = true;
10223 return WERR_NOT_SUPPORTED;
10224 }
10225
10226 /****************************************************************
10227 _spoolss_FindNextPrinterChangeNotification
10228 ****************************************************************/
10229
10230 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
10231 struct spoolss_FindNextPrinterChangeNotification *r)
10232 {
10233 p->rng_fault_state = true;
10234 return WERR_NOT_SUPPORTED;
10235 }
10236
10237 /****************************************************************
10238 _spoolss_RouterFindFirstPrinterChangeNotificationOld
10239 ****************************************************************/
10240
10241 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
10242 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10243 {
10244 p->rng_fault_state = true;
10245 return WERR_NOT_SUPPORTED;
10246 }
10247
10248 /****************************************************************
10249 _spoolss_ReplyOpenPrinter
10250 ****************************************************************/
10251
10252 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
10253 struct spoolss_ReplyOpenPrinter *r)
10254 {
10255 p->rng_fault_state = true;
10256 return WERR_NOT_SUPPORTED;
10257 }
10258
10259 /****************************************************************
10260 _spoolss_RouterReplyPrinter
10261 ****************************************************************/
10262
10263 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
10264 struct spoolss_RouterReplyPrinter *r)
10265 {
10266 p->rng_fault_state = true;
10267 return WERR_NOT_SUPPORTED;
10268 }
10269
10270 /****************************************************************
10271 _spoolss_ReplyClosePrinter
10272 ****************************************************************/
10273
10274 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
10275 struct spoolss_ReplyClosePrinter *r)
10276 {
10277 p->rng_fault_state = true;
10278 return WERR_NOT_SUPPORTED;
10279 }
10280
10281 /****************************************************************
10282 _spoolss_AddPortEx
10283 ****************************************************************/
10284
10285 WERROR _spoolss_AddPortEx(pipes_struct *p,
10286 struct spoolss_AddPortEx *r)
10287 {
10288 p->rng_fault_state = true;
10289 return WERR_NOT_SUPPORTED;
10290 }
10291
10292 /****************************************************************
10293 _spoolss_RouterFindFirstPrinterChangeNotification
10294 ****************************************************************/
10295
10296 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
10297 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10298 {
10299 p->rng_fault_state = true;
10300 return WERR_NOT_SUPPORTED;
10301 }
10302
10303 /****************************************************************
10304 _spoolss_SpoolerInit
10305 ****************************************************************/
10306
10307 WERROR _spoolss_SpoolerInit(pipes_struct *p,
10308 struct spoolss_SpoolerInit *r)
10309 {
10310 p->rng_fault_state = true;
10311 return WERR_NOT_SUPPORTED;
10312 }
10313
10314 /****************************************************************
10315 _spoolss_ResetPrinterEx
10316 ****************************************************************/
10317
10318 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
10319 struct spoolss_ResetPrinterEx *r)
10320 {
10321 p->rng_fault_state = true;
10322 return WERR_NOT_SUPPORTED;
10323 }
10324
10325 /****************************************************************
10326 _spoolss_RouterReplyPrinterEx
10327 ****************************************************************/
10328
10329 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
10330 struct spoolss_RouterReplyPrinterEx *r)
10331 {
10332 p->rng_fault_state = true;
10333 return WERR_NOT_SUPPORTED;
10334 }
10335
10336 /****************************************************************
10337 _spoolss_44
10338 ****************************************************************/
10339
10340 WERROR _spoolss_44(pipes_struct *p,
10341 struct spoolss_44 *r)
10342 {
10343 p->rng_fault_state = true;
10344 return WERR_NOT_SUPPORTED;
10345 }
10346
10347 /****************************************************************
10348 _spoolss_47
10349 ****************************************************************/
10350
10351 WERROR _spoolss_47(pipes_struct *p,
10352 struct spoolss_47 *r)
10353 {
10354 p->rng_fault_state = true;
10355 return WERR_NOT_SUPPORTED;
10356 }
10357
10358 /****************************************************************
10359 _spoolss_4a
10360 ****************************************************************/
10361
10362 WERROR _spoolss_4a(pipes_struct *p,
10363 struct spoolss_4a *r)
10364 {
10365 p->rng_fault_state = true;
10366 return WERR_NOT_SUPPORTED;
10367 }
10368
10369 /****************************************************************
10370 _spoolss_4b
10371 ****************************************************************/
10372
10373 WERROR _spoolss_4b(pipes_struct *p,
10374 struct spoolss_4b *r)
10375 {
10376 p->rng_fault_state = true;
10377 return WERR_NOT_SUPPORTED;
10378 }
10379
10380 /****************************************************************
10381 _spoolss_4c
10382 ****************************************************************/
10383
10384 WERROR _spoolss_4c(pipes_struct *p,
10385 struct spoolss_4c *r)
10386 {
10387 p->rng_fault_state = true;
10388 return WERR_NOT_SUPPORTED;
10389 }
10390
10391 /****************************************************************
10392 _spoolss_53
10393 ****************************************************************/
10394
10395 WERROR _spoolss_53(pipes_struct *p,
10396 struct spoolss_53 *r)
10397 {
10398 p->rng_fault_state = true;
10399 return WERR_NOT_SUPPORTED;
10400 }
10401
10402 /****************************************************************
10403 _spoolss_55
10404 ****************************************************************/
10405
10406 WERROR _spoolss_55(pipes_struct *p,
10407 struct spoolss_55 *r)
10408 {
10409 p->rng_fault_state = true;
10410 return WERR_NOT_SUPPORTED;
10411 }
10412
10413 /****************************************************************
10414 _spoolss_56
10415 ****************************************************************/
10416
10417 WERROR _spoolss_56(pipes_struct *p,
10418 struct spoolss_56 *r)
10419 {
10420 p->rng_fault_state = true;
10421 return WERR_NOT_SUPPORTED;
10422 }
10423
10424 /****************************************************************
10425 _spoolss_57
10426 ****************************************************************/
10427
10428 WERROR _spoolss_57(pipes_struct *p,
10429 struct spoolss_57 *r)
10430 {
10431 p->rng_fault_state = true;
10432 return WERR_NOT_SUPPORTED;
10433 }
10434
10435 /****************************************************************
10436 _spoolss_5a
10437 ****************************************************************/
10438
10439 WERROR _spoolss_5a(pipes_struct *p,
10440 struct spoolss_5a *r)
10441 {
10442 p->rng_fault_state = true;
10443 return WERR_NOT_SUPPORTED;
10444 }
10445
10446 /****************************************************************
10447 _spoolss_5b
10448 ****************************************************************/
10449
10450 WERROR _spoolss_5b(pipes_struct *p,
10451 struct spoolss_5b *r)
10452 {
10453 p->rng_fault_state = true;
10454 return WERR_NOT_SUPPORTED;
10455 }
10456
10457 /****************************************************************
10458 _spoolss_5c
10459 ****************************************************************/
10460
10461 WERROR _spoolss_5c(pipes_struct *p,
10462 struct spoolss_5c *r)
10463 {
10464 p->rng_fault_state = true;
10465 return WERR_NOT_SUPPORTED;
10466 }
10467
10468 /****************************************************************
10469 _spoolss_5d
10470 ****************************************************************/
10471
10472 WERROR _spoolss_5d(pipes_struct *p,
10473 struct spoolss_5d *r)
10474 {
10475 p->rng_fault_state = true;
10476 return WERR_NOT_SUPPORTED;
10477 }
10478
10479 /****************************************************************
10480 _spoolss_5e
10481 ****************************************************************/
10482
10483 WERROR _spoolss_5e(pipes_struct *p,
10484 struct spoolss_5e *r)
10485 {
10486 p->rng_fault_state = true;
10487 return WERR_NOT_SUPPORTED;
10488 }
10489
10490 /****************************************************************
10491 _spoolss_5f
10492 ****************************************************************/
10493
10494 WERROR _spoolss_5f(pipes_struct *p,
10495 struct spoolss_5f *r)
10496 {
10497 p->rng_fault_state = true;
10498 return WERR_NOT_SUPPORTED;
10499 }
10500
10501 /****************************************************************
10502 _spoolss_60
10503 ****************************************************************/
10504
10505 WERROR _spoolss_60(pipes_struct *p,
10506 struct spoolss_60 *r)
10507 {
10508 p->rng_fault_state = true;
10509 return WERR_NOT_SUPPORTED;
10510 }
10511
10512 /****************************************************************
10513 _spoolss_61
10514 ****************************************************************/
10515
10516 WERROR _spoolss_61(pipes_struct *p,
10517 struct spoolss_61 *r)
10518 {
10519 p->rng_fault_state = true;
10520 return WERR_NOT_SUPPORTED;
10521 }
10522
10523 /****************************************************************
10524 _spoolss_62
10525 ****************************************************************/
10526
10527 WERROR _spoolss_62(pipes_struct *p,
10528 struct spoolss_62 *r)
10529 {
10530 p->rng_fault_state = true;
10531 return WERR_NOT_SUPPORTED;
10532 }
10533
10534 /****************************************************************
10535 _spoolss_63
10536 ****************************************************************/
10537
10538 WERROR _spoolss_63(pipes_struct *p,
10539 struct spoolss_63 *r)
10540 {
10541 p->rng_fault_state = true;
10542 return WERR_NOT_SUPPORTED;
10543 }
10544
10545 /****************************************************************
10546 _spoolss_64
10547 ****************************************************************/
10548
10549 WERROR _spoolss_64(pipes_struct *p,
10550 struct spoolss_64 *r)
10551 {
10552 p->rng_fault_state = true;
10553 return WERR_NOT_SUPPORTED;
10554 }
10555
10556 /****************************************************************
10557 _spoolss_65
10558 ****************************************************************/
10559
10560 WERROR _spoolss_65(pipes_struct *p,
10561 struct spoolss_65 *r)
10562 {
10563 p->rng_fault_state = true;
10564 return WERR_NOT_SUPPORTED;
10565 }
10566
10567 /****************************************************************
10568 _spoolss_GetCorePrinterDrivers
10569 ****************************************************************/
10570
10571 WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p,
10572 struct spoolss_GetCorePrinterDrivers *r)
10573 {
10574 p->rng_fault_state = true;
10575 return WERR_NOT_SUPPORTED;
10576 }
10577
10578 /****************************************************************
10579 _spoolss_67
10580 ****************************************************************/
10581
10582 WERROR _spoolss_67(pipes_struct *p,
10583 struct spoolss_67 *r)
10584 {
10585 p->rng_fault_state = true;
10586 return WERR_NOT_SUPPORTED;
10587 }
10588
10589 /****************************************************************
10590 _spoolss_GetPrinterDriverPackagePath
10591 ****************************************************************/
10592
10593 WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p,
10594 struct spoolss_GetPrinterDriverPackagePath *r)
10595 {
10596 p->rng_fault_state = true;
10597 return WERR_NOT_SUPPORTED;
10598 }
10599
10600 /****************************************************************
10601 _spoolss_69
10602 ****************************************************************/
10603
10604 WERROR _spoolss_69(pipes_struct *p,
10605 struct spoolss_69 *r)
10606 {
10607 p->rng_fault_state = true;
10608 return WERR_NOT_SUPPORTED;
10609 }
10610
10611 /****************************************************************
10612 _spoolss_6a
10613 ****************************************************************/
10614
10615 WERROR _spoolss_6a(pipes_struct *p,
10616 struct spoolss_6a *r)
10617 {
10618 p->rng_fault_state = true;
10619 return WERR_NOT_SUPPORTED;
10620 }
10621
10622 /****************************************************************
10623 _spoolss_6b
10624 ****************************************************************/
10625
10626 WERROR _spoolss_6b(pipes_struct *p,
10627 struct spoolss_6b *r)
10628 {
10629 p->rng_fault_state = true;
10630 return WERR_NOT_SUPPORTED;
10631 }
10632
10633 /****************************************************************
10634 _spoolss_6c
10635 ****************************************************************/
10636
10637 WERROR _spoolss_6c(pipes_struct *p,
10638 struct spoolss_6c *r)
10639 {
10640 p->rng_fault_state = true;
10641 return WERR_NOT_SUPPORTED;
10642 }
10643
10644 /****************************************************************
10645 _spoolss_6d
10646 ****************************************************************/
10647
10648 WERROR _spoolss_6d(pipes_struct *p,
10649 struct spoolss_6d *r)
10650 {
10651 p->rng_fault_state = true;
10652 return WERR_NOT_SUPPORTED;
10653 }
reg import