?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-spoolss: in spoolss_EnumPrinters r->in.server is a *unique* pointer!
[Samba/kamenim.git] / source3 / rpc_server / srv_spoolss_nt.c
blob30bedc69e15059f8d5a23ca985bd2266fdd3f962
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-2000,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6 * Copyright (C) Jean François Micouleau 1998-2000,
7 * Copyright (C) Jeremy Allison 2001-2002,
8 * Copyright (C) Gerald Carter 2000-2004,
9 * Copyright (C) Tim Potter 2001-2002.
10 * Copyright (C) Guenther Deschner 2009.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 3 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <http://www.gnu.org/licenses/>.
24 */
25
26 /* Since the SPOOLSS rpc routines are basically DOS 16-bit calls wrapped
27 up, all the errors returned are DOS errors, not NT status codes. */
28
29 #include "includes.h"
30 #include "../librpc/gen_ndr/srv_spoolss.h"
31 #include "../librpc/gen_ndr/cli_spoolss.h"
32
33 /* macros stolen from s4 spoolss server */
34 #define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
35 ((info)?ndr_size_##fn(info, level, ic, 0):0)
36
37 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,ic,info,level,count) \
38 ((info)?ndr_size_##fn##_info(mem_ctx, ic, level, count, info):0)
39
40 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,ic,info,count) \
41 ((info)?ndr_size_##fn##_info(mem_ctx, ic, count, info):0)
42
43 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
44
45
46 extern userdom_struct current_user_info;
47
48 #undef DBGC_CLASS
49 #define DBGC_CLASS DBGC_RPC_SRV
50
51 #ifndef MAX_OPEN_PRINTER_EXS
52 #define MAX_OPEN_PRINTER_EXS 50
53 #endif
54
55 #define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
56 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
57
58 static Printer_entry *printers_list;
59
60 typedef struct _counter_printer_0 {
61 struct _counter_printer_0 *next;
62 struct _counter_printer_0 *prev;
63
64 int snum;
65 uint32_t counter;
66 } counter_printer_0;
67
68 static counter_printer_0 *counter_list;
69
70 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
71 static uint32_t smb_connections = 0;
72
73
74 /* in printing/nt_printing.c */
75
76 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
77
78 /* API table for Xcv Monitor functions */
79
80 struct xcv_api_table {
81 const char *name;
82 WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
83 };
84
85 /********************************************************************
86 * Canonicalize servername.
87 ********************************************************************/
88
89 static const char *canon_servername(const char *servername)
90 {
91 const char *pservername = servername;
92 while (*pservername == '\\') {
93 pservername++;
94 }
95 return pservername;
96 }
97
98 /* translate between internal status numbers and NT status numbers */
99 static int nt_printj_status(int v)
100 {
101 switch (v) {
102 case LPQ_QUEUED:
103 return 0;
104 case LPQ_PAUSED:
105 return JOB_STATUS_PAUSED;
106 case LPQ_SPOOLING:
107 return JOB_STATUS_SPOOLING;
108 case LPQ_PRINTING:
109 return JOB_STATUS_PRINTING;
110 case LPQ_ERROR:
111 return JOB_STATUS_ERROR;
112 case LPQ_DELETING:
113 return JOB_STATUS_DELETING;
114 case LPQ_OFFLINE:
115 return JOB_STATUS_OFFLINE;
116 case LPQ_PAPEROUT:
117 return JOB_STATUS_PAPEROUT;
118 case LPQ_PRINTED:
119 return JOB_STATUS_PRINTED;
120 case LPQ_DELETED:
121 return JOB_STATUS_DELETED;
122 case LPQ_BLOCKED:
123 return JOB_STATUS_BLOCKED_DEVQ;
124 case LPQ_USER_INTERVENTION:
125 return JOB_STATUS_USER_INTERVENTION;
126 }
127 return 0;
128 }
129
130 static int nt_printq_status(int v)
131 {
132 switch (v) {
133 case LPQ_PAUSED:
134 return PRINTER_STATUS_PAUSED;
135 case LPQ_QUEUED:
136 case LPQ_SPOOLING:
137 case LPQ_PRINTING:
138 return 0;
139 }
140 return 0;
141 }
142
143 /***************************************************************************
144 Disconnect from the client
145 ****************************************************************************/
146
147 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
148 {
149 WERROR result;
150 NTSTATUS status;
151
152 /*
153 * Tell the specific printing tdb we no longer want messages for this printer
154 * by deregistering our PID.
155 */
156
157 if (!print_notify_deregister_pid(snum))
158 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
159
160 /* weird if the test succeds !!! */
161 if (smb_connections==0) {
162 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
163 return;
164 }
165
166 status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
167 handle,
168 &result);
169 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
170 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
171 win_errstr(result)));
172
173 /* if it's the last connection, deconnect the IPC$ share */
174 if (smb_connections==1) {
175
176 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
177 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
178
179 messaging_deregister(smbd_messaging_context(),
180 MSG_PRINTER_NOTIFY2, NULL);
181
182 /* Tell the connections db we're no longer interested in
183 * printer notify messages. */
184
185 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
186 }
187
188 smb_connections--;
189 }
190
191 /****************************************************************************
192 Functions to free a printer entry datastruct.
193 ****************************************************************************/
194
195 static int printer_entry_destructor(Printer_entry *Printer)
196 {
197 if (Printer->notify.client_connected == true) {
198 int snum = -1;
199
200 if ( Printer->printer_type == SPLHND_SERVER) {
201 snum = -1;
202 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
203 } else if (Printer->printer_type == SPLHND_PRINTER) {
204 snum = print_queue_snum(Printer->sharename);
205 if (snum != -1)
206 srv_spoolss_replycloseprinter(snum,
207 &Printer->notify.client_hnd);
208 }
209 }
210
211 Printer->notify.flags=0;
212 Printer->notify.options=0;
213 Printer->notify.localmachine[0]='\0';
214 Printer->notify.printerlocal=0;
215 TALLOC_FREE(Printer->notify.option);
216 Printer->notify.client_connected = false;
217
218 free_nt_devicemode( &Printer->nt_devmode );
219 free_a_printer( &Printer->printer_info, 2 );
220
221 /* Remove from the internal list. */
222 DLIST_REMOVE(printers_list, Printer);
223 return 0;
224 }
225
226 /****************************************************************************
227 find printer index by handle
228 ****************************************************************************/
229
230 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
231 struct policy_handle *hnd)
232 {
233 Printer_entry *find_printer = NULL;
234
235 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
236 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
237 return NULL;
238 }
239
240 return find_printer;
241 }
242
243 /****************************************************************************
244 Close printer index by handle.
245 ****************************************************************************/
246
247 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
248 {
249 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
250
251 if (!Printer) {
252 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
253 OUR_HANDLE(hnd)));
254 return false;
255 }
256
257 close_policy_hnd(p, hnd);
258
259 return true;
260 }
261
262 /****************************************************************************
263 Delete a printer given a handle.
264 ****************************************************************************/
265
266 static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename)
267 {
268 char *cmd = lp_deleteprinter_cmd();
269 char *command = NULL;
270 int ret;
271 SE_PRIV se_printop = SE_PRINT_OPERATOR;
272 bool is_print_op = false;
273
274 /* can't fail if we don't try */
275
276 if ( !*cmd )
277 return WERR_OK;
278
279 command = talloc_asprintf(ctx,
280 "%s \"%s\"",
281 cmd, sharename);
282 if (!command) {
283 return WERR_NOMEM;
284 }
285 if ( token )
286 is_print_op = user_has_privileges( token, &se_printop );
287
288 DEBUG(10,("Running [%s]\n", command));
289
290 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
291
292 if ( is_print_op )
293 become_root();
294
295 if ( (ret = smbrun(command, NULL)) == 0 ) {
296 /* Tell everyone we updated smb.conf. */
297 message_send_all(smbd_messaging_context(),
298 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
299 }
300
301 if ( is_print_op )
302 unbecome_root();
303
304 /********** END SePrintOperatorPrivlege BLOCK **********/
305
306 DEBUGADD(10,("returned [%d]\n", ret));
307
308 TALLOC_FREE(command);
309
310 if (ret != 0)
311 return WERR_BADFID; /* What to return here? */
312
313 /* go ahead and re-read the services immediately */
314 become_root();
315 reload_services(false);
316 unbecome_root();
317
318 if ( lp_servicenumber( sharename ) < 0 )
319 return WERR_ACCESS_DENIED;
320
321 return WERR_OK;
322 }
323
324 /****************************************************************************
325 Delete a printer given a handle.
326 ****************************************************************************/
327
328 static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
329 {
330 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
331
332 if (!Printer) {
333 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
334 OUR_HANDLE(hnd)));
335 return WERR_BADFID;
336 }
337
338 /*
339 * It turns out that Windows allows delete printer on a handle
340 * opened by an admin user, then used on a pipe handle created
341 * by an anonymous user..... but they're working on security.... riiight !
342 * JRA.
343 */
344
345 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
346 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
347 return WERR_ACCESS_DENIED;
348 }
349
350 /* this does not need a become root since the access check has been
351 done on the handle already */
352
353 if (del_a_printer( Printer->sharename ) != 0) {
354 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
355 return WERR_BADFID;
356 }
357
358 return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
359 Printer->sharename );
360 }
361
362 /****************************************************************************
363 Return the snum of a printer corresponding to an handle.
364 ****************************************************************************/
365
366 static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
367 int *number, struct share_params **params)
368 {
369 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
370
371 if (!Printer) {
372 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
373 OUR_HANDLE(hnd)));
374 return false;
375 }
376
377 switch (Printer->printer_type) {
378 case SPLHND_PRINTER:
379 DEBUG(4,("short name:%s\n", Printer->sharename));
380 *number = print_queue_snum(Printer->sharename);
381 return (*number != -1);
382 case SPLHND_SERVER:
383 return false;
384 default:
385 return false;
386 }
387 }
388
389 /****************************************************************************
390 Set printer handle type.
391 Check if it's \\server or \\server\printer
392 ****************************************************************************/
393
394 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
395 {
396 DEBUG(3,("Setting printer type=%s\n", handlename));
397
398 if ( strlen(handlename) < 3 ) {
399 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
400 return false;
401 }
402
403 /* it's a print server */
404 if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
405 DEBUGADD(4,("Printer is a print server\n"));
406 Printer->printer_type = SPLHND_SERVER;
407 }
408 /* it's a printer (set_printer_hnd_name() will handle port monitors */
409 else {
410 DEBUGADD(4,("Printer is a printer\n"));
411 Printer->printer_type = SPLHND_PRINTER;
412 }
413
414 return true;
415 }
416
417 /****************************************************************************
418 Set printer handle name.. Accept names like \\server, \\server\printer,
419 \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port" See
420 the MSDN docs regarding OpenPrinter() for details on the XcvData() and
421 XcvDataPort() interface.
422 ****************************************************************************/
423
424 static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
425 {
426 int snum;
427 int n_services=lp_numservices();
428 char *aprinter, *printername;
429 const char *servername;
430 fstring sname;
431 bool found = false;
432 NT_PRINTER_INFO_LEVEL *printer = NULL;
433 WERROR result;
434
435 DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
436 (unsigned long)strlen(handlename)));
437
438 aprinter = CONST_DISCARD(char *, handlename);
439 if ( *handlename == '\\' ) {
440 servername = canon_servername(handlename);
441 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
442 *aprinter = '\0';
443 aprinter++;
444 }
445 } else {
446 servername = global_myname();
447 }
448
449 /* save the servername to fill in replies on this handle */
450
451 if ( !is_myname_or_ipaddr( servername ) )
452 return false;
453
454 fstrcpy( Printer->servername, servername );
455
456 if ( Printer->printer_type == SPLHND_SERVER )
457 return true;
458
459 if ( Printer->printer_type != SPLHND_PRINTER )
460 return false;
461
462 DEBUGADD(5, ("searching for [%s]\n", aprinter ));
463
464 /* check for the Port Monitor Interface */
465
466 if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
467 Printer->printer_type = SPLHND_PORTMON_TCP;
468 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
469 found = true;
470 }
471 else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
472 Printer->printer_type = SPLHND_PORTMON_LOCAL;
473 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
474 found = true;
475 }
476
477 /* Search all sharenames first as this is easier than pulling
478 the printer_info_2 off of disk. Don't use find_service() since
479 that calls out to map_username() */
480
481 /* do another loop to look for printernames */
482
483 for (snum=0; !found && snum<n_services; snum++) {
484
485 /* no point going on if this is not a printer */
486
487 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
488 continue;
489
490 fstrcpy(sname, lp_servicename(snum));
491 if ( strequal( aprinter, sname ) ) {
492 found = true;
493 break;
494 }
495
496 /* no point looking up the printer object if
497 we aren't allowing printername != sharename */
498
499 if ( lp_force_printername(snum) )
500 continue;
501
502 fstrcpy(sname, lp_servicename(snum));
503
504 printer = NULL;
505
506 /* This call doesn't fill in the location or comment from
507 * a CUPS server for efficiency with large numbers of printers.
508 * JRA.
509 */
510
511 result = get_a_printer_search( NULL, &printer, 2, sname );
512 if ( !W_ERROR_IS_OK(result) ) {
513 DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
514 sname, win_errstr(result)));
515 continue;
516 }
517
518 /* printername is always returned as \\server\printername */
519 if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
520 DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
521 printer->info_2->printername));
522 free_a_printer( &printer, 2);
523 continue;
524 }
525
526 printername++;
527
528 if ( strequal(printername, aprinter) ) {
529 free_a_printer( &printer, 2);
530 found = true;
531 break;
532 }
533
534 DEBUGADD(10, ("printername: %s\n", printername));
535
536 free_a_printer( &printer, 2);
537 }
538
539 free_a_printer( &printer, 2);
540
541 if ( !found ) {
542 DEBUGADD(4,("Printer not found\n"));
543 return false;
544 }
545
546 DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
547
548 fstrcpy(Printer->sharename, sname);
549
550 return true;
551 }
552
553 /****************************************************************************
554 Find first available printer slot. creates a printer handle for you.
555 ****************************************************************************/
556
557 static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
558 const char *name, uint32_t access_granted)
559 {
560 Printer_entry *new_printer;
561
562 DEBUG(10,("open_printer_hnd: name [%s]\n", name));
563
564 new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
565 if (new_printer == NULL) {
566 return false;
567 }
568 talloc_set_destructor(new_printer, printer_entry_destructor);
569
570 if (!create_policy_hnd(p, hnd, new_printer)) {
571 TALLOC_FREE(new_printer);
572 return false;
573 }
574
575 /* Add to the internal list. */
576 DLIST_ADD(printers_list, new_printer);
577
578 new_printer->notify.option=NULL;
579
580 if (!set_printer_hnd_printertype(new_printer, name)) {
581 close_printer_handle(p, hnd);
582 return false;
583 }
584
585 if (!set_printer_hnd_name(new_printer, name)) {
586 close_printer_handle(p, hnd);
587 return false;
588 }
589
590 new_printer->access_granted = access_granted;
591
592 DEBUG(5, ("%d printer handles active\n",
593 (int)num_pipe_handles(p->pipe_handles)));
594
595 return true;
596 }
597
598 /***************************************************************************
599 check to see if the client motify handle is monitoring the notification
600 given by (notify_type, notify_field).
601 **************************************************************************/
602
603 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
604 uint16_t notify_field)
605 {
606 return true;
607 }
608
609 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
610 uint16_t notify_field)
611 {
612 struct spoolss_NotifyOption *option = p->notify.option;
613 uint32_t i, j;
614
615 /*
616 * Flags should always be zero when the change notify
617 * is registered by the client's spooler. A user Win32 app
618 * might use the flags though instead of the NOTIFY_OPTION_INFO
619 * --jerry
620 */
621
622 if (!option) {
623 return false;
624 }
625
626 if (p->notify.flags)
627 return is_monitoring_event_flags(
628 p->notify.flags, notify_type, notify_field);
629
630 for (i = 0; i < option->count; i++) {
631
632 /* Check match for notify_type */
633
634 if (option->types[i].type != notify_type)
635 continue;
636
637 /* Check match for field */
638
639 for (j = 0; j < option->types[i].count; j++) {
640 if (option->types[i].fields[j].field == notify_field) {
641 return true;
642 }
643 }
644 }
645
646 DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
647 p->servername, p->sharename, notify_type, notify_field));
648
649 return false;
650 }
651
652 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
653 _data->data.integer[0] = _integer; \
654 _data->data.integer[1] = 0;
655
656
657 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
658 _data->data.string.string = talloc_strdup(mem_ctx, _p); \
659 if (!_data->data.string.string) {\
660 _data->data.string.size = 0; \
661 } \
662 _data->data.string.size = strlen_m_term(_p) * 2;
663
664 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
665 _data->data.devmode.devmode = _devmode;
666
667 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
668 _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
669 if (!_data->data.sd.sd) { \
670 _data->data.sd.sd_size = 0; \
671 } \
672 _data->data.sd.sd_size = _size;
673
674 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
675 struct tm *t,
676 const char **pp,
677 uint32_t *plen)
678 {
679 struct spoolss_Time st;
680 uint32_t len = 16;
681 char *p;
682
683 if (!init_systemtime(&st, t)) {
684 return;
685 }
686
687 p = talloc_array(mem_ctx, char, len);
688 if (!p) {
689 return;
690 }
691
692 /*
693 * Systemtime must be linearized as a set of UINT16's.
694 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
695 */
696
697 SSVAL(p, 0, st.year);
698 SSVAL(p, 2, st.month);
699 SSVAL(p, 4, st.day_of_week);
700 SSVAL(p, 6, st.day);
701 SSVAL(p, 8, st.hour);
702 SSVAL(p, 10, st.minute);
703 SSVAL(p, 12, st.second);
704 SSVAL(p, 14, st.millisecond);
705
706 *pp = p;
707 *plen = len;
708 }
709
710 /* Convert a notification message to a struct spoolss_Notify */
711
712 static void notify_one_value(struct spoolss_notify_msg *msg,
713 struct spoolss_Notify *data,
714 TALLOC_CTX *mem_ctx)
715 {
716 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
717 }
718
719 static void notify_string(struct spoolss_notify_msg *msg,
720 struct spoolss_Notify *data,
721 TALLOC_CTX *mem_ctx)
722 {
723 /* The length of the message includes the trailing \0 */
724
725 data->data.string.size = msg->len * 2;
726 data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
727 if (!data->data.string.string) {
728 data->data.string.size = 0;
729 return;
730 }
731 }
732
733 static void notify_system_time(struct spoolss_notify_msg *msg,
734 struct spoolss_Notify *data,
735 TALLOC_CTX *mem_ctx)
736 {
737 data->data.string.string = NULL;
738 data->data.string.size = 0;
739
740 if (msg->len != sizeof(time_t)) {
741 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
742 msg->len));
743 return;
744 }
745
746 init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
747 &data->data.string.string,
748 &data->data.string.size);
749 }
750
751 struct notify2_message_table {
752 const char *name;
753 void (*fn)(struct spoolss_notify_msg *msg,
754 struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
755 };
756
757 static struct notify2_message_table printer_notify_table[] = {
758 /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
759 /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
760 /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
761 /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
762 /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
763 /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
764 /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
765 /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
766 /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
767 /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
768 /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
769 /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
770 /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
771 /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
772 /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
773 /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
774 /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
775 /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
776 /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
777 };
778
779 static struct notify2_message_table job_notify_table[] = {
780 /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
781 /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
782 /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
783 /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
784 /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
785 /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
786 /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
787 /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
788 /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
789 /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
790 /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
791 /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
792 /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
793 /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
794 /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
795 /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
796 /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
797 /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
798 /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
799 /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
800 /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
801 /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
802 /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
803 /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
804 };
805
806
807 /***********************************************************************
808 Allocate talloc context for container object
809 **********************************************************************/
810
811 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
812 {
813 if ( !ctr )
814 return;
815
816 ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
817
818 return;
819 }
820
821 /***********************************************************************
822 release all allocated memory and zero out structure
823 **********************************************************************/
824
825 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
826 {
827 if ( !ctr )
828 return;
829
830 if ( ctr->ctx )
831 talloc_destroy(ctr->ctx);
832
833 ZERO_STRUCTP(ctr);
834
835 return;
836 }
837
838 /***********************************************************************
839 **********************************************************************/
840
841 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
842 {
843 if ( !ctr )
844 return NULL;
845
846 return ctr->ctx;
847 }
848
849 /***********************************************************************
850 **********************************************************************/
851
852 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
853 {
854 if ( !ctr || !ctr->msg_groups )
855 return NULL;
856
857 if ( idx >= ctr->num_groups )
858 return NULL;
859
860 return &ctr->msg_groups[idx];
861
862 }
863
864 /***********************************************************************
865 How many groups of change messages do we have ?
866 **********************************************************************/
867
868 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
869 {
870 if ( !ctr )
871 return 0;
872
873 return ctr->num_groups;
874 }
875
876 /***********************************************************************
877 Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
878 **********************************************************************/
879
880 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
881 {
882 SPOOLSS_NOTIFY_MSG_GROUP *groups = NULL;
883 SPOOLSS_NOTIFY_MSG_GROUP *msg_grp = NULL;
884 SPOOLSS_NOTIFY_MSG *msg_list = NULL;
885 int i, new_slot;
886
887 if ( !ctr || !msg )
888 return 0;
889
890 /* loop over all groups looking for a matching printer name */
891
892 for ( i=0; i<ctr->num_groups; i++ ) {
893 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
894 break;
895 }
896
897 /* add a new group? */
898
899 if ( i == ctr->num_groups ) {
900 ctr->num_groups++;
901
902 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
903 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
904 return 0;
905 }
906 ctr->msg_groups = groups;
907
908 /* clear the new entry and set the printer name */
909
910 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
911 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
912 }
913
914 /* add the change messages; 'i' is the correct index now regardless */
915
916 msg_grp = &ctr->msg_groups[i];
917
918 msg_grp->num_msgs++;
919
920 if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
921 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
922 return 0;
923 }
924 msg_grp->msgs = msg_list;
925
926 new_slot = msg_grp->num_msgs-1;
927 memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
928
929 /* need to allocate own copy of data */
930
931 if ( msg->len != 0 )
932 msg_grp->msgs[new_slot].notify.data = (char *)
933 TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
934
935 return ctr->num_groups;
936 }
937
938 /***********************************************************************
939 Send a change notication message on all handles which have a call
940 back registered
941 **********************************************************************/
942
943 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
944 {
945 Printer_entry *p;
946 TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
947 SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
948 SPOOLSS_NOTIFY_MSG *messages;
949 int sending_msg_count;
950
951 if ( !msg_group ) {
952 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
953 return;
954 }
955
956 messages = msg_group->msgs;
957
958 if ( !messages ) {
959 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
960 return;
961 }
962
963 DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
964
965 /* loop over all printers */
966
967 for (p = printers_list; p; p = p->next) {
968 struct spoolss_Notify *notifies;
969 uint32_t count = 0;
970 uint32_t id;
971 int i;
972
973 /* Is there notification on this handle? */
974
975 if ( !p->notify.client_connected )
976 continue;
977
978 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
979
980 /* For this printer? Print servers always receive
981 notifications. */
982
983 if ( ( p->printer_type == SPLHND_PRINTER ) &&
984 ( !strequal(msg_group->printername, p->sharename) ) )
985 continue;
986
987 DEBUG(10,("Our printer\n"));
988
989 /* allocate the max entries possible */
990
991 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
992 if (!notifies) {
993 return;
994 }
995
996 /* build the array of change notifications */
997
998 sending_msg_count = 0;
999
1000 for ( i=0; i<msg_group->num_msgs; i++ ) {
1001 SPOOLSS_NOTIFY_MSG *msg = &messages[i];
1002
1003 /* Are we monitoring this event? */
1004
1005 if (!is_monitoring_event(p, msg->type, msg->field))
1006 continue;
1007
1008 sending_msg_count++;
1009
1010
1011 DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1012 msg->type, msg->field, p->sharename));
1013
1014 /*
1015 * if the is a printer notification handle and not a job notification
1016 * type, then set the id to 0. Other wise just use what was specified
1017 * in the message.
1018 *
1019 * When registering change notification on a print server handle
1020 * we always need to send back the id (snum) matching the printer
1021 * for which the change took place. For change notify registered
1022 * on a printer handle, this does not matter and the id should be 0.
1023 *
1024 * --jerry
1025 */
1026
1027 if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1028 id = 0;
1029 else
1030 id = msg->id;
1031
1032
1033 /* Convert unix jobid to smb jobid */
1034
1035 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1036 id = sysjob_to_jobid(msg->id);
1037
1038 if (id == -1) {
1039 DEBUG(3, ("no such unix jobid %d\n", msg->id));
1040 goto done;
1041 }
1042 }
1043
1044 construct_info_data( &notifies[count], msg->type, msg->field, id );
1045
1046 switch(msg->type) {
1047 case PRINTER_NOTIFY_TYPE:
1048 if ( printer_notify_table[msg->field].fn )
1049 printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1050 break;
1051
1052 case JOB_NOTIFY_TYPE:
1053 if ( job_notify_table[msg->field].fn )
1054 job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1055 break;
1056
1057 default:
1058 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1059 goto done;
1060 }
1061
1062 count++;
1063 }
1064
1065 if ( sending_msg_count ) {
1066 NTSTATUS status;
1067 WERROR werr;
1068 union spoolss_ReplyPrinterInfo info;
1069 struct spoolss_NotifyInfo info0;
1070 uint32_t reply_result;
1071
1072 info0.version = 0x2;
1073 info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1074 info0.count = count;
1075 info0.notifies = notifies;
1076
1077 info.info0 = &info0;
1078
1079 status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1080 &p->notify.client_hnd,
1081 p->notify.change, /* color */
1082 p->notify.flags,
1083 &reply_result,
1084 0, /* reply_type, must be 0 */
1085 info,
1086 &werr);
1087 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1088 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1089 notify_cli_pipe->srv_name_slash,
1090 win_errstr(werr)));
1091 }
1092 switch (reply_result) {
1093 case 0:
1094 break;
1095 case PRINTER_NOTIFY_INFO_DISCARDED:
1096 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1097 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1098 break;
1099 default:
1100 break;
1101 }
1102 }
1103 }
1104
1105 done:
1106 DEBUG(8,("send_notify2_changes: Exit...\n"));
1107 return;
1108 }
1109
1110 /***********************************************************************
1111 **********************************************************************/
1112
1113 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1114 {
1115
1116 uint32_t tv_sec, tv_usec;
1117 size_t offset = 0;
1118
1119 /* Unpack message */
1120
1121 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1122 msg->printer);
1123
1124 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1125 &tv_sec, &tv_usec,
1126 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1127
1128 if (msg->len == 0)
1129 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1130 &msg->notify.value[0], &msg->notify.value[1]);
1131 else
1132 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1133 &msg->len, &msg->notify.data);
1134
1135 DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1136 msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1137
1138 tv->tv_sec = tv_sec;
1139 tv->tv_usec = tv_usec;
1140
1141 if (msg->len == 0)
1142 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1143 msg->notify.value[1]));
1144 else
1145 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1146
1147 return true;
1148 }
1149
1150 /********************************************************************
1151 Receive a notify2 message list
1152 ********************************************************************/
1153
1154 static void receive_notify2_message_list(struct messaging_context *msg,
1155 void *private_data,
1156 uint32_t msg_type,
1157 struct server_id server_id,
1158 DATA_BLOB *data)
1159 {
1160 size_t msg_count, i;
1161 char *buf = (char *)data->data;
1162 char *msg_ptr;
1163 size_t msg_len;
1164 SPOOLSS_NOTIFY_MSG notify;
1165 SPOOLSS_NOTIFY_MSG_CTR messages;
1166 int num_groups;
1167
1168 if (data->length < 4) {
1169 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1170 return;
1171 }
1172
1173 msg_count = IVAL(buf, 0);
1174 msg_ptr = buf + 4;
1175
1176 DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1177
1178 if (msg_count == 0) {
1179 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1180 return;
1181 }
1182
1183 /* initialize the container */
1184
1185 ZERO_STRUCT( messages );
1186 notify_msg_ctr_init( &messages );
1187
1188 /*
1189 * build message groups for each printer identified
1190 * in a change_notify msg. Remember that a PCN message
1191 * includes the handle returned for the srv_spoolss_replyopenprinter()
1192 * call. Therefore messages are grouped according to printer handle.
1193 */
1194
1195 for ( i=0; i<msg_count; i++ ) {
1196 struct timeval msg_tv;
1197
1198 if (msg_ptr + 4 - buf > data->length) {
1199 DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1200 return;
1201 }
1202
1203 msg_len = IVAL(msg_ptr,0);
1204 msg_ptr += 4;
1205
1206 if (msg_ptr + msg_len - buf > data->length) {
1207 DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1208 return;
1209 }
1210
1211 /* unpack messages */
1212
1213 ZERO_STRUCT( notify );
1214 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1215 msg_ptr += msg_len;
1216
1217 /* add to correct list in container */
1218
1219 notify_msg_ctr_addmsg( &messages, &notify );
1220
1221 /* free memory that might have been allocated by notify2_unpack_msg() */
1222
1223 if ( notify.len != 0 )
1224 SAFE_FREE( notify.notify.data );
1225 }
1226
1227 /* process each group of messages */
1228
1229 num_groups = notify_msg_ctr_numgroups( &messages );
1230 for ( i=0; i<num_groups; i++ )
1231 send_notify2_changes( &messages, i );
1232
1233
1234 /* cleanup */
1235
1236 DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1237 (uint32_t)msg_count ));
1238
1239 notify_msg_ctr_destroy( &messages );
1240
1241 return;
1242 }
1243
1244 /********************************************************************
1245 Send a message to ourself about new driver being installed
1246 so we can upgrade the information for each printer bound to this
1247 driver
1248 ********************************************************************/
1249
1250 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1251 {
1252 int len = strlen(drivername);
1253
1254 if (!len)
1255 return false;
1256
1257 DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1258 drivername));
1259
1260 messaging_send_buf(smbd_messaging_context(), procid_self(),
1261 MSG_PRINTER_DRVUPGRADE,
1262 (uint8_t *)drivername, len+1);
1263
1264 return true;
1265 }
1266
1267 /**********************************************************************
1268 callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1269 over all printers, upgrading ones as necessary
1270 **********************************************************************/
1271
1272 void do_drv_upgrade_printer(struct messaging_context *msg,
1273 void *private_data,
1274 uint32_t msg_type,
1275 struct server_id server_id,
1276 DATA_BLOB *data)
1277 {
1278 fstring drivername;
1279 int snum;
1280 int n_services = lp_numservices();
1281 size_t len;
1282
1283 len = MIN(data->length,sizeof(drivername)-1);
1284 strncpy(drivername, (const char *)data->data, len);
1285
1286 DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1287
1288 /* Iterate the printer list */
1289
1290 for (snum=0; snum<n_services; snum++)
1291 {
1292 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1293 {
1294 WERROR result;
1295 NT_PRINTER_INFO_LEVEL *printer = NULL;
1296
1297 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1298 if (!W_ERROR_IS_OK(result))
1299 continue;
1300
1301 if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1302 {
1303 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1304
1305 /* all we care about currently is the change_id */
1306
1307 result = mod_a_printer(printer, 2);
1308 if (!W_ERROR_IS_OK(result)) {
1309 DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1310 win_errstr(result)));
1311 }
1312 }
1313
1314 free_a_printer(&printer, 2);
1315 }
1316 }
1317
1318 /* all done */
1319 }
1320
1321 /********************************************************************
1322 Update the cache for all printq's with a registered client
1323 connection
1324 ********************************************************************/
1325
1326 void update_monitored_printq_cache( void )
1327 {
1328 Printer_entry *printer = printers_list;
1329 int snum;
1330
1331 /* loop through all printers and update the cache where
1332 client_connected == true */
1333 while ( printer )
1334 {
1335 if ( (printer->printer_type == SPLHND_PRINTER)
1336 && printer->notify.client_connected )
1337 {
1338 snum = print_queue_snum(printer->sharename);
1339 print_queue_status( snum, NULL, NULL );
1340 }
1341
1342 printer = printer->next;
1343 }
1344
1345 return;
1346 }
1347 /********************************************************************
1348 Send a message to ourself about new driver being installed
1349 so we can upgrade the information for each printer bound to this
1350 driver
1351 ********************************************************************/
1352
1353 static bool srv_spoolss_reset_printerdata(char* drivername)
1354 {
1355 int len = strlen(drivername);
1356
1357 if (!len)
1358 return false;
1359
1360 DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1361 drivername));
1362
1363 messaging_send_buf(smbd_messaging_context(), procid_self(),
1364 MSG_PRINTERDATA_INIT_RESET,
1365 (uint8_t *)drivername, len+1);
1366
1367 return true;
1368 }
1369
1370 /**********************************************************************
1371 callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1372 over all printers, resetting printer data as neessary
1373 **********************************************************************/
1374
1375 void reset_all_printerdata(struct messaging_context *msg,
1376 void *private_data,
1377 uint32_t msg_type,
1378 struct server_id server_id,
1379 DATA_BLOB *data)
1380 {
1381 fstring drivername;
1382 int snum;
1383 int n_services = lp_numservices();
1384 size_t len;
1385
1386 len = MIN( data->length, sizeof(drivername)-1 );
1387 strncpy( drivername, (const char *)data->data, len );
1388
1389 DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1390
1391 /* Iterate the printer list */
1392
1393 for ( snum=0; snum<n_services; snum++ )
1394 {
1395 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1396 {
1397 WERROR result;
1398 NT_PRINTER_INFO_LEVEL *printer = NULL;
1399
1400 result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1401 if ( !W_ERROR_IS_OK(result) )
1402 continue;
1403
1404 /*
1405 * if the printer is bound to the driver,
1406 * then reset to the new driver initdata
1407 */
1408
1409 if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1410 {
1411 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1412
1413 if ( !set_driver_init(printer, 2) ) {
1414 DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1415 printer->info_2->printername, printer->info_2->drivername));
1416 }
1417
1418 result = mod_a_printer( printer, 2 );
1419 if ( !W_ERROR_IS_OK(result) ) {
1420 DEBUG(3,("reset_all_printerdata: mod_a_printer() failed! (%s)\n",
1421 get_dos_error_msg(result)));
1422 }
1423 }
1424
1425 free_a_printer( &printer, 2 );
1426 }
1427 }
1428
1429 /* all done */
1430
1431 return;
1432 }
1433
1434 /****************************************************************
1435 _spoolss_OpenPrinter
1436 ****************************************************************/
1437
1438 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1439 struct spoolss_OpenPrinter *r)
1440 {
1441 struct spoolss_OpenPrinterEx e;
1442 WERROR werr;
1443
1444 ZERO_STRUCT(e.in.userlevel);
1445
1446 e.in.printername = r->in.printername;
1447 e.in.datatype = r->in.datatype;
1448 e.in.devmode_ctr = r->in.devmode_ctr;
1449 e.in.access_mask = r->in.access_mask;
1450 e.in.level = 0;
1451
1452 e.out.handle = r->out.handle;
1453
1454 werr = _spoolss_OpenPrinterEx(p, &e);
1455
1456 if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1457 /* OpenPrinterEx returns this for a bad
1458 * printer name. We must return WERR_INVALID_PRINTER_NAME
1459 * instead.
1460 */
1461 werr = WERR_INVALID_PRINTER_NAME;
1462 }
1463
1464 return werr;
1465 }
1466
1467 /********************************************************************
1468 ********************************************************************/
1469
1470 bool convert_devicemode(const char *printername,
1471 const struct spoolss_DeviceMode *devmode,
1472 NT_DEVICEMODE **pp_nt_devmode)
1473 {
1474 NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1475
1476 /*
1477 * Ensure nt_devmode is a valid pointer
1478 * as we will be overwriting it.
1479 */
1480
1481 if (nt_devmode == NULL) {
1482 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1483 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1484 return false;
1485 }
1486
1487 fstrcpy(nt_devmode->devicename, devmode->devicename);
1488 fstrcpy(nt_devmode->formname, devmode->formname);
1489
1490 nt_devmode->devicename[31] = '\0';
1491 nt_devmode->formname[31] = '\0';
1492
1493 nt_devmode->specversion = devmode->specversion;
1494 nt_devmode->driverversion = devmode->driverversion;
1495 nt_devmode->size = devmode->size;
1496 nt_devmode->fields = devmode->fields;
1497 nt_devmode->orientation = devmode->orientation;
1498 nt_devmode->papersize = devmode->papersize;
1499 nt_devmode->paperlength = devmode->paperlength;
1500 nt_devmode->paperwidth = devmode->paperwidth;
1501 nt_devmode->scale = devmode->scale;
1502 nt_devmode->copies = devmode->copies;
1503 nt_devmode->defaultsource = devmode->defaultsource;
1504 nt_devmode->printquality = devmode->printquality;
1505 nt_devmode->color = devmode->color;
1506 nt_devmode->duplex = devmode->duplex;
1507 nt_devmode->yresolution = devmode->yresolution;
1508 nt_devmode->ttoption = devmode->ttoption;
1509 nt_devmode->collate = devmode->collate;
1510
1511 nt_devmode->logpixels = devmode->logpixels;
1512 nt_devmode->bitsperpel = devmode->bitsperpel;
1513 nt_devmode->pelswidth = devmode->pelswidth;
1514 nt_devmode->pelsheight = devmode->pelsheight;
1515 nt_devmode->displayflags = devmode->displayflags;
1516 nt_devmode->displayfrequency = devmode->displayfrequency;
1517 nt_devmode->icmmethod = devmode->icmmethod;
1518 nt_devmode->icmintent = devmode->icmintent;
1519 nt_devmode->mediatype = devmode->mediatype;
1520 nt_devmode->dithertype = devmode->dithertype;
1521 nt_devmode->reserved1 = devmode->reserved1;
1522 nt_devmode->reserved2 = devmode->reserved2;
1523 nt_devmode->panningwidth = devmode->panningwidth;
1524 nt_devmode->panningheight = devmode->panningheight;
1525
1526 /*
1527 * Only change private and driverextra if the incoming devmode
1528 * has a new one. JRA.
1529 */
1530
1531 if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1532 SAFE_FREE(nt_devmode->nt_dev_private);
1533 nt_devmode->driverextra = devmode->__driverextra_length;
1534 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1535 return false;
1536 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1537 }
1538
1539 *pp_nt_devmode = nt_devmode;
1540
1541 return true;
1542 }
1543
1544 /****************************************************************
1545 _spoolss_OpenPrinterEx
1546 ****************************************************************/
1547
1548 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1549 struct spoolss_OpenPrinterEx *r)
1550 {
1551 int snum;
1552 Printer_entry *Printer=NULL;
1553
1554 if (!r->in.printername) {
1555 return WERR_INVALID_PARAM;
1556 }
1557
1558 /* some sanity check because you can open a printer or a print server */
1559 /* aka: \\server\printer or \\server */
1560
1561 DEBUGADD(3,("checking name: %s\n", r->in.printername));
1562
1563 if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1564 ZERO_STRUCTP(r->out.handle);
1565 return WERR_INVALID_PARAM;
1566 }
1567
1568 Printer = find_printer_index_by_hnd(p, r->out.handle);
1569 if ( !Printer ) {
1570 DEBUG(0,("_spoolss_OpenPrinterEx: logic error. Can't find printer "
1571 "handle we created for printer %s\n", r->in.printername));
1572 close_printer_handle(p, r->out.handle);
1573 ZERO_STRUCTP(r->out.handle);
1574 return WERR_INVALID_PARAM;
1575 }
1576
1577 /*
1578 * First case: the user is opening the print server:
1579 *
1580 * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1581 * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1582 *
1583 * Then both Win2k and WinNT clients try an OpenPrinterEx with
1584 * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1585 * or if the user is listed in the smb.conf printer admin parameter.
1586 *
1587 * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1588 * client view printer folder, but does not show the MSAPW.
1589 *
1590 * Note: this test needs code to check access rights here too. Jeremy
1591 * could you look at this?
1592 *
1593 * Second case: the user is opening a printer:
1594 * NT doesn't let us connect to a printer if the connecting user
1595 * doesn't have print permission.
1596 *
1597 * Third case: user is opening a Port Monitor
1598 * access checks same as opening a handle to the print server.
1599 */
1600
1601 switch (Printer->printer_type )
1602 {
1603 case SPLHND_SERVER:
1604 case SPLHND_PORTMON_TCP:
1605 case SPLHND_PORTMON_LOCAL:
1606 /* Printserver handles use global struct... */
1607
1608 snum = -1;
1609
1610 /* Map standard access rights to object specific access rights */
1611
1612 se_map_standard(&r->in.access_mask,
1613 &printserver_std_mapping);
1614
1615 /* Deny any object specific bits that don't apply to print
1616 servers (i.e printer and job specific bits) */
1617
1618 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1619
1620 if (r->in.access_mask &
1621 ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1622 DEBUG(3, ("access DENIED for non-printserver bits\n"));
1623 close_printer_handle(p, r->out.handle);
1624 ZERO_STRUCTP(r->out.handle);
1625 return WERR_ACCESS_DENIED;
1626 }
1627
1628 /* Allow admin access */
1629
1630 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1631 {
1632 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1633
1634 if (!lp_ms_add_printer_wizard()) {
1635 close_printer_handle(p, r->out.handle);
1636 ZERO_STRUCTP(r->out.handle);
1637 return WERR_ACCESS_DENIED;
1638 }
1639
1640 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1641 and not a printer admin, then fail */
1642
1643 if ((p->server_info->utok.uid != sec_initial_uid()) &&
1644 !user_has_privileges(p->server_info->ptok,
1645 &se_printop ) &&
1646 !token_contains_name_in_list(
1647 uidtoname(p->server_info->utok.uid),
1648 NULL, NULL,
1649 p->server_info->ptok,
1650 lp_printer_admin(snum))) {
1651 close_printer_handle(p, r->out.handle);
1652 ZERO_STRUCTP(r->out.handle);
1653 return WERR_ACCESS_DENIED;
1654 }
1655
1656 r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1657 }
1658 else
1659 {
1660 r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1661 }
1662
1663 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1664 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1665
1666 /* We fall through to return WERR_OK */
1667 break;
1668
1669 case SPLHND_PRINTER:
1670 /* NT doesn't let us connect to a printer if the connecting user
1671 doesn't have print permission. */
1672
1673 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1674 close_printer_handle(p, r->out.handle);
1675 ZERO_STRUCTP(r->out.handle);
1676 return WERR_BADFID;
1677 }
1678
1679 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1680 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1681 }
1682
1683 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1684
1685 /* map an empty access mask to the minimum access mask */
1686 if (r->in.access_mask == 0x0)
1687 r->in.access_mask = PRINTER_ACCESS_USE;
1688
1689 /*
1690 * If we are not serving the printer driver for this printer,
1691 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1692 * will keep NT clients happy --jerry
1693 */
1694
1695 if (lp_use_client_driver(snum)
1696 && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1697 {
1698 r->in.access_mask = PRINTER_ACCESS_USE;
1699 }
1700
1701 /* check smb.conf parameters and the the sec_desc */
1702
1703 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1704 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1705 ZERO_STRUCTP(r->out.handle);
1706 return WERR_ACCESS_DENIED;
1707 }
1708
1709 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1710 p->server_info->ptok, snum) ||
1711 !print_access_check(p->server_info, snum,
1712 r->in.access_mask)) {
1713 DEBUG(3, ("access DENIED for printer open\n"));
1714 close_printer_handle(p, r->out.handle);
1715 ZERO_STRUCTP(r->out.handle);
1716 return WERR_ACCESS_DENIED;
1717 }
1718
1719 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1720 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1721 close_printer_handle(p, r->out.handle);
1722 ZERO_STRUCTP(r->out.handle);
1723 return WERR_ACCESS_DENIED;
1724 }
1725
1726 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1727 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1728 else
1729 r->in.access_mask = PRINTER_ACCESS_USE;
1730
1731 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1732 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1733
1734 break;
1735
1736 default:
1737 /* sanity check to prevent programmer error */
1738 ZERO_STRUCTP(r->out.handle);
1739 return WERR_BADFID;
1740 }
1741
1742 Printer->access_granted = r->in.access_mask;
1743
1744 /*
1745 * If the client sent a devmode in the OpenPrinter() call, then
1746 * save it here in case we get a job submission on this handle
1747 */
1748
1749 if ((Printer->printer_type != SPLHND_SERVER) &&
1750 r->in.devmode_ctr.devmode) {
1751 convert_devicemode(Printer->sharename,
1752 r->in.devmode_ctr.devmode,
1753 &Printer->nt_devmode);
1754 }
1755
1756 #if 0 /* JERRY -- I'm doubtful this is really effective */
1757 /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1758 optimization in Windows 2000 clients --jerry */
1759
1760 if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1761 && (RA_WIN2K == get_remote_arch()) )
1762 {
1763 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1764 sys_usleep( 500000 );
1765 }
1766 #endif
1767
1768 return WERR_OK;
1769 }
1770
1771 /****************************************************************************
1772 ****************************************************************************/
1773
1774 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1775 NT_PRINTER_INFO_LEVEL_2 *d)
1776 {
1777 DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1778
1779 if (!r || !d) {
1780 return false;
1781 }
1782
1783 d->attributes = r->attributes;
1784 d->priority = r->priority;
1785 d->default_priority = r->defaultpriority;
1786 d->starttime = r->starttime;
1787 d->untiltime = r->untiltime;
1788 d->status = r->status;
1789 d->cjobs = r->cjobs;
1790
1791 fstrcpy(d->servername, r->servername);
1792 fstrcpy(d->printername, r->printername);
1793 fstrcpy(d->sharename, r->sharename);
1794 fstrcpy(d->portname, r->portname);
1795 fstrcpy(d->drivername, r->drivername);
1796 slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1797 fstrcpy(d->location, r->location);
1798 fstrcpy(d->sepfile, r->sepfile);
1799 fstrcpy(d->printprocessor, r->printprocessor);
1800 fstrcpy(d->datatype, r->datatype);
1801 fstrcpy(d->parameters, r->parameters);
1802
1803 return true;
1804 }
1805
1806 /****************************************************************************
1807 ****************************************************************************/
1808
1809 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1810 NT_PRINTER_INFO_LEVEL *printer)
1811 {
1812 bool ret;
1813
1814 switch (info_ctr->level) {
1815 case 2:
1816 /* allocate memory if needed. Messy because
1817 convert_printer_info is used to update an existing
1818 printer or build a new one */
1819
1820 if (!printer->info_2) {
1821 printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1822 if (!printer->info_2) {
1823 DEBUG(0,("convert_printer_info: "
1824 "talloc() failed!\n"));
1825 return false;
1826 }
1827 }
1828
1829 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1830 printer->info_2);
1831 printer->info_2->setuptime = time(NULL);
1832 return ret;
1833 }
1834
1835 return false;
1836 }
1837
1838 /****************************************************************
1839 _spoolss_ClosePrinter
1840 ****************************************************************/
1841
1842 WERROR _spoolss_ClosePrinter(pipes_struct *p,
1843 struct spoolss_ClosePrinter *r)
1844 {
1845 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1846
1847 if (Printer && Printer->document_started) {
1848 struct spoolss_EndDocPrinter e;
1849
1850 e.in.handle = r->in.handle;
1851
1852 _spoolss_EndDocPrinter(p, &e);
1853 }
1854
1855 if (!close_printer_handle(p, r->in.handle))
1856 return WERR_BADFID;
1857
1858 /* clear the returned printer handle. Observed behavior
1859 from Win2k server. Don't think this really matters.
1860 Previous code just copied the value of the closed
1861 handle. --jerry */
1862
1863 ZERO_STRUCTP(r->out.handle);
1864
1865 return WERR_OK;
1866 }
1867
1868 /****************************************************************
1869 _spoolss_DeletePrinter
1870 ****************************************************************/
1871
1872 WERROR _spoolss_DeletePrinter(pipes_struct *p,
1873 struct spoolss_DeletePrinter *r)
1874 {
1875 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
1876 WERROR result;
1877
1878 if (Printer && Printer->document_started) {
1879 struct spoolss_EndDocPrinter e;
1880
1881 e.in.handle = r->in.handle;
1882
1883 _spoolss_EndDocPrinter(p, &e);
1884 }
1885
1886 result = delete_printer_handle(p, r->in.handle);
1887
1888 update_c_setprinter(false);
1889
1890 return result;
1891 }
1892
1893 /*******************************************************************
1894 * static function to lookup the version id corresponding to an
1895 * long architecture string
1896 ******************************************************************/
1897
1898 static const struct print_architecture_table_node archi_table[]= {
1899
1900 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
1901 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
1902 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
1903 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
1904 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
1905 {"Windows IA64", SPL_ARCH_IA64, 3 },
1906 {"Windows x64", SPL_ARCH_X64, 3 },
1907 {NULL, "", -1 }
1908 };
1909
1910 static int get_version_id(const char *arch)
1911 {
1912 int i;
1913
1914 for (i=0; archi_table[i].long_archi != NULL; i++)
1915 {
1916 if (strcmp(arch, archi_table[i].long_archi) == 0)
1917 return (archi_table[i].version);
1918 }
1919
1920 return -1;
1921 }
1922
1923 /****************************************************************
1924 _spoolss_DeletePrinterDriver
1925 ****************************************************************/
1926
1927 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
1928 struct spoolss_DeletePrinterDriver *r)
1929 {
1930
1931 struct spoolss_DriverInfo8 *info = NULL;
1932 struct spoolss_DriverInfo8 *info_win2k = NULL;
1933 int version;
1934 WERROR status;
1935 WERROR status_win2k = WERR_ACCESS_DENIED;
1936 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1937
1938 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1939 and not a printer admin, then fail */
1940
1941 if ( (p->server_info->utok.uid != sec_initial_uid())
1942 && !user_has_privileges(p->server_info->ptok, &se_printop )
1943 && !token_contains_name_in_list(
1944 uidtoname(p->server_info->utok.uid), NULL,
1945 NULL, p->server_info->ptok,
1946 lp_printer_admin(-1)) )
1947 {
1948 return WERR_ACCESS_DENIED;
1949 }
1950
1951 /* check that we have a valid driver name first */
1952
1953 if ((version = get_version_id(r->in.architecture)) == -1)
1954 return WERR_INVALID_ENVIRONMENT;
1955
1956 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
1957 r->in.architecture,
1958 version)))
1959 {
1960 /* try for Win2k driver if "Windows NT x86" */
1961
1962 if ( version == 2 ) {
1963 version = 3;
1964 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
1965 &info,
1966 r->in.driver,
1967 r->in.architecture,
1968 version))) {
1969 status = WERR_UNKNOWN_PRINTER_DRIVER;
1970 goto done;
1971 }
1972 }
1973 /* otherwise it was a failure */
1974 else {
1975 status = WERR_UNKNOWN_PRINTER_DRIVER;
1976 goto done;
1977 }
1978
1979 }
1980
1981 if (printer_driver_in_use(info)) {
1982 status = WERR_PRINTER_DRIVER_IN_USE;
1983 goto done;
1984 }
1985
1986 if ( version == 2 )
1987 {
1988 if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
1989 &info_win2k,
1990 r->in.driver,
1991 r->in.architecture, 3)))
1992 {
1993 /* if we get to here, we now have 2 driver info structures to remove */
1994 /* remove the Win2k driver first*/
1995
1996 status_win2k = delete_printer_driver(
1997 p, info_win2k, 3, false);
1998 free_a_printer_driver(info_win2k);
1999
2000 /* this should not have failed---if it did, report to client */
2001 if ( !W_ERROR_IS_OK(status_win2k) )
2002 {
2003 status = status_win2k;
2004 goto done;
2005 }
2006 }
2007 }
2008
2009 status = delete_printer_driver(p, info, version, false);
2010
2011 /* if at least one of the deletes succeeded return OK */
2012
2013 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2014 status = WERR_OK;
2015
2016 done:
2017 free_a_printer_driver(info);
2018
2019 return status;
2020 }
2021
2022 /****************************************************************
2023 _spoolss_DeletePrinterDriverEx
2024 ****************************************************************/
2025
2026 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2027 struct spoolss_DeletePrinterDriverEx *r)
2028 {
2029 struct spoolss_DriverInfo8 *info = NULL;
2030 struct spoolss_DriverInfo8 *info_win2k = NULL;
2031 int version;
2032 bool delete_files;
2033 WERROR status;
2034 WERROR status_win2k = WERR_ACCESS_DENIED;
2035 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2036
2037 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2038 and not a printer admin, then fail */
2039
2040 if ( (p->server_info->utok.uid != sec_initial_uid())
2041 && !user_has_privileges(p->server_info->ptok, &se_printop )
2042 && !token_contains_name_in_list(
2043 uidtoname(p->server_info->utok.uid), NULL, NULL,
2044 p->server_info->ptok, lp_printer_admin(-1)) )
2045 {
2046 return WERR_ACCESS_DENIED;
2047 }
2048
2049 /* check that we have a valid driver name first */
2050 if ((version = get_version_id(r->in.architecture)) == -1) {
2051 /* this is what NT returns */
2052 return WERR_INVALID_ENVIRONMENT;
2053 }
2054
2055 if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2056 version = r->in.version;
2057
2058 status = get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
2059 r->in.architecture, version);
2060
2061 if ( !W_ERROR_IS_OK(status) )
2062 {
2063 /*
2064 * if the client asked for a specific version,
2065 * or this is something other than Windows NT x86,
2066 * then we've failed
2067 */
2068
2069 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2070 goto done;
2071
2072 /* try for Win2k driver if "Windows NT x86" */
2073
2074 version = 3;
2075 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, r->in.driver,
2076 r->in.architecture,
2077 version))) {
2078 status = WERR_UNKNOWN_PRINTER_DRIVER;
2079 goto done;
2080 }
2081 }
2082
2083 if (printer_driver_in_use(info)) {
2084 status = WERR_PRINTER_DRIVER_IN_USE;
2085 goto done;
2086 }
2087
2088 /*
2089 * we have a couple of cases to consider.
2090 * (1) Are any files in use? If so and DPD_DELTE_ALL_FILE is set,
2091 * then the delete should fail if **any** files overlap with
2092 * other drivers
2093 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2094 * non-overlapping files
2095 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2096 * is set, the do not delete any files
2097 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2098 */
2099
2100 delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2101
2102 /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2103
2104 if (delete_files && printer_driver_files_in_use(info, info) & (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
2105 /* no idea of the correct error here */
2106 status = WERR_ACCESS_DENIED;
2107 goto done;
2108 }
2109
2110
2111 /* also check for W32X86/3 if necessary; maybe we already have? */
2112
2113 if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
2114 if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info_win2k,
2115 r->in.driver,
2116 r->in.architecture, 3)))
2117 {
2118
2119 if (delete_files && printer_driver_files_in_use(info, info_win2k) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2120 /* no idea of the correct error here */
2121 free_a_printer_driver(info_win2k);
2122 status = WERR_ACCESS_DENIED;
2123 goto done;
2124 }
2125
2126 /* if we get to here, we now have 2 driver info structures to remove */
2127 /* remove the Win2k driver first*/
2128
2129 status_win2k = delete_printer_driver(
2130 p, info_win2k, 3, delete_files);
2131 free_a_printer_driver(info_win2k);
2132
2133 /* this should not have failed---if it did, report to client */
2134
2135 if ( !W_ERROR_IS_OK(status_win2k) )
2136 goto done;
2137 }
2138 }
2139
2140 status = delete_printer_driver(p, info, version, delete_files);
2141
2142 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2143 status = WERR_OK;
2144 done:
2145 free_a_printer_driver(info);
2146
2147 return status;
2148 }
2149
2150
2151 /****************************************************************************
2152 Internal routine for removing printerdata
2153 ***************************************************************************/
2154
2155 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2156 {
2157 return delete_printer_data( printer->info_2, key, value );
2158 }
2159
2160 /****************************************************************************
2161 Internal routine for storing printerdata
2162 ***************************************************************************/
2163
2164 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2165 const char *key, const char *value,
2166 uint32_t type, uint8_t *data, int real_len)
2167 {
2168 /* the registry objects enforce uniqueness based on value name */
2169
2170 return add_printer_data( printer->info_2, key, value, type, data, real_len );
2171 }
2172
2173 /********************************************************************
2174 GetPrinterData on a printer server Handle.
2175 ********************************************************************/
2176
2177 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2178 const char *value,
2179 enum winreg_Type *type,
2180 union spoolss_PrinterData *data)
2181 {
2182 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2183
2184 if (!StrCaseCmp(value, "W3SvcInstalled")) {
2185 *type = REG_DWORD;
2186 data->value = 0x00;
2187 return WERR_OK;
2188 }
2189
2190 if (!StrCaseCmp(value, "BeepEnabled")) {
2191 *type = REG_DWORD;
2192 data->value = 0x00;
2193 return WERR_OK;
2194 }
2195
2196 if (!StrCaseCmp(value, "EventLog")) {
2197 *type = REG_DWORD;
2198 /* formally was 0x1b */
2199 data->value = 0x00;
2200 return WERR_OK;
2201 }
2202
2203 if (!StrCaseCmp(value, "NetPopup")) {
2204 *type = REG_DWORD;
2205 data->value = 0x00;
2206 return WERR_OK;
2207 }
2208
2209 if (!StrCaseCmp(value, "MajorVersion")) {
2210 *type = REG_DWORD;
2211
2212 /* Windows NT 4.0 seems to not allow uploading of drivers
2213 to a server that reports 0x3 as the MajorVersion.
2214 need to investigate more how Win2k gets around this .
2215 -- jerry */
2216
2217 if (RA_WINNT == get_remote_arch()) {
2218 data->value = 0x02;
2219 } else {
2220 data->value = 0x03;
2221 }
2222
2223 return WERR_OK;
2224 }
2225
2226 if (!StrCaseCmp(value, "MinorVersion")) {
2227 *type = REG_DWORD;
2228 data->value = 0x00;
2229 return WERR_OK;
2230 }
2231
2232 /* REG_BINARY
2233 * uint32_t size = 0x114
2234 * uint32_t major = 5
2235 * uint32_t minor = [0|1]
2236 * uint32_t build = [2195|2600]
2237 * extra unicode string = e.g. "Service Pack 3"
2238 */
2239 if (!StrCaseCmp(value, "OSVersion")) {
2240 DATA_BLOB blob;
2241 enum ndr_err_code ndr_err;
2242 struct spoolss_OSVersion os;
2243
2244 os.major = 5; /* Windows 2000 == 5.0 */
2245 os.minor = 0;
2246 os.build = 2195; /* build */
2247 os.extra_string = ""; /* leave extra string empty */
2248
2249 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2250 (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2251 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2252 return WERR_GENERAL_FAILURE;
2253 }
2254
2255 *type = REG_BINARY;
2256 data->binary = blob;
2257
2258 return WERR_OK;
2259 }
2260
2261
2262 if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2263 *type = REG_SZ;
2264
2265 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2266 W_ERROR_HAVE_NO_MEMORY(data->string);
2267
2268 return WERR_OK;
2269 }
2270
2271 if (!StrCaseCmp(value, "Architecture")) {
2272 *type = REG_SZ;
2273 data->string = talloc_strdup(mem_ctx,
2274 lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", SPOOLSS_ARCHITECTURE_NT_X86));
2275 W_ERROR_HAVE_NO_MEMORY(data->string);
2276
2277 return WERR_OK;
2278 }
2279
2280 if (!StrCaseCmp(value, "DsPresent")) {
2281 *type = REG_DWORD;
2282
2283 /* only show the publish check box if we are a
2284 member of a AD domain */
2285
2286 if (lp_security() == SEC_ADS) {
2287 data->value = 0x01;
2288 } else {
2289 data->value = 0x00;
2290 }
2291 return WERR_OK;
2292 }
2293
2294 if (!StrCaseCmp(value, "DNSMachineName")) {
2295 const char *hostname = get_mydnsfullname();
2296
2297 if (!hostname) {
2298 return WERR_BADFILE;
2299 }
2300
2301 *type = REG_SZ;
2302 data->string = talloc_strdup(mem_ctx, hostname);
2303 W_ERROR_HAVE_NO_MEMORY(data->string);
2304
2305 return WERR_OK;
2306 }
2307
2308 *type = REG_NONE;
2309
2310 return WERR_INVALID_PARAM;
2311 }
2312
2313 /****************************************************************
2314 _spoolss_GetPrinterData
2315 ****************************************************************/
2316
2317 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2318 struct spoolss_GetPrinterData *r)
2319 {
2320 struct spoolss_GetPrinterDataEx r2;
2321
2322 r2.in.handle = r->in.handle;
2323 r2.in.key_name = "PrinterDriverData";
2324 r2.in.value_name = r->in.value_name;
2325 r2.in.offered = r->in.offered;
2326 r2.out.type = r->out.type;
2327 r2.out.data = r->out.data;
2328 r2.out.needed = r->out.needed;
2329
2330 return _spoolss_GetPrinterDataEx(p, &r2);
2331 }
2332
2333 /*********************************************************
2334 Connect to the client machine.
2335 **********************************************************/
2336
2337 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2338 struct sockaddr_storage *client_ss, const char *remote_machine)
2339 {
2340 NTSTATUS ret;
2341 struct cli_state *the_cli;
2342 struct sockaddr_storage rm_addr;
2343 char addr[INET6_ADDRSTRLEN];
2344
2345 if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2346 DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
2347 remote_machine));
2348 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2349 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2350 return false;
2351 }
2352 print_sockaddr(addr, sizeof(addr), &rm_addr);
2353 } else {
2354 rm_addr = *client_ss;
2355 print_sockaddr(addr, sizeof(addr), &rm_addr);
2356 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2357 addr));
2358 }
2359
2360 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2361 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
2362 addr));
2363 return false;
2364 }
2365
2366 /* setup the connection */
2367 ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2368 &rm_addr, 0, "IPC$", "IPC",
2369 "", /* username */
2370 "", /* domain */
2371 "", /* password */
2372 0, lp_client_signing(), NULL );
2373
2374 if ( !NT_STATUS_IS_OK( ret ) ) {
2375 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2376 remote_machine ));
2377 return false;
2378 }
2379
2380 if ( the_cli->protocol != PROTOCOL_NT1 ) {
2381 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2382 cli_shutdown(the_cli);
2383 return false;
2384 }
2385
2386 /*
2387 * Ok - we have an anonymous connection to the IPC$ share.
2388 * Now start the NT Domain stuff :-).
2389 */
2390
2391 ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2392 if (!NT_STATUS_IS_OK(ret)) {
2393 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2394 remote_machine, nt_errstr(ret)));
2395 cli_shutdown(the_cli);
2396 return false;
2397 }
2398
2399 return true;
2400 }
2401
2402 /***************************************************************************
2403 Connect to the client.
2404 ****************************************************************************/
2405
2406 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2407 uint32_t localprinter, uint32_t type,
2408 struct policy_handle *handle,
2409 struct sockaddr_storage *client_ss)
2410 {
2411 WERROR result;
2412 NTSTATUS status;
2413
2414 /*
2415 * If it's the first connection, contact the client
2416 * and connect to the IPC$ share anonymously
2417 */
2418 if (smb_connections==0) {
2419 fstring unix_printer;
2420
2421 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2422
2423 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2424 return false;
2425
2426 messaging_register(smbd_messaging_context(), NULL,
2427 MSG_PRINTER_NOTIFY2,
2428 receive_notify2_message_list);
2429 /* Tell the connections db we're now interested in printer
2430 * notify messages. */
2431 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2432 }
2433
2434 /*
2435 * Tell the specific printing tdb we want messages for this printer
2436 * by registering our PID.
2437 */
2438
2439 if (!print_notify_register_pid(snum))
2440 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2441
2442 smb_connections++;
2443
2444 status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2445 printer,
2446 localprinter,
2447 type,
2448 0,
2449 NULL,
2450 handle,
2451 &result);
2452 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2453 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2454 win_errstr(result)));
2455
2456 return (W_ERROR_IS_OK(result));
2457 }
2458
2459 /****************************************************************
2460 ****************************************************************/
2461
2462 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2463 const struct spoolss_NotifyOption *r)
2464 {
2465 struct spoolss_NotifyOption *option;
2466 uint32_t i,k;
2467
2468 if (!r) {
2469 return NULL;
2470 }
2471
2472 option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2473 if (!option) {
2474 return NULL;
2475 }
2476
2477 *option = *r;
2478
2479 if (!option->count) {
2480 return option;
2481 }
2482
2483 option->types = talloc_zero_array(option,
2484 struct spoolss_NotifyOptionType, option->count);
2485 if (!option->types) {
2486 talloc_free(option);
2487 return NULL;
2488 }
2489
2490 for (i=0; i < option->count; i++) {
2491 option->types[i] = r->types[i];
2492
2493 if (option->types[i].count) {
2494 option->types[i].fields = talloc_zero_array(option,
2495 union spoolss_Field, option->types[i].count);
2496 if (!option->types[i].fields) {
2497 talloc_free(option);
2498 return NULL;
2499 }
2500 for (k=0; k<option->types[i].count; k++) {
2501 option->types[i].fields[k] =
2502 r->types[i].fields[k];
2503 }
2504 }
2505 }
2506
2507 return option;
2508 }
2509
2510 /****************************************************************
2511 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2512 *
2513 * before replying OK: status=0 a rpc call is made to the workstation
2514 * asking ReplyOpenPrinter
2515 *
2516 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2517 * called from api_spoolss_rffpcnex
2518 ****************************************************************/
2519
2520 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2521 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2522 {
2523 int snum = -1;
2524 struct spoolss_NotifyOption *option = r->in.notify_options;
2525 struct sockaddr_storage client_ss;
2526
2527 /* store the notify value in the printer struct */
2528
2529 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2530
2531 if (!Printer) {
2532 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2533 "Invalid handle (%s:%u:%u).\n",
2534 OUR_HANDLE(r->in.handle)));
2535 return WERR_BADFID;
2536 }
2537
2538 Printer->notify.flags = r->in.flags;
2539 Printer->notify.options = r->in.options;
2540 Printer->notify.printerlocal = r->in.printer_local;
2541
2542 TALLOC_FREE(Printer->notify.option);
2543 Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2544
2545 fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2546
2547 /* Connect to the client machine and send a ReplyOpenPrinter */
2548
2549 if ( Printer->printer_type == SPLHND_SERVER)
2550 snum = -1;
2551 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2552 !get_printer_snum(p, r->in.handle, &snum, NULL) )
2553 return WERR_BADFID;
2554
2555 DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2556 "client_address is %s\n", p->client_address));
2557
2558 if (!interpret_string_addr(&client_ss, p->client_address,
2559 AI_NUMERICHOST)) {
2560 return WERR_SERVER_UNAVAILABLE;
2561 }
2562
2563 if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2564 Printer->notify.printerlocal, 1,
2565 &Printer->notify.client_hnd, &client_ss))
2566 return WERR_SERVER_UNAVAILABLE;
2567
2568 Printer->notify.client_connected = true;
2569
2570 return WERR_OK;
2571 }
2572
2573 /*******************************************************************
2574 * fill a notify_info_data with the servername
2575 ********************************************************************/
2576
2577 void spoolss_notify_server_name(int snum,
2578 struct spoolss_Notify *data,
2579 print_queue_struct *queue,
2580 NT_PRINTER_INFO_LEVEL *printer,
2581 TALLOC_CTX *mem_ctx)
2582 {
2583 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2584 }
2585
2586 /*******************************************************************
2587 * fill a notify_info_data with the printername (not including the servername).
2588 ********************************************************************/
2589
2590 void spoolss_notify_printer_name(int snum,
2591 struct spoolss_Notify *data,
2592 print_queue_struct *queue,
2593 NT_PRINTER_INFO_LEVEL *printer,
2594 TALLOC_CTX *mem_ctx)
2595 {
2596 /* the notify name should not contain the \\server\ part */
2597 char *p = strrchr(printer->info_2->printername, '\\');
2598
2599 if (!p) {
2600 p = printer->info_2->printername;
2601 } else {
2602 p++;
2603 }
2604
2605 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2606 }
2607
2608 /*******************************************************************
2609 * fill a notify_info_data with the servicename
2610 ********************************************************************/
2611
2612 void spoolss_notify_share_name(int snum,
2613 struct spoolss_Notify *data,
2614 print_queue_struct *queue,
2615 NT_PRINTER_INFO_LEVEL *printer,
2616 TALLOC_CTX *mem_ctx)
2617 {
2618 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2619 }
2620
2621 /*******************************************************************
2622 * fill a notify_info_data with the port name
2623 ********************************************************************/
2624
2625 void spoolss_notify_port_name(int snum,
2626 struct spoolss_Notify *data,
2627 print_queue_struct *queue,
2628 NT_PRINTER_INFO_LEVEL *printer,
2629 TALLOC_CTX *mem_ctx)
2630 {
2631 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2632 }
2633
2634 /*******************************************************************
2635 * fill a notify_info_data with the printername
2636 * but it doesn't exist, have to see what to do
2637 ********************************************************************/
2638
2639 void spoolss_notify_driver_name(int snum,
2640 struct spoolss_Notify *data,
2641 print_queue_struct *queue,
2642 NT_PRINTER_INFO_LEVEL *printer,
2643 TALLOC_CTX *mem_ctx)
2644 {
2645 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2646 }
2647
2648 /*******************************************************************
2649 * fill a notify_info_data with the comment
2650 ********************************************************************/
2651
2652 void spoolss_notify_comment(int snum,
2653 struct spoolss_Notify *data,
2654 print_queue_struct *queue,
2655 NT_PRINTER_INFO_LEVEL *printer,
2656 TALLOC_CTX *mem_ctx)
2657 {
2658 char *p;
2659
2660 if (*printer->info_2->comment == '\0') {
2661 p = lp_comment(snum);
2662 } else {
2663 p = printer->info_2->comment;
2664 }
2665
2666 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2667 }
2668
2669 /*******************************************************************
2670 * fill a notify_info_data with the comment
2671 * location = "Room 1, floor 2, building 3"
2672 ********************************************************************/
2673
2674 void spoolss_notify_location(int snum,
2675 struct spoolss_Notify *data,
2676 print_queue_struct *queue,
2677 NT_PRINTER_INFO_LEVEL *printer,
2678 TALLOC_CTX *mem_ctx)
2679 {
2680 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2681 }
2682
2683 /*******************************************************************
2684 * fill a notify_info_data with the device mode
2685 * jfm:xxxx don't to it for know but that's a real problem !!!
2686 ********************************************************************/
2687
2688 static void spoolss_notify_devmode(int snum,
2689 struct spoolss_Notify *data,
2690 print_queue_struct *queue,
2691 NT_PRINTER_INFO_LEVEL *printer,
2692 TALLOC_CTX *mem_ctx)
2693 {
2694 /* for a dummy implementation we have to zero the fields */
2695 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2696 }
2697
2698 /*******************************************************************
2699 * fill a notify_info_data with the separator file name
2700 ********************************************************************/
2701
2702 void spoolss_notify_sepfile(int snum,
2703 struct spoolss_Notify *data,
2704 print_queue_struct *queue,
2705 NT_PRINTER_INFO_LEVEL *printer,
2706 TALLOC_CTX *mem_ctx)
2707 {
2708 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2709 }
2710
2711 /*******************************************************************
2712 * fill a notify_info_data with the print processor
2713 * jfm:xxxx return always winprint to indicate we don't do anything to it
2714 ********************************************************************/
2715
2716 void spoolss_notify_print_processor(int snum,
2717 struct spoolss_Notify *data,
2718 print_queue_struct *queue,
2719 NT_PRINTER_INFO_LEVEL *printer,
2720 TALLOC_CTX *mem_ctx)
2721 {
2722 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2723 }
2724
2725 /*******************************************************************
2726 * fill a notify_info_data with the print processor options
2727 * jfm:xxxx send an empty string
2728 ********************************************************************/
2729
2730 void spoolss_notify_parameters(int snum,
2731 struct spoolss_Notify *data,
2732 print_queue_struct *queue,
2733 NT_PRINTER_INFO_LEVEL *printer,
2734 TALLOC_CTX *mem_ctx)
2735 {
2736 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2737 }
2738
2739 /*******************************************************************
2740 * fill a notify_info_data with the data type
2741 * jfm:xxxx always send RAW as data type
2742 ********************************************************************/
2743
2744 void spoolss_notify_datatype(int snum,
2745 struct spoolss_Notify *data,
2746 print_queue_struct *queue,
2747 NT_PRINTER_INFO_LEVEL *printer,
2748 TALLOC_CTX *mem_ctx)
2749 {
2750 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
2751 }
2752
2753 /*******************************************************************
2754 * fill a notify_info_data with the security descriptor
2755 * jfm:xxxx send an null pointer to say no security desc
2756 * have to implement security before !
2757 ********************************************************************/
2758
2759 static void spoolss_notify_security_desc(int snum,
2760 struct spoolss_Notify *data,
2761 print_queue_struct *queue,
2762 NT_PRINTER_INFO_LEVEL *printer,
2763 TALLOC_CTX *mem_ctx)
2764 {
2765 SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
2766 printer->info_2->secdesc_buf->sd_size,
2767 printer->info_2->secdesc_buf->sd);
2768 }
2769
2770 /*******************************************************************
2771 * fill a notify_info_data with the attributes
2772 * jfm:xxxx a samba printer is always shared
2773 ********************************************************************/
2774
2775 void spoolss_notify_attributes(int snum,
2776 struct spoolss_Notify *data,
2777 print_queue_struct *queue,
2778 NT_PRINTER_INFO_LEVEL *printer,
2779 TALLOC_CTX *mem_ctx)
2780 {
2781 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
2782 }
2783
2784 /*******************************************************************
2785 * fill a notify_info_data with the priority
2786 ********************************************************************/
2787
2788 static void spoolss_notify_priority(int snum,
2789 struct spoolss_Notify *data,
2790 print_queue_struct *queue,
2791 NT_PRINTER_INFO_LEVEL *printer,
2792 TALLOC_CTX *mem_ctx)
2793 {
2794 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
2795 }
2796
2797 /*******************************************************************
2798 * fill a notify_info_data with the default priority
2799 ********************************************************************/
2800
2801 static void spoolss_notify_default_priority(int snum,
2802 struct spoolss_Notify *data,
2803 print_queue_struct *queue,
2804 NT_PRINTER_INFO_LEVEL *printer,
2805 TALLOC_CTX *mem_ctx)
2806 {
2807 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
2808 }
2809
2810 /*******************************************************************
2811 * fill a notify_info_data with the start time
2812 ********************************************************************/
2813
2814 static void spoolss_notify_start_time(int snum,
2815 struct spoolss_Notify *data,
2816 print_queue_struct *queue,
2817 NT_PRINTER_INFO_LEVEL *printer,
2818 TALLOC_CTX *mem_ctx)
2819 {
2820 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
2821 }
2822
2823 /*******************************************************************
2824 * fill a notify_info_data with the until time
2825 ********************************************************************/
2826
2827 static void spoolss_notify_until_time(int snum,
2828 struct spoolss_Notify *data,
2829 print_queue_struct *queue,
2830 NT_PRINTER_INFO_LEVEL *printer,
2831 TALLOC_CTX *mem_ctx)
2832 {
2833 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
2834 }
2835
2836 /*******************************************************************
2837 * fill a notify_info_data with the status
2838 ********************************************************************/
2839
2840 static void spoolss_notify_status(int snum,
2841 struct spoolss_Notify *data,
2842 print_queue_struct *queue,
2843 NT_PRINTER_INFO_LEVEL *printer,
2844 TALLOC_CTX *mem_ctx)
2845 {
2846 print_status_struct status;
2847
2848 print_queue_length(snum, &status);
2849 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
2850 }
2851
2852 /*******************************************************************
2853 * fill a notify_info_data with the number of jobs queued
2854 ********************************************************************/
2855
2856 void spoolss_notify_cjobs(int snum,
2857 struct spoolss_Notify *data,
2858 print_queue_struct *queue,
2859 NT_PRINTER_INFO_LEVEL *printer,
2860 TALLOC_CTX *mem_ctx)
2861 {
2862 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
2863 }
2864
2865 /*******************************************************************
2866 * fill a notify_info_data with the average ppm
2867 ********************************************************************/
2868
2869 static void spoolss_notify_average_ppm(int snum,
2870 struct spoolss_Notify *data,
2871 print_queue_struct *queue,
2872 NT_PRINTER_INFO_LEVEL *printer,
2873 TALLOC_CTX *mem_ctx)
2874 {
2875 /* always respond 8 pages per minutes */
2876 /* a little hard ! */
2877 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
2878 }
2879
2880 /*******************************************************************
2881 * fill a notify_info_data with username
2882 ********************************************************************/
2883
2884 static void spoolss_notify_username(int snum,
2885 struct spoolss_Notify *data,
2886 print_queue_struct *queue,
2887 NT_PRINTER_INFO_LEVEL *printer,
2888 TALLOC_CTX *mem_ctx)
2889 {
2890 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
2891 }
2892
2893 /*******************************************************************
2894 * fill a notify_info_data with job status
2895 ********************************************************************/
2896
2897 static void spoolss_notify_job_status(int snum,
2898 struct spoolss_Notify *data,
2899 print_queue_struct *queue,
2900 NT_PRINTER_INFO_LEVEL *printer,
2901 TALLOC_CTX *mem_ctx)
2902 {
2903 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
2904 }
2905
2906 /*******************************************************************
2907 * fill a notify_info_data with job name
2908 ********************************************************************/
2909
2910 static void spoolss_notify_job_name(int snum,
2911 struct spoolss_Notify *data,
2912 print_queue_struct *queue,
2913 NT_PRINTER_INFO_LEVEL *printer,
2914 TALLOC_CTX *mem_ctx)
2915 {
2916 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
2917 }
2918
2919 /*******************************************************************
2920 * fill a notify_info_data with job status
2921 ********************************************************************/
2922
2923 static void spoolss_notify_job_status_string(int snum,
2924 struct spoolss_Notify *data,
2925 print_queue_struct *queue,
2926 NT_PRINTER_INFO_LEVEL *printer,
2927 TALLOC_CTX *mem_ctx)
2928 {
2929 /*
2930 * Now we're returning job status codes we just return a "" here. JRA.
2931 */
2932
2933 const char *p = "";
2934
2935 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
2936 p = "unknown";
2937
2938 switch (queue->status) {
2939 case LPQ_QUEUED:
2940 p = "Queued";
2941 break;
2942 case LPQ_PAUSED:
2943 p = ""; /* NT provides the paused string */
2944 break;
2945 case LPQ_SPOOLING:
2946 p = "Spooling";
2947 break;
2948 case LPQ_PRINTING:
2949 p = "Printing";
2950 break;
2951 }
2952 #endif /* NO LONGER NEEDED. */
2953
2954 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2955 }
2956
2957 /*******************************************************************
2958 * fill a notify_info_data with job time
2959 ********************************************************************/
2960
2961 static void spoolss_notify_job_time(int snum,
2962 struct spoolss_Notify *data,
2963 print_queue_struct *queue,
2964 NT_PRINTER_INFO_LEVEL *printer,
2965 TALLOC_CTX *mem_ctx)
2966 {
2967 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
2968 }
2969
2970 /*******************************************************************
2971 * fill a notify_info_data with job size
2972 ********************************************************************/
2973
2974 static void spoolss_notify_job_size(int snum,
2975 struct spoolss_Notify *data,
2976 print_queue_struct *queue,
2977 NT_PRINTER_INFO_LEVEL *printer,
2978 TALLOC_CTX *mem_ctx)
2979 {
2980 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
2981 }
2982
2983 /*******************************************************************
2984 * fill a notify_info_data with page info
2985 ********************************************************************/
2986 static void spoolss_notify_total_pages(int snum,
2987 struct spoolss_Notify *data,
2988 print_queue_struct *queue,
2989 NT_PRINTER_INFO_LEVEL *printer,
2990 TALLOC_CTX *mem_ctx)
2991 {
2992 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
2993 }
2994
2995 /*******************************************************************
2996 * fill a notify_info_data with pages printed info.
2997 ********************************************************************/
2998 static void spoolss_notify_pages_printed(int snum,
2999 struct spoolss_Notify *data,
3000 print_queue_struct *queue,
3001 NT_PRINTER_INFO_LEVEL *printer,
3002 TALLOC_CTX *mem_ctx)
3003 {
3004 /* Add code when back-end tracks this */
3005 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3006 }
3007
3008 /*******************************************************************
3009 Fill a notify_info_data with job position.
3010 ********************************************************************/
3011
3012 static void spoolss_notify_job_position(int snum,
3013 struct spoolss_Notify *data,
3014 print_queue_struct *queue,
3015 NT_PRINTER_INFO_LEVEL *printer,
3016 TALLOC_CTX *mem_ctx)
3017 {
3018 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3019 }
3020
3021 /*******************************************************************
3022 Fill a notify_info_data with submitted time.
3023 ********************************************************************/
3024
3025 static void spoolss_notify_submitted_time(int snum,
3026 struct spoolss_Notify *data,
3027 print_queue_struct *queue,
3028 NT_PRINTER_INFO_LEVEL *printer,
3029 TALLOC_CTX *mem_ctx)
3030 {
3031 data->data.string.string = NULL;
3032 data->data.string.size = 0;
3033
3034 init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3035 &data->data.string.string,
3036 &data->data.string.size);
3037
3038 }
3039
3040 struct s_notify_info_data_table
3041 {
3042 enum spoolss_NotifyType type;
3043 uint16_t field;
3044 const char *name;
3045 enum spoolss_NotifyTable variable_type;
3046 void (*fn) (int snum, struct spoolss_Notify *data,
3047 print_queue_struct *queue,
3048 NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3049 };
3050
3051 /* A table describing the various print notification constants and
3052 whether the notification data is a pointer to a variable sized
3053 buffer, a one value uint32_t or a two value uint32_t. */
3054
3055 static const struct s_notify_info_data_table notify_info_data_table[] =
3056 {
3057 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3058 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3059 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_share_name },
3060 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3061 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3062 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING, spoolss_notify_comment },
3063 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING, spoolss_notify_location },
3064 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3065 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING, spoolss_notify_sepfile },
3066 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3067 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3068 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3069 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, spoolss_notify_security_desc },
3070 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD, spoolss_notify_attributes },
3071 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3072 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_default_priority },
3073 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3074 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3075 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_status },
3076 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, NULL },
3077 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD, spoolss_notify_cjobs },
3078 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD, spoolss_notify_average_ppm },
3079 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, NULL },
3080 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3081 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, NULL },
3082 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3083 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINTER_NAME, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3084 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_MACHINE_NAME, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3085 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PORT_NAME, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3086 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3087 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_NOTIFY_NAME, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3088 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DATATYPE, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3089 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINT_PROCESSOR, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3090 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PARAMETERS, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3091 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DRIVER_NAME, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3092 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DEVMODE, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3093 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_job_status },
3094 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS_STRING, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, spoolss_notify_job_status_string },
3095 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, NULL },
3096 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING, spoolss_notify_job_name },
3097 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRIORITY, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3098 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_POSITION, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD, spoolss_notify_job_position },
3099 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME, spoolss_notify_submitted_time },
3100 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_START_TIME, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3101 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_UNTIL_TIME, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3102 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TIME, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_job_time },
3103 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_PAGES, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, spoolss_notify_total_pages },
3104 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PAGES_PRINTED, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, spoolss_notify_pages_printed },
3105 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_BYTES, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, spoolss_notify_job_size },
3106 };
3107
3108 /*******************************************************************
3109 Return the variable_type of info_data structure.
3110 ********************************************************************/
3111
3112 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3113 uint16_t field)
3114 {
3115 int i=0;
3116
3117 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3118 if ( (notify_info_data_table[i].type == type) &&
3119 (notify_info_data_table[i].field == field) ) {
3120 return notify_info_data_table[i].variable_type;
3121 }
3122 }
3123
3124 DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3125
3126 return 0;
3127 }
3128
3129 /****************************************************************************
3130 ****************************************************************************/
3131
3132 static bool search_notify(enum spoolss_NotifyType type,
3133 uint16_t field,
3134 int *value)
3135 {
3136 int i;
3137
3138 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3139 if (notify_info_data_table[i].type == type &&
3140 notify_info_data_table[i].field == field &&
3141 notify_info_data_table[i].fn != NULL) {
3142 *value = i;
3143 return true;
3144 }
3145 }
3146
3147 return false;
3148 }
3149
3150 /****************************************************************************
3151 ****************************************************************************/
3152
3153 void construct_info_data(struct spoolss_Notify *info_data,
3154 enum spoolss_NotifyType type,
3155 uint16_t field,
3156 int id)
3157 {
3158 info_data->type = type;
3159 info_data->field.field = field;
3160 info_data->variable_type = variable_type_of_notify_info_data(type, field);
3161 info_data->job_id = id;
3162 }
3163
3164 /*******************************************************************
3165 *
3166 * fill a notify_info struct with info asked
3167 *
3168 ********************************************************************/
3169
3170 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3171 struct spoolss_NotifyInfo *info,
3172 int snum,
3173 const struct spoolss_NotifyOptionType *option_type,
3174 uint32_t id,
3175 TALLOC_CTX *mem_ctx)
3176 {
3177 int field_num,j;
3178 enum spoolss_NotifyType type;
3179 uint16_t field;
3180
3181 struct spoolss_Notify *current_data;
3182 NT_PRINTER_INFO_LEVEL *printer = NULL;
3183 print_queue_struct *queue=NULL;
3184
3185 type = option_type->type;
3186
3187 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3188 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3189 option_type->count, lp_servicename(snum)));
3190
3191 if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3192 return false;
3193
3194 for(field_num=0; field_num < option_type->count; field_num++) {
3195 field = option_type->fields[field_num].field;
3196
3197 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3198
3199 if (!search_notify(type, field, &j) )
3200 continue;
3201
3202 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3203 struct spoolss_Notify,
3204 info->count + 1);
3205 if (info->notifies == NULL) {
3206 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3207 free_a_printer(&printer, 2);
3208 return false;
3209 }
3210
3211 current_data = &info->notifies[info->count];
3212
3213 construct_info_data(current_data, type, field, id);
3214
3215 DEBUG(10,("construct_notify_printer_info: calling [%s] snum=%d printername=[%s])\n",
3216 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3217
3218 notify_info_data_table[j].fn(snum, current_data, queue,
3219 printer, mem_ctx);
3220
3221 info->count++;
3222 }
3223
3224 free_a_printer(&printer, 2);
3225 return true;
3226 }
3227
3228 /*******************************************************************
3229 *
3230 * fill a notify_info struct with info asked
3231 *
3232 ********************************************************************/
3233
3234 static bool construct_notify_jobs_info(print_queue_struct *queue,
3235 struct spoolss_NotifyInfo *info,
3236 NT_PRINTER_INFO_LEVEL *printer,
3237 int snum,
3238 const struct spoolss_NotifyOptionType *option_type,
3239 uint32_t id,
3240 TALLOC_CTX *mem_ctx)
3241 {
3242 int field_num,j;
3243 enum spoolss_NotifyType type;
3244 uint16_t field;
3245 struct spoolss_Notify *current_data;
3246
3247 DEBUG(4,("construct_notify_jobs_info\n"));
3248
3249 type = option_type->type;
3250
3251 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3252 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3253 option_type->count));
3254
3255 for(field_num=0; field_num<option_type->count; field_num++) {
3256 field = option_type->fields[field_num].field;
3257
3258 if (!search_notify(type, field, &j) )
3259 continue;
3260
3261 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3262 struct spoolss_Notify,
3263 info->count + 1);
3264 if (info->notifies == NULL) {
3265 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3266 return false;
3267 }
3268
3269 current_data=&(info->notifies[info->count]);
3270
3271 construct_info_data(current_data, type, field, id);
3272 notify_info_data_table[j].fn(snum, current_data, queue,
3273 printer, mem_ctx);
3274 info->count++;
3275 }
3276
3277 return true;
3278 }
3279
3280 /*
3281 * JFM: The enumeration is not that simple, it's even non obvious.
3282 *
3283 * let's take an example: I want to monitor the PRINTER SERVER for
3284 * the printer's name and the number of jobs currently queued.
3285 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3286 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3287 *
3288 * I have 3 printers on the back of my server.
3289 *
3290 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3291 * structures.
3292 * Number Data Id
3293 * 1 printer 1 name 1
3294 * 2 printer 1 cjob 1
3295 * 3 printer 2 name 2
3296 * 4 printer 2 cjob 2
3297 * 5 printer 3 name 3
3298 * 6 printer 3 name 3
3299 *
3300 * that's the print server case, the printer case is even worse.
3301 */
3302
3303 /*******************************************************************
3304 *
3305 * enumerate all printers on the printserver
3306 * fill a notify_info struct with info asked
3307 *
3308 ********************************************************************/
3309
3310 static WERROR printserver_notify_info(pipes_struct *p,
3311 struct policy_handle *hnd,
3312 struct spoolss_NotifyInfo *info,
3313 TALLOC_CTX *mem_ctx)
3314 {
3315 int snum;
3316 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3317 int n_services=lp_numservices();
3318 int i;
3319 struct spoolss_NotifyOption *option;
3320 struct spoolss_NotifyOptionType option_type;
3321
3322 DEBUG(4,("printserver_notify_info\n"));
3323
3324 if (!Printer)
3325 return WERR_BADFID;
3326
3327 option = Printer->notify.option;
3328
3329 info->version = 2;
3330 info->notifies = NULL;
3331 info->count = 0;
3332
3333 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3334 sending a ffpcn() request first */
3335
3336 if ( !option )
3337 return WERR_BADFID;
3338
3339 for (i=0; i<option->count; i++) {
3340 option_type = option->types[i];
3341
3342 if (option_type.type != PRINTER_NOTIFY_TYPE)
3343 continue;
3344
3345 for (snum=0; snum<n_services; snum++)
3346 {
3347 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3348 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3349 }
3350 }
3351
3352 #if 0
3353 /*
3354 * Debugging information, don't delete.
3355 */
3356
3357 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3358 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3359 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3360
3361 for (i=0; i<info->count; i++) {
3362 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3363 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3364 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3365 }
3366 #endif
3367
3368 return WERR_OK;
3369 }
3370
3371 /*******************************************************************
3372 *
3373 * fill a notify_info struct with info asked
3374 *
3375 ********************************************************************/
3376
3377 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3378 struct spoolss_NotifyInfo *info,
3379 TALLOC_CTX *mem_ctx)
3380 {
3381 int snum;
3382 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3383 int i;
3384 uint32_t id;
3385 struct spoolss_NotifyOption *option;
3386 struct spoolss_NotifyOptionType option_type;
3387 int count,j;
3388 print_queue_struct *queue=NULL;
3389 print_status_struct status;
3390
3391 DEBUG(4,("printer_notify_info\n"));
3392
3393 if (!Printer)
3394 return WERR_BADFID;
3395
3396 option = Printer->notify.option;
3397 id = 0x0;
3398
3399 info->version = 2;
3400 info->notifies = NULL;
3401 info->count = 0;
3402
3403 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3404 sending a ffpcn() request first */
3405
3406 if ( !option )
3407 return WERR_BADFID;
3408
3409 get_printer_snum(p, hnd, &snum, NULL);
3410
3411 for (i=0; i<option->count; i++) {
3412 option_type = option->types[i];
3413
3414 switch (option_type.type) {
3415 case PRINTER_NOTIFY_TYPE:
3416 if(construct_notify_printer_info(Printer, info, snum,
3417 &option_type, id,
3418 mem_ctx))
3419 id--;
3420 break;
3421
3422 case JOB_NOTIFY_TYPE: {
3423 NT_PRINTER_INFO_LEVEL *printer = NULL;
3424
3425 count = print_queue_status(snum, &queue, &status);
3426
3427 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3428 goto done;
3429
3430 for (j=0; j<count; j++) {
3431 construct_notify_jobs_info(&queue[j], info,
3432 printer, snum,
3433 &option_type,
3434 queue[j].job,
3435 mem_ctx);
3436 }
3437
3438 free_a_printer(&printer, 2);
3439
3440 done:
3441 SAFE_FREE(queue);
3442 break;
3443 }
3444 }
3445 }
3446
3447 /*
3448 * Debugging information, don't delete.
3449 */
3450 /*
3451 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3452 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3453 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3454
3455 for (i=0; i<info->count; i++) {
3456 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3457 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3458 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3459 }
3460 */
3461 return WERR_OK;
3462 }
3463
3464 /****************************************************************
3465 _spoolss_RouterRefreshPrinterChangeNotify
3466 ****************************************************************/
3467
3468 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3469 struct spoolss_RouterRefreshPrinterChangeNotify *r)
3470 {
3471 struct spoolss_NotifyInfo *info;
3472
3473 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3474 WERROR result = WERR_BADFID;
3475
3476 /* we always have a spoolss_NotifyInfo struct */
3477 info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3478 if (!info) {
3479 result = WERR_NOMEM;
3480 goto done;
3481 }
3482
3483 *r->out.info = info;
3484
3485 if (!Printer) {
3486 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3487 "Invalid handle (%s:%u:%u).\n",
3488 OUR_HANDLE(r->in.handle)));
3489 goto done;
3490 }
3491
3492 DEBUG(4,("Printer type %x\n",Printer->printer_type));
3493
3494 /*
3495 * We are now using the change value, and
3496 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3497 * I don't have a global notification system, I'm sending back all the
3498 * informations even when _NOTHING_ has changed.
3499 */
3500
3501 /* We need to keep track of the change value to send back in
3502 RRPCN replies otherwise our updates are ignored. */
3503
3504 Printer->notify.fnpcn = true;
3505
3506 if (Printer->notify.client_connected) {
3507 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3508 "Saving change value in request [%x]\n",
3509 r->in.change_low));
3510 Printer->notify.change = r->in.change_low;
3511 }
3512
3513 /* just ignore the spoolss_NotifyOption */
3514
3515 switch (Printer->printer_type) {
3516 case SPLHND_SERVER:
3517 result = printserver_notify_info(p, r->in.handle,
3518 info, p->mem_ctx);
3519 break;
3520
3521 case SPLHND_PRINTER:
3522 result = printer_notify_info(p, r->in.handle,
3523 info, p->mem_ctx);
3524 break;
3525 }
3526
3527 Printer->notify.fnpcn = false;
3528
3529 done:
3530 return result;
3531 }
3532
3533 /********************************************************************
3534 * construct_printer_info_0
3535 * fill a printer_info_0 struct
3536 ********************************************************************/
3537
3538 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3539 const NT_PRINTER_INFO_LEVEL *ntprinter,
3540 struct spoolss_PrinterInfo0 *r,
3541 int snum)
3542 {
3543 int count;
3544 counter_printer_0 *session_counter;
3545 time_t setuptime;
3546 print_status_struct status;
3547
3548 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3549 W_ERROR_HAVE_NO_MEMORY(r->printername);
3550
3551 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3552 W_ERROR_HAVE_NO_MEMORY(r->servername);
3553
3554 count = print_queue_length(snum, &status);
3555
3556 /* check if we already have a counter for this printer */
3557 for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3558 if (session_counter->snum == snum)
3559 break;
3560 }
3561
3562 /* it's the first time, add it to the list */
3563 if (session_counter == NULL) {
3564 session_counter = SMB_MALLOC_P(counter_printer_0);
3565 W_ERROR_HAVE_NO_MEMORY(session_counter);
3566 ZERO_STRUCTP(session_counter);
3567 session_counter->snum = snum;
3568 session_counter->counter = 0;
3569 DLIST_ADD(counter_list, session_counter);
3570 }
3571
3572 /* increment it */
3573 session_counter->counter++;
3574
3575 r->cjobs = count;
3576 r->total_jobs = 0;
3577 r->total_bytes = 0;
3578
3579 setuptime = (time_t)ntprinter->info_2->setuptime;
3580
3581 init_systemtime(&r->time, gmtime(&setuptime));
3582
3583 /* JFM:
3584 * the global_counter should be stored in a TDB as it's common to all the clients
3585 * and should be zeroed on samba startup
3586 */
3587 r->global_counter = session_counter->counter;
3588 r->total_pages = 0;
3589 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3590 r->version = 0x0005; /* NT 5 */
3591 r->free_build = 0x0893; /* build 2195 */
3592 r->spooling = 0;
3593 r->max_spooling = 0;
3594 r->session_counter = session_counter->counter;
3595 r->num_error_out_of_paper = 0x0;
3596 r->num_error_not_ready = 0x0; /* number of print failure */
3597 r->job_error = 0x0;
3598 r->number_of_processors = 0x1;
3599 r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3600 r->high_part_total_bytes = 0x0;
3601 r->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3602 r->last_error = WERR_OK;
3603 r->status = nt_printq_status(status.status);
3604 r->enumerate_network_printers = 0x0;
3605 r->c_setprinter = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3606 r->processor_architecture = 0x0;
3607 r->processor_level = 0x6; /* 6 ???*/
3608 r->ref_ic = 0;
3609 r->reserved2 = 0;
3610 r->reserved3 = 0;
3611
3612 return WERR_OK;
3613 }
3614
3615 /****************************************************************************
3616 Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure. Both pointers
3617 should be valid upon entry
3618 ****************************************************************************/
3619
3620 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3621 struct spoolss_DeviceMode *r,
3622 const NT_DEVICEMODE *ntdevmode)
3623 {
3624 if (!r || !ntdevmode) {
3625 return WERR_INVALID_PARAM;
3626 }
3627
3628 r->devicename = talloc_strdup(mem_ctx, ntdevmode->devicename);
3629 W_ERROR_HAVE_NO_MEMORY(r->devicename);
3630
3631 r->specversion = ntdevmode->specversion;
3632 r->driverversion = ntdevmode->driverversion;
3633 r->size = ntdevmode->size;
3634 r->__driverextra_length = ntdevmode->driverextra;
3635 r->fields = ntdevmode->fields;
3636
3637 r->orientation = ntdevmode->orientation;
3638 r->papersize = ntdevmode->papersize;
3639 r->paperlength = ntdevmode->paperlength;
3640 r->paperwidth = ntdevmode->paperwidth;
3641 r->scale = ntdevmode->scale;
3642 r->copies = ntdevmode->copies;
3643 r->defaultsource = ntdevmode->defaultsource;
3644 r->printquality = ntdevmode->printquality;
3645 r->color = ntdevmode->color;
3646 r->duplex = ntdevmode->duplex;
3647 r->yresolution = ntdevmode->yresolution;
3648 r->ttoption = ntdevmode->ttoption;
3649 r->collate = ntdevmode->collate;
3650
3651 r->formname = talloc_strdup(mem_ctx, ntdevmode->formname);
3652 W_ERROR_HAVE_NO_MEMORY(r->formname);
3653
3654 /* all 0 below are values that have not been set in the old parsing/copy
3655 * function, maybe they should... - gd */
3656
3657 r->logpixels = 0;
3658 r->bitsperpel = 0;
3659 r->pelswidth = 0;
3660 r->pelsheight = 0;
3661 r->displayflags = 0;
3662 r->displayfrequency = 0;
3663 r->icmmethod = ntdevmode->icmmethod;
3664 r->icmintent = ntdevmode->icmintent;
3665 r->mediatype = ntdevmode->mediatype;
3666 r->dithertype = ntdevmode->dithertype;
3667 r->reserved1 = 0;
3668 r->reserved2 = 0;
3669 r->panningwidth = 0;
3670 r->panningheight = 0;
3671
3672 if (ntdevmode->nt_dev_private != NULL) {
3673 r->driverextra_data = data_blob_talloc(mem_ctx,
3674 ntdevmode->nt_dev_private,
3675 ntdevmode->driverextra);
3676 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3677 }
3678
3679 return WERR_OK;
3680 }
3681
3682
3683 /****************************************************************************
3684 Create a spoolss_DeviceMode struct. Returns talloced memory.
3685 ****************************************************************************/
3686
3687 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3688 const char *servicename)
3689 {
3690 WERROR result;
3691 NT_PRINTER_INFO_LEVEL *printer = NULL;
3692 struct spoolss_DeviceMode *devmode = NULL;
3693
3694 DEBUG(7,("construct_dev_mode\n"));
3695
3696 DEBUGADD(8,("getting printer characteristics\n"));
3697
3698 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3699 return NULL;
3700
3701 if (!printer->info_2->devmode) {
3702 DEBUG(5, ("BONG! There was no device mode!\n"));
3703 goto done;
3704 }
3705
3706 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3707 if (!devmode) {
3708 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3709 goto done;
3710 }
3711
3712 DEBUGADD(8,("loading DEVICEMODE\n"));
3713
3714 result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3715 if (!W_ERROR_IS_OK(result)) {
3716 TALLOC_FREE(devmode);
3717 }
3718
3719 done:
3720 free_a_printer(&printer,2);
3721
3722 return devmode;
3723 }
3724
3725 /********************************************************************
3726 * construct_printer_info1
3727 * fill a spoolss_PrinterInfo1 struct
3728 ********************************************************************/
3729
3730 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3731 const NT_PRINTER_INFO_LEVEL *ntprinter,
3732 uint32_t flags,
3733 struct spoolss_PrinterInfo1 *r,
3734 int snum)
3735 {
3736 r->flags = flags;
3737
3738 r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
3739 ntprinter->info_2->printername,
3740 ntprinter->info_2->drivername,
3741 ntprinter->info_2->location);
3742 W_ERROR_HAVE_NO_MEMORY(r->description);
3743
3744 if (*ntprinter->info_2->comment == '\0') {
3745 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
3746 } else {
3747 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
3748 }
3749 W_ERROR_HAVE_NO_MEMORY(r->comment);
3750
3751 r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3752 W_ERROR_HAVE_NO_MEMORY(r->name);
3753
3754 return WERR_OK;
3755 }
3756
3757 /********************************************************************
3758 * construct_printer_info2
3759 * fill a spoolss_PrinterInfo2 struct
3760 ********************************************************************/
3761
3762 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3763 const NT_PRINTER_INFO_LEVEL *ntprinter,
3764 struct spoolss_PrinterInfo2 *r,
3765 int snum)
3766 {
3767 int count;
3768
3769 print_status_struct status;
3770
3771 count = print_queue_length(snum, &status);
3772
3773 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3774 W_ERROR_HAVE_NO_MEMORY(r->servername);
3775 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3776 W_ERROR_HAVE_NO_MEMORY(r->printername);
3777 r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
3778 W_ERROR_HAVE_NO_MEMORY(r->sharename);
3779 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
3780 W_ERROR_HAVE_NO_MEMORY(r->portname);
3781 r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
3782 W_ERROR_HAVE_NO_MEMORY(r->drivername);
3783
3784 if (*ntprinter->info_2->comment == '\0') {
3785 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
3786 } else {
3787 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
3788 }
3789 W_ERROR_HAVE_NO_MEMORY(r->comment);
3790
3791 r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
3792 W_ERROR_HAVE_NO_MEMORY(r->location);
3793 r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
3794 W_ERROR_HAVE_NO_MEMORY(r->sepfile);
3795 r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
3796 W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
3797 r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
3798 W_ERROR_HAVE_NO_MEMORY(r->datatype);
3799 r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
3800 W_ERROR_HAVE_NO_MEMORY(r->parameters);
3801
3802 r->attributes = ntprinter->info_2->attributes;
3803
3804 r->priority = ntprinter->info_2->priority;
3805 r->defaultpriority = ntprinter->info_2->default_priority;
3806 r->starttime = ntprinter->info_2->starttime;
3807 r->untiltime = ntprinter->info_2->untiltime;
3808 r->status = nt_printq_status(status.status);
3809 r->cjobs = count;
3810 r->averageppm = ntprinter->info_2->averageppm;
3811
3812 r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
3813 if (!r->devmode) {
3814 DEBUG(8,("Returning NULL Devicemode!\n"));
3815 }
3816
3817 r->secdesc = NULL;
3818
3819 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3820 /* don't use talloc_steal() here unless you do a deep steal of all
3821 the SEC_DESC members */
3822
3823 r->secdesc = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
3824 }
3825
3826 return WERR_OK;
3827 }
3828
3829 /********************************************************************
3830 * construct_printer_info3
3831 * fill a spoolss_PrinterInfo3 struct
3832 ********************************************************************/
3833
3834 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3835 const NT_PRINTER_INFO_LEVEL *ntprinter,
3836 struct spoolss_PrinterInfo3 *r,
3837 int snum)
3838 {
3839 /* These are the components of the SD we are returning. */
3840
3841 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3842 /* don't use talloc_steal() here unless you do a deep steal of all
3843 the SEC_DESC members */
3844
3845 r->secdesc = dup_sec_desc(mem_ctx,
3846 ntprinter->info_2->secdesc_buf->sd);
3847 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3848 }
3849
3850 return WERR_OK;
3851 }
3852
3853 /********************************************************************
3854 * construct_printer_info4
3855 * fill a spoolss_PrinterInfo4 struct
3856 ********************************************************************/
3857
3858 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
3859 const NT_PRINTER_INFO_LEVEL *ntprinter,
3860 struct spoolss_PrinterInfo4 *r,
3861 int snum)
3862 {
3863 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3864 W_ERROR_HAVE_NO_MEMORY(r->printername);
3865 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3866 W_ERROR_HAVE_NO_MEMORY(r->servername);
3867
3868 r->attributes = ntprinter->info_2->attributes;
3869
3870 return WERR_OK;
3871 }
3872
3873 /********************************************************************
3874 * construct_printer_info5
3875 * fill a spoolss_PrinterInfo5 struct
3876 ********************************************************************/
3877
3878 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
3879 const NT_PRINTER_INFO_LEVEL *ntprinter,
3880 struct spoolss_PrinterInfo5 *r,
3881 int snum)
3882 {
3883 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3884 W_ERROR_HAVE_NO_MEMORY(r->printername);
3885 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
3886 W_ERROR_HAVE_NO_MEMORY(r->portname);
3887
3888 r->attributes = ntprinter->info_2->attributes;
3889
3890 /* these two are not used by NT+ according to MSDN */
3891
3892 r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
3893 r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
3894
3895 return WERR_OK;
3896 }
3897
3898 /********************************************************************
3899 * construct_printer_info_6
3900 * fill a spoolss_PrinterInfo6 struct
3901 ********************************************************************/
3902
3903 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
3904 const NT_PRINTER_INFO_LEVEL *ntprinter,
3905 struct spoolss_PrinterInfo6 *r,
3906 int snum)
3907 {
3908 int count;
3909 print_status_struct status;
3910
3911 count = print_queue_length(snum, &status);
3912
3913 r->status = nt_printq_status(status.status);
3914
3915 return WERR_OK;
3916 }
3917
3918 /********************************************************************
3919 * construct_printer_info7
3920 * fill a spoolss_PrinterInfo7 struct
3921 ********************************************************************/
3922
3923 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
3924 Printer_entry *print_hnd,
3925 struct spoolss_PrinterInfo7 *r,
3926 int snum)
3927 {
3928 struct GUID guid;
3929
3930 if (is_printer_published(print_hnd, snum, &guid)) {
3931 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
3932 r->action = DSPRINT_PUBLISH;
3933 } else {
3934 r->guid = talloc_strdup(mem_ctx, "");
3935 r->action = DSPRINT_UNPUBLISH;
3936 }
3937 W_ERROR_HAVE_NO_MEMORY(r->guid);
3938
3939 return WERR_OK;
3940 }
3941
3942 /********************************************************************
3943 * construct_printer_info8
3944 * fill a spoolss_PrinterInfo8 struct
3945 ********************************************************************/
3946
3947 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
3948 const NT_PRINTER_INFO_LEVEL *ntprinter,
3949 struct spoolss_DeviceModeInfo *r,
3950 int snum)
3951 {
3952 struct spoolss_DeviceMode *devmode;
3953 WERROR result;
3954
3955 if (!ntprinter->info_2->devmode) {
3956 r->devmode = NULL;
3957 return WERR_OK;
3958 }
3959
3960 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3961 W_ERROR_HAVE_NO_MEMORY(devmode);
3962
3963 result = convert_nt_devicemode(mem_ctx, devmode, ntprinter->info_2->devmode);
3964 if (!W_ERROR_IS_OK(result)) {
3965 TALLOC_FREE(devmode);
3966 return result;
3967 }
3968
3969 r->devmode = devmode;
3970
3971 return WERR_OK;
3972 }
3973
3974
3975 /********************************************************************
3976 ********************************************************************/
3977
3978 static bool snum_is_shared_printer(int snum)
3979 {
3980 return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
3981 }
3982
3983 /********************************************************************
3984 Spoolss_enumprinters.
3985 ********************************************************************/
3986
3987 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
3988 uint32_t level,
3989 uint32_t flags,
3990 union spoolss_PrinterInfo **info_p,
3991 uint32_t *count_p)
3992 {
3993 int snum;
3994 int n_services = lp_numservices();
3995 union spoolss_PrinterInfo *info = NULL;
3996 uint32_t count = 0;
3997 WERROR result = WERR_OK;
3998
3999 *count_p = 0;
4000 *info_p = NULL;
4001
4002 for (snum = 0; snum < n_services; snum++) {
4003
4004 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4005
4006 if (!snum_is_shared_printer(snum)) {
4007 continue;
4008 }
4009
4010 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4011 lp_servicename(snum), snum));
4012
4013 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4014 union spoolss_PrinterInfo,
4015 count + 1);
4016 if (!info) {
4017 result = WERR_NOMEM;
4018 goto out;
4019 }
4020
4021 result = get_a_printer(NULL, &ntprinter, 2,
4022 lp_const_servicename(snum));
4023 if (!W_ERROR_IS_OK(result)) {
4024 goto out;
4025 }
4026
4027 switch (level) {
4028 case 0:
4029 result = construct_printer_info0(info, ntprinter,
4030 &info[count].info0, snum);
4031 break;
4032 case 1:
4033 result = construct_printer_info1(info, ntprinter, flags,
4034 &info[count].info1, snum);
4035 break;
4036 case 2:
4037 result = construct_printer_info2(info, ntprinter,
4038 &info[count].info2, snum);
4039 break;
4040 case 4:
4041 result = construct_printer_info4(info, ntprinter,
4042 &info[count].info4, snum);
4043 break;
4044 case 5:
4045 result = construct_printer_info5(info, ntprinter,
4046 &info[count].info5, snum);
4047 break;
4048
4049 default:
4050 result = WERR_UNKNOWN_LEVEL;
4051 free_a_printer(&ntprinter, 2);
4052 goto out;
4053 }
4054
4055 free_a_printer(&ntprinter, 2);
4056 if (!W_ERROR_IS_OK(result)) {
4057 goto out;
4058 }
4059
4060 count++;
4061 }
4062
4063 *count_p = count;
4064 *info_p = info;
4065
4066 out:
4067 if (!W_ERROR_IS_OK(result)) {
4068 TALLOC_FREE(info);
4069 return result;
4070 }
4071
4072 *info_p = info;
4073
4074 return WERR_OK;
4075 }
4076
4077 /********************************************************************
4078 * handle enumeration of printers at level 0
4079 ********************************************************************/
4080
4081 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4082 uint32_t flags,
4083 const char *servername,
4084 union spoolss_PrinterInfo **info,
4085 uint32_t *count)
4086 {
4087 DEBUG(4,("enum_all_printers_info_0\n"));
4088
4089 return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4090 }
4091
4092
4093 /********************************************************************
4094 ********************************************************************/
4095
4096 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4097 uint32_t flags,
4098 union spoolss_PrinterInfo **info,
4099 uint32_t *count)
4100 {
4101 DEBUG(4,("enum_all_printers_info_1\n"));
4102
4103 return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4104 }
4105
4106 /********************************************************************
4107 enum_all_printers_info_1_local.
4108 *********************************************************************/
4109
4110 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4111 union spoolss_PrinterInfo **info,
4112 uint32_t *count)
4113 {
4114 DEBUG(4,("enum_all_printers_info_1_local\n"));
4115
4116 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4117 }
4118
4119 /********************************************************************
4120 enum_all_printers_info_1_name.
4121 *********************************************************************/
4122
4123 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4124 const char *name,
4125 union spoolss_PrinterInfo **info,
4126 uint32_t *count)
4127 {
4128 const char *s = name;
4129
4130 DEBUG(4,("enum_all_printers_info_1_name\n"));
4131
4132 if ((name[0] == '\\') && (name[1] == '\\')) {
4133 s = name + 2;
4134 }
4135
4136 if (!is_myname_or_ipaddr(s)) {
4137 return WERR_INVALID_NAME;
4138 }
4139
4140 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4141 }
4142
4143 /********************************************************************
4144 enum_all_printers_info_1_network.
4145 *********************************************************************/
4146
4147 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4148 const char *name,
4149 union spoolss_PrinterInfo **info,
4150 uint32_t *count)
4151 {
4152 const char *s = name;
4153
4154 DEBUG(4,("enum_all_printers_info_1_network\n"));
4155
4156 /* If we respond to a enum_printers level 1 on our name with flags
4157 set to PRINTER_ENUM_REMOTE with a list of printers then these
4158 printers incorrectly appear in the APW browse list.
4159 Specifically the printers for the server appear at the workgroup
4160 level where all the other servers in the domain are
4161 listed. Windows responds to this call with a
4162 WERR_CAN_NOT_COMPLETE so we should do the same. */
4163
4164 if (name[0] == '\\' && name[1] == '\\') {
4165 s = name + 2;
4166 }
4167
4168 if (is_myname_or_ipaddr(s)) {
4169 return WERR_CAN_NOT_COMPLETE;
4170 }
4171
4172 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4173 }
4174
4175 /********************************************************************
4176 * api_spoolss_enumprinters
4177 *
4178 * called from api_spoolss_enumprinters (see this to understand)
4179 ********************************************************************/
4180
4181 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4182 union spoolss_PrinterInfo **info,
4183 uint32_t *count)
4184 {
4185 DEBUG(4,("enum_all_printers_info_2\n"));
4186
4187 return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4188 }
4189
4190 /********************************************************************
4191 * handle enumeration of printers at level 1
4192 ********************************************************************/
4193
4194 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4195 uint32_t flags,
4196 const char *name,
4197 union spoolss_PrinterInfo **info,
4198 uint32_t *count)
4199 {
4200 /* Not all the flags are equals */
4201
4202 if (flags & PRINTER_ENUM_LOCAL) {
4203 return enum_all_printers_info_1_local(mem_ctx, info, count);
4204 }
4205
4206 if (flags & PRINTER_ENUM_NAME) {
4207 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4208 }
4209
4210 if (flags & PRINTER_ENUM_NETWORK) {
4211 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4212 }
4213
4214 return WERR_OK; /* NT4sp5 does that */
4215 }
4216
4217 /********************************************************************
4218 * handle enumeration of printers at level 2
4219 ********************************************************************/
4220
4221 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4222 uint32_t flags,
4223 const char *servername,
4224 union spoolss_PrinterInfo **info,
4225 uint32_t *count)
4226 {
4227 if (flags & PRINTER_ENUM_LOCAL) {
4228 return enum_all_printers_info_2(mem_ctx, info, count);
4229 }
4230
4231 if (flags & PRINTER_ENUM_NAME) {
4232 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4233 return WERR_INVALID_NAME;
4234 }
4235
4236 return enum_all_printers_info_2(mem_ctx, info, count);
4237 }
4238
4239 if (flags & PRINTER_ENUM_REMOTE) {
4240 return WERR_UNKNOWN_LEVEL;
4241 }
4242
4243 return WERR_OK;
4244 }
4245
4246 /********************************************************************
4247 * handle enumeration of printers at level 4
4248 ********************************************************************/
4249
4250 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4251 uint32_t flags,
4252 const char *servername,
4253 union spoolss_PrinterInfo **info,
4254 uint32_t *count)
4255 {
4256 DEBUG(4,("enum_all_printers_info_4\n"));
4257
4258 return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4259 }
4260
4261
4262 /********************************************************************
4263 * handle enumeration of printers at level 5
4264 ********************************************************************/
4265
4266 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4267 uint32_t flags,
4268 const char *servername,
4269 union spoolss_PrinterInfo **info,
4270 uint32_t *count)
4271 {
4272 DEBUG(4,("enum_all_printers_info_5\n"));
4273
4274 return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4275 }
4276
4277 /****************************************************************
4278 _spoolss_EnumPrinters
4279 ****************************************************************/
4280
4281 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4282 struct spoolss_EnumPrinters *r)
4283 {
4284 const char *name = NULL;
4285 WERROR result;
4286
4287 /* that's an [in out] buffer */
4288
4289 if (!r->in.buffer && (r->in.offered != 0)) {
4290 return WERR_INVALID_PARAM;
4291 }
4292
4293 DEBUG(4,("_spoolss_EnumPrinters\n"));
4294
4295 *r->out.needed = 0;
4296 *r->out.count = 0;
4297 *r->out.info = NULL;
4298
4299 /*
4300 * Level 1:
4301 * flags==PRINTER_ENUM_NAME
4302 * if name=="" then enumerates all printers
4303 * if name!="" then enumerate the printer
4304 * flags==PRINTER_ENUM_REMOTE
4305 * name is NULL, enumerate printers
4306 * Level 2: name!="" enumerates printers, name can't be NULL
4307 * Level 3: doesn't exist
4308 * Level 4: does a local registry lookup
4309 * Level 5: same as Level 2
4310 */
4311
4312 if (name) {
4313 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4314 W_ERROR_HAVE_NO_MEMORY(name);
4315 }
4316
4317 switch (r->in.level) {
4318 case 0:
4319 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4320 r->out.info, r->out.count);
4321 break;
4322 case 1:
4323 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4324 r->out.info, r->out.count);
4325 break;
4326 case 2:
4327 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4328 r->out.info, r->out.count);
4329 break;
4330 case 4:
4331 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4332 r->out.info, r->out.count);
4333 break;
4334 case 5:
4335 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4336 r->out.info, r->out.count);
4337 break;
4338 default:
4339 return WERR_UNKNOWN_LEVEL;
4340 }
4341
4342 if (!W_ERROR_IS_OK(result)) {
4343 return result;
4344 }
4345
4346 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4347 spoolss_EnumPrinters, NULL,
4348 *r->out.info, r->in.level,
4349 *r->out.count);
4350 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4351 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4352
4353 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4354 }
4355
4356 /****************************************************************
4357 _spoolss_GetPrinter
4358 ****************************************************************/
4359
4360 WERROR _spoolss_GetPrinter(pipes_struct *p,
4361 struct spoolss_GetPrinter *r)
4362 {
4363 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4364 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4365 WERROR result = WERR_OK;
4366
4367 int snum;
4368
4369 /* that's an [in out] buffer */
4370
4371 if (!r->in.buffer && (r->in.offered != 0)) {
4372 return WERR_INVALID_PARAM;
4373 }
4374
4375 *r->out.needed = 0;
4376
4377 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4378 return WERR_BADFID;
4379 }
4380
4381 result = get_a_printer(Printer, &ntprinter, 2,
4382 lp_const_servicename(snum));
4383 if (!W_ERROR_IS_OK(result)) {
4384 return result;
4385 }
4386
4387 switch (r->in.level) {
4388 case 0:
4389 result = construct_printer_info0(p->mem_ctx, ntprinter,
4390 &r->out.info->info0, snum);
4391 break;
4392 case 1:
4393 result = construct_printer_info1(p->mem_ctx, ntprinter,
4394 PRINTER_ENUM_ICON8,
4395 &r->out.info->info1, snum);
4396 break;
4397 case 2:
4398 result = construct_printer_info2(p->mem_ctx, ntprinter,
4399 &r->out.info->info2, snum);
4400 break;
4401 case 3:
4402 result = construct_printer_info3(p->mem_ctx, ntprinter,
4403 &r->out.info->info3, snum);
4404 break;
4405 case 4:
4406 result = construct_printer_info4(p->mem_ctx, ntprinter,
4407 &r->out.info->info4, snum);
4408 break;
4409 case 5:
4410 result = construct_printer_info5(p->mem_ctx, ntprinter,
4411 &r->out.info->info5, snum);
4412 break;
4413 case 6:
4414 result = construct_printer_info6(p->mem_ctx, ntprinter,
4415 &r->out.info->info6, snum);
4416 break;
4417 case 7:
4418 result = construct_printer_info7(p->mem_ctx, Printer,
4419 &r->out.info->info7, snum);
4420 break;
4421 case 8:
4422 result = construct_printer_info8(p->mem_ctx, ntprinter,
4423 &r->out.info->info8, snum);
4424 break;
4425 default:
4426 result = WERR_UNKNOWN_LEVEL;
4427 break;
4428 }
4429
4430 free_a_printer(&ntprinter, 2);
4431
4432 if (!W_ERROR_IS_OK(result)) {
4433 TALLOC_FREE(r->out.info);
4434 return result;
4435 }
4436
4437 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4438 r->out.info, r->in.level);
4439 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4440
4441 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4442 }
4443
4444 /********************************************************************
4445 ********************************************************************/
4446
4447 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4448 const char **string_array,
4449 const char *cservername)
4450 {
4451 int i, num_strings = 0;
4452 const char **array = NULL;
4453
4454 if (!string_array) {
4455 return NULL;
4456 }
4457
4458 for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4459
4460 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4461 cservername, string_array[i]);
4462 if (!str) {
4463 TALLOC_FREE(array);
4464 return NULL;
4465 }
4466
4467
4468 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4469 TALLOC_FREE(array);
4470 return NULL;
4471 }
4472 }
4473
4474 if (i > 0) {
4475 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4476 &array, &num_strings);
4477 }
4478
4479 return array;
4480 }
4481
4482 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4483 do { \
4484 if (in && strlen(in)) { \
4485 out = talloc_strdup(mem_ctx, in); \
4486 W_ERROR_HAVE_NO_MEMORY(out); \
4487 } else { \
4488 out = NULL; \
4489 } \
4490 } while (0);
4491
4492 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, in, out) \
4493 do { \
4494 if (in && strlen(in)) { \
4495 out = talloc_asprintf(mem_ctx, "\\\\%s%s", server, in); \
4496 } else { \
4497 out = talloc_strdup(mem_ctx, ""); \
4498 } \
4499 W_ERROR_HAVE_NO_MEMORY(out); \
4500 } while (0);
4501
4502 /********************************************************************
4503 * fill a spoolss_DriverInfo1 struct
4504 ********************************************************************/
4505
4506 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4507 struct spoolss_DriverInfo1 *r,
4508 const struct spoolss_DriverInfo8 *driver,
4509 const char *servername)
4510 {
4511 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4512 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4513
4514 return WERR_OK;
4515 }
4516
4517 /********************************************************************
4518 * fill a spoolss_DriverInfo2 struct
4519 ********************************************************************/
4520
4521 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4522 struct spoolss_DriverInfo2 *r,
4523 const struct spoolss_DriverInfo8 *driver,
4524 const char *servername)
4525
4526 {
4527 const char *cservername = canon_servername(servername);
4528
4529 r->version = driver->version;
4530
4531 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4532 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4533 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4534 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4535
4536 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4537 driver->driver_path,
4538 r->driver_path);
4539
4540 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4541 driver->data_file,
4542 r->data_file);
4543
4544 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4545 driver->config_file,
4546 r->config_file);
4547
4548 return WERR_OK;
4549 }
4550
4551 /********************************************************************
4552 * fill a spoolss_DriverInfo3 struct
4553 ********************************************************************/
4554
4555 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4556 struct spoolss_DriverInfo3 *r,
4557 const struct spoolss_DriverInfo8 *driver,
4558 const char *servername)
4559 {
4560 const char *cservername = canon_servername(servername);
4561
4562 r->version = driver->version;
4563
4564 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4565 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4566 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4567 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4568
4569 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4570 driver->driver_path,
4571 r->driver_path);
4572
4573 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4574 driver->data_file,
4575 r->data_file);
4576
4577 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4578 driver->config_file,
4579 r->config_file);
4580
4581 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4582 driver->help_file,
4583 r->help_file);
4584
4585 FILL_DRIVER_STRING(mem_ctx,
4586 driver->monitor_name,
4587 r->monitor_name);
4588
4589 FILL_DRIVER_STRING(mem_ctx,
4590 driver->default_datatype,
4591 r->default_datatype);
4592
4593 r->dependent_files = string_array_from_driver_info(mem_ctx,
4594 driver->dependent_files,
4595 cservername);
4596 return WERR_OK;
4597 }
4598
4599 /********************************************************************
4600 * fill a spoolss_DriverInfo4 struct
4601 ********************************************************************/
4602
4603 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4604 struct spoolss_DriverInfo4 *r,
4605 const struct spoolss_DriverInfo8 *driver,
4606 const char *servername)
4607 {
4608 const char *cservername = canon_servername(servername);
4609
4610 r->version = driver->version;
4611
4612 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4613 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4614 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4615 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4616
4617 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4618 driver->driver_path,
4619 r->driver_path);
4620
4621 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4622 driver->data_file,
4623 r->data_file);
4624
4625 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4626 driver->config_file,
4627 r->config_file);
4628
4629 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4630 driver->help_file,
4631 r->help_file);
4632
4633 r->dependent_files = string_array_from_driver_info(mem_ctx,
4634 driver->dependent_files,
4635 cservername);
4636
4637 FILL_DRIVER_STRING(mem_ctx,
4638 driver->monitor_name,
4639 r->monitor_name);
4640
4641 FILL_DRIVER_STRING(mem_ctx,
4642 driver->default_datatype,
4643 r->default_datatype);
4644
4645 r->previous_names = string_array_from_driver_info(mem_ctx,
4646 driver->previous_names,
4647 cservername);
4648
4649 return WERR_OK;
4650 }
4651
4652 /********************************************************************
4653 * fill a spoolss_DriverInfo5 struct
4654 ********************************************************************/
4655
4656 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4657 struct spoolss_DriverInfo5 *r,
4658 const struct spoolss_DriverInfo8 *driver,
4659 const char *servername)
4660 {
4661 const char *cservername = canon_servername(servername);
4662
4663 r->version = driver->version;
4664
4665 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4666 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4667 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4668 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4669
4670 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4671 driver->driver_path,
4672 r->driver_path);
4673
4674 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4675 driver->data_file,
4676 r->data_file);
4677
4678 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4679 driver->config_file,
4680 r->config_file);
4681
4682 r->driver_attributes = 0;
4683 r->config_version = 0;
4684 r->driver_version = 0;
4685
4686 return WERR_OK;
4687 }
4688 /********************************************************************
4689 * fill a spoolss_DriverInfo6 struct
4690 ********************************************************************/
4691
4692 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4693 struct spoolss_DriverInfo6 *r,
4694 const struct spoolss_DriverInfo8 *driver,
4695 const char *servername)
4696 {
4697 const char *cservername = canon_servername(servername);
4698
4699 r->version = driver->version;
4700
4701 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4702 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4703 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4704 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4705
4706 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4707 driver->driver_path,
4708 r->driver_path);
4709
4710 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4711 driver->data_file,
4712 r->data_file);
4713
4714 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4715 driver->config_file,
4716 r->config_file);
4717
4718 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4719 driver->help_file,
4720 r->help_file);
4721
4722 FILL_DRIVER_STRING(mem_ctx,
4723 driver->monitor_name,
4724 r->monitor_name);
4725
4726 FILL_DRIVER_STRING(mem_ctx,
4727 driver->default_datatype,
4728 r->default_datatype);
4729
4730 r->dependent_files = string_array_from_driver_info(mem_ctx,
4731 driver->dependent_files,
4732 cservername);
4733 r->previous_names = string_array_from_driver_info(mem_ctx,
4734 driver->previous_names,
4735 cservername);
4736
4737 r->driver_date = driver->driver_date;
4738 r->driver_version = driver->driver_version;
4739
4740 FILL_DRIVER_STRING(mem_ctx,
4741 driver->manufacturer_name,
4742 r->manufacturer_name);
4743 FILL_DRIVER_STRING(mem_ctx,
4744 driver->manufacturer_url,
4745 r->manufacturer_url);
4746 FILL_DRIVER_STRING(mem_ctx,
4747 driver->hardware_id,
4748 r->hardware_id);
4749 FILL_DRIVER_STRING(mem_ctx,
4750 driver->provider,
4751 r->provider);
4752
4753 return WERR_OK;
4754 }
4755
4756 /********************************************************************
4757 * fill a spoolss_DriverInfo8 struct
4758 ********************************************************************/
4759
4760 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
4761 struct spoolss_DriverInfo8 *r,
4762 const struct spoolss_DriverInfo8 *driver,
4763 const char *servername)
4764 {
4765 const char *cservername = canon_servername(servername);
4766
4767 r->version = driver->version;
4768
4769 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4770 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4771 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4772 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4773
4774 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4775 driver->driver_path,
4776 r->driver_path);
4777
4778 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4779 driver->data_file,
4780 r->data_file);
4781
4782 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4783 driver->config_file,
4784 r->config_file);
4785
4786 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4787 driver->help_file,
4788 r->help_file);
4789
4790 FILL_DRIVER_STRING(mem_ctx,
4791 driver->monitor_name,
4792 r->monitor_name);
4793
4794 FILL_DRIVER_STRING(mem_ctx,
4795 driver->default_datatype,
4796 r->default_datatype);
4797
4798 r->dependent_files = string_array_from_driver_info(mem_ctx,
4799 driver->dependent_files,
4800 cservername);
4801 r->previous_names = string_array_from_driver_info(mem_ctx,
4802 driver->previous_names,
4803 cservername);
4804
4805 r->driver_date = driver->driver_date;
4806 r->driver_version = driver->driver_version;
4807
4808 FILL_DRIVER_STRING(mem_ctx,
4809 driver->manufacturer_name,
4810 r->manufacturer_name);
4811 FILL_DRIVER_STRING(mem_ctx,
4812 driver->manufacturer_url,
4813 r->manufacturer_url);
4814 FILL_DRIVER_STRING(mem_ctx,
4815 driver->hardware_id,
4816 r->hardware_id);
4817 FILL_DRIVER_STRING(mem_ctx,
4818 driver->provider,
4819 r->provider);
4820
4821 FILL_DRIVER_STRING(mem_ctx,
4822 driver->print_processor,
4823 r->print_processor);
4824 FILL_DRIVER_STRING(mem_ctx,
4825 driver->vendor_setup,
4826 r->vendor_setup);
4827
4828 r->color_profiles = string_array_from_driver_info(mem_ctx,
4829 driver->color_profiles,
4830 cservername);
4831
4832 FILL_DRIVER_STRING(mem_ctx,
4833 driver->inf_path,
4834 r->inf_path);
4835
4836 r->printer_driver_attributes = driver->printer_driver_attributes;
4837
4838 r->core_driver_dependencies = string_array_from_driver_info(mem_ctx,
4839 driver->core_driver_dependencies,
4840 cservername);
4841
4842 r->min_inbox_driver_ver_date = driver->min_inbox_driver_ver_date;
4843 r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
4844
4845 return WERR_OK;
4846 }
4847
4848 #if 0 /* disabled until marshalling issues are resolved - gd */
4849 /********************************************************************
4850 ********************************************************************/
4851
4852 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
4853 struct spoolss_DriverFileInfo *r,
4854 const char *cservername,
4855 const char *file_name,
4856 enum spoolss_DriverFileType file_type,
4857 uint32_t file_version)
4858 {
4859 r->file_name = talloc_asprintf(mem_ctx, "\\\\%s%s",
4860 cservername, file_name);
4861 W_ERROR_HAVE_NO_MEMORY(r->file_name);
4862 r->file_type = file_type;
4863 r->file_version = file_version;
4864
4865 return WERR_OK;
4866 }
4867
4868 /********************************************************************
4869 ********************************************************************/
4870
4871 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
4872 const struct spoolss_DriverInfo8 *driver,
4873 const char *cservername,
4874 struct spoolss_DriverFileInfo **info_p,
4875 uint32_t *count_p)
4876 {
4877 struct spoolss_DriverFileInfo *info = NULL;
4878 uint32_t count = 0;
4879 WERROR result;
4880 uint32_t i;
4881
4882 *info_p = NULL;
4883 *count_p = 0;
4884
4885 if (strlen(driver->driver_path)) {
4886 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4887 struct spoolss_DriverFileInfo,
4888 count + 1);
4889 W_ERROR_HAVE_NO_MEMORY(info);
4890 result = fill_spoolss_DriverFileInfo(info,
4891 &info[count],
4892 cservername,
4893 driver->driver_path,
4894 SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
4895 0);
4896 W_ERROR_NOT_OK_RETURN(result);
4897 count++;
4898 }
4899
4900 if (strlen(driver->config_file)) {
4901 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4902 struct spoolss_DriverFileInfo,
4903 count + 1);
4904 W_ERROR_HAVE_NO_MEMORY(info);
4905 result = fill_spoolss_DriverFileInfo(info,
4906 &info[count],
4907 cservername,
4908 driver->config_file,
4909 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
4910 0);
4911 W_ERROR_NOT_OK_RETURN(result);
4912 count++;
4913 }
4914
4915 if (strlen(driver->data_file)) {
4916 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4917 struct spoolss_DriverFileInfo,
4918 count + 1);
4919 W_ERROR_HAVE_NO_MEMORY(info);
4920 result = fill_spoolss_DriverFileInfo(info,
4921 &info[count],
4922 cservername,
4923 driver->data_file,
4924 SPOOLSS_DRIVER_FILE_TYPE_DATA,
4925 0);
4926 W_ERROR_NOT_OK_RETURN(result);
4927 count++;
4928 }
4929
4930 if (strlen(driver->help_file)) {
4931 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4932 struct spoolss_DriverFileInfo,
4933 count + 1);
4934 W_ERROR_HAVE_NO_MEMORY(info);
4935 result = fill_spoolss_DriverFileInfo(info,
4936 &info[count],
4937 cservername,
4938 driver->help_file,
4939 SPOOLSS_DRIVER_FILE_TYPE_HELP,
4940 0);
4941 W_ERROR_NOT_OK_RETURN(result);
4942 count++;
4943 }
4944
4945 for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
4946 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4947 struct spoolss_DriverFileInfo,
4948 count + 1);
4949 W_ERROR_HAVE_NO_MEMORY(info);
4950 result = fill_spoolss_DriverFileInfo(info,
4951 &info[count],
4952 cservername,
4953 driver->dependent_files[i],
4954 SPOOLSS_DRIVER_FILE_TYPE_OTHER,
4955 0);
4956 W_ERROR_NOT_OK_RETURN(result);
4957 count++;
4958 }
4959
4960 *info_p = info;
4961 *count_p = count;
4962
4963 return WERR_OK;
4964 }
4965
4966 /********************************************************************
4967 * fill a spoolss_DriverInfo101 struct
4968 ********************************************************************/
4969
4970 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
4971 struct spoolss_DriverInfo101 *r,
4972 const struct spoolss_DriverInfo8 *driver,
4973 const char *servername)
4974 {
4975 const char *cservername = canon_servername(servername);
4976 WERROR result;
4977
4978 r->version = driver->version;
4979
4980 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4981 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4982 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4983 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4984
4985 result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
4986 cservername,
4987 &r->file_info,
4988 &r->file_count);
4989 if (!W_ERROR_IS_OK(result)) {
4990 return result;
4991 }
4992
4993 FILL_DRIVER_STRING(mem_ctx,
4994 driver->monitor_name,
4995 r->monitor_name);
4996
4997 FILL_DRIVER_STRING(mem_ctx,
4998 driver->default_datatype,
4999 r->default_datatype);
5000
5001 r->previous_names = string_array_from_driver_info(mem_ctx,
5002 driver->previous_names,
5003 cservername);
5004 r->driver_date = driver->driver_date;
5005 r->driver_version = driver->driver_version;
5006
5007 FILL_DRIVER_STRING(mem_ctx,
5008 driver->manufacturer_name,
5009 r->manufacturer_name);
5010 FILL_DRIVER_STRING(mem_ctx,
5011 driver->manufacturer_url,
5012 r->manufacturer_url);
5013 FILL_DRIVER_STRING(mem_ctx,
5014 driver->hardware_id,
5015 r->hardware_id);
5016 FILL_DRIVER_STRING(mem_ctx,
5017 driver->provider,
5018 r->provider);
5019
5020 return WERR_OK;
5021 }
5022 #endif
5023 /********************************************************************
5024 ********************************************************************/
5025
5026 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
5027 uint32_t level,
5028 union spoolss_DriverInfo *r,
5029 int snum,
5030 const char *servername,
5031 const char *architecture,
5032 uint32_t version)
5033 {
5034 NT_PRINTER_INFO_LEVEL *printer = NULL;
5035 struct spoolss_DriverInfo8 *driver;
5036 WERROR result;
5037
5038 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5039
5040 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5041 win_errstr(result)));
5042
5043 if (!W_ERROR_IS_OK(result)) {
5044 return WERR_INVALID_PRINTER_NAME;
5045 }
5046
5047 result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
5048 architecture, version);
5049
5050 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5051 win_errstr(result)));
5052
5053 if (!W_ERROR_IS_OK(result)) {
5054 /*
5055 * Is this a W2k client ?
5056 */
5057
5058 if (version < 3) {
5059 free_a_printer(&printer, 2);
5060 return WERR_UNKNOWN_PRINTER_DRIVER;
5061 }
5062
5063 /* Yes - try again with a WinNT driver. */
5064 version = 2;
5065 result = get_a_printer_driver(mem_ctx, &driver, printer->info_2->drivername,
5066 architecture, version);
5067 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5068 win_errstr(result)));
5069 if (!W_ERROR_IS_OK(result)) {
5070 free_a_printer(&printer, 2);
5071 return WERR_UNKNOWN_PRINTER_DRIVER;
5072 }
5073 }
5074
5075 switch (level) {
5076 case 1:
5077 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5078 break;
5079 case 2:
5080 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5081 break;
5082 case 3:
5083 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5084 break;
5085 case 4:
5086 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5087 break;
5088 case 5:
5089 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5090 break;
5091 case 6:
5092 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5093 break;
5094 case 8:
5095 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5096 break;
5097 #if 0 /* disabled until marshalling issues are resolved - gd */
5098 case 101:
5099 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5100 break;
5101 #endif
5102 default:
5103 result = WERR_UNKNOWN_LEVEL;
5104 break;
5105 }
5106
5107 free_a_printer(&printer, 2);
5108 free_a_printer_driver(driver);
5109
5110 return result;
5111 }
5112
5113 /****************************************************************
5114 _spoolss_GetPrinterDriver2
5115 ****************************************************************/
5116
5117 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5118 struct spoolss_GetPrinterDriver2 *r)
5119 {
5120 Printer_entry *printer;
5121 WERROR result;
5122
5123 const char *servername;
5124 int snum;
5125
5126 /* that's an [in out] buffer */
5127
5128 if (!r->in.buffer && (r->in.offered != 0)) {
5129 return WERR_INVALID_PARAM;
5130 }
5131
5132 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5133
5134 if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5135 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5136 return WERR_INVALID_PRINTER_NAME;
5137 }
5138
5139 *r->out.needed = 0;
5140 *r->out.server_major_version = 0;
5141 *r->out.server_minor_version = 0;
5142
5143 servername = get_server_name(printer);
5144
5145 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5146 return WERR_BADFID;
5147 }
5148
5149 result = construct_printer_driver_info_level(p->mem_ctx, r->in.level,
5150 r->out.info, snum,
5151 servername,
5152 r->in.architecture,
5153 r->in.client_major_version);
5154 if (!W_ERROR_IS_OK(result)) {
5155 TALLOC_FREE(r->out.info);
5156 return result;
5157 }
5158
5159 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5160 r->out.info, r->in.level);
5161 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5162
5163 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5164 }
5165
5166
5167 /****************************************************************
5168 _spoolss_StartPagePrinter
5169 ****************************************************************/
5170
5171 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5172 struct spoolss_StartPagePrinter *r)
5173 {
5174 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5175
5176 if (!Printer) {
5177 DEBUG(3,("_spoolss_StartPagePrinter: "
5178 "Error in startpageprinter printer handle\n"));
5179 return WERR_BADFID;
5180 }
5181
5182 Printer->page_started = true;
5183 return WERR_OK;
5184 }
5185
5186 /****************************************************************
5187 _spoolss_EndPagePrinter
5188 ****************************************************************/
5189
5190 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5191 struct spoolss_EndPagePrinter *r)
5192 {
5193 int snum;
5194
5195 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5196
5197 if (!Printer) {
5198 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5199 OUR_HANDLE(r->in.handle)));
5200 return WERR_BADFID;
5201 }
5202
5203 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5204 return WERR_BADFID;
5205
5206 Printer->page_started = false;
5207 print_job_endpage(snum, Printer->jobid);
5208
5209 return WERR_OK;
5210 }
5211
5212 /****************************************************************
5213 _spoolss_StartDocPrinter
5214 ****************************************************************/
5215
5216 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5217 struct spoolss_StartDocPrinter *r)
5218 {
5219 struct spoolss_DocumentInfo1 *info_1;
5220 int snum;
5221 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5222
5223 if (!Printer) {
5224 DEBUG(2,("_spoolss_StartDocPrinter: "
5225 "Invalid handle (%s:%u:%u)\n",
5226 OUR_HANDLE(r->in.handle)));
5227 return WERR_BADFID;
5228 }
5229
5230 if (r->in.level != 1) {
5231 return WERR_UNKNOWN_LEVEL;
5232 }
5233
5234 info_1 = r->in.info.info1;
5235
5236 /*
5237 * a nice thing with NT is it doesn't listen to what you tell it.
5238 * when asked to send _only_ RAW datas, it tries to send datas
5239 * in EMF format.
5240 *
5241 * So I add checks like in NT Server ...
5242 */
5243
5244 if (info_1->datatype) {
5245 if (strcmp(info_1->datatype, "RAW") != 0) {
5246 *r->out.job_id = 0;
5247 return WERR_INVALID_DATATYPE;
5248 }
5249 }
5250
5251 /* get the share number of the printer */
5252 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5253 return WERR_BADFID;
5254 }
5255
5256 Printer->jobid = print_job_start(p->server_info, snum,
5257 info_1->document_name,
5258 Printer->nt_devmode);
5259
5260 /* An error occured in print_job_start() so return an appropriate
5261 NT error code. */
5262
5263 if (Printer->jobid == -1) {
5264 return map_werror_from_unix(errno);
5265 }
5266
5267 Printer->document_started = true;
5268 *r->out.job_id = Printer->jobid;
5269
5270 return WERR_OK;
5271 }
5272
5273 /****************************************************************
5274 _spoolss_EndDocPrinter
5275 ****************************************************************/
5276
5277 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5278 struct spoolss_EndDocPrinter *r)
5279 {
5280 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5281 int snum;
5282
5283 if (!Printer) {
5284 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5285 OUR_HANDLE(r->in.handle)));
5286 return WERR_BADFID;
5287 }
5288
5289 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5290 return WERR_BADFID;
5291 }
5292
5293 Printer->document_started = false;
5294 print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
5295 /* error codes unhandled so far ... */
5296
5297 return WERR_OK;
5298 }
5299
5300 /****************************************************************
5301 _spoolss_WritePrinter
5302 ****************************************************************/
5303
5304 WERROR _spoolss_WritePrinter(pipes_struct *p,
5305 struct spoolss_WritePrinter *r)
5306 {
5307 uint32_t buffer_written;
5308 int snum;
5309 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5310
5311 if (!Printer) {
5312 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5313 OUR_HANDLE(r->in.handle)));
5314 *r->out.num_written = r->in._data_size;
5315 return WERR_BADFID;
5316 }
5317
5318 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5319 return WERR_BADFID;
5320
5321 buffer_written = (uint32_t)print_job_write(snum, Printer->jobid,
5322 (const char *)r->in.data.data,
5323 (SMB_OFF_T)-1,
5324 (size_t)r->in._data_size);
5325 if (buffer_written == (uint32_t)-1) {
5326 *r->out.num_written = 0;
5327 if (errno == ENOSPC)
5328 return WERR_NO_SPOOL_SPACE;
5329 else
5330 return WERR_ACCESS_DENIED;
5331 }
5332
5333 *r->out.num_written = r->in._data_size;
5334
5335 return WERR_OK;
5336 }
5337
5338 /********************************************************************
5339 * api_spoolss_getprinter
5340 * called from the spoolss dispatcher
5341 *
5342 ********************************************************************/
5343
5344 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5345 pipes_struct *p)
5346 {
5347 int snum;
5348 WERROR errcode = WERR_BADFUNC;
5349 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5350
5351 if (!Printer) {
5352 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5353 OUR_HANDLE(handle)));
5354 return WERR_BADFID;
5355 }
5356
5357 if (!get_printer_snum(p, handle, &snum, NULL))
5358 return WERR_BADFID;
5359
5360 switch (command) {
5361 case SPOOLSS_PRINTER_CONTROL_PAUSE:
5362 errcode = print_queue_pause(p->server_info, snum);
5363 break;
5364 case SPOOLSS_PRINTER_CONTROL_RESUME:
5365 case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5366 errcode = print_queue_resume(p->server_info, snum);
5367 break;
5368 case SPOOLSS_PRINTER_CONTROL_PURGE:
5369 errcode = print_queue_purge(p->server_info, snum);
5370 break;
5371 default:
5372 return WERR_UNKNOWN_LEVEL;
5373 }
5374
5375 return errcode;
5376 }
5377
5378
5379 /****************************************************************
5380 _spoolss_AbortPrinter
5381 * From MSDN: "Deletes printer's spool file if printer is configured
5382 * for spooling"
5383 ****************************************************************/
5384
5385 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5386 struct spoolss_AbortPrinter *r)
5387 {
5388 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5389 int snum;
5390 WERROR errcode = WERR_OK;
5391
5392 if (!Printer) {
5393 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5394 OUR_HANDLE(r->in.handle)));
5395 return WERR_BADFID;
5396 }
5397
5398 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5399 return WERR_BADFID;
5400
5401 print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5402
5403 return errcode;
5404 }
5405
5406 /********************************************************************
5407 * called by spoolss_api_setprinter
5408 * when updating a printer description
5409 ********************************************************************/
5410
5411 static WERROR update_printer_sec(struct policy_handle *handle,
5412 pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5413 {
5414 SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5415 WERROR result;
5416 int snum;
5417
5418 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5419
5420 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5421 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5422 OUR_HANDLE(handle)));
5423
5424 result = WERR_BADFID;
5425 goto done;
5426 }
5427
5428 if (!secdesc_ctr) {
5429 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5430 result = WERR_INVALID_PARAM;
5431 goto done;
5432 }
5433
5434 /* Check the user has permissions to change the security
5435 descriptor. By experimentation with two NT machines, the user
5436 requires Full Access to the printer to change security
5437 information. */
5438
5439 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5440 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5441 result = WERR_ACCESS_DENIED;
5442 goto done;
5443 }
5444
5445 /* NT seems to like setting the security descriptor even though
5446 nothing may have actually changed. */
5447
5448 if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5449 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5450 result = WERR_BADFID;
5451 goto done;
5452 }
5453
5454 if (DEBUGLEVEL >= 10) {
5455 SEC_ACL *the_acl;
5456 int i;
5457
5458 the_acl = old_secdesc_ctr->sd->dacl;
5459 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5460 PRINTERNAME(snum), the_acl->num_aces));
5461
5462 for (i = 0; i < the_acl->num_aces; i++) {
5463 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5464 &the_acl->aces[i].trustee),
5465 the_acl->aces[i].access_mask));
5466 }
5467
5468 the_acl = secdesc_ctr->sd->dacl;
5469
5470 if (the_acl) {
5471 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5472 PRINTERNAME(snum), the_acl->num_aces));
5473
5474 for (i = 0; i < the_acl->num_aces; i++) {
5475 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5476 &the_acl->aces[i].trustee),
5477 the_acl->aces[i].access_mask));
5478 }
5479 } else {
5480 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5481 }
5482 }
5483
5484 new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5485 if (!new_secdesc_ctr) {
5486 result = WERR_NOMEM;
5487 goto done;
5488 }
5489
5490 if (security_descriptor_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5491 result = WERR_OK;
5492 goto done;
5493 }
5494
5495 result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5496
5497 done:
5498
5499 return result;
5500 }
5501
5502 /********************************************************************
5503 Canonicalize printer info from a client
5504
5505 ATTN: It does not matter what we set the servername to hear
5506 since we do the necessary work in get_a_printer() to set it to
5507 the correct value based on what the client sent in the
5508 _spoolss_open_printer_ex().
5509 ********************************************************************/
5510
5511 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5512 {
5513 fstring printername;
5514 const char *p;
5515
5516 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5517 "portname=%s drivername=%s comment=%s location=%s\n",
5518 info->servername, info->printername, info->sharename,
5519 info->portname, info->drivername, info->comment, info->location));
5520
5521 /* we force some elements to "correct" values */
5522 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5523 fstrcpy(info->sharename, lp_servicename(snum));
5524
5525 /* check to see if we allow printername != sharename */
5526
5527 if ( lp_force_printername(snum) ) {
5528 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5529 global_myname(), info->sharename );
5530 } else {
5531
5532 /* make sure printername is in \\server\printername format */
5533
5534 fstrcpy( printername, info->printername );
5535 p = printername;
5536 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5537 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5538 p++;
5539 }
5540
5541 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5542 global_myname(), p );
5543 }
5544
5545 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5546 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5547
5548
5549
5550 return true;
5551 }
5552
5553 /****************************************************************************
5554 ****************************************************************************/
5555
5556 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5557 {
5558 char *cmd = lp_addport_cmd();
5559 char *command = NULL;
5560 int ret;
5561 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5562 bool is_print_op = false;
5563
5564 if ( !*cmd ) {
5565 return WERR_ACCESS_DENIED;
5566 }
5567
5568 command = talloc_asprintf(ctx,
5569 "%s \"%s\" \"%s\"", cmd, portname, uri );
5570 if (!command) {
5571 return WERR_NOMEM;
5572 }
5573
5574 if ( token )
5575 is_print_op = user_has_privileges( token, &se_printop );
5576
5577 DEBUG(10,("Running [%s]\n", command));
5578
5579 /********* BEGIN SePrintOperatorPrivilege **********/
5580
5581 if ( is_print_op )
5582 become_root();
5583
5584 ret = smbrun(command, NULL);
5585
5586 if ( is_print_op )
5587 unbecome_root();
5588
5589 /********* END SePrintOperatorPrivilege **********/
5590
5591 DEBUGADD(10,("returned [%d]\n", ret));
5592
5593 TALLOC_FREE(command);
5594
5595 if ( ret != 0 ) {
5596 return WERR_ACCESS_DENIED;
5597 }
5598
5599 return WERR_OK;
5600 }
5601
5602 /****************************************************************************
5603 ****************************************************************************/
5604
5605 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5606 {
5607 char *cmd = lp_addprinter_cmd();
5608 char **qlines;
5609 char *command = NULL;
5610 int numlines;
5611 int ret;
5612 int fd;
5613 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5614 bool is_print_op = false;
5615 char *remote_machine = talloc_strdup(ctx, "%m");
5616
5617 if (!remote_machine) {
5618 return false;
5619 }
5620 remote_machine = talloc_sub_basic(ctx,
5621 current_user_info.smb_name,
5622 current_user_info.domain,
5623 remote_machine);
5624 if (!remote_machine) {
5625 return false;
5626 }
5627
5628 command = talloc_asprintf(ctx,
5629 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5630 cmd, printer->info_2->printername, printer->info_2->sharename,
5631 printer->info_2->portname, printer->info_2->drivername,
5632 printer->info_2->location, printer->info_2->comment, remote_machine);
5633 if (!command) {
5634 return false;
5635 }
5636
5637 if ( token )
5638 is_print_op = user_has_privileges( token, &se_printop );
5639
5640 DEBUG(10,("Running [%s]\n", command));
5641
5642 /********* BEGIN SePrintOperatorPrivilege **********/
5643
5644 if ( is_print_op )
5645 become_root();
5646
5647 if ( (ret = smbrun(command, &fd)) == 0 ) {
5648 /* Tell everyone we updated smb.conf. */
5649 message_send_all(smbd_messaging_context(),
5650 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
5651 }
5652
5653 if ( is_print_op )
5654 unbecome_root();
5655
5656 /********* END SePrintOperatorPrivilege **********/
5657
5658 DEBUGADD(10,("returned [%d]\n", ret));
5659
5660 TALLOC_FREE(command);
5661 TALLOC_FREE(remote_machine);
5662
5663 if ( ret != 0 ) {
5664 if (fd != -1)
5665 close(fd);
5666 return false;
5667 }
5668
5669 /* reload our services immediately */
5670 become_root();
5671 reload_services(false);
5672 unbecome_root();
5673
5674 numlines = 0;
5675 /* Get lines and convert them back to dos-codepage */
5676 qlines = fd_lines_load(fd, &numlines, 0, NULL);
5677 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5678 close(fd);
5679
5680 /* Set the portname to what the script says the portname should be. */
5681 /* but don't require anything to be return from the script exit a good error code */
5682
5683 if (numlines) {
5684 /* Set the portname to what the script says the portname should be. */
5685 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
5686 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
5687 }
5688
5689 TALLOC_FREE(qlines);
5690 return true;
5691 }
5692
5693
5694 /********************************************************************
5695 * Called by spoolss_api_setprinter
5696 * when updating a printer description.
5697 ********************************************************************/
5698
5699 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
5700 struct spoolss_SetPrinterInfoCtr *info_ctr,
5701 struct spoolss_DeviceMode *devmode)
5702 {
5703 int snum;
5704 NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
5705 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5706 WERROR result;
5707 DATA_BLOB buffer;
5708 fstring asc_buffer;
5709
5710 DEBUG(8,("update_printer\n"));
5711
5712 result = WERR_OK;
5713
5714 if (!Printer) {
5715 result = WERR_BADFID;
5716 goto done;
5717 }
5718
5719 if (!get_printer_snum(p, handle, &snum, NULL)) {
5720 result = WERR_BADFID;
5721 goto done;
5722 }
5723
5724 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
5725 (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
5726 result = WERR_BADFID;
5727 goto done;
5728 }
5729
5730 DEBUGADD(8,("Converting info_2 struct\n"));
5731
5732 /*
5733 * convert_printer_info converts the incoming
5734 * info from the client and overwrites the info
5735 * just read from the tdb in the pointer 'printer'.
5736 */
5737
5738 if (!convert_printer_info(info_ctr, printer)) {
5739 result = WERR_NOMEM;
5740 goto done;
5741 }
5742
5743 if (devmode) {
5744 /* we have a valid devmode
5745 convert it and link it*/
5746
5747 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
5748 if (!convert_devicemode(printer->info_2->printername, devmode,
5749 &printer->info_2->devmode)) {
5750 result = WERR_NOMEM;
5751 goto done;
5752 }
5753 }
5754
5755 /* Do sanity check on the requested changes for Samba */
5756
5757 if (!check_printer_ok(printer->info_2, snum)) {
5758 result = WERR_INVALID_PARAM;
5759 goto done;
5760 }
5761
5762 /* FIXME!!! If the driver has changed we really should verify that
5763 it is installed before doing much else --jerry */
5764
5765 /* Check calling user has permission to update printer description */
5766
5767 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
5768 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
5769 result = WERR_ACCESS_DENIED;
5770 goto done;
5771 }
5772
5773 /* Call addprinter hook */
5774 /* Check changes to see if this is really needed */
5775
5776 if ( *lp_addprinter_cmd()
5777 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
5778 || !strequal(printer->info_2->comment, old_printer->info_2->comment)
5779 || !strequal(printer->info_2->portname, old_printer->info_2->portname)
5780 || !strequal(printer->info_2->location, old_printer->info_2->location)) )
5781 {
5782 /* add_printer_hook() will call reload_services() */
5783
5784 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
5785 printer) ) {
5786 result = WERR_ACCESS_DENIED;
5787 goto done;
5788 }
5789 }
5790
5791 /*
5792 * When a *new* driver is bound to a printer, the drivername is used to
5793 * lookup previously saved driver initialization info, which is then
5794 * bound to the printer, simulating what happens in the Windows arch.
5795 */
5796 if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
5797 {
5798 if (!set_driver_init(printer, 2))
5799 {
5800 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
5801 printer->info_2->drivername));
5802 }
5803
5804 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
5805 printer->info_2->drivername));
5806
5807 notify_printer_driver(snum, printer->info_2->drivername);
5808 }
5809
5810 /*
5811 * flag which changes actually occured. This is a small subset of
5812 * all the possible changes. We also have to update things in the
5813 * DsSpooler key.
5814 */
5815
5816 if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
5817 push_reg_sz(talloc_tos(), &buffer, printer->info_2->comment);
5818 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
5819 REG_SZ, buffer.data, buffer.length);
5820
5821 notify_printer_comment(snum, printer->info_2->comment);
5822 }
5823
5824 if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
5825 push_reg_sz(talloc_tos(), &buffer, printer->info_2->sharename);
5826 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
5827 REG_SZ, buffer.data, buffer.length);
5828
5829 notify_printer_sharename(snum, printer->info_2->sharename);
5830 }
5831
5832 if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
5833 char *pname;
5834
5835 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
5836 pname++;
5837 else
5838 pname = printer->info_2->printername;
5839
5840
5841 push_reg_sz(talloc_tos(), &buffer, pname);
5842 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
5843 REG_SZ, buffer.data, buffer.length);
5844
5845 notify_printer_printername( snum, pname );
5846 }
5847
5848 if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
5849 push_reg_sz(talloc_tos(), &buffer, printer->info_2->portname);
5850 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
5851 REG_SZ, buffer.data, buffer.length);
5852
5853 notify_printer_port(snum, printer->info_2->portname);
5854 }
5855
5856 if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
5857 push_reg_sz(talloc_tos(), &buffer, printer->info_2->location);
5858 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
5859 REG_SZ, buffer.data, buffer.length);
5860
5861 notify_printer_location(snum, printer->info_2->location);
5862 }
5863
5864 /* here we need to update some more DsSpooler keys */
5865 /* uNCName, serverName, shortServerName */
5866
5867 push_reg_sz(talloc_tos(), &buffer, global_myname());
5868 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
5869 REG_SZ, buffer.data, buffer.length);
5870 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
5871 REG_SZ, buffer.data, buffer.length);
5872
5873 slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
5874 global_myname(), printer->info_2->sharename );
5875 push_reg_sz(talloc_tos(), &buffer, asc_buffer);
5876 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
5877 REG_SZ, buffer.data, buffer.length);
5878
5879 /* Update printer info */
5880 result = mod_a_printer(printer, 2);
5881
5882 done:
5883 free_a_printer(&printer, 2);
5884 free_a_printer(&old_printer, 2);
5885
5886
5887 return result;
5888 }
5889
5890 /****************************************************************************
5891 ****************************************************************************/
5892 static WERROR publish_or_unpublish_printer(pipes_struct *p,
5893 struct policy_handle *handle,
5894 struct spoolss_SetPrinterInfo7 *info7)
5895 {
5896 #ifdef HAVE_ADS
5897 int snum;
5898 Printer_entry *Printer;
5899
5900 if ( lp_security() != SEC_ADS ) {
5901 return WERR_UNKNOWN_LEVEL;
5902 }
5903
5904 Printer = find_printer_index_by_hnd(p, handle);
5905
5906 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
5907
5908 if (!Printer)
5909 return WERR_BADFID;
5910
5911 if (!get_printer_snum(p, handle, &snum, NULL))
5912 return WERR_BADFID;
5913
5914 nt_printer_publish(Printer, snum, info7->action);
5915
5916 return WERR_OK;
5917 #else
5918 return WERR_UNKNOWN_LEVEL;
5919 #endif
5920 }
5921
5922 /****************************************************************
5923 _spoolss_SetPrinter
5924 ****************************************************************/
5925
5926 WERROR _spoolss_SetPrinter(pipes_struct *p,
5927 struct spoolss_SetPrinter *r)
5928 {
5929 WERROR result;
5930
5931 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5932
5933 if (!Printer) {
5934 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
5935 OUR_HANDLE(r->in.handle)));
5936 return WERR_BADFID;
5937 }
5938
5939 /* check the level */
5940 switch (r->in.info_ctr->level) {
5941 case 0:
5942 return control_printer(r->in.handle, r->in.command, p);
5943 case 2:
5944 result = update_printer(p, r->in.handle,
5945 r->in.info_ctr,
5946 r->in.devmode_ctr->devmode);
5947 if (!W_ERROR_IS_OK(result))
5948 return result;
5949 if (r->in.secdesc_ctr->sd)
5950 result = update_printer_sec(r->in.handle, p,
5951 r->in.secdesc_ctr);
5952 return result;
5953 case 3:
5954 return update_printer_sec(r->in.handle, p,
5955 r->in.secdesc_ctr);
5956 case 7:
5957 return publish_or_unpublish_printer(p, r->in.handle,
5958 r->in.info_ctr->info.info7);
5959 default:
5960 return WERR_UNKNOWN_LEVEL;
5961 }
5962 }
5963
5964 /****************************************************************
5965 _spoolss_FindClosePrinterNotify
5966 ****************************************************************/
5967
5968 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
5969 struct spoolss_FindClosePrinterNotify *r)
5970 {
5971 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5972
5973 if (!Printer) {
5974 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
5975 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
5976 return WERR_BADFID;
5977 }
5978
5979 if (Printer->notify.client_connected == true) {
5980 int snum = -1;
5981
5982 if ( Printer->printer_type == SPLHND_SERVER)
5983 snum = -1;
5984 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
5985 !get_printer_snum(p, r->in.handle, &snum, NULL) )
5986 return WERR_BADFID;
5987
5988 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
5989 }
5990
5991 Printer->notify.flags=0;
5992 Printer->notify.options=0;
5993 Printer->notify.localmachine[0]='\0';
5994 Printer->notify.printerlocal=0;
5995 TALLOC_FREE(Printer->notify.option);
5996 Printer->notify.client_connected = false;
5997
5998 return WERR_OK;
5999 }
6000
6001 /****************************************************************
6002 _spoolss_AddJob
6003 ****************************************************************/
6004
6005 WERROR _spoolss_AddJob(pipes_struct *p,
6006 struct spoolss_AddJob *r)
6007 {
6008 if (!r->in.buffer && (r->in.offered != 0)) {
6009 return WERR_INVALID_PARAM;
6010 }
6011
6012 /* this is what a NT server returns for AddJob. AddJob must fail on
6013 * non-local printers */
6014
6015 if (r->in.level != 1) {
6016 return WERR_UNKNOWN_LEVEL;
6017 }
6018
6019 return WERR_INVALID_PARAM;
6020 }
6021
6022 /****************************************************************************
6023 fill_job_info1
6024 ****************************************************************************/
6025
6026 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6027 struct spoolss_JobInfo1 *r,
6028 const print_queue_struct *queue,
6029 int position, int snum,
6030 const NT_PRINTER_INFO_LEVEL *ntprinter)
6031 {
6032 struct tm *t;
6033
6034 t = gmtime(&queue->time);
6035
6036 r->job_id = queue->job;
6037
6038 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6039 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6040 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6041 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6042 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6043 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6044 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6045 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6046 r->data_type = talloc_strdup(mem_ctx, "RAW");
6047 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6048 r->text_status = talloc_strdup(mem_ctx, "");
6049 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6050
6051 r->status = nt_printj_status(queue->status);
6052 r->priority = queue->priority;
6053 r->position = position;
6054 r->total_pages = queue->page_count;
6055 r->pages_printed = 0; /* ??? */
6056
6057 init_systemtime(&r->submitted, t);
6058
6059 return WERR_OK;
6060 }
6061
6062 /****************************************************************************
6063 fill_job_info2
6064 ****************************************************************************/
6065
6066 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6067 struct spoolss_JobInfo2 *r,
6068 const print_queue_struct *queue,
6069 int position, int snum,
6070 const NT_PRINTER_INFO_LEVEL *ntprinter,
6071 struct spoolss_DeviceMode *devmode)
6072 {
6073 struct tm *t;
6074
6075 t = gmtime(&queue->time);
6076
6077 r->job_id = queue->job;
6078
6079 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6080 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6081 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6082 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6083 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6084 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6085 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6086 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6087 r->notify_name = talloc_strdup(mem_ctx, queue->fs_user);
6088 W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6089 r->data_type = talloc_strdup(mem_ctx, "RAW");
6090 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6091 r->print_processor = talloc_strdup(mem_ctx, "winprint");
6092 W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6093 r->parameters = talloc_strdup(mem_ctx, "");
6094 W_ERROR_HAVE_NO_MEMORY(r->parameters);
6095 r->driver_name = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6096 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6097
6098 r->devmode = devmode;
6099
6100 r->text_status = talloc_strdup(mem_ctx, "");
6101 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6102
6103 r->secdesc = NULL;
6104
6105 r->status = nt_printj_status(queue->status);
6106 r->priority = queue->priority;
6107 r->position = position;
6108 r->start_time = 0;
6109 r->until_time = 0;
6110 r->total_pages = queue->page_count;
6111 r->size = queue->size;
6112 init_systemtime(&r->submitted, t);
6113 r->time = 0;
6114 r->pages_printed = 0; /* ??? */
6115
6116 return WERR_OK;
6117 }
6118
6119 /****************************************************************************
6120 fill_job_info3
6121 ****************************************************************************/
6122
6123 static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
6124 struct spoolss_JobInfo3 *r,
6125 const print_queue_struct *queue,
6126 const print_queue_struct *next_queue,
6127 int position, int snum,
6128 const NT_PRINTER_INFO_LEVEL *ntprinter)
6129 {
6130 r->job_id = queue->job;
6131 r->next_job_id = 0;
6132 if (next_queue) {
6133 r->next_job_id = next_queue->job;
6134 }
6135 r->reserved = 0;
6136
6137 return WERR_OK;
6138 }
6139
6140 /****************************************************************************
6141 Enumjobs at level 1.
6142 ****************************************************************************/
6143
6144 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6145 const print_queue_struct *queue,
6146 uint32_t num_queues, int snum,
6147 const NT_PRINTER_INFO_LEVEL *ntprinter,
6148 union spoolss_JobInfo **info_p,
6149 uint32_t *count)
6150 {
6151 union spoolss_JobInfo *info;
6152 int i;
6153 WERROR result = WERR_OK;
6154
6155 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6156 W_ERROR_HAVE_NO_MEMORY(info);
6157
6158 *count = num_queues;
6159
6160 for (i=0; i<*count; i++) {
6161 result = fill_job_info1(info,
6162 &info[i].info1,
6163 &queue[i],
6164 i,
6165 snum,
6166 ntprinter);
6167 if (!W_ERROR_IS_OK(result)) {
6168 goto out;
6169 }
6170 }
6171
6172 out:
6173 if (!W_ERROR_IS_OK(result)) {
6174 TALLOC_FREE(info);
6175 *count = 0;
6176 return result;
6177 }
6178
6179 *info_p = info;
6180
6181 return WERR_OK;
6182 }
6183
6184 /****************************************************************************
6185 Enumjobs at level 2.
6186 ****************************************************************************/
6187
6188 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6189 const print_queue_struct *queue,
6190 uint32_t num_queues, int snum,
6191 const NT_PRINTER_INFO_LEVEL *ntprinter,
6192 union spoolss_JobInfo **info_p,
6193 uint32_t *count)
6194 {
6195 union spoolss_JobInfo *info;
6196 int i;
6197 WERROR result = WERR_OK;
6198
6199 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6200 W_ERROR_HAVE_NO_MEMORY(info);
6201
6202 *count = num_queues;
6203
6204 for (i=0; i<*count; i++) {
6205
6206 struct spoolss_DeviceMode *devmode;
6207
6208 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6209 if (!devmode) {
6210 result = WERR_NOMEM;
6211 goto out;
6212 }
6213
6214 result = fill_job_info2(info,
6215 &info[i].info2,
6216 &queue[i],
6217 i,
6218 snum,
6219 ntprinter,
6220 devmode);
6221 if (!W_ERROR_IS_OK(result)) {
6222 goto out;
6223 }
6224 }
6225
6226 out:
6227 if (!W_ERROR_IS_OK(result)) {
6228 TALLOC_FREE(info);
6229 *count = 0;
6230 return result;
6231 }
6232
6233 *info_p = info;
6234
6235 return WERR_OK;
6236 }
6237
6238 /****************************************************************************
6239 Enumjobs at level 3.
6240 ****************************************************************************/
6241
6242 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
6243 const print_queue_struct *queue,
6244 uint32_t num_queues, int snum,
6245 const NT_PRINTER_INFO_LEVEL *ntprinter,
6246 union spoolss_JobInfo **info_p,
6247 uint32_t *count)
6248 {
6249 union spoolss_JobInfo *info;
6250 int i;
6251 WERROR result = WERR_OK;
6252
6253 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6254 W_ERROR_HAVE_NO_MEMORY(info);
6255
6256 *count = num_queues;
6257
6258 for (i=0; i<*count; i++) {
6259 const print_queue_struct *next_queue = NULL;
6260
6261 if (i+1 < *count) {
6262 next_queue = &queue[i+1];
6263 }
6264
6265 result = fill_job_info3(info,
6266 &info[i].info3,
6267 &queue[i],
6268 next_queue,
6269 i,
6270 snum,
6271 ntprinter);
6272 if (!W_ERROR_IS_OK(result)) {
6273 goto out;
6274 }
6275 }
6276
6277 out:
6278 if (!W_ERROR_IS_OK(result)) {
6279 TALLOC_FREE(info);
6280 *count = 0;
6281 return result;
6282 }
6283
6284 *info_p = info;
6285
6286 return WERR_OK;
6287 }
6288
6289 /****************************************************************
6290 _spoolss_EnumJobs
6291 ****************************************************************/
6292
6293 WERROR _spoolss_EnumJobs(pipes_struct *p,
6294 struct spoolss_EnumJobs *r)
6295 {
6296 WERROR result;
6297 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6298 int snum;
6299 print_status_struct prt_status;
6300 print_queue_struct *queue = NULL;
6301 uint32_t count;
6302
6303 /* that's an [in out] buffer */
6304
6305 if (!r->in.buffer && (r->in.offered != 0)) {
6306 return WERR_INVALID_PARAM;
6307 }
6308
6309 DEBUG(4,("_spoolss_EnumJobs\n"));
6310
6311 *r->out.needed = 0;
6312 *r->out.count = 0;
6313 *r->out.info = NULL;
6314
6315 /* lookup the printer snum and tdb entry */
6316
6317 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6318 return WERR_BADFID;
6319 }
6320
6321 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6322 if (!W_ERROR_IS_OK(result)) {
6323 return result;
6324 }
6325
6326 count = print_queue_status(snum, &queue, &prt_status);
6327 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6328 count, prt_status.status, prt_status.message));
6329
6330 if (count == 0) {
6331 SAFE_FREE(queue);
6332 free_a_printer(&ntprinter, 2);
6333 return WERR_OK;
6334 }
6335
6336 switch (r->in.level) {
6337 case 1:
6338 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6339 ntprinter, r->out.info, r->out.count);
6340 break;
6341 case 2:
6342 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6343 ntprinter, r->out.info, r->out.count);
6344 break;
6345 case 3:
6346 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
6347 ntprinter, r->out.info, r->out.count);
6348 break;
6349 default:
6350 result = WERR_UNKNOWN_LEVEL;
6351 break;
6352 }
6353
6354 SAFE_FREE(queue);
6355 free_a_printer(&ntprinter, 2);
6356
6357 if (!W_ERROR_IS_OK(result)) {
6358 return result;
6359 }
6360
6361 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6362 spoolss_EnumJobs, NULL,
6363 *r->out.info, r->in.level,
6364 *r->out.count);
6365 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6366 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6367
6368 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6369 }
6370
6371 /****************************************************************
6372 _spoolss_ScheduleJob
6373 ****************************************************************/
6374
6375 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6376 struct spoolss_ScheduleJob *r)
6377 {
6378 return WERR_OK;
6379 }
6380
6381 /****************************************************************
6382 _spoolss_SetJob
6383 ****************************************************************/
6384
6385 WERROR _spoolss_SetJob(pipes_struct *p,
6386 struct spoolss_SetJob *r)
6387 {
6388 int snum;
6389 WERROR errcode = WERR_BADFUNC;
6390
6391 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6392 return WERR_BADFID;
6393 }
6394
6395 if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6396 return WERR_INVALID_PRINTER_NAME;
6397 }
6398
6399 switch (r->in.command) {
6400 case SPOOLSS_JOB_CONTROL_CANCEL:
6401 case SPOOLSS_JOB_CONTROL_DELETE:
6402 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6403 errcode = WERR_OK;
6404 }
6405 break;
6406 case SPOOLSS_JOB_CONTROL_PAUSE:
6407 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6408 errcode = WERR_OK;
6409 }
6410 break;
6411 case SPOOLSS_JOB_CONTROL_RESTART:
6412 case SPOOLSS_JOB_CONTROL_RESUME:
6413 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6414 errcode = WERR_OK;
6415 }
6416 break;
6417 default:
6418 return WERR_UNKNOWN_LEVEL;
6419 }
6420
6421 return errcode;
6422 }
6423
6424 /****************************************************************************
6425 Enumerates all printer drivers by level and architecture.
6426 ****************************************************************************/
6427
6428 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
6429 const char *servername,
6430 const char *architecture,
6431 uint32_t level,
6432 union spoolss_DriverInfo **info_p,
6433 uint32_t *count_p)
6434 {
6435 int i;
6436 int ndrivers;
6437 uint32_t version;
6438 fstring *list = NULL;
6439 struct spoolss_DriverInfo8 *driver;
6440 union spoolss_DriverInfo *info = NULL;
6441 uint32_t count = 0;
6442 WERROR result = WERR_OK;
6443
6444 *count_p = 0;
6445 *info_p = NULL;
6446
6447 for (version=0; version<DRIVER_MAX_VERSION; version++) {
6448 list = NULL;
6449 ndrivers = get_ntdrivers(&list, architecture, version);
6450 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6451 ndrivers, architecture, version));
6452
6453 if (ndrivers == -1) {
6454 result = WERR_NOMEM;
6455 goto out;
6456 }
6457
6458 if (ndrivers != 0) {
6459 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6460 union spoolss_DriverInfo,
6461 count + ndrivers);
6462 if (!info) {
6463 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
6464 "failed to enlarge driver info buffer!\n"));
6465 result = WERR_NOMEM;
6466 goto out;
6467 }
6468 }
6469
6470 for (i=0; i<ndrivers; i++) {
6471 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6472 ZERO_STRUCT(driver);
6473 result = get_a_printer_driver(mem_ctx, &driver, list[i],
6474 architecture, version);
6475 if (!W_ERROR_IS_OK(result)) {
6476 goto out;
6477 }
6478
6479 switch (level) {
6480 case 1:
6481 result = fill_printer_driver_info1(info, &info[count+i].info1,
6482 driver, servername);
6483 break;
6484 case 2:
6485 result = fill_printer_driver_info2(info, &info[count+i].info2,
6486 driver, servername);
6487 break;
6488 case 3:
6489 result = fill_printer_driver_info3(info, &info[count+i].info3,
6490 driver, servername);
6491 break;
6492 case 4:
6493 result = fill_printer_driver_info4(info, &info[count+i].info4,
6494 driver, servername);
6495 break;
6496 case 5:
6497 result = fill_printer_driver_info5(info, &info[count+i].info5,
6498 driver, servername);
6499 break;
6500 case 6:
6501 result = fill_printer_driver_info6(info, &info[count+i].info6,
6502 driver, servername);
6503 break;
6504 case 8:
6505 result = fill_printer_driver_info8(info, &info[count+i].info8,
6506 driver, servername);
6507 break;
6508 default:
6509 result = WERR_UNKNOWN_LEVEL;
6510 break;
6511 }
6512
6513 free_a_printer_driver(driver);
6514
6515 if (!W_ERROR_IS_OK(result)) {
6516 goto out;
6517 }
6518 }
6519
6520 count += ndrivers;
6521 SAFE_FREE(list);
6522 }
6523
6524 out:
6525 SAFE_FREE(list);
6526
6527 if (!W_ERROR_IS_OK(result)) {
6528 TALLOC_FREE(info);
6529 return result;
6530 }
6531
6532 *info_p = info;
6533 *count_p = count;
6534
6535 return WERR_OK;
6536 }
6537
6538 /****************************************************************************
6539 Enumerates all printer drivers by level.
6540 ****************************************************************************/
6541
6542 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6543 const char *servername,
6544 const char *architecture,
6545 uint32_t level,
6546 union spoolss_DriverInfo **info_p,
6547 uint32_t *count_p)
6548 {
6549 uint32_t a,i;
6550 WERROR result = WERR_OK;
6551
6552 if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
6553
6554 for (a=0; archi_table[a].long_archi != NULL; a++) {
6555
6556 union spoolss_DriverInfo *info = NULL;
6557 uint32_t count = 0;
6558
6559 result = enumprinterdrivers_level_by_architecture(mem_ctx,
6560 servername,
6561 archi_table[a].long_archi,
6562 level,
6563 &info,
6564 &count);
6565 if (!W_ERROR_IS_OK(result)) {
6566 continue;
6567 }
6568
6569 for (i=0; i < count; i++) {
6570 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
6571 info[i], info_p, count_p);
6572 }
6573 }
6574
6575 return result;
6576 }
6577
6578 return enumprinterdrivers_level_by_architecture(mem_ctx,
6579 servername,
6580 architecture,
6581 level,
6582 info_p,
6583 count_p);
6584 }
6585
6586 /****************************************************************
6587 _spoolss_EnumPrinterDrivers
6588 ****************************************************************/
6589
6590 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6591 struct spoolss_EnumPrinterDrivers *r)
6592 {
6593 const char *cservername;
6594 WERROR result;
6595
6596 /* that's an [in out] buffer */
6597
6598 if (!r->in.buffer && (r->in.offered != 0)) {
6599 return WERR_INVALID_PARAM;
6600 }
6601
6602 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6603
6604 *r->out.needed = 0;
6605 *r->out.count = 0;
6606 *r->out.info = NULL;
6607
6608 cservername = canon_servername(r->in.server);
6609
6610 if (!is_myname_or_ipaddr(cservername)) {
6611 return WERR_UNKNOWN_PRINTER_DRIVER;
6612 }
6613
6614 result = enumprinterdrivers_level(p->mem_ctx, cservername,
6615 r->in.environment,
6616 r->in.level,
6617 r->out.info,
6618 r->out.count);
6619 if (!W_ERROR_IS_OK(result)) {
6620 return result;
6621 }
6622
6623 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6624 spoolss_EnumPrinterDrivers, NULL,
6625 *r->out.info, r->in.level,
6626 *r->out.count);
6627 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6628 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6629
6630 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6631 }
6632
6633 /****************************************************************************
6634 ****************************************************************************/
6635
6636 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
6637 struct spoolss_FormInfo1 *r,
6638 const nt_forms_struct *form)
6639 {
6640 r->form_name = talloc_strdup(mem_ctx, form->name);
6641 W_ERROR_HAVE_NO_MEMORY(r->form_name);
6642
6643 r->flags = form->flag;
6644 r->size.width = form->width;
6645 r->size.height = form->length;
6646 r->area.left = form->left;
6647 r->area.top = form->top;
6648 r->area.right = form->right;
6649 r->area.bottom = form->bottom;
6650
6651 return WERR_OK;
6652 }
6653
6654 /****************************************************************
6655 spoolss_enumforms_level1
6656 ****************************************************************/
6657
6658 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
6659 const nt_forms_struct *builtin_forms,
6660 uint32_t num_builtin_forms,
6661 const nt_forms_struct *user_forms,
6662 uint32_t num_user_forms,
6663 union spoolss_FormInfo **info_p,
6664 uint32_t *count)
6665 {
6666 union spoolss_FormInfo *info;
6667 WERROR result = WERR_OK;
6668 int i;
6669
6670 *count = num_builtin_forms + num_user_forms;
6671
6672 info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
6673 W_ERROR_HAVE_NO_MEMORY(info);
6674
6675 /* construct the list of form structures */
6676 for (i=0; i<num_builtin_forms; i++) {
6677 DEBUGADD(6,("Filling builtin form number [%d]\n",i));
6678 result = fill_form_info_1(info, &info[i].info1,
6679 &builtin_forms[i]);
6680 if (!W_ERROR_IS_OK(result)) {
6681 goto out;
6682 }
6683 }
6684
6685 for (i=0; i<num_user_forms; i++) {
6686 DEBUGADD(6,("Filling user form number [%d]\n",i));
6687 result = fill_form_info_1(info, &info[i+num_builtin_forms].info1,
6688 &user_forms[i]);
6689 if (!W_ERROR_IS_OK(result)) {
6690 goto out;
6691 }
6692 }
6693
6694 out:
6695 if (!W_ERROR_IS_OK(result)) {
6696 TALLOC_FREE(info);
6697 *count = 0;
6698 return result;
6699 }
6700
6701 *info_p = info;
6702
6703 return WERR_OK;
6704 }
6705
6706 /****************************************************************
6707 _spoolss_EnumForms
6708 ****************************************************************/
6709
6710 WERROR _spoolss_EnumForms(pipes_struct *p,
6711 struct spoolss_EnumForms *r)
6712 {
6713 WERROR result;
6714 nt_forms_struct *user_forms = NULL;
6715 nt_forms_struct *builtin_forms = NULL;
6716 uint32_t num_user_forms;
6717 uint32_t num_builtin_forms;
6718
6719 *r->out.count = 0;
6720 *r->out.needed = 0;
6721 *r->out.info = NULL;
6722
6723 /* that's an [in out] buffer */
6724
6725 if (!r->in.buffer && (r->in.offered != 0) ) {
6726 return WERR_INVALID_PARAM;
6727 }
6728
6729 DEBUG(4,("_spoolss_EnumForms\n"));
6730 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6731 DEBUGADD(5,("Info level [%d]\n", r->in.level));
6732
6733 num_builtin_forms = get_builtin_ntforms(&builtin_forms);
6734 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
6735 num_user_forms = get_ntforms(&user_forms);
6736 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
6737
6738 if (num_user_forms + num_builtin_forms == 0) {
6739 SAFE_FREE(builtin_forms);
6740 SAFE_FREE(user_forms);
6741 return WERR_NO_MORE_ITEMS;
6742 }
6743
6744 switch (r->in.level) {
6745 case 1:
6746 result = spoolss_enumforms_level1(p->mem_ctx,
6747 builtin_forms,
6748 num_builtin_forms,
6749 user_forms,
6750 num_user_forms,
6751 r->out.info,
6752 r->out.count);
6753 break;
6754 default:
6755 result = WERR_UNKNOWN_LEVEL;
6756 break;
6757 }
6758
6759 SAFE_FREE(user_forms);
6760 SAFE_FREE(builtin_forms);
6761
6762 if (!W_ERROR_IS_OK(result)) {
6763 return result;
6764 }
6765
6766 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6767 spoolss_EnumForms, NULL,
6768 *r->out.info, r->in.level,
6769 *r->out.count);
6770 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6771 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6772
6773 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6774 }
6775
6776 /****************************************************************
6777 ****************************************************************/
6778
6779 static WERROR find_form_byname(const char *name,
6780 nt_forms_struct *form)
6781 {
6782 nt_forms_struct *list = NULL;
6783 int num_forms = 0, i = 0;
6784
6785 if (get_a_builtin_ntform_by_string(name, form)) {
6786 return WERR_OK;
6787 }
6788
6789 num_forms = get_ntforms(&list);
6790 DEBUGADD(5,("Number of forms [%d]\n", num_forms));
6791
6792 if (num_forms == 0) {
6793 return WERR_BADFID;
6794 }
6795
6796 /* Check if the requested name is in the list of form structures */
6797 for (i = 0; i < num_forms; i++) {
6798
6799 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
6800
6801 if (strequal(name, list[i].name)) {
6802 DEBUGADD(6,("Found form %s number [%d]\n", name, i));
6803 *form = list[i];
6804 SAFE_FREE(list);
6805 return WERR_OK;
6806 }
6807 }
6808
6809 SAFE_FREE(list);
6810
6811 return WERR_BADFID;
6812 }
6813
6814 /****************************************************************
6815 _spoolss_GetForm
6816 ****************************************************************/
6817
6818 WERROR _spoolss_GetForm(pipes_struct *p,
6819 struct spoolss_GetForm *r)
6820 {
6821 WERROR result;
6822 nt_forms_struct form;
6823
6824 /* that's an [in out] buffer */
6825
6826 if (!r->in.buffer && (r->in.offered != 0)) {
6827 return WERR_INVALID_PARAM;
6828 }
6829
6830 DEBUG(4,("_spoolss_GetForm\n"));
6831 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
6832 DEBUGADD(5,("Info level [%d]\n", r->in.level));
6833
6834 result = find_form_byname(r->in.form_name, &form);
6835 if (!W_ERROR_IS_OK(result)) {
6836 TALLOC_FREE(r->out.info);
6837 return result;
6838 }
6839
6840 switch (r->in.level) {
6841 case 1:
6842 result = fill_form_info_1(p->mem_ctx,
6843 &r->out.info->info1,
6844 &form);
6845 break;
6846
6847 default:
6848 result = WERR_UNKNOWN_LEVEL;
6849 break;
6850 }
6851
6852 if (!W_ERROR_IS_OK(result)) {
6853 TALLOC_FREE(r->out.info);
6854 return result;
6855 }
6856
6857 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
6858 r->out.info, r->in.level);
6859 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
6860
6861 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6862 }
6863
6864 /****************************************************************************
6865 ****************************************************************************/
6866
6867 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
6868 struct spoolss_PortInfo1 *r,
6869 const char *name)
6870 {
6871 r->port_name = talloc_strdup(mem_ctx, name);
6872 W_ERROR_HAVE_NO_MEMORY(r->port_name);
6873
6874 return WERR_OK;
6875 }
6876
6877 /****************************************************************************
6878 TODO: This probably needs distinguish between TCP/IP and Local ports
6879 somehow.
6880 ****************************************************************************/
6881
6882 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
6883 struct spoolss_PortInfo2 *r,
6884 const char *name)
6885 {
6886 r->port_name = talloc_strdup(mem_ctx, name);
6887 W_ERROR_HAVE_NO_MEMORY(r->port_name);
6888
6889 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
6890 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
6891
6892 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
6893 W_ERROR_HAVE_NO_MEMORY(r->description);
6894
6895 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
6896 r->reserved = 0;
6897
6898 return WERR_OK;
6899 }
6900
6901
6902 /****************************************************************************
6903 wrapper around the enumer ports command
6904 ****************************************************************************/
6905
6906 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
6907 {
6908 char *cmd = lp_enumports_cmd();
6909 char **qlines = NULL;
6910 char *command = NULL;
6911 int numlines;
6912 int ret;
6913 int fd;
6914
6915 *count = 0;
6916 *lines = NULL;
6917
6918 /* if no hook then just fill in the default port */
6919
6920 if ( !*cmd ) {
6921 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
6922 return WERR_NOMEM;
6923 }
6924 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
6925 TALLOC_FREE(qlines);
6926 return WERR_NOMEM;
6927 }
6928 qlines[1] = NULL;
6929 numlines = 1;
6930 }
6931 else {
6932 /* we have a valid enumport command */
6933
6934 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
6935 if (!command) {
6936 return WERR_NOMEM;
6937 }
6938
6939 DEBUG(10,("Running [%s]\n", command));
6940 ret = smbrun(command, &fd);
6941 DEBUG(10,("Returned [%d]\n", ret));
6942 TALLOC_FREE(command);
6943 if (ret != 0) {
6944 if (fd != -1) {
6945 close(fd);
6946 }
6947 return WERR_ACCESS_DENIED;
6948 }
6949
6950 numlines = 0;
6951 qlines = fd_lines_load(fd, &numlines, 0, NULL);
6952 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6953 close(fd);
6954 }
6955
6956 *count = numlines;
6957 *lines = qlines;
6958
6959 return WERR_OK;
6960 }
6961
6962 /****************************************************************************
6963 enumports level 1.
6964 ****************************************************************************/
6965
6966 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
6967 union spoolss_PortInfo **info_p,
6968 uint32_t *count)
6969 {
6970 union spoolss_PortInfo *info = NULL;
6971 int i=0;
6972 WERROR result = WERR_OK;
6973 char **qlines = NULL;
6974 int numlines = 0;
6975
6976 result = enumports_hook(talloc_tos(), &numlines, &qlines );
6977 if (!W_ERROR_IS_OK(result)) {
6978 goto out;
6979 }
6980
6981 if (numlines) {
6982 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
6983 if (!info) {
6984 DEBUG(10,("Returning WERR_NOMEM\n"));
6985 result = WERR_NOMEM;
6986 goto out;
6987 }
6988
6989 for (i=0; i<numlines; i++) {
6990 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
6991 result = fill_port_1(info, &info[i].info1, qlines[i]);
6992 if (!W_ERROR_IS_OK(result)) {
6993 goto out;
6994 }
6995 }
6996 }
6997 TALLOC_FREE(qlines);
6998
6999 out:
7000 if (!W_ERROR_IS_OK(result)) {
7001 TALLOC_FREE(info);
7002 TALLOC_FREE(qlines);
7003 *count = 0;
7004 *info_p = NULL;
7005 return result;
7006 }
7007
7008 *info_p = info;
7009 *count = numlines;
7010
7011 return WERR_OK;
7012 }
7013
7014 /****************************************************************************
7015 enumports level 2.
7016 ****************************************************************************/
7017
7018 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7019 union spoolss_PortInfo **info_p,
7020 uint32_t *count)
7021 {
7022 union spoolss_PortInfo *info = NULL;
7023 int i=0;
7024 WERROR result = WERR_OK;
7025 char **qlines = NULL;
7026 int numlines = 0;
7027
7028 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7029 if (!W_ERROR_IS_OK(result)) {
7030 goto out;
7031 }
7032
7033 if (numlines) {
7034 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7035 if (!info) {
7036 DEBUG(10,("Returning WERR_NOMEM\n"));
7037 result = WERR_NOMEM;
7038 goto out;
7039 }
7040
7041 for (i=0; i<numlines; i++) {
7042 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7043 result = fill_port_2(info, &info[i].info2, qlines[i]);
7044 if (!W_ERROR_IS_OK(result)) {
7045 goto out;
7046 }
7047 }
7048 }
7049 TALLOC_FREE(qlines);
7050
7051 out:
7052 if (!W_ERROR_IS_OK(result)) {
7053 TALLOC_FREE(info);
7054 TALLOC_FREE(qlines);
7055 *count = 0;
7056 *info_p = NULL;
7057 return result;
7058 }
7059
7060 *info_p = info;
7061 *count = numlines;
7062
7063 return WERR_OK;
7064 }
7065
7066 /****************************************************************
7067 _spoolss_EnumPorts
7068 ****************************************************************/
7069
7070 WERROR _spoolss_EnumPorts(pipes_struct *p,
7071 struct spoolss_EnumPorts *r)
7072 {
7073 WERROR result;
7074
7075 /* that's an [in out] buffer */
7076
7077 if (!r->in.buffer && (r->in.offered != 0)) {
7078 return WERR_INVALID_PARAM;
7079 }
7080
7081 DEBUG(4,("_spoolss_EnumPorts\n"));
7082
7083 *r->out.count = 0;
7084 *r->out.needed = 0;
7085 *r->out.info = NULL;
7086
7087 switch (r->in.level) {
7088 case 1:
7089 result = enumports_level_1(p->mem_ctx, r->out.info,
7090 r->out.count);
7091 break;
7092 case 2:
7093 result = enumports_level_2(p->mem_ctx, r->out.info,
7094 r->out.count);
7095 break;
7096 default:
7097 return WERR_UNKNOWN_LEVEL;
7098 }
7099
7100 if (!W_ERROR_IS_OK(result)) {
7101 return result;
7102 }
7103
7104 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7105 spoolss_EnumPorts, NULL,
7106 *r->out.info, r->in.level,
7107 *r->out.count);
7108 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7109 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7110
7111 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7112 }
7113
7114 /****************************************************************************
7115 ****************************************************************************/
7116
7117 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7118 const char *server,
7119 struct spoolss_SetPrinterInfoCtr *info_ctr,
7120 struct spoolss_DeviceMode *devmode,
7121 struct security_descriptor *sec_desc,
7122 struct spoolss_UserLevelCtr *user_ctr,
7123 struct policy_handle *handle)
7124 {
7125 NT_PRINTER_INFO_LEVEL *printer = NULL;
7126 fstring name;
7127 int snum;
7128 WERROR err = WERR_OK;
7129
7130 if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7131 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7132 return WERR_NOMEM;
7133 }
7134
7135 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7136 if (!convert_printer_info(info_ctr, printer)) {
7137 free_a_printer(&printer, 2);
7138 return WERR_NOMEM;
7139 }
7140
7141 /* samba does not have a concept of local, non-shared printers yet, so
7142 * make sure we always setup sharename - gd */
7143 if ((printer->info_2->sharename[0] == '\0') && (printer->info_2->printername != '\0')) {
7144 DEBUG(5, ("spoolss_addprinterex_level_2: "
7145 "no sharename has been set, setting printername %s as sharename\n",
7146 printer->info_2->printername));
7147 fstrcpy(printer->info_2->sharename, printer->info_2->printername);
7148 }
7149
7150 /* check to see if the printer already exists */
7151
7152 if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7153 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7154 printer->info_2->sharename));
7155 free_a_printer(&printer, 2);
7156 return WERR_PRINTER_ALREADY_EXISTS;
7157 }
7158
7159 if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
7160 if ((snum = print_queue_snum(printer->info_2->printername)) != -1) {
7161 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7162 printer->info_2->printername));
7163 free_a_printer(&printer, 2);
7164 return WERR_PRINTER_ALREADY_EXISTS;
7165 }
7166 }
7167
7168 /* validate printer info struct */
7169 if (!info_ctr->info.info2->printername ||
7170 strlen(info_ctr->info.info2->printername) == 0) {
7171 free_a_printer(&printer,2);
7172 return WERR_INVALID_PRINTER_NAME;
7173 }
7174 if (!info_ctr->info.info2->portname ||
7175 strlen(info_ctr->info.info2->portname) == 0) {
7176 free_a_printer(&printer,2);
7177 return WERR_UNKNOWN_PORT;
7178 }
7179 if (!info_ctr->info.info2->drivername ||
7180 strlen(info_ctr->info.info2->drivername) == 0) {
7181 free_a_printer(&printer,2);
7182 return WERR_UNKNOWN_PRINTER_DRIVER;
7183 }
7184 if (!info_ctr->info.info2->printprocessor ||
7185 strlen(info_ctr->info.info2->printprocessor) == 0) {
7186 free_a_printer(&printer,2);
7187 return WERR_UNKNOWN_PRINTPROCESSOR;
7188 }
7189
7190 /* FIXME!!! smbd should check to see if the driver is installed before
7191 trying to add a printer like this --jerry */
7192
7193 if (*lp_addprinter_cmd() ) {
7194 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7195 printer) ) {
7196 free_a_printer(&printer,2);
7197 return WERR_ACCESS_DENIED;
7198 }
7199 } else {
7200 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7201 "smb.conf parameter \"addprinter command\" is defined. This"
7202 "parameter must exist for this call to succeed\n",
7203 printer->info_2->sharename ));
7204 }
7205
7206 /* use our primary netbios name since get_a_printer() will convert
7207 it to what the client expects on a case by case basis */
7208
7209 slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7210 printer->info_2->sharename);
7211
7212
7213 if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7214 free_a_printer(&printer,2);
7215 return WERR_ACCESS_DENIED;
7216 }
7217
7218 /* you must be a printer admin to add a new printer */
7219 if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
7220 free_a_printer(&printer,2);
7221 return WERR_ACCESS_DENIED;
7222 }
7223
7224 /*
7225 * Do sanity check on the requested changes for Samba.
7226 */
7227
7228 if (!check_printer_ok(printer->info_2, snum)) {
7229 free_a_printer(&printer,2);
7230 return WERR_INVALID_PARAM;
7231 }
7232
7233 /*
7234 * When a printer is created, the drivername bound to the printer is used
7235 * to lookup previously saved driver initialization info, which is then
7236 * bound to the new printer, simulating what happens in the Windows arch.
7237 */
7238
7239 if (!devmode)
7240 {
7241 set_driver_init(printer, 2);
7242 }
7243 else
7244 {
7245 /* A valid devmode was included, convert and link it
7246 */
7247 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7248
7249 if (!convert_devicemode(printer->info_2->printername, devmode,
7250 &printer->info_2->devmode)) {
7251 return WERR_NOMEM;
7252 }
7253 }
7254
7255 /* write the ASCII on disk */
7256 err = mod_a_printer(printer, 2);
7257 if (!W_ERROR_IS_OK(err)) {
7258 free_a_printer(&printer,2);
7259 return err;
7260 }
7261
7262 if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7263 /* Handle open failed - remove addition. */
7264 del_a_printer(printer->info_2->sharename);
7265 free_a_printer(&printer,2);
7266 ZERO_STRUCTP(handle);
7267 return WERR_ACCESS_DENIED;
7268 }
7269
7270 update_c_setprinter(false);
7271 free_a_printer(&printer,2);
7272
7273 return WERR_OK;
7274 }
7275
7276 /****************************************************************
7277 _spoolss_AddPrinterEx
7278 ****************************************************************/
7279
7280 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7281 struct spoolss_AddPrinterEx *r)
7282 {
7283 switch (r->in.info_ctr->level) {
7284 case 1:
7285 /* we don't handle yet */
7286 /* but I know what to do ... */
7287 return WERR_UNKNOWN_LEVEL;
7288 case 2:
7289 return spoolss_addprinterex_level_2(p, r->in.server,
7290 r->in.info_ctr,
7291 r->in.devmode_ctr->devmode,
7292 r->in.secdesc_ctr->sd,
7293 r->in.userlevel_ctr,
7294 r->out.handle);
7295 default:
7296 return WERR_UNKNOWN_LEVEL;
7297 }
7298 }
7299
7300 /****************************************************************
7301 _spoolss_AddPrinter
7302 ****************************************************************/
7303
7304 WERROR _spoolss_AddPrinter(pipes_struct *p,
7305 struct spoolss_AddPrinter *r)
7306 {
7307 struct spoolss_AddPrinterEx a;
7308 struct spoolss_UserLevelCtr userlevel_ctr;
7309
7310 ZERO_STRUCT(userlevel_ctr);
7311
7312 userlevel_ctr.level = 1;
7313
7314 a.in.server = r->in.server;
7315 a.in.info_ctr = r->in.info_ctr;
7316 a.in.devmode_ctr = r->in.devmode_ctr;
7317 a.in.secdesc_ctr = r->in.secdesc_ctr;
7318 a.in.userlevel_ctr = &userlevel_ctr;
7319 a.out.handle = r->out.handle;
7320
7321 return _spoolss_AddPrinterEx(p, &a);
7322 }
7323
7324 /****************************************************************
7325 _spoolss_AddPrinterDriver
7326 ****************************************************************/
7327
7328 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7329 struct spoolss_AddPrinterDriver *r)
7330 {
7331 WERROR err = WERR_OK;
7332 char *driver_name = NULL;
7333 uint32_t version;
7334 const char *fn;
7335
7336 switch (p->hdr_req.opnum) {
7337 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7338 fn = "_spoolss_AddPrinterDriver";
7339 break;
7340 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7341 fn = "_spoolss_AddPrinterDriverEx";
7342 break;
7343 default:
7344 return WERR_INVALID_PARAM;
7345 }
7346
7347
7348 /* FIXME */
7349 if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
7350 /* Clever hack from Martin Zielinski <mz@seh.de>
7351 * to allow downgrade from level 8 (Vista).
7352 */
7353 DEBUG(0,("%s: level %d not yet implemented\n", fn,
7354 r->in.info_ctr->level));
7355 return WERR_UNKNOWN_LEVEL;
7356 }
7357
7358 DEBUG(5,("Cleaning driver's information\n"));
7359 err = clean_up_driver_struct(p, r->in.info_ctr);
7360 if (!W_ERROR_IS_OK(err))
7361 goto done;
7362
7363 DEBUG(5,("Moving driver to final destination\n"));
7364 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, r->in.info_ctr,
7365 &err)) ) {
7366 goto done;
7367 }
7368
7369 if (add_a_printer_driver(p->mem_ctx, r->in.info_ctr, &driver_name, &version)!=0) {
7370 err = WERR_ACCESS_DENIED;
7371 goto done;
7372 }
7373
7374 /*
7375 * I think this is where he DrvUpgradePrinter() hook would be
7376 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7377 * server. Right now, we just need to send ourselves a message
7378 * to update each printer bound to this driver. --jerry
7379 */
7380
7381 if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7382 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7383 fn, driver_name));
7384 }
7385
7386 /*
7387 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7388 * decide if the driver init data should be deleted. The rules are:
7389 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7390 * 2) delete init data only if there is no 2k/Xp driver
7391 * 3) always delete init data
7392 * The generalized rule is always use init data from the highest order driver.
7393 * It is necessary to follow the driver install by an initialization step to
7394 * finish off this process.
7395 */
7396
7397 switch (version) {
7398 /*
7399 * 9x printer driver - never delete init data
7400 */
7401 case 0:
7402 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7403 fn, driver_name));
7404 break;
7405
7406 /*
7407 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7408 * there is no 2k/Xp driver init data for this driver name.
7409 */
7410 case 2:
7411 {
7412 struct spoolss_DriverInfo8 *driver1;
7413
7414 if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &driver1, driver_name, "Windows NT x86", 3))) {
7415 /*
7416 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7417 */
7418 if (!del_driver_init(driver_name))
7419 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7420 fn, driver_name));
7421 } else {
7422 /*
7423 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7424 */
7425 free_a_printer_driver(driver1);
7426 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7427 fn, driver_name));
7428 }
7429 }
7430 break;
7431
7432 /*
7433 * 2k or Xp printer driver - always delete init data
7434 */
7435 case 3:
7436 if (!del_driver_init(driver_name))
7437 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7438 fn, driver_name));
7439 break;
7440
7441 default:
7442 DEBUG(0,("%s: invalid level=%d\n", fn,
7443 r->in.info_ctr->level));
7444 break;
7445 }
7446
7447
7448 done:
7449 return err;
7450 }
7451
7452 /****************************************************************
7453 _spoolss_AddPrinterDriverEx
7454 ****************************************************************/
7455
7456 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7457 struct spoolss_AddPrinterDriverEx *r)
7458 {
7459 struct spoolss_AddPrinterDriver a;
7460
7461 /*
7462 * we only support the semantics of AddPrinterDriver()
7463 * i.e. only copy files that are newer than existing ones
7464 */
7465
7466 if (r->in.flags != APD_COPY_NEW_FILES) {
7467 return WERR_ACCESS_DENIED;
7468 }
7469
7470 a.in.servername = r->in.servername;
7471 a.in.info_ctr = r->in.info_ctr;
7472
7473 return _spoolss_AddPrinterDriver(p, &a);
7474 }
7475
7476 /****************************************************************************
7477 ****************************************************************************/
7478
7479 struct _spoolss_paths {
7480 int type;
7481 const char *share;
7482 const char *dir;
7483 };
7484
7485 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7486
7487 static const struct _spoolss_paths spoolss_paths[]= {
7488 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
7489 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
7490 };
7491
7492 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7493 const char *servername,
7494 const char *environment,
7495 int component,
7496 char **path)
7497 {
7498 const char *pservername = NULL;
7499 const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7500 const char *short_archi;
7501
7502 *path = NULL;
7503
7504 /* environment may be empty */
7505 if (environment && strlen(environment)) {
7506 long_archi = environment;
7507 }
7508
7509 /* servername may be empty */
7510 if (servername && strlen(servername)) {
7511 pservername = canon_servername(servername);
7512
7513 if (!is_myname_or_ipaddr(pservername)) {
7514 return WERR_INVALID_PARAM;
7515 }
7516 }
7517
7518 if (!(short_archi = get_short_archi(long_archi))) {
7519 return WERR_INVALID_ENVIRONMENT;
7520 }
7521
7522 switch (component) {
7523 case SPOOLSS_PRTPROCS_PATH:
7524 case SPOOLSS_DRIVER_PATH:
7525 if (pservername) {
7526 *path = talloc_asprintf(mem_ctx,
7527 "\\\\%s\\%s\\%s",
7528 pservername,
7529 spoolss_paths[component].share,
7530 short_archi);
7531 } else {
7532 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7533 SPOOLSS_DEFAULT_SERVER_PATH,
7534 spoolss_paths[component].dir,
7535 short_archi);
7536 }
7537 break;
7538 default:
7539 return WERR_INVALID_PARAM;
7540 }
7541
7542 if (!*path) {
7543 return WERR_NOMEM;
7544 }
7545
7546 return WERR_OK;
7547 }
7548
7549 /****************************************************************************
7550 ****************************************************************************/
7551
7552 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7553 const char *servername,
7554 const char *environment,
7555 struct spoolss_DriverDirectoryInfo1 *r)
7556 {
7557 WERROR werr;
7558 char *path = NULL;
7559
7560 werr = compose_spoolss_server_path(mem_ctx,
7561 servername,
7562 environment,
7563 SPOOLSS_DRIVER_PATH,
7564 &path);
7565 if (!W_ERROR_IS_OK(werr)) {
7566 return werr;
7567 }
7568
7569 DEBUG(4,("printer driver directory: [%s]\n", path));
7570
7571 r->directory_name = path;
7572
7573 return WERR_OK;
7574 }
7575
7576 /****************************************************************
7577 _spoolss_GetPrinterDriverDirectory
7578 ****************************************************************/
7579
7580 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7581 struct spoolss_GetPrinterDriverDirectory *r)
7582 {
7583 WERROR werror;
7584
7585 /* that's an [in out] buffer */
7586
7587 if (!r->in.buffer && (r->in.offered != 0)) {
7588 return WERR_INVALID_PARAM;
7589 }
7590
7591 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7592 r->in.level));
7593
7594 *r->out.needed = 0;
7595
7596 /* r->in.level is ignored */
7597
7598 werror = getprinterdriverdir_level_1(p->mem_ctx,
7599 r->in.server,
7600 r->in.environment,
7601 &r->out.info->info1);
7602 if (!W_ERROR_IS_OK(werror)) {
7603 TALLOC_FREE(r->out.info);
7604 return werror;
7605 }
7606
7607 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
7608 r->out.info, r->in.level);
7609 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7610
7611 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7612 }
7613
7614 /****************************************************************
7615 _spoolss_EnumPrinterData
7616 ****************************************************************/
7617
7618 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
7619 struct spoolss_EnumPrinterData *r)
7620 {
7621 NT_PRINTER_INFO_LEVEL *printer = NULL;
7622 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7623 int snum;
7624 WERROR result;
7625 struct regval_blob *val = NULL;
7626 NT_PRINTER_DATA *p_data;
7627 int i, key_index, num_values;
7628 int name_length;
7629
7630 *r->out.value_needed = 0;
7631 *r->out.type = REG_NONE;
7632 *r->out.data_needed = 0;
7633
7634 DEBUG(5,("_spoolss_EnumPrinterData\n"));
7635
7636 if (!Printer) {
7637 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
7638 OUR_HANDLE(r->in.handle)));
7639 return WERR_BADFID;
7640 }
7641
7642 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7643 return WERR_BADFID;
7644 }
7645
7646 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7647 if (!W_ERROR_IS_OK(result)) {
7648 return result;
7649 }
7650
7651 p_data = printer->info_2->data;
7652 key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
7653
7654 result = WERR_OK;
7655
7656 /*
7657 * The NT machine wants to know the biggest size of value and data
7658 *
7659 * cf: MSDN EnumPrinterData remark section
7660 */
7661
7662 if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
7663
7664 uint32_t biggest_valuesize = 0;
7665 uint32_t biggest_datasize = 0;
7666
7667 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7668
7669 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
7670
7671 for ( i=0; i<num_values; i++ )
7672 {
7673 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
7674
7675 name_length = strlen(val->valuename);
7676 if ( strlen(val->valuename) > biggest_valuesize )
7677 biggest_valuesize = name_length;
7678
7679 if ( val->size > biggest_datasize )
7680 biggest_datasize = val->size;
7681
7682 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
7683 biggest_datasize));
7684 }
7685
7686 /* the value is an UNICODE string but real_value_size is the length
7687 in bytes including the trailing 0 */
7688
7689 *r->out.value_needed = 2 * (1 + biggest_valuesize);
7690 *r->out.data_needed = biggest_datasize;
7691
7692 DEBUG(6,("final values: [%d], [%d]\n",
7693 *r->out.value_needed, *r->out.data_needed));
7694
7695 goto done;
7696 }
7697
7698 /*
7699 * the value len is wrong in NT sp3
7700 * that's the number of bytes not the number of unicode chars
7701 */
7702
7703 if (key_index != -1) {
7704 val = regval_ctr_specific_value(p_data->keys[key_index].values,
7705 r->in.enum_index);
7706 }
7707
7708 if (!val) {
7709
7710 /* out_value should default to "" or else NT4 has
7711 problems unmarshalling the response */
7712
7713 if (r->in.value_offered) {
7714 *r->out.value_needed = 1;
7715 r->out.value_name = talloc_strdup(r, "");
7716 if (!r->out.value_name) {
7717 result = WERR_NOMEM;
7718 goto done;
7719 }
7720 } else {
7721 r->out.value_name = NULL;
7722 *r->out.value_needed = 0;
7723 }
7724
7725 /* the data is counted in bytes */
7726
7727 *r->out.data_needed = r->in.data_offered;
7728
7729 result = WERR_NO_MORE_ITEMS;
7730 } else {
7731 /*
7732 * the value is:
7733 * - counted in bytes in the request
7734 * - counted in UNICODE chars in the max reply
7735 * - counted in bytes in the real size
7736 *
7737 * take a pause *before* coding not *during* coding
7738 */
7739
7740 /* name */
7741 if (r->in.value_offered) {
7742 r->out.value_name = talloc_strdup(r, regval_name(val));
7743 if (!r->out.value_name) {
7744 result = WERR_NOMEM;
7745 goto done;
7746 }
7747 *r->out.value_needed = strlen_m(regval_name(val));
7748 } else {
7749 r->out.value_name = NULL;
7750 *r->out.value_needed = 0;
7751 }
7752
7753 /* type */
7754
7755 *r->out.type = regval_type(val);
7756
7757 /* data - counted in bytes */
7758
7759 /*
7760 * See the section "Dynamically Typed Query Parameters"
7761 * in MS-RPRN.
7762 */
7763
7764 if (r->out.data && regval_data_p(val) &&
7765 regval_size(val) && r->in.data_offered) {
7766 memcpy(r->out.data, regval_data_p(val),
7767 MIN(regval_size(val),r->in.data_offered));
7768 }
7769
7770 *r->out.data_needed = regval_size(val);
7771 }
7772
7773 done:
7774 free_a_printer(&printer, 2);
7775 return result;
7776 }
7777
7778 /****************************************************************
7779 _spoolss_SetPrinterData
7780 ****************************************************************/
7781
7782 WERROR _spoolss_SetPrinterData(pipes_struct *p,
7783 struct spoolss_SetPrinterData *r)
7784 {
7785 struct spoolss_SetPrinterDataEx r2;
7786
7787 r2.in.handle = r->in.handle;
7788 r2.in.key_name = "PrinterDriverData";
7789 r2.in.value_name = r->in.value_name;
7790 r2.in.type = r->in.type;
7791 r2.in.data = r->in.data;
7792 r2.in._offered = r->in._offered;
7793
7794 return _spoolss_SetPrinterDataEx(p, &r2);
7795 }
7796
7797 /****************************************************************
7798 _spoolss_ResetPrinter
7799 ****************************************************************/
7800
7801 WERROR _spoolss_ResetPrinter(pipes_struct *p,
7802 struct spoolss_ResetPrinter *r)
7803 {
7804 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7805 int snum;
7806
7807 DEBUG(5,("_spoolss_ResetPrinter\n"));
7808
7809 /*
7810 * All we do is to check to see if the handle and queue is valid.
7811 * This call really doesn't mean anything to us because we only
7812 * support RAW printing. --jerry
7813 */
7814
7815 if (!Printer) {
7816 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
7817 OUR_HANDLE(r->in.handle)));
7818 return WERR_BADFID;
7819 }
7820
7821 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7822 return WERR_BADFID;
7823
7824
7825 /* blindly return success */
7826 return WERR_OK;
7827 }
7828
7829 /****************************************************************
7830 _spoolss_DeletePrinterData
7831 ****************************************************************/
7832
7833 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
7834 struct spoolss_DeletePrinterData *r)
7835 {
7836 struct spoolss_DeletePrinterDataEx r2;
7837
7838 r2.in.handle = r->in.handle;
7839 r2.in.key_name = "PrinterDriverData";
7840 r2.in.value_name = r->in.value_name;
7841
7842 return _spoolss_DeletePrinterDataEx(p, &r2);
7843 }
7844
7845 /****************************************************************
7846 _spoolss_AddForm
7847 ****************************************************************/
7848
7849 WERROR _spoolss_AddForm(pipes_struct *p,
7850 struct spoolss_AddForm *r)
7851 {
7852 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
7853 nt_forms_struct tmpForm;
7854 int snum = -1;
7855 WERROR status = WERR_OK;
7856 NT_PRINTER_INFO_LEVEL *printer = NULL;
7857 SE_PRIV se_printop = SE_PRINT_OPERATOR;
7858
7859 int count=0;
7860 nt_forms_struct *list=NULL;
7861 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7862
7863 DEBUG(5,("_spoolss_AddForm\n"));
7864
7865 if (!Printer) {
7866 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
7867 OUR_HANDLE(r->in.handle)));
7868 return WERR_BADFID;
7869 }
7870
7871
7872 /* forms can be added on printer of on the print server handle */
7873
7874 if ( Printer->printer_type == SPLHND_PRINTER )
7875 {
7876 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7877 return WERR_BADFID;
7878
7879 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7880 if (!W_ERROR_IS_OK(status))
7881 goto done;
7882 }
7883
7884 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
7885 and not a printer admin, then fail */
7886
7887 if ((p->server_info->utok.uid != sec_initial_uid()) &&
7888 !user_has_privileges(p->server_info->ptok, &se_printop) &&
7889 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7890 NULL, NULL,
7891 p->server_info->ptok,
7892 lp_printer_admin(snum))) {
7893 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
7894 return WERR_ACCESS_DENIED;
7895 }
7896
7897 /* can't add if builtin */
7898
7899 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
7900 status = WERR_FILE_EXISTS;
7901 goto done;
7902 }
7903
7904 count = get_ntforms(&list);
7905
7906 if(!add_a_form(&list, form, &count)) {
7907 status = WERR_NOMEM;
7908 goto done;
7909 }
7910
7911 become_root();
7912 write_ntforms(&list, count);
7913 unbecome_root();
7914
7915 /*
7916 * ChangeID must always be set if this is a printer
7917 */
7918
7919 if ( Printer->printer_type == SPLHND_PRINTER )
7920 status = mod_a_printer(printer, 2);
7921
7922 done:
7923 if ( printer )
7924 free_a_printer(&printer, 2);
7925 SAFE_FREE(list);
7926
7927 return status;
7928 }
7929
7930 /****************************************************************
7931 _spoolss_DeleteForm
7932 ****************************************************************/
7933
7934 WERROR _spoolss_DeleteForm(pipes_struct *p,
7935 struct spoolss_DeleteForm *r)
7936 {
7937 const char *form_name = r->in.form_name;
7938 nt_forms_struct tmpForm;
7939 int count=0;
7940 nt_forms_struct *list=NULL;
7941 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
7942 int snum = -1;
7943 WERROR status = WERR_OK;
7944 NT_PRINTER_INFO_LEVEL *printer = NULL;
7945 SE_PRIV se_printop = SE_PRINT_OPERATOR;
7946 bool ret = false;
7947
7948 DEBUG(5,("_spoolss_DeleteForm\n"));
7949
7950 if (!Printer) {
7951 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
7952 OUR_HANDLE(r->in.handle)));
7953 return WERR_BADFID;
7954 }
7955
7956 /* forms can be deleted on printer of on the print server handle */
7957
7958 if ( Printer->printer_type == SPLHND_PRINTER )
7959 {
7960 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
7961 return WERR_BADFID;
7962
7963 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7964 if (!W_ERROR_IS_OK(status))
7965 goto done;
7966 }
7967
7968 if ((p->server_info->utok.uid != sec_initial_uid()) &&
7969 !user_has_privileges(p->server_info->ptok, &se_printop) &&
7970 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
7971 NULL, NULL,
7972 p->server_info->ptok,
7973 lp_printer_admin(snum))) {
7974 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
7975 return WERR_ACCESS_DENIED;
7976 }
7977
7978
7979 /* can't delete if builtin */
7980
7981 if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
7982 status = WERR_INVALID_PARAM;
7983 goto done;
7984 }
7985
7986 count = get_ntforms(&list);
7987
7988 become_root();
7989 ret = delete_a_form(&list, form_name, &count, &status);
7990 unbecome_root();
7991 if (ret == false) {
7992 goto done;
7993 }
7994
7995 /*
7996 * ChangeID must always be set if this is a printer
7997 */
7998
7999 if ( Printer->printer_type == SPLHND_PRINTER )
8000 status = mod_a_printer(printer, 2);
8001
8002 done:
8003 if ( printer )
8004 free_a_printer(&printer, 2);
8005 SAFE_FREE(list);
8006
8007 return status;
8008 }
8009
8010 /****************************************************************
8011 _spoolss_SetForm
8012 ****************************************************************/
8013
8014 WERROR _spoolss_SetForm(pipes_struct *p,
8015 struct spoolss_SetForm *r)
8016 {
8017 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8018 nt_forms_struct tmpForm;
8019 int snum = -1;
8020 WERROR status = WERR_OK;
8021 NT_PRINTER_INFO_LEVEL *printer = NULL;
8022 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8023
8024 int count=0;
8025 nt_forms_struct *list=NULL;
8026 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8027
8028 DEBUG(5,("_spoolss_SetForm\n"));
8029
8030 if (!Printer) {
8031 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8032 OUR_HANDLE(r->in.handle)));
8033 return WERR_BADFID;
8034 }
8035
8036 /* forms can be modified on printer of on the print server handle */
8037
8038 if ( Printer->printer_type == SPLHND_PRINTER )
8039 {
8040 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8041 return WERR_BADFID;
8042
8043 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8044 if (!W_ERROR_IS_OK(status))
8045 goto done;
8046 }
8047
8048 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8049 and not a printer admin, then fail */
8050
8051 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8052 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8053 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8054 NULL, NULL,
8055 p->server_info->ptok,
8056 lp_printer_admin(snum))) {
8057 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8058 return WERR_ACCESS_DENIED;
8059 }
8060
8061 /* can't set if builtin */
8062 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8063 status = WERR_INVALID_PARAM;
8064 goto done;
8065 }
8066
8067 count = get_ntforms(&list);
8068 update_a_form(&list, form, count);
8069 become_root();
8070 write_ntforms(&list, count);
8071 unbecome_root();
8072
8073 /*
8074 * ChangeID must always be set if this is a printer
8075 */
8076
8077 if ( Printer->printer_type == SPLHND_PRINTER )
8078 status = mod_a_printer(printer, 2);
8079
8080
8081 done:
8082 if ( printer )
8083 free_a_printer(&printer, 2);
8084 SAFE_FREE(list);
8085
8086 return status;
8087 }
8088
8089 /****************************************************************************
8090 fill_print_processor1
8091 ****************************************************************************/
8092
8093 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8094 struct spoolss_PrintProcessorInfo1 *r,
8095 const char *print_processor_name)
8096 {
8097 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8098 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8099
8100 return WERR_OK;
8101 }
8102
8103 /****************************************************************************
8104 enumprintprocessors level 1.
8105 ****************************************************************************/
8106
8107 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8108 union spoolss_PrintProcessorInfo **info_p,
8109 uint32_t *count)
8110 {
8111 union spoolss_PrintProcessorInfo *info;
8112 WERROR result;
8113
8114 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8115 W_ERROR_HAVE_NO_MEMORY(info);
8116
8117 *count = 1;
8118
8119 result = fill_print_processor1(info, &info[0].info1, "winprint");
8120 if (!W_ERROR_IS_OK(result)) {
8121 goto out;
8122 }
8123
8124 out:
8125 if (!W_ERROR_IS_OK(result)) {
8126 TALLOC_FREE(info);
8127 *count = 0;
8128 return result;
8129 }
8130
8131 *info_p = info;
8132
8133 return WERR_OK;
8134 }
8135
8136 /****************************************************************
8137 _spoolss_EnumPrintProcessors
8138 ****************************************************************/
8139
8140 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8141 struct spoolss_EnumPrintProcessors *r)
8142 {
8143 WERROR result;
8144
8145 /* that's an [in out] buffer */
8146
8147 if (!r->in.buffer && (r->in.offered != 0)) {
8148 return WERR_INVALID_PARAM;
8149 }
8150
8151 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8152
8153 /*
8154 * Enumerate the print processors ...
8155 *
8156 * Just reply with "winprint", to keep NT happy
8157 * and I can use my nice printer checker.
8158 */
8159
8160 *r->out.count = 0;
8161 *r->out.needed = 0;
8162 *r->out.info = NULL;
8163
8164 switch (r->in.level) {
8165 case 1:
8166 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8167 r->out.count);
8168 break;
8169 default:
8170 return WERR_UNKNOWN_LEVEL;
8171 }
8172
8173 if (!W_ERROR_IS_OK(result)) {
8174 return result;
8175 }
8176
8177 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8178 spoolss_EnumPrintProcessors, NULL,
8179 *r->out.info, r->in.level,
8180 *r->out.count);
8181 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8182 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8183
8184 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8185 }
8186
8187 /****************************************************************************
8188 fill_printprocdatatype1
8189 ****************************************************************************/
8190
8191 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8192 struct spoolss_PrintProcDataTypesInfo1 *r,
8193 const char *name_array)
8194 {
8195 r->name_array = talloc_strdup(mem_ctx, name_array);
8196 W_ERROR_HAVE_NO_MEMORY(r->name_array);
8197
8198 return WERR_OK;
8199 }
8200
8201 /****************************************************************************
8202 enumprintprocdatatypes level 1.
8203 ****************************************************************************/
8204
8205 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8206 union spoolss_PrintProcDataTypesInfo **info_p,
8207 uint32_t *count)
8208 {
8209 WERROR result;
8210 union spoolss_PrintProcDataTypesInfo *info;
8211
8212 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8213 W_ERROR_HAVE_NO_MEMORY(info);
8214
8215 *count = 1;
8216
8217 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8218 if (!W_ERROR_IS_OK(result)) {
8219 goto out;
8220 }
8221
8222 out:
8223 if (!W_ERROR_IS_OK(result)) {
8224 TALLOC_FREE(info);
8225 *count = 0;
8226 return result;
8227 }
8228
8229 *info_p = info;
8230
8231 return WERR_OK;
8232 }
8233
8234 /****************************************************************
8235 _spoolss_EnumPrintProcDataTypes
8236 ****************************************************************/
8237
8238 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8239 struct spoolss_EnumPrintProcDataTypes *r)
8240 {
8241 WERROR result;
8242
8243 /* that's an [in out] buffer */
8244
8245 if (!r->in.buffer && (r->in.offered != 0)) {
8246 return WERR_INVALID_PARAM;
8247 }
8248
8249 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8250
8251 *r->out.count = 0;
8252 *r->out.needed = 0;
8253 *r->out.info = NULL;
8254
8255 switch (r->in.level) {
8256 case 1:
8257 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8258 r->out.count);
8259 break;
8260 default:
8261 return WERR_UNKNOWN_LEVEL;
8262 }
8263
8264 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8265 spoolss_EnumPrintProcDataTypes, NULL,
8266 *r->out.info, r->in.level,
8267 *r->out.count);
8268 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8269 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8270
8271 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8272 }
8273
8274 /****************************************************************************
8275 fill_monitor_1
8276 ****************************************************************************/
8277
8278 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8279 struct spoolss_MonitorInfo1 *r,
8280 const char *monitor_name)
8281 {
8282 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8283 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8284
8285 return WERR_OK;
8286 }
8287
8288 /****************************************************************************
8289 fill_monitor_2
8290 ****************************************************************************/
8291
8292 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8293 struct spoolss_MonitorInfo2 *r,
8294 const char *monitor_name,
8295 const char *environment,
8296 const char *dll_name)
8297 {
8298 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8299 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8300 r->environment = talloc_strdup(mem_ctx, environment);
8301 W_ERROR_HAVE_NO_MEMORY(r->environment);
8302 r->dll_name = talloc_strdup(mem_ctx, dll_name);
8303 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8304
8305 return WERR_OK;
8306 }
8307
8308 /****************************************************************************
8309 enumprintmonitors level 1.
8310 ****************************************************************************/
8311
8312 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8313 union spoolss_MonitorInfo **info_p,
8314 uint32_t *count)
8315 {
8316 union spoolss_MonitorInfo *info;
8317 WERROR result = WERR_OK;
8318
8319 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8320 W_ERROR_HAVE_NO_MEMORY(info);
8321
8322 *count = 2;
8323
8324 result = fill_monitor_1(info, &info[0].info1,
8325 SPL_LOCAL_PORT);
8326 if (!W_ERROR_IS_OK(result)) {
8327 goto out;
8328 }
8329
8330 result = fill_monitor_1(info, &info[1].info1,
8331 SPL_TCPIP_PORT);
8332 if (!W_ERROR_IS_OK(result)) {
8333 goto out;
8334 }
8335
8336 out:
8337 if (!W_ERROR_IS_OK(result)) {
8338 TALLOC_FREE(info);
8339 *count = 0;
8340 return result;
8341 }
8342
8343 *info_p = info;
8344
8345 return WERR_OK;
8346 }
8347
8348 /****************************************************************************
8349 enumprintmonitors level 2.
8350 ****************************************************************************/
8351
8352 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8353 union spoolss_MonitorInfo **info_p,
8354 uint32_t *count)
8355 {
8356 union spoolss_MonitorInfo *info;
8357 WERROR result = WERR_OK;
8358
8359 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8360 W_ERROR_HAVE_NO_MEMORY(info);
8361
8362 *count = 2;
8363
8364 result = fill_monitor_2(info, &info[0].info2,
8365 SPL_LOCAL_PORT,
8366 "Windows NT X86", /* FIXME */
8367 "localmon.dll");
8368 if (!W_ERROR_IS_OK(result)) {
8369 goto out;
8370 }
8371
8372 result = fill_monitor_2(info, &info[1].info2,
8373 SPL_TCPIP_PORT,
8374 "Windows NT X86", /* FIXME */
8375 "tcpmon.dll");
8376 if (!W_ERROR_IS_OK(result)) {
8377 goto out;
8378 }
8379
8380 out:
8381 if (!W_ERROR_IS_OK(result)) {
8382 TALLOC_FREE(info);
8383 *count = 0;
8384 return result;
8385 }
8386
8387 *info_p = info;
8388
8389 return WERR_OK;
8390 }
8391
8392 /****************************************************************
8393 _spoolss_EnumMonitors
8394 ****************************************************************/
8395
8396 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8397 struct spoolss_EnumMonitors *r)
8398 {
8399 WERROR result;
8400
8401 /* that's an [in out] buffer */
8402
8403 if (!r->in.buffer && (r->in.offered != 0)) {
8404 return WERR_INVALID_PARAM;
8405 }
8406
8407 DEBUG(5,("_spoolss_EnumMonitors\n"));
8408
8409 /*
8410 * Enumerate the print monitors ...
8411 *
8412 * Just reply with "Local Port", to keep NT happy
8413 * and I can use my nice printer checker.
8414 */
8415
8416 *r->out.count = 0;
8417 *r->out.needed = 0;
8418 *r->out.info = NULL;
8419
8420 switch (r->in.level) {
8421 case 1:
8422 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8423 r->out.count);
8424 break;
8425 case 2:
8426 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8427 r->out.count);
8428 break;
8429 default:
8430 return WERR_UNKNOWN_LEVEL;
8431 }
8432
8433 if (!W_ERROR_IS_OK(result)) {
8434 return result;
8435 }
8436
8437 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8438 spoolss_EnumMonitors, NULL,
8439 *r->out.info, r->in.level,
8440 *r->out.count);
8441 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8442 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8443
8444 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8445 }
8446
8447 /****************************************************************************
8448 ****************************************************************************/
8449
8450 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8451 const print_queue_struct *queue,
8452 int count, int snum,
8453 const NT_PRINTER_INFO_LEVEL *ntprinter,
8454 uint32_t jobid,
8455 struct spoolss_JobInfo1 *r)
8456 {
8457 int i = 0;
8458 bool found = false;
8459
8460 for (i=0; i<count && found == false; i++) {
8461 if (queue[i].job == (int)jobid) {
8462 found = true;
8463 }
8464 }
8465
8466 if (found == false) {
8467 /* NT treats not found as bad param... yet another bad choice */
8468 return WERR_INVALID_PARAM;
8469 }
8470
8471 return fill_job_info1(mem_ctx,
8472 r,
8473 &queue[i-1],
8474 i,
8475 snum,
8476 ntprinter);
8477 }
8478
8479 /****************************************************************************
8480 ****************************************************************************/
8481
8482 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8483 const print_queue_struct *queue,
8484 int count, int snum,
8485 const NT_PRINTER_INFO_LEVEL *ntprinter,
8486 uint32_t jobid,
8487 struct spoolss_JobInfo2 *r)
8488 {
8489 int i = 0;
8490 bool found = false;
8491 struct spoolss_DeviceMode *devmode;
8492 NT_DEVICEMODE *nt_devmode;
8493 WERROR result;
8494
8495 for (i=0; i<count && found == false; i++) {
8496 if (queue[i].job == (int)jobid) {
8497 found = true;
8498 }
8499 }
8500
8501 if (found == false) {
8502 /* NT treats not found as bad param... yet another bad
8503 choice */
8504 return WERR_INVALID_PARAM;
8505 }
8506
8507 /*
8508 * if the print job does not have a DEVMODE associated with it,
8509 * just use the one for the printer. A NULL devicemode is not
8510 * a failure condition
8511 */
8512
8513 nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8514 if (nt_devmode) {
8515 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
8516 W_ERROR_HAVE_NO_MEMORY(devmode);
8517 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
8518 if (!W_ERROR_IS_OK(result)) {
8519 return result;
8520 }
8521 } else {
8522 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
8523 W_ERROR_HAVE_NO_MEMORY(devmode);
8524 }
8525
8526 return fill_job_info2(mem_ctx,
8527 r,
8528 &queue[i-1],
8529 i,
8530 snum,
8531 ntprinter,
8532 devmode);
8533 }
8534
8535 /****************************************************************
8536 _spoolss_GetJob
8537 ****************************************************************/
8538
8539 WERROR _spoolss_GetJob(pipes_struct *p,
8540 struct spoolss_GetJob *r)
8541 {
8542 WERROR result = WERR_OK;
8543 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
8544 int snum;
8545 int count;
8546 print_queue_struct *queue = NULL;
8547 print_status_struct prt_status;
8548
8549 /* that's an [in out] buffer */
8550
8551 if (!r->in.buffer && (r->in.offered != 0)) {
8552 return WERR_INVALID_PARAM;
8553 }
8554
8555 DEBUG(5,("_spoolss_GetJob\n"));
8556
8557 *r->out.needed = 0;
8558
8559 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8560 return WERR_BADFID;
8561 }
8562
8563 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
8564 if (!W_ERROR_IS_OK(result)) {
8565 return result;
8566 }
8567
8568 count = print_queue_status(snum, &queue, &prt_status);
8569
8570 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8571 count, prt_status.status, prt_status.message));
8572
8573 switch (r->in.level) {
8574 case 1:
8575 result = getjob_level_1(p->mem_ctx,
8576 queue, count, snum, ntprinter,
8577 r->in.job_id, &r->out.info->info1);
8578 break;
8579 case 2:
8580 result = getjob_level_2(p->mem_ctx,
8581 queue, count, snum, ntprinter,
8582 r->in.job_id, &r->out.info->info2);
8583 break;
8584 default:
8585 result = WERR_UNKNOWN_LEVEL;
8586 break;
8587 }
8588
8589 SAFE_FREE(queue);
8590 free_a_printer(&ntprinter, 2);
8591
8592 if (!W_ERROR_IS_OK(result)) {
8593 TALLOC_FREE(r->out.info);
8594 return result;
8595 }
8596
8597 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
8598 r->out.info, r->in.level);
8599 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8600
8601 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8602 }
8603
8604 /****************************************************************
8605 _spoolss_GetPrinterDataEx
8606 ****************************************************************/
8607
8608 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
8609 struct spoolss_GetPrinterDataEx *r)
8610 {
8611
8612 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8613 struct regval_blob *val = NULL;
8614 NT_PRINTER_INFO_LEVEL *printer = NULL;
8615 int snum = 0;
8616 WERROR result = WERR_OK;
8617 DATA_BLOB blob;
8618
8619 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8620
8621 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8622 r->in.key_name, r->in.value_name));
8623
8624 /* in case of problem, return some default values */
8625
8626 *r->out.needed = 0;
8627 *r->out.type = REG_NONE;
8628
8629 if (!Printer) {
8630 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8631 OUR_HANDLE(r->in.handle)));
8632 result = WERR_BADFID;
8633 goto done;
8634 }
8635
8636 /* Is the handle to a printer or to the server? */
8637
8638 if (Printer->printer_type == SPLHND_SERVER) {
8639
8640 result = getprinterdata_printer_server(p->mem_ctx,
8641 r->in.value_name,
8642 r->out.type,
8643 r->out.data);
8644 goto done;
8645 }
8646
8647 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8648 result = WERR_BADFID;
8649 goto done;
8650 }
8651
8652 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8653 if (!W_ERROR_IS_OK(result)) {
8654 goto done;
8655 }
8656
8657 /* check to see if the keyname is valid */
8658 if (!strlen(r->in.key_name)) {
8659 result = WERR_INVALID_PARAM;
8660 goto done;
8661 }
8662
8663 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
8664
8665 if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
8666 strequal(r->in.value_name, "ChangeId")) {
8667 *r->out.type = REG_DWORD;
8668 *r->out.needed = 4;
8669 r->out.data->value = printer->info_2->changeid;
8670 result = WERR_OK;
8671 goto done;
8672 }
8673
8674 if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
8675 DEBUG(4,("_spoolss_GetPrinterDataEx: "
8676 "Invalid keyname [%s]\n", r->in.key_name ));
8677 result = WERR_BADFILE;
8678 goto done;
8679 }
8680
8681 val = get_printer_data(printer->info_2,
8682 r->in.key_name, r->in.value_name);
8683 if (!val) {
8684 result = WERR_BADFILE;
8685 goto done;
8686 }
8687
8688 *r->out.needed = regval_size(val);
8689 *r->out.type = regval_type(val);
8690
8691 blob = data_blob_const(regval_data_p(val), regval_size(val));
8692
8693 result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
8694 r->out.data,
8695 *r->out.type);
8696
8697 done:
8698 if (printer) {
8699 free_a_printer(&printer, 2);
8700 }
8701
8702 if (!W_ERROR_IS_OK(result)) {
8703 return result;
8704 }
8705
8706 *r->out.needed = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
8707 *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
8708 r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
8709
8710 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
8711 }
8712
8713 /****************************************************************
8714 _spoolss_SetPrinterDataEx
8715 ****************************************************************/
8716
8717 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
8718 struct spoolss_SetPrinterDataEx *r)
8719 {
8720 NT_PRINTER_INFO_LEVEL *printer = NULL;
8721 int snum = 0;
8722 WERROR result = WERR_OK;
8723 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8724 char *oid_string;
8725 DATA_BLOB blob;
8726
8727 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
8728
8729 /* From MSDN documentation of SetPrinterDataEx: pass request to
8730 SetPrinterData if key is "PrinterDriverData" */
8731
8732 if (!Printer) {
8733 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8734 OUR_HANDLE(r->in.handle)));
8735 return WERR_BADFID;
8736 }
8737
8738 if (Printer->printer_type == SPLHND_SERVER) {
8739 DEBUG(10,("_spoolss_SetPrinterDataEx: "
8740 "Not implemented for server handles yet\n"));
8741 return WERR_INVALID_PARAM;
8742 }
8743
8744 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8745 return WERR_BADFID;
8746 }
8747
8748 /*
8749 * Access check : NT returns "access denied" if you make a
8750 * SetPrinterData call without the necessary privildge.
8751 * we were originally returning OK if nothing changed
8752 * which made Win2k issue **a lot** of SetPrinterData
8753 * when connecting to a printer --jerry
8754 */
8755
8756 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8757 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
8758 "change denied by handle access permissions\n"));
8759 return WERR_ACCESS_DENIED;
8760 }
8761
8762 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
8763 if (!W_ERROR_IS_OK(result)) {
8764 return result;
8765 }
8766
8767 /* check for OID in valuename */
8768
8769 oid_string = strchr(r->in.value_name, ',');
8770 if (oid_string) {
8771 *oid_string = '\0';
8772 oid_string++;
8773 }
8774
8775 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8776 r->in.type, &r->in.data);
8777 if (!W_ERROR_IS_OK(result)) {
8778 goto done;
8779 }
8780
8781 /*
8782 * When client side code sets a magic printer data key, detect it and save
8783 * the current printer data and the magic key's data (its the DEVMODE) for
8784 * future printer/driver initializations.
8785 */
8786 if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8787 /* Set devmode and printer initialization info */
8788 result = save_driver_init(printer, 2, blob.data, blob.length);
8789
8790 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8791
8792 goto done;
8793 }
8794
8795 /* save the registry data */
8796
8797 result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
8798 r->in.type, blob.data, blob.length);
8799
8800 if (W_ERROR_IS_OK(result)) {
8801 /* save the OID if one was specified */
8802 if (oid_string) {
8803 char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
8804 r->in.key_name, SPOOL_OID_KEY);
8805 if (!str) {
8806 result = WERR_NOMEM;
8807 goto done;
8808 }
8809
8810 /*
8811 * I'm not checking the status here on purpose. Don't know
8812 * if this is right, but I'm returning the status from the
8813 * previous set_printer_dataex() call. I have no idea if
8814 * this is right. --jerry
8815 */
8816
8817 set_printer_dataex(printer, str, r->in.value_name,
8818 REG_SZ, (uint8_t *)oid_string,
8819 strlen(oid_string)+1);
8820 }
8821
8822 result = mod_a_printer(printer, 2);
8823 }
8824
8825 done:
8826 free_a_printer(&printer, 2);
8827
8828 return result;
8829 }
8830
8831 /****************************************************************
8832 _spoolss_DeletePrinterDataEx
8833 ****************************************************************/
8834
8835 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
8836 struct spoolss_DeletePrinterDataEx *r)
8837 {
8838 NT_PRINTER_INFO_LEVEL *printer = NULL;
8839 int snum=0;
8840 WERROR status = WERR_OK;
8841 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8842
8843 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
8844
8845 if (!Printer) {
8846 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
8847 "Invalid handle (%s:%u:%u).\n",
8848 OUR_HANDLE(r->in.handle)));
8849 return WERR_BADFID;
8850 }
8851
8852 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8853 return WERR_BADFID;
8854
8855 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8856 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
8857 "printer properties change denied by handle\n"));
8858 return WERR_ACCESS_DENIED;
8859 }
8860
8861 if (!r->in.value_name || !r->in.key_name) {
8862 return WERR_NOMEM;
8863 }
8864
8865 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8866 if (!W_ERROR_IS_OK(status))
8867 return status;
8868
8869 status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
8870
8871 if ( W_ERROR_IS_OK(status) )
8872 mod_a_printer( printer, 2 );
8873
8874 free_a_printer(&printer, 2);
8875
8876 return status;
8877 }
8878
8879 /****************************************************************
8880 _spoolss_EnumPrinterKey
8881 ****************************************************************/
8882
8883 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
8884 struct spoolss_EnumPrinterKey *r)
8885 {
8886 fstring *keynames = NULL;
8887 int num_keys;
8888 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8889 NT_PRINTER_DATA *data;
8890 NT_PRINTER_INFO_LEVEL *printer = NULL;
8891 int snum = 0;
8892 WERROR result = WERR_BADFILE;
8893 int i;
8894 const char **array = NULL;
8895 DATA_BLOB blob;
8896
8897 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
8898
8899 if (!Printer) {
8900 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
8901 OUR_HANDLE(r->in.handle)));
8902 return WERR_BADFID;
8903 }
8904
8905 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8906 return WERR_BADFID;
8907 }
8908
8909 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8910 if (!W_ERROR_IS_OK(result)) {
8911 return result;
8912 }
8913
8914 /* get the list of subkey names */
8915
8916 data = printer->info_2->data;
8917
8918 num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
8919 if (num_keys == -1) {
8920 result = WERR_BADFILE;
8921 goto done;
8922 }
8923
8924 array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 2);
8925 if (!array) {
8926 result = WERR_NOMEM;
8927 goto done;
8928 }
8929
8930 if (!num_keys) {
8931 array[0] = talloc_strdup(array, "");
8932 if (!array[0]) {
8933 result = WERR_NOMEM;
8934 goto done;
8935 }
8936 }
8937
8938 for (i=0; i < num_keys; i++) {
8939
8940 DEBUG(10,("_spoolss_EnumPrinterKey: adding keyname: %s\n",
8941 keynames[i]));
8942
8943 array[i] = talloc_strdup(array, keynames[i]);
8944 if (!array[i]) {
8945 result = WERR_NOMEM;
8946 goto done;
8947 }
8948 }
8949
8950 if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
8951 result = WERR_NOMEM;
8952 goto done;
8953 }
8954
8955 *r->out._ndr_size = r->in.offered / 2;
8956 *r->out.needed = blob.length;
8957
8958 if (r->in.offered < *r->out.needed) {
8959 result = WERR_MORE_DATA;
8960 } else {
8961 result = WERR_OK;
8962 r->out.key_buffer->string_array = array;
8963 }
8964
8965 done:
8966 if (!W_ERROR_IS_OK(result)) {
8967 TALLOC_FREE(array);
8968 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
8969 *r->out.needed = 0;
8970 }
8971 }
8972
8973 free_a_printer(&printer, 2);
8974 SAFE_FREE(keynames);
8975
8976 return result;
8977 }
8978
8979 /****************************************************************
8980 _spoolss_DeletePrinterKey
8981 ****************************************************************/
8982
8983 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
8984 struct spoolss_DeletePrinterKey *r)
8985 {
8986 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8987 NT_PRINTER_INFO_LEVEL *printer = NULL;
8988 int snum=0;
8989 WERROR status;
8990
8991 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
8992
8993 if (!Printer) {
8994 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
8995 OUR_HANDLE(r->in.handle)));
8996 return WERR_BADFID;
8997 }
8998
8999 /* if keyname == NULL, return error */
9000
9001 if ( !r->in.key_name )
9002 return WERR_INVALID_PARAM;
9003
9004 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9005 return WERR_BADFID;
9006
9007 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9008 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9009 "printer properties change denied by handle\n"));
9010 return WERR_ACCESS_DENIED;
9011 }
9012
9013 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9014 if (!W_ERROR_IS_OK(status))
9015 return status;
9016
9017 /* delete the key and all subneys */
9018
9019 status = delete_all_printer_data( printer->info_2, r->in.key_name );
9020
9021 if ( W_ERROR_IS_OK(status) )
9022 status = mod_a_printer(printer, 2);
9023
9024 free_a_printer( &printer, 2 );
9025
9026 return status;
9027 }
9028
9029 /****************************************************************
9030 ****************************************************************/
9031
9032 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9033 struct regval_blob *v,
9034 struct spoolss_PrinterEnumValues *r)
9035 {
9036 WERROR result;
9037
9038 r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
9039 W_ERROR_HAVE_NO_MEMORY(r->data);
9040
9041 r->value_name = talloc_strdup(mem_ctx, regval_name(v));
9042 W_ERROR_HAVE_NO_MEMORY(r->value_name);
9043
9044 r->type = regval_type(v);
9045 r->data_length = regval_size(v);
9046
9047 if (r->data_length) {
9048 DATA_BLOB blob = data_blob_const(regval_data_p(v),
9049 regval_size(v));
9050 result = pull_spoolss_PrinterData(mem_ctx, &blob,
9051 r->data,
9052 r->type);
9053 if (!W_ERROR_IS_OK(result)) {
9054 return result;
9055 }
9056 }
9057
9058 return WERR_OK;
9059 }
9060
9061 /****************************************************************
9062 _spoolss_EnumPrinterDataEx
9063 ****************************************************************/
9064
9065 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9066 struct spoolss_EnumPrinterDataEx *r)
9067 {
9068 uint32_t count = 0;
9069 NT_PRINTER_INFO_LEVEL *printer = NULL;
9070 struct spoolss_PrinterEnumValues *info = NULL;
9071 NT_PRINTER_DATA *p_data;
9072 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9073 int snum;
9074 WERROR result;
9075 int key_index;
9076 int i;
9077
9078 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9079
9080 *r->out.count = 0;
9081 *r->out.needed = 0;
9082 *r->out.info = NULL;
9083
9084 if (!Printer) {
9085 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9086 OUR_HANDLE(r->in.handle)));
9087 return WERR_BADFID;
9088 }
9089
9090 /*
9091 * first check for a keyname of NULL or "". Win2k seems to send
9092 * this a lot and we should send back WERR_INVALID_PARAM
9093 * no need to spend time looking up the printer in this case.
9094 * --jerry
9095 */
9096
9097 if (!strlen(r->in.key_name)) {
9098 result = WERR_INVALID_PARAM;
9099 goto done;
9100 }
9101
9102 /* get the printer off of disk */
9103
9104 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9105 return WERR_BADFID;
9106 }
9107
9108 ZERO_STRUCT(printer);
9109 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9110 if (!W_ERROR_IS_OK(result)) {
9111 return result;
9112 }
9113
9114 /* now look for a match on the key name */
9115
9116 p_data = printer->info_2->data;
9117
9118 key_index = lookup_printerkey(p_data, r->in.key_name);
9119 if (key_index == -1) {
9120 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9121 r->in.key_name));
9122 result = WERR_INVALID_PARAM;
9123 goto done;
9124 }
9125
9126 /* allocate the memory for the array of pointers -- if necessary */
9127
9128 count = regval_ctr_numvals(p_data->keys[key_index].values);
9129 if (!count) {
9130 result = WERR_OK; /* ??? */
9131 goto done;
9132 }
9133
9134 info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9135 struct spoolss_PrinterEnumValues,
9136 count);
9137 if (!info) {
9138 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9139 result = WERR_NOMEM;
9140 goto done;
9141 }
9142
9143 /*
9144 * loop through all params and build the array to pass
9145 * back to the client
9146 */
9147
9148 for (i=0; i < count; i++) {
9149
9150 struct regval_blob *val;
9151
9152 /* lookup the registry value */
9153
9154 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9155
9156 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9157
9158 /* copy the data */
9159
9160 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9161 if (!W_ERROR_IS_OK(result)) {
9162 goto done;
9163 }
9164 }
9165
9166 #if 0 /* FIXME - gd */
9167 /* housekeeping information in the reply */
9168
9169 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9170 * the hand marshalled container size is a multiple
9171 * of 4 bytes for RPC alignment.
9172 */
9173
9174 if (needed % 4) {
9175 needed += 4-(needed % 4);
9176 }
9177 #endif
9178 *r->out.count = count;
9179 *r->out.info = info;
9180
9181 done:
9182
9183 if (printer) {
9184 free_a_printer(&printer, 2);
9185 }
9186
9187 if (!W_ERROR_IS_OK(result)) {
9188 return result;
9189 }
9190
9191 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9192 spoolss_EnumPrinterDataEx, NULL,
9193 *r->out.info,
9194 *r->out.count);
9195 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9196 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9197
9198 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9199 }
9200
9201 /****************************************************************************
9202 ****************************************************************************/
9203
9204 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9205 const char *servername,
9206 const char *environment,
9207 struct spoolss_PrintProcessorDirectoryInfo1 *r)
9208 {
9209 WERROR werr;
9210 char *path = NULL;
9211
9212 werr = compose_spoolss_server_path(mem_ctx,
9213 servername,
9214 environment,
9215 SPOOLSS_PRTPROCS_PATH,
9216 &path);
9217 if (!W_ERROR_IS_OK(werr)) {
9218 return werr;
9219 }
9220
9221 DEBUG(4,("print processor directory: [%s]\n", path));
9222
9223 r->directory_name = path;
9224
9225 return WERR_OK;
9226 }
9227
9228 /****************************************************************
9229 _spoolss_GetPrintProcessorDirectory
9230 ****************************************************************/
9231
9232 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9233 struct spoolss_GetPrintProcessorDirectory *r)
9234 {
9235 WERROR result;
9236
9237 /* that's an [in out] buffer */
9238
9239 if (!r->in.buffer && (r->in.offered != 0)) {
9240 return WERR_INVALID_PARAM;
9241 }
9242
9243 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9244 r->in.level));
9245
9246 *r->out.needed = 0;
9247
9248 /* r->in.level is ignored */
9249
9250 /* We always should reply with a local print processor directory so that
9251 * users are not forced to have a [prnproc$] share on the Samba spoolss
9252 * server - Guenther */
9253
9254 result = getprintprocessordirectory_level_1(p->mem_ctx,
9255 NULL, /* r->in.server */
9256 r->in.environment,
9257 &r->out.info->info1);
9258 if (!W_ERROR_IS_OK(result)) {
9259 TALLOC_FREE(r->out.info);
9260 return result;
9261 }
9262
9263 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9264 r->out.info, r->in.level);
9265 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9266
9267 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9268 }
9269
9270 /*******************************************************************
9271 ********************************************************************/
9272
9273 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9274 const char *dllname)
9275 {
9276 enum ndr_err_code ndr_err;
9277 struct spoolss_MonitorUi ui;
9278
9279 ui.dll_name = dllname;
9280
9281 ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9282 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9283 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9284 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9285 }
9286 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9287 }
9288
9289 /*******************************************************************
9290 Streams the monitor UI DLL name in UNICODE
9291 *******************************************************************/
9292
9293 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9294 NT_USER_TOKEN *token, DATA_BLOB *in,
9295 DATA_BLOB *out, uint32_t *needed)
9296 {
9297 const char *dllname = "tcpmonui.dll";
9298
9299 *needed = (strlen(dllname)+1) * 2;
9300
9301 if (out->length < *needed) {
9302 return WERR_INSUFFICIENT_BUFFER;
9303 }
9304
9305 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9306 return WERR_NOMEM;
9307 }
9308
9309 return WERR_OK;
9310 }
9311
9312 /*******************************************************************
9313 ********************************************************************/
9314
9315 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9316 struct spoolss_PortData1 *port1,
9317 const DATA_BLOB *buf)
9318 {
9319 enum ndr_err_code ndr_err;
9320 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9321 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9322 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9323 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9324 }
9325 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9326 }
9327
9328 /*******************************************************************
9329 ********************************************************************/
9330
9331 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9332 struct spoolss_PortData2 *port2,
9333 const DATA_BLOB *buf)
9334 {
9335 enum ndr_err_code ndr_err;
9336 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9337 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9338 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9339 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9340 }
9341 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9342 }
9343
9344 /*******************************************************************
9345 Create a new TCP/IP port
9346 *******************************************************************/
9347
9348 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9349 NT_USER_TOKEN *token, DATA_BLOB *in,
9350 DATA_BLOB *out, uint32_t *needed)
9351 {
9352 struct spoolss_PortData1 port1;
9353 struct spoolss_PortData2 port2;
9354 char *device_uri = NULL;
9355 uint32_t version;
9356
9357 const char *portname;
9358 const char *hostaddress;
9359 const char *queue;
9360 uint32_t port_number;
9361 uint32_t protocol;
9362
9363 /* peek for spoolss_PortData version */
9364
9365 if (!in || (in->length < (128 + 4))) {
9366 return WERR_GENERAL_FAILURE;
9367 }
9368
9369 version = IVAL(in->data, 128);
9370
9371 switch (version) {
9372 case 1:
9373 ZERO_STRUCT(port1);
9374
9375 if (!pull_port_data_1(mem_ctx, &port1, in)) {
9376 return WERR_NOMEM;
9377 }
9378
9379 portname = port1.portname;
9380 hostaddress = port1.hostaddress;
9381 queue = port1.queue;
9382 protocol = port1.protocol;
9383 port_number = port1.port_number;
9384
9385 break;
9386 case 2:
9387 ZERO_STRUCT(port2);
9388
9389 if (!pull_port_data_2(mem_ctx, &port2, in)) {
9390 return WERR_NOMEM;
9391 }
9392
9393 portname = port2.portname;
9394 hostaddress = port2.hostaddress;
9395 queue = port2.queue;
9396 protocol = port2.protocol;
9397 port_number = port2.port_number;
9398
9399 break;
9400 default:
9401 DEBUG(1,("xcvtcp_addport: "
9402 "unknown version of port_data: %d\n", version));
9403 return WERR_UNKNOWN_PORT;
9404 }
9405
9406 /* create the device URI and call the add_port_hook() */
9407
9408 switch (protocol) {
9409 case PROTOCOL_RAWTCP_TYPE:
9410 device_uri = talloc_asprintf(mem_ctx,
9411 "socket://%s:%d/", hostaddress,
9412 port_number);
9413 break;
9414
9415 case PROTOCOL_LPR_TYPE:
9416 device_uri = talloc_asprintf(mem_ctx,
9417 "lpr://%s/%s", hostaddress, queue );
9418 break;
9419
9420 default:
9421 return WERR_UNKNOWN_PORT;
9422 }
9423
9424 if (!device_uri) {
9425 return WERR_NOMEM;
9426 }
9427
9428 return add_port_hook(mem_ctx, token, portname, device_uri);
9429 }
9430
9431 /*******************************************************************
9432 *******************************************************************/
9433
9434 struct xcv_api_table xcvtcp_cmds[] = {
9435 { "MonitorUI", xcvtcp_monitorui },
9436 { "AddPort", xcvtcp_addport},
9437 { NULL, NULL }
9438 };
9439
9440 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9441 NT_USER_TOKEN *token, const char *command,
9442 DATA_BLOB *inbuf,
9443 DATA_BLOB *outbuf,
9444 uint32_t *needed )
9445 {
9446 int i;
9447
9448 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9449
9450 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9451 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9452 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9453 }
9454
9455 return WERR_BADFUNC;
9456 }
9457
9458 /*******************************************************************
9459 *******************************************************************/
9460 #if 0 /* don't support management using the "Local Port" monitor */
9461
9462 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9463 NT_USER_TOKEN *token, DATA_BLOB *in,
9464 DATA_BLOB *out, uint32_t *needed)
9465 {
9466 const char *dllname = "localui.dll";
9467
9468 *needed = (strlen(dllname)+1) * 2;
9469
9470 if (out->length < *needed) {
9471 return WERR_INSUFFICIENT_BUFFER;
9472 }
9473
9474 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9475 return WERR_NOMEM;
9476 }
9477
9478 return WERR_OK;
9479 }
9480
9481 /*******************************************************************
9482 *******************************************************************/
9483
9484 struct xcv_api_table xcvlocal_cmds[] = {
9485 { "MonitorUI", xcvlocal_monitorui },
9486 { NULL, NULL }
9487 };
9488 #else
9489 struct xcv_api_table xcvlocal_cmds[] = {
9490 { NULL, NULL }
9491 };
9492 #endif
9493
9494
9495
9496 /*******************************************************************
9497 *******************************************************************/
9498
9499 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9500 NT_USER_TOKEN *token, const char *command,
9501 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9502 uint32_t *needed)
9503 {
9504 int i;
9505
9506 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9507
9508 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9509 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9510 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9511 }
9512 return WERR_BADFUNC;
9513 }
9514
9515 /****************************************************************
9516 _spoolss_XcvData
9517 ****************************************************************/
9518
9519 WERROR _spoolss_XcvData(pipes_struct *p,
9520 struct spoolss_XcvData *r)
9521 {
9522 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9523 DATA_BLOB out_data = data_blob_null;
9524 WERROR werror;
9525
9526 if (!Printer) {
9527 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9528 OUR_HANDLE(r->in.handle)));
9529 return WERR_BADFID;
9530 }
9531
9532 /* Has to be a handle to the TCP/IP port monitor */
9533
9534 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9535 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9536 return WERR_BADFID;
9537 }
9538
9539 /* requires administrative access to the server */
9540
9541 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9542 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9543 return WERR_ACCESS_DENIED;
9544 }
9545
9546 /* Allocate the outgoing buffer */
9547
9548 if (r->in.out_data_size) {
9549 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9550 if (out_data.data == NULL) {
9551 return WERR_NOMEM;
9552 }
9553 }
9554
9555 switch ( Printer->printer_type ) {
9556 case SPLHND_PORTMON_TCP:
9557 werror = process_xcvtcp_command(p->mem_ctx,
9558 p->server_info->ptok,
9559 r->in.function_name,
9560 &r->in.in_data, &out_data,
9561 r->out.needed);
9562 break;
9563 case SPLHND_PORTMON_LOCAL:
9564 werror = process_xcvlocal_command(p->mem_ctx,
9565 p->server_info->ptok,
9566 r->in.function_name,
9567 &r->in.in_data, &out_data,
9568 r->out.needed);
9569 break;
9570 default:
9571 werror = WERR_INVALID_PRINT_MONITOR;
9572 }
9573
9574 if (!W_ERROR_IS_OK(werror)) {
9575 return werror;
9576 }
9577
9578 *r->out.status_code = 0;
9579
9580 if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
9581 memcpy(r->out.out_data, out_data.data,
9582 MIN(r->in.out_data_size, out_data.length));
9583 }
9584
9585 return WERR_OK;
9586 }
9587
9588 /****************************************************************
9589 _spoolss_AddPrintProcessor
9590 ****************************************************************/
9591
9592 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
9593 struct spoolss_AddPrintProcessor *r)
9594 {
9595 /* for now, just indicate success and ignore the add. We'll
9596 automatically set the winprint processor for printer
9597 entries later. Used to debug the LexMark Optra S 1855 PCL
9598 driver --jerry */
9599
9600 return WERR_OK;
9601 }
9602
9603 /****************************************************************
9604 _spoolss_AddPort
9605 ****************************************************************/
9606
9607 WERROR _spoolss_AddPort(pipes_struct *p,
9608 struct spoolss_AddPort *r)
9609 {
9610 /* do what w2k3 does */
9611
9612 return WERR_NOT_SUPPORTED;
9613 }
9614
9615 /****************************************************************
9616 _spoolss_GetPrinterDriver
9617 ****************************************************************/
9618
9619 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
9620 struct spoolss_GetPrinterDriver *r)
9621 {
9622 p->rng_fault_state = true;
9623 return WERR_NOT_SUPPORTED;
9624 }
9625
9626 /****************************************************************
9627 _spoolss_ReadPrinter
9628 ****************************************************************/
9629
9630 WERROR _spoolss_ReadPrinter(pipes_struct *p,
9631 struct spoolss_ReadPrinter *r)
9632 {
9633 p->rng_fault_state = true;
9634 return WERR_NOT_SUPPORTED;
9635 }
9636
9637 /****************************************************************
9638 _spoolss_WaitForPrinterChange
9639 ****************************************************************/
9640
9641 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
9642 struct spoolss_WaitForPrinterChange *r)
9643 {
9644 p->rng_fault_state = true;
9645 return WERR_NOT_SUPPORTED;
9646 }
9647
9648 /****************************************************************
9649 _spoolss_ConfigurePort
9650 ****************************************************************/
9651
9652 WERROR _spoolss_ConfigurePort(pipes_struct *p,
9653 struct spoolss_ConfigurePort *r)
9654 {
9655 p->rng_fault_state = true;
9656 return WERR_NOT_SUPPORTED;
9657 }
9658
9659 /****************************************************************
9660 _spoolss_DeletePort
9661 ****************************************************************/
9662
9663 WERROR _spoolss_DeletePort(pipes_struct *p,
9664 struct spoolss_DeletePort *r)
9665 {
9666 p->rng_fault_state = true;
9667 return WERR_NOT_SUPPORTED;
9668 }
9669
9670 /****************************************************************
9671 _spoolss_CreatePrinterIC
9672 ****************************************************************/
9673
9674 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
9675 struct spoolss_CreatePrinterIC *r)
9676 {
9677 p->rng_fault_state = true;
9678 return WERR_NOT_SUPPORTED;
9679 }
9680
9681 /****************************************************************
9682 _spoolss_PlayGDIScriptOnPrinterIC
9683 ****************************************************************/
9684
9685 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
9686 struct spoolss_PlayGDIScriptOnPrinterIC *r)
9687 {
9688 p->rng_fault_state = true;
9689 return WERR_NOT_SUPPORTED;
9690 }
9691
9692 /****************************************************************
9693 _spoolss_DeletePrinterIC
9694 ****************************************************************/
9695
9696 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
9697 struct spoolss_DeletePrinterIC *r)
9698 {
9699 p->rng_fault_state = true;
9700 return WERR_NOT_SUPPORTED;
9701 }
9702
9703 /****************************************************************
9704 _spoolss_AddPrinterConnection
9705 ****************************************************************/
9706
9707 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
9708 struct spoolss_AddPrinterConnection *r)
9709 {
9710 p->rng_fault_state = true;
9711 return WERR_NOT_SUPPORTED;
9712 }
9713
9714 /****************************************************************
9715 _spoolss_DeletePrinterConnection
9716 ****************************************************************/
9717
9718 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
9719 struct spoolss_DeletePrinterConnection *r)
9720 {
9721 p->rng_fault_state = true;
9722 return WERR_NOT_SUPPORTED;
9723 }
9724
9725 /****************************************************************
9726 _spoolss_PrinterMessageBox
9727 ****************************************************************/
9728
9729 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
9730 struct spoolss_PrinterMessageBox *r)
9731 {
9732 p->rng_fault_state = true;
9733 return WERR_NOT_SUPPORTED;
9734 }
9735
9736 /****************************************************************
9737 _spoolss_AddMonitor
9738 ****************************************************************/
9739
9740 WERROR _spoolss_AddMonitor(pipes_struct *p,
9741 struct spoolss_AddMonitor *r)
9742 {
9743 p->rng_fault_state = true;
9744 return WERR_NOT_SUPPORTED;
9745 }
9746
9747 /****************************************************************
9748 _spoolss_DeleteMonitor
9749 ****************************************************************/
9750
9751 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
9752 struct spoolss_DeleteMonitor *r)
9753 {
9754 p->rng_fault_state = true;
9755 return WERR_NOT_SUPPORTED;
9756 }
9757
9758 /****************************************************************
9759 _spoolss_DeletePrintProcessor
9760 ****************************************************************/
9761
9762 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
9763 struct spoolss_DeletePrintProcessor *r)
9764 {
9765 p->rng_fault_state = true;
9766 return WERR_NOT_SUPPORTED;
9767 }
9768
9769 /****************************************************************
9770 _spoolss_AddPrintProvidor
9771 ****************************************************************/
9772
9773 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
9774 struct spoolss_AddPrintProvidor *r)
9775 {
9776 p->rng_fault_state = true;
9777 return WERR_NOT_SUPPORTED;
9778 }
9779
9780 /****************************************************************
9781 _spoolss_DeletePrintProvidor
9782 ****************************************************************/
9783
9784 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
9785 struct spoolss_DeletePrintProvidor *r)
9786 {
9787 p->rng_fault_state = true;
9788 return WERR_NOT_SUPPORTED;
9789 }
9790
9791 /****************************************************************
9792 _spoolss_FindFirstPrinterChangeNotification
9793 ****************************************************************/
9794
9795 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
9796 struct spoolss_FindFirstPrinterChangeNotification *r)
9797 {
9798 p->rng_fault_state = true;
9799 return WERR_NOT_SUPPORTED;
9800 }
9801
9802 /****************************************************************
9803 _spoolss_FindNextPrinterChangeNotification
9804 ****************************************************************/
9805
9806 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
9807 struct spoolss_FindNextPrinterChangeNotification *r)
9808 {
9809 p->rng_fault_state = true;
9810 return WERR_NOT_SUPPORTED;
9811 }
9812
9813 /****************************************************************
9814 _spoolss_RouterFindFirstPrinterChangeNotificationOld
9815 ****************************************************************/
9816
9817 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
9818 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
9819 {
9820 p->rng_fault_state = true;
9821 return WERR_NOT_SUPPORTED;
9822 }
9823
9824 /****************************************************************
9825 _spoolss_ReplyOpenPrinter
9826 ****************************************************************/
9827
9828 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
9829 struct spoolss_ReplyOpenPrinter *r)
9830 {
9831 p->rng_fault_state = true;
9832 return WERR_NOT_SUPPORTED;
9833 }
9834
9835 /****************************************************************
9836 _spoolss_RouterReplyPrinter
9837 ****************************************************************/
9838
9839 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
9840 struct spoolss_RouterReplyPrinter *r)
9841 {
9842 p->rng_fault_state = true;
9843 return WERR_NOT_SUPPORTED;
9844 }
9845
9846 /****************************************************************
9847 _spoolss_ReplyClosePrinter
9848 ****************************************************************/
9849
9850 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
9851 struct spoolss_ReplyClosePrinter *r)
9852 {
9853 p->rng_fault_state = true;
9854 return WERR_NOT_SUPPORTED;
9855 }
9856
9857 /****************************************************************
9858 _spoolss_AddPortEx
9859 ****************************************************************/
9860
9861 WERROR _spoolss_AddPortEx(pipes_struct *p,
9862 struct spoolss_AddPortEx *r)
9863 {
9864 p->rng_fault_state = true;
9865 return WERR_NOT_SUPPORTED;
9866 }
9867
9868 /****************************************************************
9869 _spoolss_RouterFindFirstPrinterChangeNotification
9870 ****************************************************************/
9871
9872 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
9873 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
9874 {
9875 p->rng_fault_state = true;
9876 return WERR_NOT_SUPPORTED;
9877 }
9878
9879 /****************************************************************
9880 _spoolss_SpoolerInit
9881 ****************************************************************/
9882
9883 WERROR _spoolss_SpoolerInit(pipes_struct *p,
9884 struct spoolss_SpoolerInit *r)
9885 {
9886 p->rng_fault_state = true;
9887 return WERR_NOT_SUPPORTED;
9888 }
9889
9890 /****************************************************************
9891 _spoolss_ResetPrinterEx
9892 ****************************************************************/
9893
9894 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
9895 struct spoolss_ResetPrinterEx *r)
9896 {
9897 p->rng_fault_state = true;
9898 return WERR_NOT_SUPPORTED;
9899 }
9900
9901 /****************************************************************
9902 _spoolss_RouterReplyPrinterEx
9903 ****************************************************************/
9904
9905 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
9906 struct spoolss_RouterReplyPrinterEx *r)
9907 {
9908 p->rng_fault_state = true;
9909 return WERR_NOT_SUPPORTED;
9910 }
9911
9912 /****************************************************************
9913 _spoolss_44
9914 ****************************************************************/
9915
9916 WERROR _spoolss_44(pipes_struct *p,
9917 struct spoolss_44 *r)
9918 {
9919 p->rng_fault_state = true;
9920 return WERR_NOT_SUPPORTED;
9921 }
9922
9923 /****************************************************************
9924 _spoolss_47
9925 ****************************************************************/
9926
9927 WERROR _spoolss_47(pipes_struct *p,
9928 struct spoolss_47 *r)
9929 {
9930 p->rng_fault_state = true;
9931 return WERR_NOT_SUPPORTED;
9932 }
9933
9934 /****************************************************************
9935 _spoolss_4a
9936 ****************************************************************/
9937
9938 WERROR _spoolss_4a(pipes_struct *p,
9939 struct spoolss_4a *r)
9940 {
9941 p->rng_fault_state = true;
9942 return WERR_NOT_SUPPORTED;
9943 }
9944
9945 /****************************************************************
9946 _spoolss_4b
9947 ****************************************************************/
9948
9949 WERROR _spoolss_4b(pipes_struct *p,
9950 struct spoolss_4b *r)
9951 {
9952 p->rng_fault_state = true;
9953 return WERR_NOT_SUPPORTED;
9954 }
9955
9956 /****************************************************************
9957 _spoolss_4c
9958 ****************************************************************/
9959
9960 WERROR _spoolss_4c(pipes_struct *p,
9961 struct spoolss_4c *r)
9962 {
9963 p->rng_fault_state = true;
9964 return WERR_NOT_SUPPORTED;
9965 }
9966
9967 /****************************************************************
9968 _spoolss_53
9969 ****************************************************************/
9970
9971 WERROR _spoolss_53(pipes_struct *p,
9972 struct spoolss_53 *r)
9973 {
9974 p->rng_fault_state = true;
9975 return WERR_NOT_SUPPORTED;
9976 }
9977
9978 /****************************************************************
9979 _spoolss_55
9980 ****************************************************************/
9981
9982 WERROR _spoolss_55(pipes_struct *p,
9983 struct spoolss_55 *r)
9984 {
9985 p->rng_fault_state = true;
9986 return WERR_NOT_SUPPORTED;
9987 }
9988
9989 /****************************************************************
9990 _spoolss_56
9991 ****************************************************************/
9992
9993 WERROR _spoolss_56(pipes_struct *p,
9994 struct spoolss_56 *r)
9995 {
9996 p->rng_fault_state = true;
9997 return WERR_NOT_SUPPORTED;
9998 }
9999
10000 /****************************************************************
10001 _spoolss_57
10002 ****************************************************************/
10003
10004 WERROR _spoolss_57(pipes_struct *p,
10005 struct spoolss_57 *r)
10006 {
10007 p->rng_fault_state = true;
10008 return WERR_NOT_SUPPORTED;
10009 }
10010
10011 /****************************************************************
10012 _spoolss_5a
10013 ****************************************************************/
10014
10015 WERROR _spoolss_5a(pipes_struct *p,
10016 struct spoolss_5a *r)
10017 {
10018 p->rng_fault_state = true;
10019 return WERR_NOT_SUPPORTED;
10020 }
10021
10022 /****************************************************************
10023 _spoolss_5b
10024 ****************************************************************/
10025
10026 WERROR _spoolss_5b(pipes_struct *p,
10027 struct spoolss_5b *r)
10028 {
10029 p->rng_fault_state = true;
10030 return WERR_NOT_SUPPORTED;
10031 }
10032
10033 /****************************************************************
10034 _spoolss_5c
10035 ****************************************************************/
10036
10037 WERROR _spoolss_5c(pipes_struct *p,
10038 struct spoolss_5c *r)
10039 {
10040 p->rng_fault_state = true;
10041 return WERR_NOT_SUPPORTED;
10042 }
10043
10044 /****************************************************************
10045 _spoolss_5d
10046 ****************************************************************/
10047
10048 WERROR _spoolss_5d(pipes_struct *p,
10049 struct spoolss_5d *r)
10050 {
10051 p->rng_fault_state = true;
10052 return WERR_NOT_SUPPORTED;
10053 }
10054
10055 /****************************************************************
10056 _spoolss_5e
10057 ****************************************************************/
10058
10059 WERROR _spoolss_5e(pipes_struct *p,
10060 struct spoolss_5e *r)
10061 {
10062 p->rng_fault_state = true;
10063 return WERR_NOT_SUPPORTED;
10064 }
10065
10066 /****************************************************************
10067 _spoolss_5f
10068 ****************************************************************/
10069
10070 WERROR _spoolss_5f(pipes_struct *p,
10071 struct spoolss_5f *r)
10072 {
10073 p->rng_fault_state = true;
10074 return WERR_NOT_SUPPORTED;
10075 }
10076
10077 /****************************************************************
10078 _spoolss_60
10079 ****************************************************************/
10080
10081 WERROR _spoolss_60(pipes_struct *p,
10082 struct spoolss_60 *r)
10083 {
10084 p->rng_fault_state = true;
10085 return WERR_NOT_SUPPORTED;
10086 }
10087
10088 /****************************************************************
10089 _spoolss_61
10090 ****************************************************************/
10091
10092 WERROR _spoolss_61(pipes_struct *p,
10093 struct spoolss_61 *r)
10094 {
10095 p->rng_fault_state = true;
10096 return WERR_NOT_SUPPORTED;
10097 }
10098
10099 /****************************************************************
10100 _spoolss_62
10101 ****************************************************************/
10102
10103 WERROR _spoolss_62(pipes_struct *p,
10104 struct spoolss_62 *r)
10105 {
10106 p->rng_fault_state = true;
10107 return WERR_NOT_SUPPORTED;
10108 }
10109
10110 /****************************************************************
10111 _spoolss_63
10112 ****************************************************************/
10113
10114 WERROR _spoolss_63(pipes_struct *p,
10115 struct spoolss_63 *r)
10116 {
10117 p->rng_fault_state = true;
10118 return WERR_NOT_SUPPORTED;
10119 }
10120
10121 /****************************************************************
10122 _spoolss_64
10123 ****************************************************************/
10124
10125 WERROR _spoolss_64(pipes_struct *p,
10126 struct spoolss_64 *r)
10127 {
10128 p->rng_fault_state = true;
10129 return WERR_NOT_SUPPORTED;
10130 }
10131
10132 /****************************************************************
10133 _spoolss_65
10134 ****************************************************************/
10135
10136 WERROR _spoolss_65(pipes_struct *p,
10137 struct spoolss_65 *r)
10138 {
10139 p->rng_fault_state = true;
10140 return WERR_NOT_SUPPORTED;
10141 }
10142
10143 /****************************************************************
10144 _spoolss_GetCorePrinterDrivers
10145 ****************************************************************/
10146
10147 WERROR _spoolss_GetCorePrinterDrivers(pipes_struct *p,
10148 struct spoolss_GetCorePrinterDrivers *r)
10149 {
10150 p->rng_fault_state = true;
10151 return WERR_NOT_SUPPORTED;
10152 }
10153
10154 /****************************************************************
10155 _spoolss_67
10156 ****************************************************************/
10157
10158 WERROR _spoolss_67(pipes_struct *p,
10159 struct spoolss_67 *r)
10160 {
10161 p->rng_fault_state = true;
10162 return WERR_NOT_SUPPORTED;
10163 }
10164
10165 /****************************************************************
10166 _spoolss_GetPrinterDriverPackagePath
10167 ****************************************************************/
10168
10169 WERROR _spoolss_GetPrinterDriverPackagePath(pipes_struct *p,
10170 struct spoolss_GetPrinterDriverPackagePath *r)
10171 {
10172 p->rng_fault_state = true;
10173 return WERR_NOT_SUPPORTED;
10174 }
10175
10176 /****************************************************************
10177 _spoolss_69
10178 ****************************************************************/
10179
10180 WERROR _spoolss_69(pipes_struct *p,
10181 struct spoolss_69 *r)
10182 {
10183 p->rng_fault_state = true;
10184 return WERR_NOT_SUPPORTED;
10185 }
10186
10187 /****************************************************************
10188 _spoolss_6a
10189 ****************************************************************/
10190
10191 WERROR _spoolss_6a(pipes_struct *p,
10192 struct spoolss_6a *r)
10193 {
10194 p->rng_fault_state = true;
10195 return WERR_NOT_SUPPORTED;
10196 }
10197
10198 /****************************************************************
10199 _spoolss_6b
10200 ****************************************************************/
10201
10202 WERROR _spoolss_6b(pipes_struct *p,
10203 struct spoolss_6b *r)
10204 {
10205 p->rng_fault_state = true;
10206 return WERR_NOT_SUPPORTED;
10207 }
10208
10209 /****************************************************************
10210 _spoolss_6c
10211 ****************************************************************/
10212
10213 WERROR _spoolss_6c(pipes_struct *p,
10214 struct spoolss_6c *r)
10215 {
10216 p->rng_fault_state = true;
10217 return WERR_NOT_SUPPORTED;
10218 }
10219
10220 /****************************************************************
10221 _spoolss_6d
10222 ****************************************************************/
10223
10224 WERROR _spoolss_6d(pipes_struct *p,
10225 struct spoolss_6d *r)
10226 {
10227 p->rng_fault_state = true;
10228 return WERR_NOT_SUPPORTED;
10229 }
kamenim's samba4 branches