?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
spoolss: fix jobid in level 2 GetJob and EnumJobs responses
[Samba.git] / source3 / rpc_server / spoolss / srv_spoolss_nt.c
blob45d60df613ee0db1606c1b07eb84ea62cae825ae
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-2000,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6 * Copyright (C) Jean François Micouleau 1998-2000,
7 * Copyright (C) Jeremy Allison 2001-2002,
8 * Copyright (C) Gerald Carter 2000-2004,
9 * Copyright (C) Tim Potter 2001-2002.
10 * Copyright (C) Guenther Deschner 2009-2010.
11 * Copyright (C) Andreas Schneider 2010.
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 3 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, see <http://www.gnu.org/licenses/>.
25 */
26
27 /* Since the SPOOLSS rpc routines are basically DOS 16-bit calls wrapped
28 up, all the errors returned are DOS errors, not NT status codes. */
29
30 #include "includes.h"
31 #include "ntdomain.h"
32 #include "nt_printing.h"
33 #include "srv_spoolss_util.h"
34 #include "../librpc/gen_ndr/srv_spoolss.h"
35 #include "../librpc/gen_ndr/ndr_spoolss_c.h"
36 #include "rpc_client/init_spoolss.h"
37 #include "rpc_client/cli_pipe.h"
38 #include "../libcli/security/security.h"
39 #include "librpc/gen_ndr/ndr_security.h"
40 #include "registry.h"
41 #include "include/printing.h"
42 #include "secrets.h"
43 #include "../librpc/gen_ndr/netlogon.h"
44 #include "rpc_misc.h"
45 #include "printing/notify.h"
46 #include "serverid.h"
47 #include "../libcli/registry/util_reg.h"
48 #include "smbd/smbd.h"
49 #include "smbd/globals.h"
50 #include "auth.h"
51 #include "messages.h"
52 #include "rpc_server/spoolss/srv_spoolss_nt.h"
53 #include "util_tdb.h"
54 #include "libsmb/libsmb.h"
55 #include "printing/printer_list.h"
56 #include "../lib/tsocket/tsocket.h"
57 #include "rpc_client/cli_winreg_spoolss.h"
58 #include "../libcli/smb/smbXcli_base.h"
59
60 /* macros stolen from s4 spoolss server */
61 #define SPOOLSS_BUFFER_UNION(fn,info,level) \
62 ((info)?ndr_size_##fn(info, level, 0):0)
63
64 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,info,level,count) \
65 ((info)?ndr_size_##fn##_info(mem_ctx, level, count, info):0)
66
67 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,info,count) \
68 ((info)?ndr_size_##fn##_info(mem_ctx, count, info):0)
69
70 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
71
72 #undef DBGC_CLASS
73 #define DBGC_CLASS DBGC_RPC_SRV
74
75 #ifndef MAX_OPEN_PRINTER_EXS
76 #define MAX_OPEN_PRINTER_EXS 50
77 #endif
78
79 struct notify_back_channel;
80
81 /* structure to store the printer handles */
82 /* and a reference to what it's pointing to */
83 /* and the notify info asked about */
84 /* that's the central struct */
85 struct printer_handle {
86 struct printer_handle *prev, *next;
87 bool document_started;
88 bool page_started;
89 uint32 jobid; /* jobid in printing backend */
90 int printer_type;
91 const char *servername;
92 fstring sharename;
93 uint32 type;
94 uint32 access_granted;
95 struct {
96 uint32 flags;
97 uint32 options;
98 fstring localmachine;
99 uint32 printerlocal;
100 struct spoolss_NotifyOption *option;
101 struct policy_handle cli_hnd;
102 struct notify_back_channel *cli_chan;
103 uint32 change;
104 /* are we in a FindNextPrinterChangeNotify() call? */
105 bool fnpcn;
106 struct messaging_context *msg_ctx;
107 } notify;
108 struct {
109 fstring machine;
110 fstring user;
111 } client;
112
113 /* devmode sent in the OpenPrinter() call */
114 struct spoolss_DeviceMode *devmode;
115
116 /* TODO cache the printer info2 structure */
117 struct spoolss_PrinterInfo2 *info2;
118
119 };
120
121 static struct printer_handle *printers_list;
122
123 struct printer_session_counter {
124 struct printer_session_counter *next;
125 struct printer_session_counter *prev;
126
127 int snum;
128 uint32_t counter;
129 };
130
131 static struct printer_session_counter *counter_list;
132
133 struct notify_back_channel {
134 struct notify_back_channel *prev, *next;
135
136 /* associated client */
137 struct sockaddr_storage client_address;
138
139 /* print notify back-channel pipe handle*/
140 struct rpc_pipe_client *cli_pipe;
141 struct cli_state *cli;
142 uint32_t active_connections;
143 };
144
145 static struct notify_back_channel *back_channels;
146
147 /* Map generic permissions to printer object specific permissions */
148
149 const struct standard_mapping printer_std_mapping = {
150 PRINTER_READ,
151 PRINTER_WRITE,
152 PRINTER_EXECUTE,
153 PRINTER_ALL_ACCESS
154 };
155
156 /* Map generic permissions to print server object specific permissions */
157
158 const struct standard_mapping printserver_std_mapping = {
159 SERVER_READ,
160 SERVER_WRITE,
161 SERVER_EXECUTE,
162 SERVER_ALL_ACCESS
163 };
164
165 /* API table for Xcv Monitor functions */
166
167 struct xcv_api_table {
168 const char *name;
169 WERROR(*fn) (TALLOC_CTX *mem_ctx, struct security_token *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
170 };
171
172 static void prune_printername_cache(void);
173
174 /********************************************************************
175 * Canonicalize servername.
176 ********************************************************************/
177
178 static const char *canon_servername(const char *servername)
179 {
180 const char *pservername = servername;
181 while (*pservername == '\\') {
182 pservername++;
183 }
184 return pservername;
185 }
186
187 /* translate between internal status numbers and NT status numbers */
188 static int nt_printj_status(int v)
189 {
190 switch (v) {
191 case LPQ_QUEUED:
192 return 0;
193 case LPQ_PAUSED:
194 return JOB_STATUS_PAUSED;
195 case LPQ_SPOOLING:
196 return JOB_STATUS_SPOOLING;
197 case LPQ_PRINTING:
198 return JOB_STATUS_PRINTING;
199 case LPQ_ERROR:
200 return JOB_STATUS_ERROR;
201 case LPQ_DELETING:
202 return JOB_STATUS_DELETING;
203 case LPQ_OFFLINE:
204 return JOB_STATUS_OFFLINE;
205 case LPQ_PAPEROUT:
206 return JOB_STATUS_PAPEROUT;
207 case LPQ_PRINTED:
208 return JOB_STATUS_PRINTED;
209 case LPQ_DELETED:
210 return JOB_STATUS_DELETED;
211 case LPQ_BLOCKED:
212 return JOB_STATUS_BLOCKED_DEVQ;
213 case LPQ_USER_INTERVENTION:
214 return JOB_STATUS_USER_INTERVENTION;
215 }
216 return 0;
217 }
218
219 static int nt_printq_status(int v)
220 {
221 switch (v) {
222 case LPQ_PAUSED:
223 return PRINTER_STATUS_PAUSED;
224 case LPQ_QUEUED:
225 case LPQ_SPOOLING:
226 case LPQ_PRINTING:
227 return 0;
228 }
229 return 0;
230 }
231
232 /***************************************************************************
233 Disconnect from the client
234 ****************************************************************************/
235
236 static void srv_spoolss_replycloseprinter(int snum,
237 struct printer_handle *prn_hnd)
238 {
239 WERROR result;
240 NTSTATUS status;
241
242 /*
243 * Tell the specific printing tdb we no longer want messages for this printer
244 * by deregistering our PID.
245 */
246
247 if (!print_notify_deregister_pid(snum)) {
248 DEBUG(0, ("Failed to register our pid for printer %s\n",
249 lp_const_servicename(snum)));
250 }
251
252 /* weird if the test succeeds !!! */
253 if (prn_hnd->notify.cli_chan == NULL ||
254 prn_hnd->notify.cli_chan->cli_pipe == NULL ||
255 prn_hnd->notify.cli_chan->cli_pipe->binding_handle == NULL ||
256 prn_hnd->notify.cli_chan->active_connections == 0) {
257 DEBUG(0, ("Trying to close unexisting backchannel!\n"));
258 DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
259 TALLOC_FREE(prn_hnd->notify.cli_chan);
260 return;
261 }
262
263 status = dcerpc_spoolss_ReplyClosePrinter(
264 prn_hnd->notify.cli_chan->cli_pipe->binding_handle,
265 talloc_tos(),
266 &prn_hnd->notify.cli_hnd,
267 &result);
268 if (!NT_STATUS_IS_OK(status)) {
269 DEBUG(0, ("dcerpc_spoolss_ReplyClosePrinter failed [%s].\n",
270 nt_errstr(status)));
271 result = ntstatus_to_werror(status);
272 } else if (!W_ERROR_IS_OK(result)) {
273 DEBUG(0, ("reply_close_printer failed [%s].\n",
274 win_errstr(result)));
275 }
276
277 /* if it's the last connection, deconnect the IPC$ share */
278 if (prn_hnd->notify.cli_chan->active_connections == 1) {
279
280 cli_shutdown(prn_hnd->notify.cli_chan->cli);
281 DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
282 TALLOC_FREE(prn_hnd->notify.cli_chan);
283
284 if (prn_hnd->notify.msg_ctx != NULL) {
285 messaging_deregister(prn_hnd->notify.msg_ctx,
286 MSG_PRINTER_NOTIFY2, NULL);
287 }
288 }
289
290 if (prn_hnd->notify.cli_chan) {
291 prn_hnd->notify.cli_chan->active_connections--;
292 prn_hnd->notify.cli_chan = NULL;
293 }
294 }
295
296 /****************************************************************************
297 Functions to free a printer entry datastruct.
298 ****************************************************************************/
299
300 static int printer_entry_destructor(struct printer_handle *Printer)
301 {
302 if (Printer->notify.cli_chan != NULL &&
303 Printer->notify.cli_chan->active_connections > 0) {
304 int snum = -1;
305
306 switch(Printer->printer_type) {
307 case SPLHND_SERVER:
308 srv_spoolss_replycloseprinter(snum, Printer);
309 break;
310
311 case SPLHND_PRINTER:
312 snum = print_queue_snum(Printer->sharename);
313 if (snum != -1) {
314 srv_spoolss_replycloseprinter(snum, Printer);
315 }
316 break;
317 default:
318 break;
319 }
320 }
321
322 Printer->notify.flags=0;
323 Printer->notify.options=0;
324 Printer->notify.localmachine[0]='\0';
325 Printer->notify.printerlocal=0;
326 TALLOC_FREE(Printer->notify.option);
327 TALLOC_FREE(Printer->devmode);
328
329 /* Remove from the internal list. */
330 DLIST_REMOVE(printers_list, Printer);
331 return 0;
332 }
333
334 /****************************************************************************
335 find printer index by handle
336 ****************************************************************************/
337
338 static struct printer_handle *find_printer_index_by_hnd(struct pipes_struct *p,
339 struct policy_handle *hnd)
340 {
341 struct printer_handle *find_printer = NULL;
342
343 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
344 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
345 return NULL;
346 }
347
348 return find_printer;
349 }
350
351 /****************************************************************************
352 Close printer index by handle.
353 ****************************************************************************/
354
355 static bool close_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
356 {
357 struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
358
359 if (!Printer) {
360 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
361 OUR_HANDLE(hnd)));
362 return false;
363 }
364
365 close_policy_hnd(p, hnd);
366
367 return true;
368 }
369
370 /****************************************************************************
371 Delete a printer given a handle.
372 ****************************************************************************/
373
374 static WERROR delete_printer_hook(TALLOC_CTX *ctx, struct security_token *token,
375 const char *sharename,
376 struct messaging_context *msg_ctx)
377 {
378 char *cmd = lp_deleteprinter_command(talloc_tos());
379 char *command = NULL;
380 int ret;
381 bool is_print_op = false;
382
383 /* can't fail if we don't try */
384
385 if ( !*cmd )
386 return WERR_OK;
387
388 command = talloc_asprintf(ctx,
389 "%s \"%s\"",
390 cmd, sharename);
391 if (!command) {
392 return WERR_NOMEM;
393 }
394 if ( token )
395 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
396
397 DEBUG(10,("Running [%s]\n", command));
398
399 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
400
401 if ( is_print_op )
402 become_root();
403
404 if ( (ret = smbrun(command, NULL)) == 0 ) {
405 /* Tell everyone we updated smb.conf. */
406 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
407 }
408
409 if ( is_print_op )
410 unbecome_root();
411
412 /********** END SePrintOperatorPrivlege BLOCK **********/
413
414 DEBUGADD(10,("returned [%d]\n", ret));
415
416 TALLOC_FREE(command);
417
418 if (ret != 0)
419 return WERR_BADFID; /* What to return here? */
420
421 return WERR_OK;
422 }
423
424 /****************************************************************************
425 Delete a printer given a handle.
426 ****************************************************************************/
427
428 static WERROR delete_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
429 {
430 struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
431 WERROR result;
432
433 if (!Printer) {
434 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
435 OUR_HANDLE(hnd)));
436 return WERR_BADFID;
437 }
438
439 /*
440 * It turns out that Windows allows delete printer on a handle
441 * opened by an admin user, then used on a pipe handle created
442 * by an anonymous user..... but they're working on security.... riiight !
443 * JRA.
444 */
445
446 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
447 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
448 return WERR_ACCESS_DENIED;
449 }
450
451 /* this does not need a become root since the access check has been
452 done on the handle already */
453
454 result = winreg_delete_printer_key_internal(p->mem_ctx,
455 get_session_info_system(),
456 p->msg_ctx,
457 Printer->sharename,
458 "");
459 if (!W_ERROR_IS_OK(result)) {
460 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
461 return WERR_BADFID;
462 }
463
464 result = delete_printer_hook(p->mem_ctx, p->session_info->security_token,
465 Printer->sharename, p->msg_ctx);
466 if (!W_ERROR_IS_OK(result)) {
467 return result;
468 }
469 prune_printername_cache();
470 return WERR_OK;
471 }
472
473 /****************************************************************************
474 Return the snum of a printer corresponding to an handle.
475 ****************************************************************************/
476
477 static bool get_printer_snum(struct pipes_struct *p, struct policy_handle *hnd,
478 int *number, struct share_params **params)
479 {
480 struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
481
482 if (!Printer) {
483 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
484 OUR_HANDLE(hnd)));
485 return false;
486 }
487
488 switch (Printer->printer_type) {
489 case SPLHND_PRINTER:
490 DEBUG(4,("short name:%s\n", Printer->sharename));
491 *number = print_queue_snum(Printer->sharename);
492 return (*number != -1);
493 case SPLHND_SERVER:
494 return false;
495 default:
496 return false;
497 }
498 }
499
500 /****************************************************************************
501 Set printer handle type.
502 Check if it's \\server or \\server\printer
503 ****************************************************************************/
504
505 static bool set_printer_hnd_printertype(struct printer_handle *Printer, const char *handlename)
506 {
507 DEBUG(3,("Setting printer type=%s\n", handlename));
508
509 /* it's a print server */
510 if (handlename && *handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
511 DEBUGADD(4,("Printer is a print server\n"));
512 Printer->printer_type = SPLHND_SERVER;
513 }
514 /* it's a printer (set_printer_hnd_name() will handle port monitors */
515 else {
516 DEBUGADD(4,("Printer is a printer\n"));
517 Printer->printer_type = SPLHND_PRINTER;
518 }
519
520 return true;
521 }
522
523 static void prune_printername_cache_fn(const char *key, const char *value,
524 time_t timeout, void *private_data)
525 {
526 gencache_del(key);
527 }
528
529 static void prune_printername_cache(void)
530 {
531 gencache_iterate(prune_printername_cache_fn, NULL, "PRINTERNAME/*");
532 }
533
534 /****************************************************************************
535 Set printer handle name.. Accept names like \\server, \\server\printer,
536 \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port" See
537 the MSDN docs regarding OpenPrinter() for details on the XcvData() and
538 XcvDataPort() interface.
539 ****************************************************************************/
540
541 static WERROR set_printer_hnd_name(TALLOC_CTX *mem_ctx,
542 const struct auth_session_info *session_info,
543 struct messaging_context *msg_ctx,
544 struct printer_handle *Printer,
545 const char *handlename)
546 {
547 int snum;
548 int n_services=lp_numservices();
549 char *aprinter;
550 const char *printername;
551 const char *servername = NULL;
552 fstring sname;
553 bool found = false;
554 struct spoolss_PrinterInfo2 *info2 = NULL;
555 WERROR result;
556 char *p;
557
558 /*
559 * Hopefully nobody names his printers like this. Maybe \ or ,
560 * are illegal in printer names even?
561 */
562 const char printer_not_found[] = "Printer \\, !@#$%^&*( not found";
563 char *cache_key;
564 char *tmp;
565
566 DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
567 (unsigned long)strlen(handlename)));
568
569 aprinter = discard_const_p(char, handlename);
570 if ( *handlename == '\\' ) {
571 servername = canon_servername(handlename);
572 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
573 *aprinter = '\0';
574 aprinter++;
575 }
576 if (!is_myname_or_ipaddr(servername)) {
577 return WERR_INVALID_PRINTER_NAME;
578 }
579 Printer->servername = talloc_asprintf(Printer, "\\\\%s", servername);
580 if (Printer->servername == NULL) {
581 return WERR_NOMEM;
582 }
583 }
584
585 if (Printer->printer_type == SPLHND_SERVER) {
586 return WERR_OK;
587 }
588
589 if (Printer->printer_type != SPLHND_PRINTER) {
590 return WERR_INVALID_HANDLE;
591 }
592
593 DEBUGADD(5, ("searching for [%s]\n", aprinter));
594
595 p = strchr(aprinter, ',');
596 if (p != NULL) {
597 char *p2 = p;
598 p++;
599 if (*p == ' ') {
600 p++;
601 }
602 if (strncmp(p, "DrvConvert", strlen("DrvConvert")) == 0) {
603 *p2 = '\0';
604 } else if (strncmp(p, "LocalOnly", strlen("LocalOnly")) == 0) {
605 *p2 = '\0';
606 }
607 }
608
609 if (p) {
610 DEBUGADD(5, ("stripped handlename: [%s]\n", aprinter));
611 }
612
613 /* check for the Port Monitor Interface */
614 if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
615 Printer->printer_type = SPLHND_PORTMON_TCP;
616 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
617 found = true;
618 }
619 else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
620 Printer->printer_type = SPLHND_PORTMON_LOCAL;
621 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
622 found = true;
623 }
624
625 /*
626 * With hundreds of printers, the "for" loop iterating all
627 * shares can be quite expensive, as it is done on every
628 * OpenPrinter. The loop maps "aprinter" to "sname", the
629 * result of which we cache in gencache.
630 */
631
632 cache_key = talloc_asprintf(talloc_tos(), "PRINTERNAME/%s",
633 aprinter);
634 if ((cache_key != NULL) &&
635 gencache_get(cache_key, talloc_tos(), &tmp, NULL)) {
636
637 found = (strcmp(tmp, printer_not_found) != 0);
638 if (!found) {
639 DEBUG(4, ("Printer %s not found\n", aprinter));
640 TALLOC_FREE(tmp);
641 return WERR_INVALID_PRINTER_NAME;
642 }
643 fstrcpy(sname, tmp);
644 TALLOC_FREE(tmp);
645 }
646
647 /* Search all sharenames first as this is easier than pulling
648 the printer_info_2 off of disk. Don't use find_service() since
649 that calls out to map_username() */
650
651 /* do another loop to look for printernames */
652 for (snum = 0; !found && snum < n_services; snum++) {
653 const char *printer = lp_const_servicename(snum);
654
655 /* no point going on if this is not a printer */
656 if (!(lp_snum_ok(snum) && lp_printable(snum))) {
657 continue;
658 }
659
660 /* ignore [printers] share */
661 if (strequal(printer, "printers")) {
662 continue;
663 }
664
665 fstrcpy(sname, printer);
666 if (strequal(aprinter, printer)) {
667 found = true;
668 break;
669 }
670
671 /* no point looking up the printer object if
672 we aren't allowing printername != sharename */
673 if (lp_force_printername(snum)) {
674 continue;
675 }
676
677 result = winreg_get_printer_internal(mem_ctx,
678 session_info,
679 msg_ctx,
680 sname,
681 &info2);
682 if ( !W_ERROR_IS_OK(result) ) {
683 DEBUG(2,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
684 sname, win_errstr(result)));
685 continue;
686 }
687
688 printername = strrchr(info2->printername, '\\');
689 if (printername == NULL) {
690 printername = info2->printername;
691 } else {
692 printername++;
693 }
694
695 if (strequal(printername, aprinter)) {
696 found = true;
697 break;
698 }
699
700 DEBUGADD(10, ("printername: %s\n", printername));
701
702 TALLOC_FREE(info2);
703 }
704
705 if ( !found ) {
706 if (cache_key != NULL) {
707 gencache_set(cache_key, printer_not_found,
708 time(NULL)+300);
709 TALLOC_FREE(cache_key);
710 }
711 DEBUGADD(4,("Printer not found\n"));
712 return WERR_INVALID_PRINTER_NAME;
713 }
714
715 if (cache_key != NULL) {
716 gencache_set(cache_key, sname, time(NULL)+300);
717 TALLOC_FREE(cache_key);
718 }
719
720 DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
721
722 strlcpy(Printer->sharename, sname, sizeof(Printer->sharename));
723
724 return WERR_OK;
725 }
726
727 /****************************************************************************
728 Find first available printer slot. creates a printer handle for you.
729 ****************************************************************************/
730
731 static WERROR open_printer_hnd(struct pipes_struct *p,
732 struct policy_handle *hnd,
733 const char *name,
734 uint32_t access_granted)
735 {
736 struct printer_handle *new_printer;
737 WERROR result;
738
739 DEBUG(10,("open_printer_hnd: name [%s]\n", name));
740
741 new_printer = talloc_zero(p->mem_ctx, struct printer_handle);
742 if (new_printer == NULL) {
743 return WERR_NOMEM;
744 }
745 talloc_set_destructor(new_printer, printer_entry_destructor);
746
747 /* This also steals the printer_handle on the policy_handle */
748 if (!create_policy_hnd(p, hnd, new_printer)) {
749 TALLOC_FREE(new_printer);
750 return WERR_INVALID_HANDLE;
751 }
752
753 /* Add to the internal list. */
754 DLIST_ADD(printers_list, new_printer);
755
756 new_printer->notify.option=NULL;
757
758 if (!set_printer_hnd_printertype(new_printer, name)) {
759 close_printer_handle(p, hnd);
760 return WERR_INVALID_HANDLE;
761 }
762
763 result = set_printer_hnd_name(p->mem_ctx,
764 get_session_info_system(),
765 p->msg_ctx,
766 new_printer, name);
767 if (!W_ERROR_IS_OK(result)) {
768 close_printer_handle(p, hnd);
769 return result;
770 }
771
772 new_printer->access_granted = access_granted;
773
774 DEBUG(5, ("%d printer handles active\n",
775 (int)num_pipe_handles(p)));
776
777 return WERR_OK;
778 }
779
780 /***************************************************************************
781 check to see if the client motify handle is monitoring the notification
782 given by (notify_type, notify_field).
783 **************************************************************************/
784
785 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
786 uint16_t notify_field)
787 {
788 return true;
789 }
790
791 static bool is_monitoring_event(struct printer_handle *p, uint16_t notify_type,
792 uint16_t notify_field)
793 {
794 struct spoolss_NotifyOption *option = p->notify.option;
795 uint32_t i, j;
796
797 /*
798 * Flags should always be zero when the change notify
799 * is registered by the client's spooler. A user Win32 app
800 * might use the flags though instead of the NOTIFY_OPTION_INFO
801 * --jerry
802 */
803
804 if (!option) {
805 return false;
806 }
807
808 if (p->notify.flags)
809 return is_monitoring_event_flags(
810 p->notify.flags, notify_type, notify_field);
811
812 for (i = 0; i < option->count; i++) {
813
814 /* Check match for notify_type */
815
816 if (option->types[i].type != notify_type)
817 continue;
818
819 /* Check match for field */
820
821 for (j = 0; j < option->types[i].count; j++) {
822 if (option->types[i].fields[j].field == notify_field) {
823 return true;
824 }
825 }
826 }
827
828 DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
829 p->servername, p->sharename, notify_type, notify_field));
830
831 return false;
832 }
833
834 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
835 _data->data.integer[0] = _integer; \
836 _data->data.integer[1] = 0;
837
838
839 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
840 _data->data.string.string = talloc_strdup(mem_ctx, _p); \
841 if (!_data->data.string.string) {\
842 _data->data.string.size = 0; \
843 } \
844 _data->data.string.size = strlen_m_term(_p) * 2;
845
846 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
847 _data->data.devmode.devmode = _devmode;
848
849 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
850 struct tm *t,
851 const char **pp,
852 uint32_t *plen)
853 {
854 struct spoolss_Time st;
855 uint32_t len = 16;
856 char *p;
857
858 if (!init_systemtime(&st, t)) {
859 return;
860 }
861
862 p = talloc_array(mem_ctx, char, len);
863 if (!p) {
864 return;
865 }
866
867 /*
868 * Systemtime must be linearized as a set of UINT16's.
869 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
870 */
871
872 SSVAL(p, 0, st.year);
873 SSVAL(p, 2, st.month);
874 SSVAL(p, 4, st.day_of_week);
875 SSVAL(p, 6, st.day);
876 SSVAL(p, 8, st.hour);
877 SSVAL(p, 10, st.minute);
878 SSVAL(p, 12, st.second);
879 SSVAL(p, 14, st.millisecond);
880
881 *pp = p;
882 *plen = len;
883 }
884
885 /* Convert a notification message to a struct spoolss_Notify */
886
887 static void notify_one_value(struct spoolss_notify_msg *msg,
888 struct spoolss_Notify *data,
889 TALLOC_CTX *mem_ctx)
890 {
891 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
892 }
893
894 static void notify_string(struct spoolss_notify_msg *msg,
895 struct spoolss_Notify *data,
896 TALLOC_CTX *mem_ctx)
897 {
898 /* The length of the message includes the trailing \0 */
899
900 data->data.string.size = msg->len * 2;
901 data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
902 if (!data->data.string.string) {
903 data->data.string.size = 0;
904 return;
905 }
906 }
907
908 static void notify_system_time(struct spoolss_notify_msg *msg,
909 struct spoolss_Notify *data,
910 TALLOC_CTX *mem_ctx)
911 {
912 data->data.string.string = NULL;
913 data->data.string.size = 0;
914
915 if (msg->len != sizeof(time_t)) {
916 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
917 msg->len));
918 return;
919 }
920
921 init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
922 &data->data.string.string,
923 &data->data.string.size);
924 }
925
926 struct notify2_message_table {
927 const char *name;
928 void (*fn)(struct spoolss_notify_msg *msg,
929 struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
930 };
931
932 static struct notify2_message_table printer_notify_table[] = {
933 /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
934 /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
935 /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
936 /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
937 /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
938 /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
939 /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
940 /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
941 /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
942 /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
943 /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
944 /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
945 /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
946 /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
947 /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
948 /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
949 /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
950 /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
951 /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
952 };
953
954 static struct notify2_message_table job_notify_table[] = {
955 /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
956 /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
957 /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
958 /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
959 /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
960 /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
961 /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
962 /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
963 /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
964 /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
965 /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
966 /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
967 /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
968 /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
969 /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
970 /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
971 /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
972 /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
973 /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
974 /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
975 /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
976 /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
977 /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
978 /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
979 };
980
981
982 /***********************************************************************
983 Allocate talloc context for container object
984 **********************************************************************/
985
986 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
987 {
988 if ( !ctr )
989 return;
990
991 ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
992
993 return;
994 }
995
996 /***********************************************************************
997 release all allocated memory and zero out structure
998 **********************************************************************/
999
1000 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
1001 {
1002 if ( !ctr )
1003 return;
1004
1005 if ( ctr->ctx )
1006 talloc_destroy(ctr->ctx);
1007
1008 ZERO_STRUCTP(ctr);
1009
1010 return;
1011 }
1012
1013 /***********************************************************************
1014 **********************************************************************/
1015
1016 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
1017 {
1018 if ( !ctr )
1019 return NULL;
1020
1021 return ctr->ctx;
1022 }
1023
1024 /***********************************************************************
1025 **********************************************************************/
1026
1027 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
1028 {
1029 if ( !ctr || !ctr->msg_groups )
1030 return NULL;
1031
1032 if ( idx >= ctr->num_groups )
1033 return NULL;
1034
1035 return &ctr->msg_groups[idx];
1036
1037 }
1038
1039 /***********************************************************************
1040 How many groups of change messages do we have ?
1041 **********************************************************************/
1042
1043 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
1044 {
1045 if ( !ctr )
1046 return 0;
1047
1048 return ctr->num_groups;
1049 }
1050
1051 /***********************************************************************
1052 Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
1053 **********************************************************************/
1054
1055 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
1056 {
1057 SPOOLSS_NOTIFY_MSG_GROUP *groups = NULL;
1058 SPOOLSS_NOTIFY_MSG_GROUP *msg_grp = NULL;
1059 SPOOLSS_NOTIFY_MSG *msg_list = NULL;
1060 int i, new_slot;
1061
1062 if ( !ctr || !msg )
1063 return 0;
1064
1065 /* loop over all groups looking for a matching printer name */
1066
1067 for ( i=0; i<ctr->num_groups; i++ ) {
1068 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
1069 break;
1070 }
1071
1072 /* add a new group? */
1073
1074 if ( i == ctr->num_groups ) {
1075 ctr->num_groups++;
1076
1077 if ( !(groups = talloc_realloc( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
1078 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
1079 return 0;
1080 }
1081 ctr->msg_groups = groups;
1082
1083 /* clear the new entry and set the printer name */
1084
1085 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
1086 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
1087 }
1088
1089 /* add the change messages; 'i' is the correct index now regardless */
1090
1091 msg_grp = &ctr->msg_groups[i];
1092
1093 msg_grp->num_msgs++;
1094
1095 if ( !(msg_list = talloc_realloc( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
1096 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
1097 return 0;
1098 }
1099 msg_grp->msgs = msg_list;
1100
1101 new_slot = msg_grp->num_msgs-1;
1102 memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
1103
1104 /* need to allocate own copy of data */
1105
1106 if ( msg->len != 0 )
1107 msg_grp->msgs[new_slot].notify.data = (char *)
1108 talloc_memdup( ctr->ctx, msg->notify.data, msg->len );
1109
1110 return ctr->num_groups;
1111 }
1112
1113 static void construct_info_data(struct spoolss_Notify *info_data,
1114 enum spoolss_NotifyType type,
1115 uint16_t field, int id);
1116
1117 /***********************************************************************
1118 Send a change notication message on all handles which have a call
1119 back registered
1120 **********************************************************************/
1121
1122 static int build_notify2_messages(TALLOC_CTX *mem_ctx,
1123 struct printer_handle *prn_hnd,
1124 SPOOLSS_NOTIFY_MSG *messages,
1125 uint32_t num_msgs,
1126 struct spoolss_Notify **_notifies,
1127 int *_count)
1128 {
1129 struct spoolss_Notify *notifies;
1130 SPOOLSS_NOTIFY_MSG *msg;
1131 int count = 0;
1132 uint32_t id;
1133 int i;
1134
1135 notifies = talloc_zero_array(mem_ctx,
1136 struct spoolss_Notify, num_msgs);
1137 if (!notifies) {
1138 return ENOMEM;
1139 }
1140
1141 for (i = 0; i < num_msgs; i++) {
1142
1143 msg = &messages[i];
1144
1145 /* Are we monitoring this event? */
1146
1147 if (!is_monitoring_event(prn_hnd, msg->type, msg->field)) {
1148 continue;
1149 }
1150
1151 DEBUG(10, ("Sending message type [0x%x] field [0x%2x] "
1152 "for printer [%s]\n",
1153 msg->type, msg->field, prn_hnd->sharename));
1154
1155 /*
1156 * if the is a printer notification handle and not a job
1157 * notification type, then set the id to 0.
1158 * Otherwise just use what was specified in the message.
1159 *
1160 * When registering change notification on a print server
1161 * handle we always need to send back the id (snum) matching
1162 * the printer for which the change took place.
1163 * For change notify registered on a printer handle,
1164 * this does not matter and the id should be 0.
1165 *
1166 * --jerry
1167 */
1168
1169 if ((msg->type == PRINTER_NOTIFY_TYPE) &&
1170 (prn_hnd->printer_type == SPLHND_PRINTER)) {
1171 id = 0;
1172 } else {
1173 id = msg->id;
1174 }
1175
1176 /* Convert unix jobid to smb jobid */
1177
1178 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1179 id = sysjob_to_jobid(msg->id);
1180
1181 if (id == -1) {
1182 DEBUG(3, ("no such unix jobid %d\n",
1183 msg->id));
1184 continue;
1185 }
1186 }
1187
1188 construct_info_data(&notifies[count],
1189 msg->type, msg->field, id);
1190
1191 switch(msg->type) {
1192 case PRINTER_NOTIFY_TYPE:
1193 if (printer_notify_table[msg->field].fn) {
1194 printer_notify_table[msg->field].fn(msg,
1195 &notifies[count], mem_ctx);
1196 }
1197 break;
1198
1199 case JOB_NOTIFY_TYPE:
1200 if (job_notify_table[msg->field].fn) {
1201 job_notify_table[msg->field].fn(msg,
1202 &notifies[count], mem_ctx);
1203 }
1204 break;
1205
1206 default:
1207 DEBUG(5, ("Unknown notification type %d\n",
1208 msg->type));
1209 continue;
1210 }
1211
1212 count++;
1213 }
1214
1215 *_notifies = notifies;
1216 *_count = count;
1217
1218 return 0;
1219 }
1220
1221 static int send_notify2_printer(TALLOC_CTX *mem_ctx,
1222 struct printer_handle *prn_hnd,
1223 SPOOLSS_NOTIFY_MSG_GROUP *msg_group)
1224 {
1225 struct spoolss_Notify *notifies;
1226 int count = 0;
1227 union spoolss_ReplyPrinterInfo info;
1228 struct spoolss_NotifyInfo info0;
1229 uint32_t reply_result;
1230 NTSTATUS status;
1231 WERROR werr;
1232 int ret;
1233
1234 /* Is there notification on this handle? */
1235 if (prn_hnd->notify.cli_chan == NULL ||
1236 prn_hnd->notify.cli_chan->cli_pipe == NULL ||
1237 prn_hnd->notify.cli_chan->cli_pipe->binding_handle == NULL ||
1238 prn_hnd->notify.cli_chan->active_connections == 0) {
1239 return 0;
1240 }
1241
1242 DEBUG(10, ("Client connected! [\\\\%s\\%s]\n",
1243 prn_hnd->servername, prn_hnd->sharename));
1244
1245 /* For this printer? Print servers always receive notifications. */
1246 if ((prn_hnd->printer_type == SPLHND_PRINTER) &&
1247 (!strequal(msg_group->printername, prn_hnd->sharename))) {
1248 return 0;
1249 }
1250
1251 DEBUG(10,("Our printer\n"));
1252
1253 /* build the array of change notifications */
1254 ret = build_notify2_messages(mem_ctx, prn_hnd,
1255 msg_group->msgs,
1256 msg_group->num_msgs,
1257 &notifies, &count);
1258 if (ret) {
1259 return ret;
1260 }
1261
1262 info0.version = 0x2;
1263 info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1264 info0.count = count;
1265 info0.notifies = notifies;
1266
1267 info.info0 = &info0;
1268
1269 status = dcerpc_spoolss_RouterReplyPrinterEx(
1270 prn_hnd->notify.cli_chan->cli_pipe->binding_handle,
1271 mem_ctx,
1272 &prn_hnd->notify.cli_hnd,
1273 prn_hnd->notify.change, /* color */
1274 prn_hnd->notify.flags,
1275 &reply_result,
1276 0, /* reply_type, must be 0 */
1277 info, &werr);
1278 if (!NT_STATUS_IS_OK(status)) {
1279 DEBUG(1, ("dcerpc_spoolss_RouterReplyPrinterEx to client: %s "
1280 "failed: %s\n",
1281 prn_hnd->notify.cli_chan->cli_pipe->srv_name_slash,
1282 nt_errstr(status)));
1283 werr = ntstatus_to_werror(status);
1284 } else if (!W_ERROR_IS_OK(werr)) {
1285 DEBUG(1, ("RouterReplyPrinterEx to client: %s "
1286 "failed: %s\n",
1287 prn_hnd->notify.cli_chan->cli_pipe->srv_name_slash,
1288 win_errstr(werr)));
1289 }
1290 switch (reply_result) {
1291 case 0:
1292 break;
1293 case PRINTER_NOTIFY_INFO_DISCARDED:
1294 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1295 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1296 break;
1297 default:
1298 break;
1299 }
1300
1301 return 0;
1302 }
1303
1304 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
1305 {
1306 struct printer_handle *p;
1307 TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
1308 SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
1309 int ret;
1310
1311 if ( !msg_group ) {
1312 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
1313 return;
1314 }
1315
1316 if (!msg_group->msgs) {
1317 DEBUG(5, ("send_notify2_changes() called with no messages!\n"));
1318 return;
1319 }
1320
1321 DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
1322
1323 /* loop over all printers */
1324
1325 for (p = printers_list; p; p = p->next) {
1326 ret = send_notify2_printer(mem_ctx, p, msg_group);
1327 if (ret) {
1328 goto done;
1329 }
1330 }
1331
1332 done:
1333 DEBUG(8,("send_notify2_changes: Exit...\n"));
1334 return;
1335 }
1336
1337 /***********************************************************************
1338 **********************************************************************/
1339
1340 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1341 {
1342
1343 uint32_t tv_sec, tv_usec;
1344 size_t offset = 0;
1345
1346 /* Unpack message */
1347
1348 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1349 msg->printer);
1350
1351 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1352 &tv_sec, &tv_usec,
1353 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1354
1355 if (msg->len == 0)
1356 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1357 &msg->notify.value[0], &msg->notify.value[1]);
1358 else
1359 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1360 &msg->len, &msg->notify.data);
1361
1362 DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1363 msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1364
1365 tv->tv_sec = tv_sec;
1366 tv->tv_usec = tv_usec;
1367
1368 if (msg->len == 0)
1369 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1370 msg->notify.value[1]));
1371 else
1372 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1373
1374 return true;
1375 }
1376
1377 /********************************************************************
1378 Receive a notify2 message list
1379 ********************************************************************/
1380
1381 static void receive_notify2_message_list(struct messaging_context *msg,
1382 void *private_data,
1383 uint32_t msg_type,
1384 struct server_id server_id,
1385 DATA_BLOB *data)
1386 {
1387 size_t msg_count, i;
1388 char *buf = (char *)data->data;
1389 char *msg_ptr;
1390 size_t msg_len;
1391 SPOOLSS_NOTIFY_MSG notify;
1392 SPOOLSS_NOTIFY_MSG_CTR messages;
1393 int num_groups;
1394
1395 if (data->length < 4) {
1396 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1397 return;
1398 }
1399
1400 msg_count = IVAL(buf, 0);
1401 msg_ptr = buf + 4;
1402
1403 DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1404
1405 if (msg_count == 0) {
1406 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1407 return;
1408 }
1409
1410 /* initialize the container */
1411
1412 ZERO_STRUCT( messages );
1413 notify_msg_ctr_init( &messages );
1414
1415 /*
1416 * build message groups for each printer identified
1417 * in a change_notify msg. Remember that a PCN message
1418 * includes the handle returned for the srv_spoolss_replyopenprinter()
1419 * call. Therefore messages are grouped according to printer handle.
1420 */
1421
1422 for ( i=0; i<msg_count; i++ ) {
1423 struct timeval msg_tv;
1424
1425 if (msg_ptr + 4 - buf > data->length) {
1426 DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1427 return;
1428 }
1429
1430 msg_len = IVAL(msg_ptr,0);
1431 msg_ptr += 4;
1432
1433 if (msg_ptr + msg_len - buf > data->length) {
1434 DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1435 return;
1436 }
1437
1438 /* unpack messages */
1439
1440 ZERO_STRUCT( notify );
1441 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1442 msg_ptr += msg_len;
1443
1444 /* add to correct list in container */
1445
1446 notify_msg_ctr_addmsg( &messages, &notify );
1447
1448 /* free memory that might have been allocated by notify2_unpack_msg() */
1449
1450 if ( notify.len != 0 )
1451 SAFE_FREE( notify.notify.data );
1452 }
1453
1454 /* process each group of messages */
1455
1456 num_groups = notify_msg_ctr_numgroups( &messages );
1457 for ( i=0; i<num_groups; i++ )
1458 send_notify2_changes( &messages, i );
1459
1460
1461 /* cleanup */
1462
1463 DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1464 (uint32_t)msg_count ));
1465
1466 notify_msg_ctr_destroy( &messages );
1467
1468 return;
1469 }
1470
1471 /********************************************************************
1472 Send a message to ourself about new driver being installed
1473 so we can upgrade the information for each printer bound to this
1474 driver
1475 ********************************************************************/
1476
1477 static bool srv_spoolss_drv_upgrade_printer(const char *drivername,
1478 struct messaging_context *msg_ctx)
1479 {
1480 int len = strlen(drivername);
1481
1482 if (!len)
1483 return false;
1484
1485 DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1486 drivername));
1487
1488 messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
1489 MSG_PRINTER_DRVUPGRADE,
1490 (const uint8_t *)drivername, len+1);
1491
1492 return true;
1493 }
1494
1495 void srv_spoolss_cleanup(void)
1496 {
1497 struct printer_session_counter *session_counter;
1498
1499 for (session_counter = counter_list;
1500 session_counter != NULL;
1501 session_counter = counter_list) {
1502 DLIST_REMOVE(counter_list, session_counter);
1503 TALLOC_FREE(session_counter);
1504 }
1505 }
1506
1507 /**********************************************************************
1508 callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1509 over all printers, upgrading ones as necessary
1510 This is now *ONLY* called inside the background lpq updater. JRA.
1511 **********************************************************************/
1512
1513 void do_drv_upgrade_printer(struct messaging_context *msg,
1514 void *private_data,
1515 uint32_t msg_type,
1516 struct server_id server_id,
1517 DATA_BLOB *data)
1518 {
1519 TALLOC_CTX *tmp_ctx;
1520 const struct auth_session_info *session_info = get_session_info_system();
1521 struct spoolss_PrinterInfo2 *pinfo2;
1522 WERROR result;
1523 const char *drivername;
1524 int snum;
1525 int n_services = lp_numservices();
1526 struct dcerpc_binding_handle *b = NULL;
1527
1528 tmp_ctx = talloc_new(NULL);
1529 if (!tmp_ctx) return;
1530
1531 drivername = talloc_strndup(tmp_ctx, (const char *)data->data, data->length);
1532 if (!drivername) {
1533 DEBUG(0, ("do_drv_upgrade_printer: Out of memoery ?!\n"));
1534 goto done;
1535 }
1536
1537 DEBUG(10, ("do_drv_upgrade_printer: "
1538 "Got message for new driver [%s]\n", drivername));
1539
1540 /* Iterate the printer list */
1541
1542 for (snum = 0; snum < n_services; snum++) {
1543 if (!lp_snum_ok(snum) || !lp_printable(snum)) {
1544 continue;
1545 }
1546
1547 /* ignore [printers] share */
1548 if (strequal(lp_const_servicename(snum), "printers")) {
1549 continue;
1550 }
1551
1552 if (b == NULL) {
1553 result = winreg_printer_binding_handle(tmp_ctx,
1554 session_info,
1555 msg,
1556 &b);
1557 if (!W_ERROR_IS_OK(result)) {
1558 break;
1559 }
1560 }
1561
1562 result = winreg_get_printer(tmp_ctx, b,
1563 lp_const_servicename(snum),
1564 &pinfo2);
1565
1566 if (!W_ERROR_IS_OK(result)) {
1567 continue;
1568 }
1569
1570 if (!pinfo2->drivername) {
1571 continue;
1572 }
1573
1574 if (strcmp(drivername, pinfo2->drivername) != 0) {
1575 continue;
1576 }
1577
1578 DEBUG(6,("Updating printer [%s]\n", pinfo2->printername));
1579
1580 /* all we care about currently is the change_id */
1581 result = winreg_printer_update_changeid(tmp_ctx, b,
1582 pinfo2->printername);
1583
1584 if (!W_ERROR_IS_OK(result)) {
1585 DEBUG(3, ("do_drv_upgrade_printer: "
1586 "Failed to update changeid [%s]\n",
1587 win_errstr(result)));
1588 }
1589 }
1590
1591 /* all done */
1592 done:
1593 talloc_free(tmp_ctx);
1594 }
1595
1596 /********************************************************************
1597 Update the cache for all printq's with a registered client
1598 connection
1599 ********************************************************************/
1600
1601 void update_monitored_printq_cache(struct messaging_context *msg_ctx)
1602 {
1603 struct printer_handle *printer = printers_list;
1604 int snum;
1605
1606 /* loop through all printers and update the cache where
1607 a client is connected */
1608 while (printer) {
1609 if ((printer->printer_type == SPLHND_PRINTER) &&
1610 ((printer->notify.cli_chan != NULL) &&
1611 (printer->notify.cli_chan->active_connections > 0))) {
1612 snum = print_queue_snum(printer->sharename);
1613 print_queue_status(msg_ctx, snum, NULL, NULL);
1614 }
1615
1616 printer = printer->next;
1617 }
1618
1619 return;
1620 }
1621
1622 /****************************************************************
1623 _spoolss_OpenPrinter
1624 ****************************************************************/
1625
1626 WERROR _spoolss_OpenPrinter(struct pipes_struct *p,
1627 struct spoolss_OpenPrinter *r)
1628 {
1629 struct spoolss_OpenPrinterEx e;
1630 struct spoolss_UserLevel1 level1;
1631 WERROR werr;
1632
1633 ZERO_STRUCT(level1);
1634
1635 e.in.printername = r->in.printername;
1636 e.in.datatype = r->in.datatype;
1637 e.in.devmode_ctr = r->in.devmode_ctr;
1638 e.in.access_mask = r->in.access_mask;
1639 e.in.userlevel_ctr.level = 1;
1640 e.in.userlevel_ctr.user_info.level1 = &level1;
1641
1642 e.out.handle = r->out.handle;
1643
1644 werr = _spoolss_OpenPrinterEx(p, &e);
1645
1646 if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1647 /* OpenPrinterEx returns this for a bad
1648 * printer name. We must return WERR_INVALID_PRINTER_NAME
1649 * instead.
1650 */
1651 werr = WERR_INVALID_PRINTER_NAME;
1652 }
1653
1654 return werr;
1655 }
1656
1657 static WERROR copy_devicemode(TALLOC_CTX *mem_ctx,
1658 struct spoolss_DeviceMode *orig,
1659 struct spoolss_DeviceMode **dest)
1660 {
1661 struct spoolss_DeviceMode *dm;
1662
1663 dm = talloc(mem_ctx, struct spoolss_DeviceMode);
1664 if (!dm) {
1665 return WERR_NOMEM;
1666 }
1667
1668 /* copy all values, then duplicate strings and structs */
1669 *dm = *orig;
1670
1671 dm->devicename = talloc_strdup(dm, orig->devicename);
1672 if (!dm->devicename) {
1673 return WERR_NOMEM;
1674 }
1675 dm->formname = talloc_strdup(dm, orig->formname);
1676 if (!dm->formname) {
1677 return WERR_NOMEM;
1678 }
1679 if (orig->driverextra_data.data) {
1680 dm->driverextra_data.data =
1681 (uint8_t *) talloc_memdup(dm, orig->driverextra_data.data,
1682 orig->driverextra_data.length);
1683 if (!dm->driverextra_data.data) {
1684 return WERR_NOMEM;
1685 }
1686 }
1687
1688 *dest = dm;
1689 return WERR_OK;
1690 }
1691
1692 /****************************************************************
1693 _spoolss_OpenPrinterEx
1694 ****************************************************************/
1695
1696 WERROR _spoolss_OpenPrinterEx(struct pipes_struct *p,
1697 struct spoolss_OpenPrinterEx *r)
1698 {
1699 int snum;
1700 char *raddr;
1701 char *rhost;
1702 struct printer_handle *Printer=NULL;
1703 WERROR result;
1704 int rc;
1705
1706 if (!r->in.printername) {
1707 return WERR_INVALID_PARAM;
1708 }
1709
1710 if (!*r->in.printername) {
1711 return WERR_INVALID_PARAM;
1712 }
1713
1714 if (r->in.userlevel_ctr.level > 3) {
1715 return WERR_INVALID_PARAM;
1716 }
1717 if ((r->in.userlevel_ctr.level == 1 && !r->in.userlevel_ctr.user_info.level1) ||
1718 (r->in.userlevel_ctr.level == 2 && !r->in.userlevel_ctr.user_info.level2) ||
1719 (r->in.userlevel_ctr.level == 3 && !r->in.userlevel_ctr.user_info.level3)) {
1720 return WERR_INVALID_PARAM;
1721 }
1722
1723 /*
1724 * The printcap printer share inventory is updated on client
1725 * enumeration. For clients that do not perform enumeration prior to
1726 * access, such as cupssmbadd, we reinitialise the printer share
1727 * inventory on open as well.
1728 */
1729 become_root();
1730 delete_and_reload_printers(server_event_context(), p->msg_ctx);
1731 unbecome_root();
1732
1733 /* some sanity check because you can open a printer or a print server */
1734 /* aka: \\server\printer or \\server */
1735
1736 DEBUGADD(3,("checking name: %s\n", r->in.printername));
1737
1738 result = open_printer_hnd(p, r->out.handle, r->in.printername, 0);
1739 if (!W_ERROR_IS_OK(result)) {
1740 DEBUG(3,("_spoolss_OpenPrinterEx: Cannot open a printer handle "
1741 "for printer %s\n", r->in.printername));
1742 ZERO_STRUCTP(r->out.handle);
1743 return result;
1744 }
1745
1746 Printer = find_printer_index_by_hnd(p, r->out.handle);
1747 if ( !Printer ) {
1748 DEBUG(0,("_spoolss_OpenPrinterEx: logic error. Can't find printer "
1749 "handle we created for printer %s\n", r->in.printername));
1750 close_printer_handle(p, r->out.handle);
1751 ZERO_STRUCTP(r->out.handle);
1752 return WERR_INVALID_PARAM;
1753 }
1754
1755 /*
1756 * First case: the user is opening the print server:
1757 *
1758 * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1759 * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1760 *
1761 * Then both Win2k and WinNT clients try an OpenPrinterEx with
1762 * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1763 * or if the user is listed in the smb.conf printer admin parameter.
1764 *
1765 * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1766 * client view printer folder, but does not show the MSAPW.
1767 *
1768 * Note: this test needs code to check access rights here too. Jeremy
1769 * could you look at this?
1770 *
1771 * Second case: the user is opening a printer:
1772 * NT doesn't let us connect to a printer if the connecting user
1773 * doesn't have print permission.
1774 *
1775 * Third case: user is opening a Port Monitor
1776 * access checks same as opening a handle to the print server.
1777 */
1778
1779 switch (Printer->printer_type )
1780 {
1781 case SPLHND_SERVER:
1782 case SPLHND_PORTMON_TCP:
1783 case SPLHND_PORTMON_LOCAL:
1784 /* Printserver handles use global struct... */
1785
1786 snum = -1;
1787
1788 /* Map standard access rights to object specific access rights */
1789
1790 se_map_standard(&r->in.access_mask,
1791 &printserver_std_mapping);
1792
1793 /* Deny any object specific bits that don't apply to print
1794 servers (i.e printer and job specific bits) */
1795
1796 r->in.access_mask &= SEC_MASK_SPECIFIC;
1797
1798 if (r->in.access_mask &
1799 ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1800 DEBUG(3, ("access DENIED for non-printserver bits\n"));
1801 close_printer_handle(p, r->out.handle);
1802 ZERO_STRUCTP(r->out.handle);
1803 return WERR_ACCESS_DENIED;
1804 }
1805
1806 /* Allow admin access */
1807
1808 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1809 {
1810 if (!lp_show_add_printer_wizard()) {
1811 close_printer_handle(p, r->out.handle);
1812 ZERO_STRUCTP(r->out.handle);
1813 return WERR_ACCESS_DENIED;
1814 }
1815
1816 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1817 and not a printer admin, then fail */
1818
1819 if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
1820 !security_token_has_privilege(p->session_info->security_token, SEC_PRIV_PRINT_OPERATOR) &&
1821 !nt_token_check_sid(&global_sid_Builtin_Print_Operators,
1822 p->session_info->security_token)) {
1823 close_printer_handle(p, r->out.handle);
1824 ZERO_STRUCTP(r->out.handle);
1825 DEBUG(3,("access DENIED as user is not root, "
1826 "has no printoperator privilege, "
1827 "not a member of the printoperator builtin group and "
1828 "is not in printer admin list"));
1829 return WERR_ACCESS_DENIED;
1830 }
1831
1832 r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1833 }
1834 else
1835 {
1836 r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1837 }
1838
1839 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1840 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1841
1842 /* We fall through to return WERR_OK */
1843 break;
1844
1845 case SPLHND_PRINTER:
1846 /* NT doesn't let us connect to a printer if the connecting user
1847 doesn't have print permission. */
1848
1849 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1850 close_printer_handle(p, r->out.handle);
1851 ZERO_STRUCTP(r->out.handle);
1852 return WERR_BADFID;
1853 }
1854
1855 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1856 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1857 }
1858
1859 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1860
1861 /* map an empty access mask to the minimum access mask */
1862 if (r->in.access_mask == 0x0)
1863 r->in.access_mask = PRINTER_ACCESS_USE;
1864
1865 /*
1866 * If we are not serving the printer driver for this printer,
1867 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1868 * will keep NT clients happy --jerry
1869 */
1870
1871 if (lp_use_client_driver(snum)
1872 && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1873 {
1874 r->in.access_mask = PRINTER_ACCESS_USE;
1875 }
1876
1877 /* check smb.conf parameters and the the sec_desc */
1878 raddr = tsocket_address_inet_addr_string(p->remote_address,
1879 p->mem_ctx);
1880 if (raddr == NULL) {
1881 return WERR_NOMEM;
1882 }
1883
1884 rc = get_remote_hostname(p->remote_address,
1885 &rhost,
1886 p->mem_ctx);
1887 if (rc < 0) {
1888 return WERR_NOMEM;
1889 }
1890 if (strequal(rhost, "UNKNOWN")) {
1891 rhost = raddr;
1892 }
1893
1894 if (!allow_access(lp_hosts_deny(snum), lp_hosts_allow(snum),
1895 rhost, raddr)) {
1896 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1897 ZERO_STRUCTP(r->out.handle);
1898 return WERR_ACCESS_DENIED;
1899 }
1900
1901 if (!user_ok_token(uidtoname(p->session_info->unix_token->uid), NULL,
1902 p->session_info->security_token, snum) ||
1903 !W_ERROR_IS_OK(print_access_check(p->session_info,
1904 p->msg_ctx,
1905 snum,
1906 r->in.access_mask))) {
1907 DEBUG(3, ("access DENIED for printer open\n"));
1908 close_printer_handle(p, r->out.handle);
1909 ZERO_STRUCTP(r->out.handle);
1910 return WERR_ACCESS_DENIED;
1911 }
1912
1913 if ((r->in.access_mask & SEC_MASK_SPECIFIC)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1914 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1915 close_printer_handle(p, r->out.handle);
1916 ZERO_STRUCTP(r->out.handle);
1917 return WERR_ACCESS_DENIED;
1918 }
1919
1920 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1921 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1922 else
1923 r->in.access_mask = PRINTER_ACCESS_USE;
1924
1925 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1926 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1927
1928 winreg_create_printer_internal(p->mem_ctx,
1929 get_session_info_system(),
1930 p->msg_ctx,
1931 lp_const_servicename(snum));
1932
1933 break;
1934
1935 default:
1936 /* sanity check to prevent programmer error */
1937 ZERO_STRUCTP(r->out.handle);
1938 return WERR_BADFID;
1939 }
1940
1941 Printer->access_granted = r->in.access_mask;
1942
1943 /*
1944 * If the client sent a devmode in the OpenPrinter() call, then
1945 * save it here in case we get a job submission on this handle
1946 */
1947
1948 if ((Printer->printer_type != SPLHND_SERVER)
1949 && (r->in.devmode_ctr.devmode != NULL)) {
1950 copy_devicemode(NULL, r->in.devmode_ctr.devmode,
1951 &Printer->devmode);
1952 }
1953
1954 return WERR_OK;
1955 }
1956
1957 /****************************************************************
1958 _spoolss_ClosePrinter
1959 ****************************************************************/
1960
1961 WERROR _spoolss_ClosePrinter(struct pipes_struct *p,
1962 struct spoolss_ClosePrinter *r)
1963 {
1964 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
1965
1966 if (Printer && Printer->document_started) {
1967 struct spoolss_EndDocPrinter e;
1968
1969 e.in.handle = r->in.handle;
1970
1971 _spoolss_EndDocPrinter(p, &e);
1972 }
1973
1974 if (!close_printer_handle(p, r->in.handle))
1975 return WERR_BADFID;
1976
1977 /* clear the returned printer handle. Observed behavior
1978 from Win2k server. Don't think this really matters.
1979 Previous code just copied the value of the closed
1980 handle. --jerry */
1981
1982 ZERO_STRUCTP(r->out.handle);
1983
1984 return WERR_OK;
1985 }
1986
1987 /****************************************************************
1988 _spoolss_DeletePrinter
1989 ****************************************************************/
1990
1991 WERROR _spoolss_DeletePrinter(struct pipes_struct *p,
1992 struct spoolss_DeletePrinter *r)
1993 {
1994 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
1995 WERROR result;
1996 int snum;
1997
1998 if (Printer && Printer->document_started) {
1999 struct spoolss_EndDocPrinter e;
2000
2001 e.in.handle = r->in.handle;
2002
2003 _spoolss_EndDocPrinter(p, &e);
2004 }
2005
2006 if (get_printer_snum(p, r->in.handle, &snum, NULL)) {
2007 winreg_delete_printer_key_internal(p->mem_ctx,
2008 get_session_info_system(),
2009 p->msg_ctx,
2010 lp_const_servicename(snum),
2011 "");
2012 }
2013
2014 result = delete_printer_handle(p, r->in.handle);
2015
2016 return result;
2017 }
2018
2019 /*******************************************************************
2020 * static function to lookup the version id corresponding to an
2021 * long architecture string
2022 ******************************************************************/
2023
2024 static const struct print_architecture_table_node archi_table[]= {
2025
2026 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
2027 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
2028 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
2029 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
2030 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
2031 {"Windows IA64", SPL_ARCH_IA64, 3 },
2032 {"Windows x64", SPL_ARCH_X64, 3 },
2033 {NULL, "", -1 }
2034 };
2035
2036 static const int drv_cversion[] = {SPOOLSS_DRIVER_VERSION_9X,
2037 SPOOLSS_DRIVER_VERSION_NT35,
2038 SPOOLSS_DRIVER_VERSION_NT4,
2039 SPOOLSS_DRIVER_VERSION_200X,
2040 -1};
2041
2042 static int get_version_id(const char *arch)
2043 {
2044 int i;
2045
2046 for (i=0; archi_table[i].long_archi != NULL; i++)
2047 {
2048 if (strcmp(arch, archi_table[i].long_archi) == 0)
2049 return (archi_table[i].version);
2050 }
2051
2052 return -1;
2053 }
2054
2055 /****************************************************************
2056 _spoolss_DeletePrinterDriver
2057 ****************************************************************/
2058
2059 WERROR _spoolss_DeletePrinterDriver(struct pipes_struct *p,
2060 struct spoolss_DeletePrinterDriver *r)
2061 {
2062
2063 struct spoolss_DriverInfo8 *info = NULL;
2064 int version;
2065 WERROR status;
2066 struct dcerpc_binding_handle *b;
2067 TALLOC_CTX *tmp_ctx = NULL;
2068 int i;
2069 bool found;
2070
2071 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2072 and not a printer admin, then fail */
2073
2074 if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
2075 !security_token_has_privilege(p->session_info->security_token,
2076 SEC_PRIV_PRINT_OPERATOR)) {
2077 return WERR_ACCESS_DENIED;
2078 }
2079
2080 /* check that we have a valid driver name first */
2081
2082 if ((version = get_version_id(r->in.architecture)) == -1) {
2083 return WERR_INVALID_ENVIRONMENT;
2084 }
2085
2086 tmp_ctx = talloc_new(p->mem_ctx);
2087 if (!tmp_ctx) {
2088 return WERR_NOMEM;
2089 }
2090
2091 status = winreg_printer_binding_handle(tmp_ctx,
2092 get_session_info_system(),
2093 p->msg_ctx,
2094 &b);
2095 if (!W_ERROR_IS_OK(status)) {
2096 goto done;
2097 }
2098
2099 for (found = false, i = 0; drv_cversion[i] >= 0; i++) {
2100 status = winreg_get_driver(tmp_ctx, b,
2101 r->in.architecture, r->in.driver,
2102 drv_cversion[i], &info);
2103 if (!W_ERROR_IS_OK(status)) {
2104 DEBUG(5, ("skipping del of driver with version %d\n",
2105 drv_cversion[i]));
2106 continue;
2107 }
2108 found = true;
2109
2110 if (printer_driver_in_use(tmp_ctx, b, info)) {
2111 status = WERR_PRINTER_DRIVER_IN_USE;
2112 goto done;
2113 }
2114
2115 status = winreg_del_driver(tmp_ctx, b, info, drv_cversion[i]);
2116 if (!W_ERROR_IS_OK(status)) {
2117 DEBUG(0, ("failed del of driver with version %d\n",
2118 drv_cversion[i]));
2119 goto done;
2120 }
2121 }
2122 if (found == false) {
2123 DEBUG(0, ("driver %s not found for deletion\n", r->in.driver));
2124 status = WERR_UNKNOWN_PRINTER_DRIVER;
2125 } else {
2126 status = WERR_OK;
2127 }
2128
2129 done:
2130 talloc_free(tmp_ctx);
2131
2132 return status;
2133 }
2134
2135 static WERROR spoolss_dpd_version(TALLOC_CTX *mem_ctx,
2136 struct pipes_struct *p,
2137 struct spoolss_DeletePrinterDriverEx *r,
2138 struct dcerpc_binding_handle *b,
2139 struct spoolss_DriverInfo8 *info)
2140 {
2141 WERROR status;
2142 bool delete_files;
2143
2144 if (printer_driver_in_use(mem_ctx, b, info)) {
2145 status = WERR_PRINTER_DRIVER_IN_USE;
2146 goto done;
2147 }
2148
2149 /*
2150 * we have a couple of cases to consider.
2151 * (1) Are any files in use? If so and DPD_DELETE_ALL_FILES is set,
2152 * then the delete should fail if **any** files overlap with
2153 * other drivers
2154 * (2) If DPD_DELETE_UNUSED_FILES is set, then delete all
2155 * non-overlapping files
2156 * (3) If neither DPD_DELETE_ALL_FILES nor DPD_DELETE_UNUSED_FILES
2157 * are set, then do not delete any files
2158 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2159 */
2160
2161 delete_files = r->in.delete_flags
2162 & (DPD_DELETE_ALL_FILES | DPD_DELETE_UNUSED_FILES);
2163
2164
2165 if (delete_files) {
2166 bool in_use = printer_driver_files_in_use(mem_ctx, b, info);
2167 if (in_use && (r->in.delete_flags & DPD_DELETE_ALL_FILES)) {
2168 status = WERR_PRINTER_DRIVER_IN_USE;
2169 goto done;
2170 }
2171 /*
2172 * printer_driver_files_in_use() has trimmed overlapping files
2173 * from info so they are not removed on DPD_DELETE_UNUSED_FILES
2174 */
2175 }
2176
2177
2178 status = winreg_del_driver(mem_ctx, b, info, info->version);
2179 if (!W_ERROR_IS_OK(status)) {
2180 goto done;
2181 }
2182
2183 /*
2184 * now delete any associated files if delete_files is
2185 * true. Even if this part failes, we return succes
2186 * because the driver doesn not exist any more
2187 */
2188 if (delete_files) {
2189 delete_driver_files(p->session_info, info);
2190 }
2191
2192 done:
2193 return status;
2194 }
2195
2196 /****************************************************************
2197 _spoolss_DeletePrinterDriverEx
2198 ****************************************************************/
2199
2200 WERROR _spoolss_DeletePrinterDriverEx(struct pipes_struct *p,
2201 struct spoolss_DeletePrinterDriverEx *r)
2202 {
2203 struct spoolss_DriverInfo8 *info = NULL;
2204 WERROR status;
2205 struct dcerpc_binding_handle *b;
2206 TALLOC_CTX *tmp_ctx = NULL;
2207 int i;
2208 bool found;
2209
2210 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2211 and not a printer admin, then fail */
2212
2213 if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
2214 !security_token_has_privilege(p->session_info->security_token,
2215 SEC_PRIV_PRINT_OPERATOR)) {
2216 return WERR_ACCESS_DENIED;
2217 }
2218
2219 /* check that we have a valid driver name first */
2220 if (get_version_id(r->in.architecture) == -1) {
2221 /* this is what NT returns */
2222 return WERR_INVALID_ENVIRONMENT;
2223 }
2224
2225 tmp_ctx = talloc_new(p->mem_ctx);
2226 if (!tmp_ctx) {
2227 return WERR_NOMEM;
2228 }
2229
2230 status = winreg_printer_binding_handle(tmp_ctx,
2231 get_session_info_system(),
2232 p->msg_ctx,
2233 &b);
2234 if (!W_ERROR_IS_OK(status)) {
2235 goto done;
2236 }
2237
2238 for (found = false, i = 0; drv_cversion[i] >= 0; i++) {
2239 if ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2240 && (drv_cversion[i] != r->in.version)) {
2241 continue;
2242 }
2243
2244 /* check if a driver with this version exists before delete */
2245 status = winreg_get_driver(tmp_ctx, b,
2246 r->in.architecture, r->in.driver,
2247 drv_cversion[i], &info);
2248 if (!W_ERROR_IS_OK(status)) {
2249 DEBUG(5, ("skipping del of driver with version %d\n",
2250 drv_cversion[i]));
2251 continue;
2252 }
2253 found = true;
2254
2255 status = spoolss_dpd_version(tmp_ctx, p, r, b, info);
2256 if (!W_ERROR_IS_OK(status)) {
2257 DEBUG(0, ("failed to delete driver with version %d\n",
2258 drv_cversion[i]));
2259 goto done;
2260 }
2261 }
2262 if (found == false) {
2263 DEBUG(0, ("driver %s not found for deletion\n", r->in.driver));
2264 status = WERR_UNKNOWN_PRINTER_DRIVER;
2265 } else {
2266 status = WERR_OK;
2267 }
2268
2269 done:
2270 talloc_free(tmp_ctx);
2271 return status;
2272 }
2273
2274
2275 /********************************************************************
2276 GetPrinterData on a printer server Handle.
2277 ********************************************************************/
2278
2279 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2280 const char *value,
2281 enum winreg_Type *type,
2282 union spoolss_PrinterData *data)
2283 {
2284 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2285
2286 if (!strcasecmp_m(value, "W3SvcInstalled")) {
2287 *type = REG_DWORD;
2288 SIVAL(&data->value, 0, 0x00);
2289 return WERR_OK;
2290 }
2291
2292 if (!strcasecmp_m(value, "BeepEnabled")) {
2293 *type = REG_DWORD;
2294 SIVAL(&data->value, 0, 0x00);
2295 return WERR_OK;
2296 }
2297
2298 if (!strcasecmp_m(value, "EventLog")) {
2299 *type = REG_DWORD;
2300 /* formally was 0x1b */
2301 SIVAL(&data->value, 0, 0x00);
2302 return WERR_OK;
2303 }
2304
2305 if (!strcasecmp_m(value, "NetPopup")) {
2306 *type = REG_DWORD;
2307 SIVAL(&data->value, 0, 0x00);
2308 return WERR_OK;
2309 }
2310
2311 if (!strcasecmp_m(value, "MajorVersion")) {
2312 *type = REG_DWORD;
2313
2314 /* Windows NT 4.0 seems to not allow uploading of drivers
2315 to a server that reports 0x3 as the MajorVersion.
2316 need to investigate more how Win2k gets around this .
2317 -- jerry */
2318
2319 if (RA_WINNT == get_remote_arch()) {
2320 SIVAL(&data->value, 0, 0x02);
2321 } else {
2322 SIVAL(&data->value, 0, 0x03);
2323 }
2324
2325 return WERR_OK;
2326 }
2327
2328 if (!strcasecmp_m(value, "MinorVersion")) {
2329 *type = REG_DWORD;
2330 SIVAL(&data->value, 0, 0x00);
2331 return WERR_OK;
2332 }
2333
2334 /* REG_BINARY
2335 * uint32_t size = 0x114
2336 * uint32_t major = 5
2337 * uint32_t minor = [0|1]
2338 * uint32_t build = [2195|2600]
2339 * extra unicode string = e.g. "Service Pack 3"
2340 */
2341 if (!strcasecmp_m(value, "OSVersion")) {
2342 DATA_BLOB blob;
2343 enum ndr_err_code ndr_err;
2344 struct spoolss_OSVersion os;
2345
2346 os.major = lp_parm_int(GLOBAL_SECTION_SNUM,
2347 "spoolss", "os_major", 5);
2348 /* Windows 2000 == 5.0 */
2349 os.minor = lp_parm_int(GLOBAL_SECTION_SNUM,
2350 "spoolss", "os_minor", 0);
2351 os.build = lp_parm_int(GLOBAL_SECTION_SNUM,
2352 "spoolss", "os_build", 2195);
2353 os.extra_string = ""; /* leave extra string empty */
2354
2355 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &os,
2356 (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2357 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2358 return WERR_GENERAL_FAILURE;
2359 }
2360
2361 if (DEBUGLEVEL >= 10) {
2362 NDR_PRINT_DEBUG(spoolss_OSVersion, &os);
2363 }
2364
2365 *type = REG_BINARY;
2366 data->binary = blob;
2367
2368 return WERR_OK;
2369 }
2370
2371
2372 if (!strcasecmp_m(value, "DefaultSpoolDirectory")) {
2373 *type = REG_SZ;
2374
2375 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2376 W_ERROR_HAVE_NO_MEMORY(data->string);
2377
2378 return WERR_OK;
2379 }
2380
2381 if (!strcasecmp_m(value, "Architecture")) {
2382 *type = REG_SZ;
2383 data->string = talloc_strdup(mem_ctx,
2384 lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", SPOOLSS_ARCHITECTURE_NT_X86));
2385 W_ERROR_HAVE_NO_MEMORY(data->string);
2386
2387 return WERR_OK;
2388 }
2389
2390 if (!strcasecmp_m(value, "DsPresent")) {
2391 *type = REG_DWORD;
2392
2393 /* only show the publish check box if we are a
2394 member of a AD domain */
2395
2396 if (lp_security() == SEC_ADS) {
2397 SIVAL(&data->value, 0, 0x01);
2398 } else {
2399 SIVAL(&data->value, 0, 0x00);
2400 }
2401 return WERR_OK;
2402 }
2403
2404 if (!strcasecmp_m(value, "DNSMachineName")) {
2405 const char *hostname = get_mydnsfullname();
2406
2407 if (!hostname) {
2408 return WERR_BADFILE;
2409 }
2410
2411 *type = REG_SZ;
2412 data->string = talloc_strdup(mem_ctx, hostname);
2413 W_ERROR_HAVE_NO_MEMORY(data->string);
2414
2415 return WERR_OK;
2416 }
2417
2418 *type = REG_NONE;
2419
2420 return WERR_INVALID_PARAM;
2421 }
2422
2423 /****************************************************************
2424 _spoolss_GetPrinterData
2425 ****************************************************************/
2426
2427 WERROR _spoolss_GetPrinterData(struct pipes_struct *p,
2428 struct spoolss_GetPrinterData *r)
2429 {
2430 struct spoolss_GetPrinterDataEx r2;
2431
2432 r2.in.handle = r->in.handle;
2433 r2.in.key_name = "PrinterDriverData";
2434 r2.in.value_name = r->in.value_name;
2435 r2.in.offered = r->in.offered;
2436 r2.out.type = r->out.type;
2437 r2.out.data = r->out.data;
2438 r2.out.needed = r->out.needed;
2439
2440 return _spoolss_GetPrinterDataEx(p, &r2);
2441 }
2442
2443 /*********************************************************
2444 Connect to the client machine.
2445 **********************************************************/
2446
2447 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe, struct cli_state **pp_cli,
2448 struct sockaddr_storage *client_ss, const char *remote_machine)
2449 {
2450 NTSTATUS ret;
2451 struct sockaddr_storage rm_addr;
2452 char addr[INET6_ADDRSTRLEN];
2453
2454 if ( is_zero_addr(client_ss) ) {
2455 DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
2456 remote_machine));
2457 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2458 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2459 return false;
2460 }
2461 print_sockaddr(addr, sizeof(addr), &rm_addr);
2462 } else {
2463 rm_addr = *client_ss;
2464 print_sockaddr(addr, sizeof(addr), &rm_addr);
2465 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2466 addr));
2467 }
2468
2469 if (ismyaddr((struct sockaddr *)(void *)&rm_addr)) {
2470 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
2471 addr));
2472 return false;
2473 }
2474
2475 /* setup the connection */
2476 ret = cli_full_connection( pp_cli, lp_netbios_name(), remote_machine,
2477 &rm_addr, 0, "IPC$", "IPC",
2478 "", /* username */
2479 "", /* domain */
2480 "", /* password */
2481 0, lp_client_signing());
2482
2483 if ( !NT_STATUS_IS_OK( ret ) ) {
2484 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2485 remote_machine ));
2486 return false;
2487 }
2488
2489 if ( smbXcli_conn_protocol((*pp_cli)->conn) != PROTOCOL_NT1 ) {
2490 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2491 cli_shutdown(*pp_cli);
2492 return false;
2493 }
2494
2495 /*
2496 * Ok - we have an anonymous connection to the IPC$ share.
2497 * Now start the NT Domain stuff :-).
2498 */
2499
2500 ret = cli_rpc_pipe_open_noauth(*pp_cli, &ndr_table_spoolss, pp_pipe);
2501 if (!NT_STATUS_IS_OK(ret)) {
2502 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2503 remote_machine, nt_errstr(ret)));
2504 cli_shutdown(*pp_cli);
2505 return false;
2506 }
2507
2508 return true;
2509 }
2510
2511 /***************************************************************************
2512 Connect to the client.
2513 ****************************************************************************/
2514
2515 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2516 uint32_t localprinter,
2517 enum winreg_Type type,
2518 struct policy_handle *handle,
2519 struct notify_back_channel **_chan,
2520 struct sockaddr_storage *client_ss,
2521 struct messaging_context *msg_ctx)
2522 {
2523 WERROR result;
2524 NTSTATUS status;
2525 struct notify_back_channel *chan;
2526
2527 for (chan = back_channels; chan; chan = chan->next) {
2528 if (memcmp(&chan->client_address, client_ss,
2529 sizeof(struct sockaddr_storage)) == 0) {
2530 break;
2531 }
2532 }
2533
2534 /*
2535 * If it's the first connection, contact the client
2536 * and connect to the IPC$ share anonymously
2537 */
2538 if (!chan) {
2539 fstring unix_printer;
2540
2541 /* the +2 is to strip the leading 2 backslashs */
2542 fstrcpy(unix_printer, printer + 2);
2543
2544 chan = talloc_zero(NULL, struct notify_back_channel);
2545 if (!chan) {
2546 return false;
2547 }
2548 chan->client_address = *client_ss;
2549
2550 if (!spoolss_connect_to_client(&chan->cli_pipe, &chan->cli, client_ss, unix_printer)) {
2551 TALLOC_FREE(chan);
2552 return false;
2553 }
2554
2555 DLIST_ADD(back_channels, chan);
2556
2557 messaging_register(msg_ctx, NULL, MSG_PRINTER_NOTIFY2,
2558 receive_notify2_message_list);
2559 }
2560
2561 if (chan->cli_pipe == NULL ||
2562 chan->cli_pipe->binding_handle == NULL) {
2563 DEBUG(0, ("srv_spoolss_replyopenprinter: error - "
2564 "NULL %s for printer %s\n",
2565 chan->cli_pipe == NULL ?
2566 "chan->cli_pipe" : "chan->cli_pipe->binding_handle",
2567 printer));
2568 return false;
2569 }
2570
2571 /*
2572 * Tell the specific printing tdb we want messages for this printer
2573 * by registering our PID.
2574 */
2575
2576 if (!print_notify_register_pid(snum)) {
2577 DEBUG(0, ("Failed to register our pid for printer %s\n",
2578 printer));
2579 }
2580
2581 status = dcerpc_spoolss_ReplyOpenPrinter(chan->cli_pipe->binding_handle,
2582 talloc_tos(),
2583 printer,
2584 localprinter,
2585 type,
2586 0,
2587 NULL,
2588 handle,
2589 &result);
2590 if (!NT_STATUS_IS_OK(status)) {
2591 DEBUG(5, ("dcerpc_spoolss_ReplyOpenPrinter returned [%s]\n", nt_errstr(status)));
2592 result = ntstatus_to_werror(status);
2593 } else if (!W_ERROR_IS_OK(result)) {
2594 DEBUG(5, ("ReplyOpenPrinter returned [%s]\n", win_errstr(result)));
2595 }
2596
2597 chan->active_connections++;
2598 *_chan = chan;
2599
2600 return (W_ERROR_IS_OK(result));
2601 }
2602
2603 /****************************************************************
2604 ****************************************************************/
2605
2606 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2607 const struct spoolss_NotifyOption *r)
2608 {
2609 struct spoolss_NotifyOption *option;
2610 uint32_t i,k;
2611
2612 if (!r) {
2613 return NULL;
2614 }
2615
2616 option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2617 if (!option) {
2618 return NULL;
2619 }
2620
2621 *option = *r;
2622
2623 if (!option->count) {
2624 return option;
2625 }
2626
2627 option->types = talloc_zero_array(option,
2628 struct spoolss_NotifyOptionType, option->count);
2629 if (!option->types) {
2630 talloc_free(option);
2631 return NULL;
2632 }
2633
2634 for (i=0; i < option->count; i++) {
2635 option->types[i] = r->types[i];
2636
2637 if (option->types[i].count) {
2638 option->types[i].fields = talloc_zero_array(option,
2639 union spoolss_Field, option->types[i].count);
2640 if (!option->types[i].fields) {
2641 talloc_free(option);
2642 return NULL;
2643 }
2644 for (k=0; k<option->types[i].count; k++) {
2645 option->types[i].fields[k] =
2646 r->types[i].fields[k];
2647 }
2648 }
2649 }
2650
2651 return option;
2652 }
2653
2654 /****************************************************************
2655 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2656 *
2657 * before replying OK: status=0 a rpc call is made to the workstation
2658 * asking ReplyOpenPrinter
2659 *
2660 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2661 * called from api_spoolss_rffpcnex
2662 ****************************************************************/
2663
2664 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct pipes_struct *p,
2665 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2666 {
2667 int snum = -1;
2668 struct spoolss_NotifyOption *option = r->in.notify_options;
2669 struct sockaddr_storage client_ss;
2670 ssize_t client_len;
2671
2672 /* store the notify value in the printer struct */
2673
2674 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
2675
2676 if (!Printer) {
2677 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2678 "Invalid handle (%s:%u:%u).\n",
2679 OUR_HANDLE(r->in.handle)));
2680 return WERR_BADFID;
2681 }
2682
2683 Printer->notify.flags = r->in.flags;
2684 Printer->notify.options = r->in.options;
2685 Printer->notify.printerlocal = r->in.printer_local;
2686 Printer->notify.msg_ctx = p->msg_ctx;
2687
2688 TALLOC_FREE(Printer->notify.option);
2689 Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2690
2691 fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2692
2693 /* Connect to the client machine and send a ReplyOpenPrinter */
2694
2695 if ( Printer->printer_type == SPLHND_SERVER)
2696 snum = -1;
2697 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2698 !get_printer_snum(p, r->in.handle, &snum, NULL) )
2699 return WERR_BADFID;
2700
2701 DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2702 "remote_address is %s\n",
2703 tsocket_address_string(p->remote_address, p->mem_ctx)));
2704
2705 if (!lp_print_notify_backchannel(snum)) {
2706 DEBUG(10, ("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2707 "backchannel disabled\n"));
2708 return WERR_SERVER_UNAVAILABLE;
2709 }
2710
2711 client_len = tsocket_address_bsd_sockaddr(p->remote_address,
2712 (struct sockaddr *) &client_ss,
2713 sizeof(struct sockaddr_storage));
2714 if (client_len < 0) {
2715 return WERR_NOMEM;
2716 }
2717
2718 if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2719 Printer->notify.printerlocal, REG_SZ,
2720 &Printer->notify.cli_hnd,
2721 &Printer->notify.cli_chan,
2722 &client_ss, p->msg_ctx)) {
2723 return WERR_SERVER_UNAVAILABLE;
2724 }
2725
2726 return WERR_OK;
2727 }
2728
2729 /*******************************************************************
2730 * fill a notify_info_data with the servername
2731 ********************************************************************/
2732
2733 static void spoolss_notify_server_name(struct messaging_context *msg_ctx,
2734 int snum,
2735 struct spoolss_Notify *data,
2736 print_queue_struct *queue,
2737 struct spoolss_PrinterInfo2 *pinfo2,
2738 TALLOC_CTX *mem_ctx)
2739 {
2740 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->servername);
2741 }
2742
2743 /*******************************************************************
2744 * fill a notify_info_data with the printername (not including the servername).
2745 ********************************************************************/
2746
2747 static void spoolss_notify_printer_name(struct messaging_context *msg_ctx,
2748 int snum,
2749 struct spoolss_Notify *data,
2750 print_queue_struct *queue,
2751 struct spoolss_PrinterInfo2 *pinfo2,
2752 TALLOC_CTX *mem_ctx)
2753 {
2754 /* the notify name should not contain the \\server\ part */
2755 const char *p = strrchr(pinfo2->printername, '\\');
2756
2757 if (!p) {
2758 p = pinfo2->printername;
2759 } else {
2760 p++;
2761 }
2762
2763 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2764 }
2765
2766 /*******************************************************************
2767 * fill a notify_info_data with the servicename
2768 ********************************************************************/
2769
2770 static void spoolss_notify_share_name(struct messaging_context *msg_ctx,
2771 int snum,
2772 struct spoolss_Notify *data,
2773 print_queue_struct *queue,
2774 struct spoolss_PrinterInfo2 *pinfo2,
2775 TALLOC_CTX *mem_ctx)
2776 {
2777 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(talloc_tos(), snum));
2778 }
2779
2780 /*******************************************************************
2781 * fill a notify_info_data with the port name
2782 ********************************************************************/
2783
2784 static void spoolss_notify_port_name(struct messaging_context *msg_ctx,
2785 int snum,
2786 struct spoolss_Notify *data,
2787 print_queue_struct *queue,
2788 struct spoolss_PrinterInfo2 *pinfo2,
2789 TALLOC_CTX *mem_ctx)
2790 {
2791 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->portname);
2792 }
2793
2794 /*******************************************************************
2795 * fill a notify_info_data with the printername
2796 * but it doesn't exist, have to see what to do
2797 ********************************************************************/
2798
2799 static void spoolss_notify_driver_name(struct messaging_context *msg_ctx,
2800 int snum,
2801 struct spoolss_Notify *data,
2802 print_queue_struct *queue,
2803 struct spoolss_PrinterInfo2 *pinfo2,
2804 TALLOC_CTX *mem_ctx)
2805 {
2806 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->drivername);
2807 }
2808
2809 /*******************************************************************
2810 * fill a notify_info_data with the comment
2811 ********************************************************************/
2812
2813 static void spoolss_notify_comment(struct messaging_context *msg_ctx,
2814 int snum,
2815 struct spoolss_Notify *data,
2816 print_queue_struct *queue,
2817 struct spoolss_PrinterInfo2 *pinfo2,
2818 TALLOC_CTX *mem_ctx)
2819 {
2820 const char *p;
2821
2822 if (*pinfo2->comment == '\0') {
2823 p = lp_comment(talloc_tos(), snum);
2824 } else {
2825 p = pinfo2->comment;
2826 }
2827
2828 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2829 }
2830
2831 /*******************************************************************
2832 * fill a notify_info_data with the comment
2833 * location = "Room 1, floor 2, building 3"
2834 ********************************************************************/
2835
2836 static void spoolss_notify_location(struct messaging_context *msg_ctx,
2837 int snum,
2838 struct spoolss_Notify *data,
2839 print_queue_struct *queue,
2840 struct spoolss_PrinterInfo2 *pinfo2,
2841 TALLOC_CTX *mem_ctx)
2842 {
2843 const char *loc = pinfo2->location;
2844 NTSTATUS status;
2845
2846 status = printer_list_get_printer(mem_ctx,
2847 pinfo2->sharename,
2848 NULL,
2849 &loc,
2850 NULL);
2851 if (NT_STATUS_IS_OK(status)) {
2852 if (loc == NULL) {
2853 loc = pinfo2->location;
2854 }
2855 }
2856
2857 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, loc);
2858 }
2859
2860 /*******************************************************************
2861 * fill a notify_info_data with the device mode
2862 * jfm:xxxx don't to it for know but that's a real problem !!!
2863 ********************************************************************/
2864
2865 static void spoolss_notify_devmode(struct messaging_context *msg_ctx,
2866 int snum,
2867 struct spoolss_Notify *data,
2868 print_queue_struct *queue,
2869 struct spoolss_PrinterInfo2 *pinfo2,
2870 TALLOC_CTX *mem_ctx)
2871 {
2872 /* for a dummy implementation we have to zero the fields */
2873 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2874 }
2875
2876 /*******************************************************************
2877 * fill a notify_info_data with the separator file name
2878 ********************************************************************/
2879
2880 static void spoolss_notify_sepfile(struct messaging_context *msg_ctx,
2881 int snum,
2882 struct spoolss_Notify *data,
2883 print_queue_struct *queue,
2884 struct spoolss_PrinterInfo2 *pinfo2,
2885 TALLOC_CTX *mem_ctx)
2886 {
2887 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->sepfile);
2888 }
2889
2890 /*******************************************************************
2891 * fill a notify_info_data with the print processor
2892 * jfm:xxxx return always winprint to indicate we don't do anything to it
2893 ********************************************************************/
2894
2895 static void spoolss_notify_print_processor(struct messaging_context *msg_ctx,
2896 int snum,
2897 struct spoolss_Notify *data,
2898 print_queue_struct *queue,
2899 struct spoolss_PrinterInfo2 *pinfo2,
2900 TALLOC_CTX *mem_ctx)
2901 {
2902 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->printprocessor);
2903 }
2904
2905 /*******************************************************************
2906 * fill a notify_info_data with the print processor options
2907 * jfm:xxxx send an empty string
2908 ********************************************************************/
2909
2910 static void spoolss_notify_parameters(struct messaging_context *msg_ctx,
2911 int snum,
2912 struct spoolss_Notify *data,
2913 print_queue_struct *queue,
2914 struct spoolss_PrinterInfo2 *pinfo2,
2915 TALLOC_CTX *mem_ctx)
2916 {
2917 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->parameters);
2918 }
2919
2920 /*******************************************************************
2921 * fill a notify_info_data with the data type
2922 * jfm:xxxx always send RAW as data type
2923 ********************************************************************/
2924
2925 static void spoolss_notify_datatype(struct messaging_context *msg_ctx,
2926 int snum,
2927 struct spoolss_Notify *data,
2928 print_queue_struct *queue,
2929 struct spoolss_PrinterInfo2 *pinfo2,
2930 TALLOC_CTX *mem_ctx)
2931 {
2932 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->datatype);
2933 }
2934
2935 /*******************************************************************
2936 * fill a notify_info_data with the security descriptor
2937 * jfm:xxxx send an null pointer to say no security desc
2938 * have to implement security before !
2939 ********************************************************************/
2940
2941 static void spoolss_notify_security_desc(struct messaging_context *msg_ctx,
2942 int snum,
2943 struct spoolss_Notify *data,
2944 print_queue_struct *queue,
2945 struct spoolss_PrinterInfo2 *pinfo2,
2946 TALLOC_CTX *mem_ctx)
2947 {
2948 if (pinfo2->secdesc == NULL) {
2949 data->data.sd.sd = NULL;
2950 } else {
2951 data->data.sd.sd = security_descriptor_copy(mem_ctx,
2952 pinfo2->secdesc);
2953 }
2954 data->data.sd.sd_size = ndr_size_security_descriptor(data->data.sd.sd,
2955 0);
2956 }
2957
2958 /*******************************************************************
2959 * fill a notify_info_data with the attributes
2960 * jfm:xxxx a samba printer is always shared
2961 ********************************************************************/
2962
2963 static void spoolss_notify_attributes(struct messaging_context *msg_ctx,
2964 int snum,
2965 struct spoolss_Notify *data,
2966 print_queue_struct *queue,
2967 struct spoolss_PrinterInfo2 *pinfo2,
2968 TALLOC_CTX *mem_ctx)
2969 {
2970 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->attributes);
2971 }
2972
2973 /*******************************************************************
2974 * fill a notify_info_data with the priority
2975 ********************************************************************/
2976
2977 static void spoolss_notify_priority(struct messaging_context *msg_ctx,
2978 int snum,
2979 struct spoolss_Notify *data,
2980 print_queue_struct *queue,
2981 struct spoolss_PrinterInfo2 *pinfo2,
2982 TALLOC_CTX *mem_ctx)
2983 {
2984 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->priority);
2985 }
2986
2987 /*******************************************************************
2988 * fill a notify_info_data with the default priority
2989 ********************************************************************/
2990
2991 static void spoolss_notify_default_priority(struct messaging_context *msg_ctx,
2992 int snum,
2993 struct spoolss_Notify *data,
2994 print_queue_struct *queue,
2995 struct spoolss_PrinterInfo2 *pinfo2,
2996 TALLOC_CTX *mem_ctx)
2997 {
2998 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->defaultpriority);
2999 }
3000
3001 /*******************************************************************
3002 * fill a notify_info_data with the start time
3003 ********************************************************************/
3004
3005 static void spoolss_notify_start_time(struct messaging_context *msg_ctx,
3006 int snum,
3007 struct spoolss_Notify *data,
3008 print_queue_struct *queue,
3009 struct spoolss_PrinterInfo2 *pinfo2,
3010 TALLOC_CTX *mem_ctx)
3011 {
3012 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->starttime);
3013 }
3014
3015 /*******************************************************************
3016 * fill a notify_info_data with the until time
3017 ********************************************************************/
3018
3019 static void spoolss_notify_until_time(struct messaging_context *msg_ctx,
3020 int snum,
3021 struct spoolss_Notify *data,
3022 print_queue_struct *queue,
3023 struct spoolss_PrinterInfo2 *pinfo2,
3024 TALLOC_CTX *mem_ctx)
3025 {
3026 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->untiltime);
3027 }
3028
3029 /*******************************************************************
3030 * fill a notify_info_data with the status
3031 ********************************************************************/
3032
3033 static void spoolss_notify_status(struct messaging_context *msg_ctx,
3034 int snum,
3035 struct spoolss_Notify *data,
3036 print_queue_struct *queue,
3037 struct spoolss_PrinterInfo2 *pinfo2,
3038 TALLOC_CTX *mem_ctx)
3039 {
3040 print_status_struct status;
3041
3042 print_queue_length(msg_ctx, snum, &status);
3043 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3044 }
3045
3046 /*******************************************************************
3047 * fill a notify_info_data with the number of jobs queued
3048 ********************************************************************/
3049
3050 static void spoolss_notify_cjobs(struct messaging_context *msg_ctx,
3051 int snum,
3052 struct spoolss_Notify *data,
3053 print_queue_struct *queue,
3054 struct spoolss_PrinterInfo2 *pinfo2,
3055 TALLOC_CTX *mem_ctx)
3056 {
3057 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(
3058 data, print_queue_length(msg_ctx, snum, NULL));
3059 }
3060
3061 /*******************************************************************
3062 * fill a notify_info_data with the average ppm
3063 ********************************************************************/
3064
3065 static void spoolss_notify_average_ppm(struct messaging_context *msg_ctx,
3066 int snum,
3067 struct spoolss_Notify *data,
3068 print_queue_struct *queue,
3069 struct spoolss_PrinterInfo2 *pinfo2,
3070 TALLOC_CTX *mem_ctx)
3071 {
3072 /* always respond 8 pages per minutes */
3073 /* a little hard ! */
3074 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->averageppm);
3075 }
3076
3077 /*******************************************************************
3078 * fill a notify_info_data with username
3079 ********************************************************************/
3080
3081 static void spoolss_notify_username(struct messaging_context *msg_ctx,
3082 int snum,
3083 struct spoolss_Notify *data,
3084 print_queue_struct *queue,
3085 struct spoolss_PrinterInfo2 *pinfo2,
3086 TALLOC_CTX *mem_ctx)
3087 {
3088 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3089 }
3090
3091 /*******************************************************************
3092 * fill a notify_info_data with job status
3093 ********************************************************************/
3094
3095 static void spoolss_notify_job_status(struct messaging_context *msg_ctx,
3096 int snum,
3097 struct spoolss_Notify *data,
3098 print_queue_struct *queue,
3099 struct spoolss_PrinterInfo2 *pinfo2,
3100 TALLOC_CTX *mem_ctx)
3101 {
3102 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3103 }
3104
3105 /*******************************************************************
3106 * fill a notify_info_data with job name
3107 ********************************************************************/
3108
3109 static void spoolss_notify_job_name(struct messaging_context *msg_ctx,
3110 int snum,
3111 struct spoolss_Notify *data,
3112 print_queue_struct *queue,
3113 struct spoolss_PrinterInfo2 *pinfo2,
3114 TALLOC_CTX *mem_ctx)
3115 {
3116 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3117 }
3118
3119 /*******************************************************************
3120 * fill a notify_info_data with job status
3121 ********************************************************************/
3122
3123 static void spoolss_notify_job_status_string(struct messaging_context *msg_ctx,
3124 int snum,
3125 struct spoolss_Notify *data,
3126 print_queue_struct *queue,
3127 struct spoolss_PrinterInfo2 *pinfo2,
3128 TALLOC_CTX *mem_ctx)
3129 {
3130 /*
3131 * Now we're returning job status codes we just return a "" here. JRA.
3132 */
3133
3134 const char *p = "";
3135
3136 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3137 p = "unknown";
3138
3139 switch (queue->status) {
3140 case LPQ_QUEUED:
3141 p = "Queued";
3142 break;
3143 case LPQ_PAUSED:
3144 p = ""; /* NT provides the paused string */
3145 break;
3146 case LPQ_SPOOLING:
3147 p = "Spooling";
3148 break;
3149 case LPQ_PRINTING:
3150 p = "Printing";
3151 break;
3152 }
3153 #endif /* NO LONGER NEEDED. */
3154
3155 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3156 }
3157
3158 /*******************************************************************
3159 * fill a notify_info_data with job time
3160 ********************************************************************/
3161
3162 static void spoolss_notify_job_time(struct messaging_context *msg_ctx,
3163 int snum,
3164 struct spoolss_Notify *data,
3165 print_queue_struct *queue,
3166 struct spoolss_PrinterInfo2 *pinfo2,
3167 TALLOC_CTX *mem_ctx)
3168 {
3169 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3170 }
3171
3172 /*******************************************************************
3173 * fill a notify_info_data with job size
3174 ********************************************************************/
3175
3176 static void spoolss_notify_job_size(struct messaging_context *msg_ctx,
3177 int snum,
3178 struct spoolss_Notify *data,
3179 print_queue_struct *queue,
3180 struct spoolss_PrinterInfo2 *pinfo2,
3181 TALLOC_CTX *mem_ctx)
3182 {
3183 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3184 }
3185
3186 /*******************************************************************
3187 * fill a notify_info_data with page info
3188 ********************************************************************/
3189 static void spoolss_notify_total_pages(struct messaging_context *msg_ctx,
3190 int snum,
3191 struct spoolss_Notify *data,
3192 print_queue_struct *queue,
3193 struct spoolss_PrinterInfo2 *pinfo2,
3194 TALLOC_CTX *mem_ctx)
3195 {
3196 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3197 }
3198
3199 /*******************************************************************
3200 * fill a notify_info_data with pages printed info.
3201 ********************************************************************/
3202 static void spoolss_notify_pages_printed(struct messaging_context *msg_ctx,
3203 int snum,
3204 struct spoolss_Notify *data,
3205 print_queue_struct *queue,
3206 struct spoolss_PrinterInfo2 *pinfo2,
3207 TALLOC_CTX *mem_ctx)
3208 {
3209 /* Add code when back-end tracks this */
3210 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3211 }
3212
3213 /*******************************************************************
3214 Fill a notify_info_data with job position.
3215 ********************************************************************/
3216
3217 static void spoolss_notify_job_position(struct messaging_context *msg_ctx,
3218 int snum,
3219 struct spoolss_Notify *data,
3220 print_queue_struct *queue,
3221 struct spoolss_PrinterInfo2 *pinfo2,
3222 TALLOC_CTX *mem_ctx)
3223 {
3224 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->sysjob);
3225 }
3226
3227 /*******************************************************************
3228 Fill a notify_info_data with submitted time.
3229 ********************************************************************/
3230
3231 static void spoolss_notify_submitted_time(struct messaging_context *msg_ctx,
3232 int snum,
3233 struct spoolss_Notify *data,
3234 print_queue_struct *queue,
3235 struct spoolss_PrinterInfo2 *pinfo2,
3236 TALLOC_CTX *mem_ctx)
3237 {
3238 data->data.string.string = NULL;
3239 data->data.string.size = 0;
3240
3241 init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3242 &data->data.string.string,
3243 &data->data.string.size);
3244
3245 }
3246
3247 struct s_notify_info_data_table
3248 {
3249 enum spoolss_NotifyType type;
3250 uint16_t field;
3251 const char *name;
3252 enum spoolss_NotifyTable variable_type;
3253 void (*fn) (struct messaging_context *msg_ctx,
3254 int snum, struct spoolss_Notify *data,
3255 print_queue_struct *queue,
3256 struct spoolss_PrinterInfo2 *pinfo2,
3257 TALLOC_CTX *mem_ctx);
3258 };
3259
3260 /* A table describing the various print notification constants and
3261 whether the notification data is a pointer to a variable sized
3262 buffer, a one value uint32_t or a two value uint32_t. */
3263
3264 static const struct s_notify_info_data_table notify_info_data_table[] =
3265 {
3266 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3267 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3268 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_share_name },
3269 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3270 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3271 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING, spoolss_notify_comment },
3272 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING, spoolss_notify_location },
3273 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3274 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING, spoolss_notify_sepfile },
3275 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3276 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3277 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3278 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, spoolss_notify_security_desc },
3279 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD, spoolss_notify_attributes },
3280 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3281 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_default_priority },
3282 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3283 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3284 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_status },
3285 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, NULL },
3286 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD, spoolss_notify_cjobs },
3287 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD, spoolss_notify_average_ppm },
3288 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, NULL },
3289 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3290 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, NULL },
3291 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3292 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINTER_NAME, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3293 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_MACHINE_NAME, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3294 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PORT_NAME, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3295 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3296 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_NOTIFY_NAME, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3297 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DATATYPE, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3298 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINT_PROCESSOR, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3299 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PARAMETERS, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3300 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DRIVER_NAME, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3301 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DEVMODE, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3302 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_job_status },
3303 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS_STRING, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, spoolss_notify_job_status_string },
3304 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, NULL },
3305 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING, spoolss_notify_job_name },
3306 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRIORITY, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3307 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_POSITION, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD, spoolss_notify_job_position },
3308 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME, spoolss_notify_submitted_time },
3309 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_START_TIME, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3310 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_UNTIL_TIME, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3311 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TIME, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_job_time },
3312 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_PAGES, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, spoolss_notify_total_pages },
3313 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PAGES_PRINTED, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, spoolss_notify_pages_printed },
3314 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_BYTES, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, spoolss_notify_job_size },
3315 };
3316
3317 /*******************************************************************
3318 Return the variable_type of info_data structure.
3319 ********************************************************************/
3320
3321 static enum spoolss_NotifyTable variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3322 uint16_t field)
3323 {
3324 int i=0;
3325
3326 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3327 if ( (notify_info_data_table[i].type == type) &&
3328 (notify_info_data_table[i].field == field) ) {
3329 return notify_info_data_table[i].variable_type;
3330 }
3331 }
3332
3333 DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3334
3335 return (enum spoolss_NotifyTable) 0;
3336 }
3337
3338 /****************************************************************************
3339 ****************************************************************************/
3340
3341 static bool search_notify(enum spoolss_NotifyType type,
3342 uint16_t field,
3343 int *value)
3344 {
3345 int i;
3346
3347 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3348 if (notify_info_data_table[i].type == type &&
3349 notify_info_data_table[i].field == field &&
3350 notify_info_data_table[i].fn != NULL) {
3351 *value = i;
3352 return true;
3353 }
3354 }
3355
3356 return false;
3357 }
3358
3359 /****************************************************************************
3360 ****************************************************************************/
3361
3362 static void construct_info_data(struct spoolss_Notify *info_data,
3363 enum spoolss_NotifyType type,
3364 uint16_t field, int id)
3365 {
3366 info_data->type = type;
3367 info_data->field.field = field;
3368 info_data->variable_type = variable_type_of_notify_info_data(type, field);
3369 info_data->job_id = id;
3370 }
3371
3372 /*******************************************************************
3373 *
3374 * fill a notify_info struct with info asked
3375 *
3376 ********************************************************************/
3377
3378 static bool construct_notify_printer_info(struct messaging_context *msg_ctx,
3379 struct printer_handle *print_hnd,
3380 struct spoolss_NotifyInfo *info,
3381 struct spoolss_PrinterInfo2 *pinfo2,
3382 int snum,
3383 const struct spoolss_NotifyOptionType *option_type,
3384 uint32_t id,
3385 TALLOC_CTX *mem_ctx)
3386 {
3387 int field_num,j;
3388 enum spoolss_NotifyType type;
3389 uint16_t field;
3390
3391 struct spoolss_Notify *current_data;
3392
3393 type = option_type->type;
3394
3395 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3396 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3397 option_type->count, lp_servicename(talloc_tos(), snum)));
3398
3399 for(field_num=0; field_num < option_type->count; field_num++) {
3400 field = option_type->fields[field_num].field;
3401
3402 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3403
3404 if (!search_notify(type, field, &j) )
3405 continue;
3406
3407 info->notifies = talloc_realloc(info, info->notifies,
3408 struct spoolss_Notify,
3409 info->count + 1);
3410 if (info->notifies == NULL) {
3411 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3412 return false;
3413 }
3414
3415 current_data = &info->notifies[info->count];
3416
3417 construct_info_data(current_data, type, field, id);
3418
3419 DEBUG(10, ("construct_notify_printer_info: "
3420 "calling [%s] snum=%d printername=[%s])\n",
3421 notify_info_data_table[j].name, snum,
3422 pinfo2->printername));
3423
3424 notify_info_data_table[j].fn(msg_ctx, snum, current_data,
3425 NULL, pinfo2, mem_ctx);
3426
3427 info->count++;
3428 }
3429
3430 return true;
3431 }
3432
3433 /*******************************************************************
3434 *
3435 * fill a notify_info struct with info asked
3436 *
3437 ********************************************************************/
3438
3439 static bool construct_notify_jobs_info(struct messaging_context *msg_ctx,
3440 print_queue_struct *queue,
3441 struct spoolss_NotifyInfo *info,
3442 struct spoolss_PrinterInfo2 *pinfo2,
3443 int snum,
3444 const struct spoolss_NotifyOptionType *option_type,
3445 uint32_t id,
3446 TALLOC_CTX *mem_ctx)
3447 {
3448 int field_num,j;
3449 enum spoolss_NotifyType type;
3450 uint16_t field;
3451 struct spoolss_Notify *current_data;
3452
3453 DEBUG(4,("construct_notify_jobs_info\n"));
3454
3455 type = option_type->type;
3456
3457 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3458 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3459 option_type->count));
3460
3461 for(field_num=0; field_num<option_type->count; field_num++) {
3462 field = option_type->fields[field_num].field;
3463
3464 if (!search_notify(type, field, &j) )
3465 continue;
3466
3467 info->notifies = talloc_realloc(info, info->notifies,
3468 struct spoolss_Notify,
3469 info->count + 1);
3470 if (info->notifies == NULL) {
3471 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3472 return false;
3473 }
3474
3475 current_data=&(info->notifies[info->count]);
3476
3477 construct_info_data(current_data, type, field, id);
3478 notify_info_data_table[j].fn(msg_ctx, snum, current_data,
3479 queue, pinfo2, mem_ctx);
3480 info->count++;
3481 }
3482
3483 return true;
3484 }
3485
3486 /*
3487 * JFM: The enumeration is not that simple, it's even non obvious.
3488 *
3489 * let's take an example: I want to monitor the PRINTER SERVER for
3490 * the printer's name and the number of jobs currently queued.
3491 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3492 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3493 *
3494 * I have 3 printers on the back of my server.
3495 *
3496 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3497 * structures.
3498 * Number Data Id
3499 * 1 printer 1 name 1
3500 * 2 printer 1 cjob 1
3501 * 3 printer 2 name 2
3502 * 4 printer 2 cjob 2
3503 * 5 printer 3 name 3
3504 * 6 printer 3 name 3
3505 *
3506 * that's the print server case, the printer case is even worse.
3507 */
3508
3509 /*******************************************************************
3510 *
3511 * enumerate all printers on the printserver
3512 * fill a notify_info struct with info asked
3513 *
3514 ********************************************************************/
3515
3516 static WERROR printserver_notify_info(struct pipes_struct *p,
3517 struct policy_handle *hnd,
3518 struct spoolss_NotifyInfo *info,
3519 TALLOC_CTX *mem_ctx)
3520 {
3521 int snum;
3522 struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
3523 int n_services=lp_numservices();
3524 int i;
3525 struct spoolss_NotifyOption *option;
3526 struct spoolss_NotifyOptionType option_type;
3527 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3528 WERROR result;
3529
3530 DEBUG(4,("printserver_notify_info\n"));
3531
3532 if (!Printer)
3533 return WERR_BADFID;
3534
3535 option = Printer->notify.option;
3536
3537 info->version = 2;
3538 info->notifies = NULL;
3539 info->count = 0;
3540
3541 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3542 sending a ffpcn() request first */
3543
3544 if ( !option )
3545 return WERR_BADFID;
3546
3547 for (i=0; i<option->count; i++) {
3548 option_type = option->types[i];
3549
3550 if (option_type.type != PRINTER_NOTIFY_TYPE)
3551 continue;
3552
3553 for (snum = 0; snum < n_services; snum++) {
3554 if (!lp_browseable(snum) ||
3555 !lp_snum_ok(snum) ||
3556 !lp_printable(snum)) {
3557 continue; /* skip */
3558 }
3559
3560 /* Maybe we should use the SYSTEM session_info here... */
3561 result = winreg_get_printer_internal(mem_ctx,
3562 get_session_info_system(),
3563 p->msg_ctx,
3564 lp_servicename(talloc_tos(), snum),
3565 &pinfo2);
3566 if (!W_ERROR_IS_OK(result)) {
3567 DEBUG(4, ("printserver_notify_info: "
3568 "Failed to get printer [%s]\n",
3569 lp_servicename(talloc_tos(), snum)));
3570 continue;
3571 }
3572
3573
3574 construct_notify_printer_info(p->msg_ctx,
3575 Printer, info,
3576 pinfo2, snum,
3577 &option_type, snum,
3578 mem_ctx);
3579
3580 TALLOC_FREE(pinfo2);
3581 }
3582 }
3583
3584 #if 0
3585 /*
3586 * Debugging information, don't delete.
3587 */
3588
3589 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3590 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3591 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3592
3593 for (i=0; i<info->count; i++) {
3594 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3595 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3596 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3597 }
3598 #endif
3599
3600 return WERR_OK;
3601 }
3602
3603 /*******************************************************************
3604 *
3605 * fill a notify_info struct with info asked
3606 *
3607 ********************************************************************/
3608
3609 static WERROR printer_notify_info(struct pipes_struct *p,
3610 struct policy_handle *hnd,
3611 struct spoolss_NotifyInfo *info,
3612 TALLOC_CTX *mem_ctx)
3613 {
3614 int snum;
3615 struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
3616 int i;
3617 uint32_t id;
3618 struct spoolss_NotifyOption *option;
3619 struct spoolss_NotifyOptionType option_type;
3620 int count,j;
3621 print_queue_struct *queue=NULL;
3622 print_status_struct status;
3623 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3624 WERROR result;
3625 struct tdb_print_db *pdb;
3626
3627 DEBUG(4,("printer_notify_info\n"));
3628
3629 if (!Printer)
3630 return WERR_BADFID;
3631
3632 option = Printer->notify.option;
3633 id = 0x0;
3634
3635 info->version = 2;
3636 info->notifies = NULL;
3637 info->count = 0;
3638
3639 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3640 sending a ffpcn() request first */
3641
3642 if ( !option )
3643 return WERR_BADFID;
3644
3645 if (!get_printer_snum(p, hnd, &snum, NULL)) {
3646 return WERR_BADFID;
3647 }
3648
3649 pdb = get_print_db_byname(Printer->sharename);
3650 if (pdb == NULL) {
3651 return WERR_BADFID;
3652 }
3653
3654 /* Maybe we should use the SYSTEM session_info here... */
3655 result = winreg_get_printer_internal(mem_ctx,
3656 get_session_info_system(),
3657 p->msg_ctx,
3658 lp_servicename(talloc_tos(), snum), &pinfo2);
3659 if (!W_ERROR_IS_OK(result)) {
3660 result = WERR_BADFID;
3661 goto err_pdb_drop;
3662 }
3663
3664 /*
3665 * When sending a PRINTER_NOTIFY_FIELD_SERVER_NAME we should send the
3666 * correct servername.
3667 */
3668 pinfo2->servername = talloc_strdup(pinfo2, Printer->servername);
3669 if (pinfo2->servername == NULL) {
3670 result = WERR_NOMEM;
3671 goto err_pdb_drop;
3672 }
3673
3674 for (i = 0; i < option->count; i++) {
3675 option_type = option->types[i];
3676
3677 switch (option_type.type) {
3678 case PRINTER_NOTIFY_TYPE:
3679 if (construct_notify_printer_info(p->msg_ctx,
3680 Printer, info,
3681 pinfo2, snum,
3682 &option_type, id,
3683 mem_ctx)) {
3684 id--;
3685 }
3686 break;
3687
3688 case JOB_NOTIFY_TYPE:
3689
3690 count = print_queue_status(p->msg_ctx, snum, &queue,
3691 &status);
3692
3693 for (j = 0; j < count; j++) {
3694 uint32_t jobid;
3695 jobid = sysjob_to_jobid_pdb(pdb,
3696 queue[j].sysjob);
3697 if (jobid == (uint32_t)-1) {
3698 DEBUG(2, ("ignoring untracked job %d\n",
3699 queue[j].sysjob));
3700 continue;
3701 }
3702 /* FIXME check return value */
3703 construct_notify_jobs_info(p->msg_ctx,
3704 &queue[j], info,
3705 pinfo2, snum,
3706 &option_type,
3707 jobid,
3708 mem_ctx);
3709 }
3710
3711 SAFE_FREE(queue);
3712 break;
3713 }
3714 }
3715
3716 /*
3717 * Debugging information, don't delete.
3718 */
3719 /*
3720 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3721 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3722 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3723
3724 for (i=0; i<info->count; i++) {
3725 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3726 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3727 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3728 }
3729 */
3730
3731 talloc_free(pinfo2);
3732 result = WERR_OK;
3733 err_pdb_drop:
3734 release_print_db(pdb);
3735 return result;
3736 }
3737
3738 /****************************************************************
3739 _spoolss_RouterRefreshPrinterChangeNotify
3740 ****************************************************************/
3741
3742 WERROR _spoolss_RouterRefreshPrinterChangeNotify(struct pipes_struct *p,
3743 struct spoolss_RouterRefreshPrinterChangeNotify *r)
3744 {
3745 struct spoolss_NotifyInfo *info;
3746
3747 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
3748 WERROR result = WERR_BADFID;
3749
3750 /* we always have a spoolss_NotifyInfo struct */
3751 info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3752 if (!info) {
3753 result = WERR_NOMEM;
3754 goto done;
3755 }
3756
3757 *r->out.info = info;
3758
3759 if (!Printer) {
3760 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3761 "Invalid handle (%s:%u:%u).\n",
3762 OUR_HANDLE(r->in.handle)));
3763 goto done;
3764 }
3765
3766 DEBUG(4,("Printer type %x\n",Printer->printer_type));
3767
3768 /*
3769 * We are now using the change value, and
3770 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3771 * I don't have a global notification system, I'm sending back all the
3772 * information even when _NOTHING_ has changed.
3773 */
3774
3775 /* We need to keep track of the change value to send back in
3776 RRPCN replies otherwise our updates are ignored. */
3777
3778 Printer->notify.fnpcn = true;
3779
3780 if (Printer->notify.cli_chan != NULL &&
3781 Printer->notify.cli_chan->active_connections > 0) {
3782 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3783 "Saving change value in request [%x]\n",
3784 r->in.change_low));
3785 Printer->notify.change = r->in.change_low;
3786 }
3787
3788 /* just ignore the spoolss_NotifyOption */
3789
3790 switch (Printer->printer_type) {
3791 case SPLHND_SERVER:
3792 result = printserver_notify_info(p, r->in.handle,
3793 info, p->mem_ctx);
3794 break;
3795
3796 case SPLHND_PRINTER:
3797 result = printer_notify_info(p, r->in.handle,
3798 info, p->mem_ctx);
3799 break;
3800 }
3801
3802 Printer->notify.fnpcn = false;
3803
3804 done:
3805 return result;
3806 }
3807
3808 /********************************************************************
3809 ********************************************************************/
3810
3811 static WERROR create_printername(TALLOC_CTX *mem_ctx,
3812 const char *servername,
3813 const char *printername,
3814 const char **printername_p)
3815 {
3816 /* FIXME: add lp_force_printername() */
3817
3818 if (servername == NULL) {
3819 *printername_p = talloc_strdup(mem_ctx, printername);
3820 W_ERROR_HAVE_NO_MEMORY(*printername_p);
3821 return WERR_OK;
3822 }
3823
3824 if (servername[0] == '\\' && servername[1] == '\\') {
3825 servername += 2;
3826 }
3827
3828 *printername_p = talloc_asprintf(mem_ctx, "\\\\%s\\%s", servername, printername);
3829 W_ERROR_HAVE_NO_MEMORY(*printername_p);
3830
3831 return WERR_OK;
3832 }
3833
3834 /********************************************************************
3835 ********************************************************************/
3836
3837 static void compose_devicemode_devicename(struct spoolss_DeviceMode *dm,
3838 const char *printername)
3839 {
3840 if (dm == NULL) {
3841 return;
3842 }
3843
3844 dm->devicename = talloc_strndup(dm, printername,
3845 MIN(strlen(printername), 31));
3846 }
3847
3848 /********************************************************************
3849 * construct_printer_info_0
3850 * fill a printer_info_0 struct
3851 ********************************************************************/
3852
3853 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3854 const struct auth_session_info *session_info,
3855 struct messaging_context *msg_ctx,
3856 struct spoolss_PrinterInfo2 *info2,
3857 const char *servername,
3858 struct spoolss_PrinterInfo0 *r,
3859 int snum)
3860 {
3861 int count;
3862 struct printer_session_counter *session_counter;
3863 struct timeval setuptime;
3864 print_status_struct status;
3865 WERROR result;
3866
3867 result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
3868 if (!W_ERROR_IS_OK(result)) {
3869 return result;
3870 }
3871
3872 if (servername) {
3873 r->servername = talloc_strdup(mem_ctx, servername);
3874 W_ERROR_HAVE_NO_MEMORY(r->servername);
3875 } else {
3876 r->servername = NULL;
3877 }
3878
3879 count = print_queue_length(msg_ctx, snum, &status);
3880
3881 /* check if we already have a counter for this printer */
3882 for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3883 if (session_counter->snum == snum)
3884 break;
3885 }
3886
3887 /* it's the first time, add it to the list */
3888 if (session_counter == NULL) {
3889 session_counter = talloc_zero(counter_list, struct printer_session_counter);
3890 W_ERROR_HAVE_NO_MEMORY(session_counter);
3891 session_counter->snum = snum;
3892 session_counter->counter = 0;
3893 DLIST_ADD(counter_list, session_counter);
3894 }
3895
3896 /* increment it */
3897 session_counter->counter++;
3898
3899 r->cjobs = count;
3900 r->total_jobs = 0;
3901 r->total_bytes = 0;
3902
3903 get_startup_time(&setuptime);
3904 init_systemtime(&r->time, gmtime(&setuptime.tv_sec));
3905
3906 /* JFM:
3907 * the global_counter should be stored in a TDB as it's common to all the clients
3908 * and should be zeroed on samba startup
3909 */
3910 r->global_counter = session_counter->counter;
3911 r->total_pages = 0;
3912 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3913 SSVAL(&r->version, 0, 0x0005); /* NT 5 */
3914 SSVAL(&r->version, 2, 0x0893); /* build 2195 */
3915 r->free_build = SPOOLSS_RELEASE_BUILD;
3916 r->spooling = 0;
3917 r->max_spooling = 0;
3918 r->session_counter = session_counter->counter;
3919 r->num_error_out_of_paper = 0x0;
3920 r->num_error_not_ready = 0x0; /* number of print failure */
3921 r->job_error = 0x0;
3922 r->number_of_processors = 0x1;
3923 r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3924 r->high_part_total_bytes = 0x0;
3925
3926 /* ChangeID in milliseconds*/
3927 winreg_printer_get_changeid_internal(mem_ctx, session_info, msg_ctx,
3928 info2->sharename, &r->change_id);
3929
3930 r->last_error = WERR_OK;
3931 r->status = nt_printq_status(status.status);
3932 r->enumerate_network_printers = 0x0;
3933 r->c_setprinter = 0x0;
3934 r->processor_architecture = PROCESSOR_ARCHITECTURE_INTEL;
3935 r->processor_level = 0x6; /* 6 ???*/
3936 r->ref_ic = 0;
3937 r->reserved2 = 0;
3938 r->reserved3 = 0;
3939
3940 return WERR_OK;
3941 }
3942
3943
3944 /********************************************************************
3945 * construct_printer_info1
3946 * fill a spoolss_PrinterInfo1 struct
3947 ********************************************************************/
3948
3949 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3950 const struct spoolss_PrinterInfo2 *info2,
3951 uint32_t flags,
3952 const char *servername,
3953 struct spoolss_PrinterInfo1 *r,
3954 int snum)
3955 {
3956 WERROR result;
3957
3958 r->flags = flags;
3959
3960 if (info2->comment == NULL || info2->comment[0] == '\0') {
3961 r->comment = lp_comment(mem_ctx, snum);
3962 } else {
3963 r->comment = talloc_strdup(mem_ctx, info2->comment); /* saved comment */
3964 }
3965 W_ERROR_HAVE_NO_MEMORY(r->comment);
3966
3967 result = create_printername(mem_ctx, servername, info2->printername, &r->name);
3968 if (!W_ERROR_IS_OK(result)) {
3969 return result;
3970 }
3971
3972 r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
3973 r->name,
3974 info2->drivername,
3975 r->comment);
3976 W_ERROR_HAVE_NO_MEMORY(r->description);
3977
3978 return WERR_OK;
3979 }
3980
3981 /********************************************************************
3982 * construct_printer_info2
3983 * fill a spoolss_PrinterInfo2 struct
3984 ********************************************************************/
3985
3986 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3987 struct messaging_context *msg_ctx,
3988 const struct spoolss_PrinterInfo2 *info2,
3989 const char *servername,
3990 struct spoolss_PrinterInfo2 *r,
3991 int snum)
3992 {
3993 int count;
3994 print_status_struct status;
3995 WERROR result;
3996
3997 count = print_queue_length(msg_ctx, snum, &status);
3998
3999 if (servername) {
4000 r->servername = talloc_strdup(mem_ctx, servername);
4001 W_ERROR_HAVE_NO_MEMORY(r->servername);
4002 } else {
4003 r->servername = NULL;
4004 }
4005
4006 result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
4007 if (!W_ERROR_IS_OK(result)) {
4008 return result;
4009 }
4010
4011 r->sharename = lp_servicename(mem_ctx, snum);
4012 W_ERROR_HAVE_NO_MEMORY(r->sharename);
4013 r->portname = talloc_strdup(mem_ctx, info2->portname);
4014 W_ERROR_HAVE_NO_MEMORY(r->portname);
4015 r->drivername = talloc_strdup(mem_ctx, info2->drivername);
4016 W_ERROR_HAVE_NO_MEMORY(r->drivername);
4017
4018 if (info2->comment[0] == '\0') {
4019 r->comment = lp_comment(mem_ctx, snum);
4020 } else {
4021 r->comment = talloc_strdup(mem_ctx, info2->comment);
4022 }
4023 W_ERROR_HAVE_NO_MEMORY(r->comment);
4024
4025 r->location = talloc_strdup(mem_ctx, info2->location);
4026 if (info2->location[0] == '\0') {
4027 const char *loc = NULL;
4028 NTSTATUS nt_status;
4029
4030 nt_status = printer_list_get_printer(mem_ctx,
4031 info2->sharename,
4032 NULL,
4033 &loc,
4034 NULL);
4035 if (NT_STATUS_IS_OK(nt_status)) {
4036 if (loc != NULL) {
4037 r->location = talloc_strdup(mem_ctx, loc);
4038 }
4039 }
4040 }
4041 W_ERROR_HAVE_NO_MEMORY(r->location);
4042
4043 r->sepfile = talloc_strdup(mem_ctx, info2->sepfile);
4044 W_ERROR_HAVE_NO_MEMORY(r->sepfile);
4045 r->printprocessor = talloc_strdup(mem_ctx, info2->printprocessor);
4046 W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
4047 r->datatype = talloc_strdup(mem_ctx, info2->datatype);
4048 W_ERROR_HAVE_NO_MEMORY(r->datatype);
4049 r->parameters = talloc_strdup(mem_ctx, info2->parameters);
4050 W_ERROR_HAVE_NO_MEMORY(r->parameters);
4051
4052 r->attributes = info2->attributes;
4053
4054 r->priority = info2->priority;
4055 r->defaultpriority = info2->defaultpriority;
4056 r->starttime = info2->starttime;
4057 r->untiltime = info2->untiltime;
4058 r->status = nt_printq_status(status.status);
4059 r->cjobs = count;
4060 r->averageppm = info2->averageppm;
4061
4062 if (info2->devmode != NULL) {
4063 result = copy_devicemode(mem_ctx,
4064 info2->devmode,
4065 &r->devmode);
4066 if (!W_ERROR_IS_OK(result)) {
4067 return result;
4068 }
4069 } else if (lp_default_devmode(snum)) {
4070 result = spoolss_create_default_devmode(mem_ctx,
4071 info2->printername,
4072 &r->devmode);
4073 if (!W_ERROR_IS_OK(result)) {
4074 return result;
4075 }
4076 } else {
4077 r->devmode = NULL;
4078 DEBUG(8,("Returning NULL Devicemode!\n"));
4079 }
4080
4081 compose_devicemode_devicename(r->devmode, r->printername);
4082
4083 r->secdesc = NULL;
4084
4085 if (info2->secdesc != NULL) {
4086 /* don't use talloc_steal() here unless you do a deep steal of all
4087 the SEC_DESC members */
4088
4089 r->secdesc = security_descriptor_copy(mem_ctx, info2->secdesc);
4090 if (r->secdesc == NULL) {
4091 return WERR_NOMEM;
4092 }
4093 }
4094
4095 return WERR_OK;
4096 }
4097
4098 /********************************************************************
4099 * construct_printer_info3
4100 * fill a spoolss_PrinterInfo3 struct
4101 ********************************************************************/
4102
4103 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
4104 const struct spoolss_PrinterInfo2 *info2,
4105 const char *servername,
4106 struct spoolss_PrinterInfo3 *r,
4107 int snum)
4108 {
4109 /* These are the components of the SD we are returning. */
4110
4111 if (info2->secdesc != NULL) {
4112 /* don't use talloc_steal() here unless you do a deep steal of all
4113 the SEC_DESC members */
4114
4115 r->secdesc = security_descriptor_copy(mem_ctx, info2->secdesc);
4116 if (r->secdesc == NULL) {
4117 return WERR_NOMEM;
4118 }
4119 }
4120
4121 return WERR_OK;
4122 }
4123
4124 /********************************************************************
4125 * construct_printer_info4
4126 * fill a spoolss_PrinterInfo4 struct
4127 ********************************************************************/
4128
4129 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
4130 const struct spoolss_PrinterInfo2 *info2,
4131 const char *servername,
4132 struct spoolss_PrinterInfo4 *r,
4133 int snum)
4134 {
4135 WERROR result;
4136
4137 result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
4138 if (!W_ERROR_IS_OK(result)) {
4139 return result;
4140 }
4141
4142 if (servername) {
4143 r->servername = talloc_strdup(mem_ctx, servername);
4144 W_ERROR_HAVE_NO_MEMORY(r->servername);
4145 } else {
4146 r->servername = NULL;
4147 }
4148
4149 r->attributes = info2->attributes;
4150
4151 return WERR_OK;
4152 }
4153
4154 /********************************************************************
4155 * construct_printer_info5
4156 * fill a spoolss_PrinterInfo5 struct
4157 ********************************************************************/
4158
4159 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
4160 const struct spoolss_PrinterInfo2 *info2,
4161 const char *servername,
4162 struct spoolss_PrinterInfo5 *r,
4163 int snum)
4164 {
4165 WERROR result;
4166
4167 result = create_printername(mem_ctx, servername, info2->printername, &r->printername);
4168 if (!W_ERROR_IS_OK(result)) {
4169 return result;
4170 }
4171
4172 r->portname = talloc_strdup(mem_ctx, info2->portname);
4173 W_ERROR_HAVE_NO_MEMORY(r->portname);
4174
4175 r->attributes = info2->attributes;
4176
4177 /* these two are not used by NT+ according to MSDN */
4178 r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
4179 r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
4180
4181 return WERR_OK;
4182 }
4183
4184 /********************************************************************
4185 * construct_printer_info_6
4186 * fill a spoolss_PrinterInfo6 struct
4187 ********************************************************************/
4188
4189 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
4190 struct messaging_context *msg_ctx,
4191 const struct spoolss_PrinterInfo2 *info2,
4192 const char *servername,
4193 struct spoolss_PrinterInfo6 *r,
4194 int snum)
4195 {
4196 print_status_struct status;
4197
4198 print_queue_length(msg_ctx, snum, &status);
4199
4200 r->status = nt_printq_status(status.status);
4201
4202 return WERR_OK;
4203 }
4204
4205 /********************************************************************
4206 * construct_printer_info7
4207 * fill a spoolss_PrinterInfo7 struct
4208 ********************************************************************/
4209
4210 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4211 struct messaging_context *msg_ctx,
4212 const char *servername,
4213 struct spoolss_PrinterInfo7 *r,
4214 int snum)
4215 {
4216 const struct auth_session_info *session_info;
4217 char *printer;
4218 WERROR werr;
4219 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
4220 if (tmp_ctx == NULL) {
4221 return WERR_NOMEM;
4222 }
4223
4224 session_info = get_session_info_system();
4225 SMB_ASSERT(session_info != NULL);
4226
4227 printer = lp_servicename(tmp_ctx, snum);
4228 if (printer == NULL) {
4229 DEBUG(0, ("invalid printer snum %d\n", snum));
4230 werr = WERR_INVALID_PARAM;
4231 goto out_tmp_free;
4232 }
4233
4234 if (is_printer_published(tmp_ctx, session_info, msg_ctx,
4235 servername, printer, NULL)) {
4236 struct GUID guid;
4237 werr = nt_printer_guid_get(tmp_ctx, session_info, msg_ctx,
4238 printer, &guid);
4239 if (!W_ERROR_IS_OK(werr)) {
4240 goto out_tmp_free;
4241 }
4242 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
4243 r->action = DSPRINT_PUBLISH;
4244 } else {
4245 r->guid = talloc_strdup(mem_ctx, "");
4246 r->action = DSPRINT_UNPUBLISH;
4247 }
4248 if (r->guid == NULL) {
4249 werr = WERR_NOMEM;
4250 goto out_tmp_free;
4251 }
4252
4253 werr = WERR_OK;
4254 out_tmp_free:
4255 talloc_free(tmp_ctx);
4256 return werr;
4257 }
4258
4259 /********************************************************************
4260 * construct_printer_info8
4261 * fill a spoolss_PrinterInfo8 struct
4262 ********************************************************************/
4263
4264 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4265 const struct spoolss_PrinterInfo2 *info2,
4266 const char *servername,
4267 struct spoolss_DeviceModeInfo *r,
4268 int snum)
4269 {
4270 WERROR result;
4271 const char *printername;
4272
4273 result = create_printername(mem_ctx, servername, info2->printername, &printername);
4274 if (!W_ERROR_IS_OK(result)) {
4275 return result;
4276 }
4277
4278 if (info2->devmode != NULL) {
4279 result = copy_devicemode(mem_ctx,
4280 info2->devmode,
4281 &r->devmode);
4282 if (!W_ERROR_IS_OK(result)) {
4283 return result;
4284 }
4285 } else if (lp_default_devmode(snum)) {
4286 result = spoolss_create_default_devmode(mem_ctx,
4287 info2->printername,
4288 &r->devmode);
4289 if (!W_ERROR_IS_OK(result)) {
4290 return result;
4291 }
4292 } else {
4293 r->devmode = NULL;
4294 DEBUG(8,("Returning NULL Devicemode!\n"));
4295 }
4296
4297 compose_devicemode_devicename(r->devmode, printername);
4298
4299 return WERR_OK;
4300 }
4301
4302 /********************************************************************
4303 Spoolss_enumprinters.
4304 ********************************************************************/
4305
4306 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4307 const struct auth_session_info *session_info,
4308 struct messaging_context *msg_ctx,
4309 const char *servername,
4310 uint32_t level,
4311 uint32_t flags,
4312 union spoolss_PrinterInfo **info_p,
4313 uint32_t *count_p)
4314 {
4315 int snum;
4316 int n_services;
4317 union spoolss_PrinterInfo *info = NULL;
4318 uint32_t count = 0;
4319 WERROR result = WERR_OK;
4320 struct dcerpc_binding_handle *b = NULL;
4321 TALLOC_CTX *tmp_ctx = NULL;
4322
4323 tmp_ctx = talloc_new(mem_ctx);
4324 if (!tmp_ctx) {
4325 return WERR_NOMEM;
4326 }
4327
4328 /*
4329 * printer shares are updated on client enumeration. The background
4330 * printer process updates printer_list.tdb at regular intervals.
4331 */
4332 become_root();
4333 delete_and_reload_printers(server_event_context(), msg_ctx);
4334 unbecome_root();
4335
4336 n_services = lp_numservices();
4337 *count_p = 0;
4338 *info_p = NULL;
4339
4340 for (snum = 0; snum < n_services; snum++) {
4341
4342 const char *printer;
4343 struct spoolss_PrinterInfo2 *info2;
4344
4345 if (!snum_is_shared_printer(snum)) {
4346 continue;
4347 }
4348
4349 printer = lp_const_servicename(snum);
4350
4351 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4352 printer, snum));
4353
4354 if (b == NULL) {
4355 result = winreg_printer_binding_handle(tmp_ctx,
4356 session_info,
4357 msg_ctx,
4358 &b);
4359 if (!W_ERROR_IS_OK(result)) {
4360 goto out;
4361 }
4362 }
4363
4364 result = winreg_create_printer(tmp_ctx, b,
4365 printer);
4366 if (!W_ERROR_IS_OK(result)) {
4367 goto out;
4368 }
4369
4370 info = talloc_realloc(tmp_ctx, info,
4371 union spoolss_PrinterInfo,
4372 count + 1);
4373 if (!info) {
4374 result = WERR_NOMEM;
4375 goto out;
4376 }
4377
4378 result = winreg_get_printer(tmp_ctx, b,
4379 printer, &info2);
4380 if (!W_ERROR_IS_OK(result)) {
4381 goto out;
4382 }
4383
4384 switch (level) {
4385 case 0:
4386 result = construct_printer_info0(info, session_info,
4387 msg_ctx, info2,
4388 servername,
4389 &info[count].info0, snum);
4390 break;
4391 case 1:
4392 result = construct_printer_info1(info, info2, flags,
4393 servername,
4394 &info[count].info1, snum);
4395 break;
4396 case 2:
4397 result = construct_printer_info2(info, msg_ctx, info2,
4398 servername,
4399 &info[count].info2, snum);
4400 break;
4401 case 4:
4402 result = construct_printer_info4(info, info2,
4403 servername,
4404 &info[count].info4, snum);
4405 break;
4406 case 5:
4407 result = construct_printer_info5(info, info2,
4408 servername,
4409 &info[count].info5, snum);
4410 break;
4411
4412 default:
4413 result = WERR_UNKNOWN_LEVEL;
4414 goto out;
4415 }
4416
4417 if (!W_ERROR_IS_OK(result)) {
4418 goto out;
4419 }
4420
4421 count++;
4422 }
4423
4424 out:
4425 if (W_ERROR_IS_OK(result)) {
4426 *info_p = talloc_move(mem_ctx, &info);
4427 *count_p = count;
4428 }
4429
4430 talloc_free(tmp_ctx);
4431
4432 return result;
4433 }
4434
4435 /********************************************************************
4436 * handle enumeration of printers at level 0
4437 ********************************************************************/
4438
4439 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4440 const struct auth_session_info *session_info,
4441 struct messaging_context *msg_ctx,
4442 uint32_t flags,
4443 const char *servername,
4444 union spoolss_PrinterInfo **info,
4445 uint32_t *count)
4446 {
4447 DEBUG(4,("enum_all_printers_info_0\n"));
4448
4449 return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4450 servername, 0, flags, info, count);
4451 }
4452
4453
4454 /********************************************************************
4455 ********************************************************************/
4456
4457 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4458 const struct auth_session_info *session_info,
4459 struct messaging_context *msg_ctx,
4460 const char *servername,
4461 uint32_t flags,
4462 union spoolss_PrinterInfo **info,
4463 uint32_t *count)
4464 {
4465 DEBUG(4,("enum_all_printers_info_1\n"));
4466
4467 return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4468 servername, 1, flags, info, count);
4469 }
4470
4471 /********************************************************************
4472 enum_all_printers_info_1_local.
4473 *********************************************************************/
4474
4475 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4476 const struct auth_session_info *session_info,
4477 struct messaging_context *msg_ctx,
4478 const char *servername,
4479 union spoolss_PrinterInfo **info,
4480 uint32_t *count)
4481 {
4482 DEBUG(4,("enum_all_printers_info_1_local\n"));
4483
4484 return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4485 servername, PRINTER_ENUM_ICON8, info, count);
4486 }
4487
4488 /********************************************************************
4489 enum_all_printers_info_1_name.
4490 *********************************************************************/
4491
4492 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4493 const struct auth_session_info *session_info,
4494 struct messaging_context *msg_ctx,
4495 const char *servername,
4496 union spoolss_PrinterInfo **info,
4497 uint32_t *count)
4498 {
4499 const char *s = servername;
4500
4501 DEBUG(4,("enum_all_printers_info_1_name\n"));
4502
4503 if (servername != NULL &&
4504 (servername[0] == '\\') && (servername[1] == '\\')) {
4505 s = servername + 2;
4506 }
4507
4508 if (!is_myname_or_ipaddr(s)) {
4509 return WERR_INVALID_NAME;
4510 }
4511
4512 return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4513 servername, PRINTER_ENUM_ICON8, info, count);
4514 }
4515
4516 /********************************************************************
4517 enum_all_printers_info_1_network.
4518 *********************************************************************/
4519
4520 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4521 const struct auth_session_info *session_info,
4522 struct messaging_context *msg_ctx,
4523 const char *servername,
4524 union spoolss_PrinterInfo **info,
4525 uint32_t *count)
4526 {
4527 const char *s = servername;
4528
4529 DEBUG(4,("enum_all_printers_info_1_network\n"));
4530
4531 /* If we respond to a enum_printers level 1 on our name with flags
4532 set to PRINTER_ENUM_REMOTE with a list of printers then these
4533 printers incorrectly appear in the APW browse list.
4534 Specifically the printers for the server appear at the workgroup
4535 level where all the other servers in the domain are
4536 listed. Windows responds to this call with a
4537 WERR_CAN_NOT_COMPLETE so we should do the same. */
4538
4539 if (servername != NULL &&
4540 (servername[0] == '\\') && (servername[1] == '\\')) {
4541 s = servername + 2;
4542 }
4543
4544 if (is_myname_or_ipaddr(s)) {
4545 return WERR_CAN_NOT_COMPLETE;
4546 }
4547
4548 return enum_all_printers_info_1(mem_ctx, session_info, msg_ctx,
4549 servername, PRINTER_ENUM_NAME, info, count);
4550 }
4551
4552 /********************************************************************
4553 * api_spoolss_enumprinters
4554 *
4555 * called from api_spoolss_enumprinters (see this to understand)
4556 ********************************************************************/
4557
4558 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4559 const struct auth_session_info *session_info,
4560 struct messaging_context *msg_ctx,
4561 const char *servername,
4562 union spoolss_PrinterInfo **info,
4563 uint32_t *count)
4564 {
4565 DEBUG(4,("enum_all_printers_info_2\n"));
4566
4567 return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4568 servername, 2, 0, info, count);
4569 }
4570
4571 /********************************************************************
4572 * handle enumeration of printers at level 1
4573 ********************************************************************/
4574
4575 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4576 const struct auth_session_info *session_info,
4577 struct messaging_context *msg_ctx,
4578 uint32_t flags,
4579 const char *servername,
4580 union spoolss_PrinterInfo **info,
4581 uint32_t *count)
4582 {
4583 /* Not all the flags are equals */
4584
4585 if (flags & PRINTER_ENUM_LOCAL) {
4586 return enum_all_printers_info_1_local(mem_ctx, session_info,
4587 msg_ctx, servername, info, count);
4588 }
4589
4590 if (flags & PRINTER_ENUM_NAME) {
4591 return enum_all_printers_info_1_name(mem_ctx, session_info,
4592 msg_ctx, servername, info,
4593 count);
4594 }
4595
4596 if (flags & PRINTER_ENUM_NETWORK) {
4597 return enum_all_printers_info_1_network(mem_ctx, session_info,
4598 msg_ctx, servername, info,
4599 count);
4600 }
4601
4602 return WERR_OK; /* NT4sp5 does that */
4603 }
4604
4605 /********************************************************************
4606 * handle enumeration of printers at level 2
4607 ********************************************************************/
4608
4609 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4610 const struct auth_session_info *session_info,
4611 struct messaging_context *msg_ctx,
4612 uint32_t flags,
4613 const char *servername,
4614 union spoolss_PrinterInfo **info,
4615 uint32_t *count)
4616 {
4617 if (flags & PRINTER_ENUM_LOCAL) {
4618
4619 return enum_all_printers_info_2(mem_ctx, session_info, msg_ctx,
4620 servername,
4621 info, count);
4622 }
4623
4624 if (flags & PRINTER_ENUM_NAME) {
4625 if (servername && !is_myname_or_ipaddr(canon_servername(servername))) {
4626 return WERR_INVALID_NAME;
4627 }
4628
4629 return enum_all_printers_info_2(mem_ctx, session_info, msg_ctx,
4630 servername,
4631 info, count);
4632 }
4633
4634 if (flags & PRINTER_ENUM_REMOTE) {
4635 return WERR_UNKNOWN_LEVEL;
4636 }
4637
4638 return WERR_OK;
4639 }
4640
4641 /********************************************************************
4642 * handle enumeration of printers at level 4
4643 ********************************************************************/
4644
4645 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4646 const struct auth_session_info *session_info,
4647 struct messaging_context *msg_ctx,
4648 uint32_t flags,
4649 const char *servername,
4650 union spoolss_PrinterInfo **info,
4651 uint32_t *count)
4652 {
4653 DEBUG(4,("enum_all_printers_info_4\n"));
4654
4655 return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4656 servername, 4, flags, info, count);
4657 }
4658
4659
4660 /********************************************************************
4661 * handle enumeration of printers at level 5
4662 ********************************************************************/
4663
4664 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4665 const struct auth_session_info *session_info,
4666 struct messaging_context *msg_ctx,
4667 uint32_t flags,
4668 const char *servername,
4669 union spoolss_PrinterInfo **info,
4670 uint32_t *count)
4671 {
4672 DEBUG(4,("enum_all_printers_info_5\n"));
4673
4674 return enum_all_printers_info_level(mem_ctx, session_info, msg_ctx,
4675 servername, 5, flags, info, count);
4676 }
4677
4678 /****************************************************************
4679 _spoolss_EnumPrinters
4680 ****************************************************************/
4681
4682 WERROR _spoolss_EnumPrinters(struct pipes_struct *p,
4683 struct spoolss_EnumPrinters *r)
4684 {
4685 const struct auth_session_info *session_info = get_session_info_system();
4686 WERROR result;
4687
4688 /* that's an [in out] buffer */
4689
4690 if (!r->in.buffer && (r->in.offered != 0)) {
4691 return WERR_INVALID_PARAM;
4692 }
4693
4694 DEBUG(4,("_spoolss_EnumPrinters\n"));
4695
4696 *r->out.needed = 0;
4697 *r->out.count = 0;
4698 *r->out.info = NULL;
4699
4700 /*
4701 * Level 1:
4702 * flags==PRINTER_ENUM_NAME
4703 * if name=="" then enumerates all printers
4704 * if name!="" then enumerate the printer
4705 * flags==PRINTER_ENUM_REMOTE
4706 * name is NULL, enumerate printers
4707 * Level 2: name!="" enumerates printers, name can't be NULL
4708 * Level 3: doesn't exist
4709 * Level 4: does a local registry lookup
4710 * Level 5: same as Level 2
4711 */
4712
4713 if (r->in.server && r->in.server[0] == '\0') {
4714 r->in.server = NULL;
4715 }
4716
4717 switch (r->in.level) {
4718 case 0:
4719 result = enumprinters_level0(p->mem_ctx, session_info,
4720 p->msg_ctx, r->in.flags,
4721 r->in.server,
4722 r->out.info, r->out.count);
4723 break;
4724 case 1:
4725 result = enumprinters_level1(p->mem_ctx, session_info,
4726 p->msg_ctx, r->in.flags,
4727 r->in.server,
4728 r->out.info, r->out.count);
4729 break;
4730 case 2:
4731 result = enumprinters_level2(p->mem_ctx, session_info,
4732 p->msg_ctx, r->in.flags,
4733 r->in.server,
4734 r->out.info, r->out.count);
4735 break;
4736 case 4:
4737 result = enumprinters_level4(p->mem_ctx, session_info,
4738 p->msg_ctx, r->in.flags,
4739 r->in.server,
4740 r->out.info, r->out.count);
4741 break;
4742 case 5:
4743 result = enumprinters_level5(p->mem_ctx, session_info,
4744 p->msg_ctx, r->in.flags,
4745 r->in.server,
4746 r->out.info, r->out.count);
4747 break;
4748 default:
4749 return WERR_UNKNOWN_LEVEL;
4750 }
4751
4752 if (!W_ERROR_IS_OK(result)) {
4753 return result;
4754 }
4755
4756 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4757 spoolss_EnumPrinters,
4758 *r->out.info, r->in.level,
4759 *r->out.count);
4760 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4761 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4762
4763 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4764 }
4765
4766 /****************************************************************
4767 _spoolss_GetPrinter
4768 ****************************************************************/
4769
4770 WERROR _spoolss_GetPrinter(struct pipes_struct *p,
4771 struct spoolss_GetPrinter *r)
4772 {
4773 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
4774 struct spoolss_PrinterInfo2 *info2 = NULL;
4775 WERROR result = WERR_OK;
4776 int snum;
4777
4778 /* that's an [in out] buffer */
4779
4780 if (!r->in.buffer && (r->in.offered != 0)) {
4781 return WERR_INVALID_PARAM;
4782 }
4783
4784 *r->out.needed = 0;
4785
4786 if (Printer == NULL) {
4787 return WERR_BADFID;
4788 }
4789
4790 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4791 return WERR_BADFID;
4792 }
4793
4794 result = winreg_get_printer_internal(p->mem_ctx,
4795 get_session_info_system(),
4796 p->msg_ctx,
4797 lp_const_servicename(snum),
4798 &info2);
4799 if (!W_ERROR_IS_OK(result)) {
4800 goto out;
4801 }
4802
4803 switch (r->in.level) {
4804 case 0:
4805 result = construct_printer_info0(p->mem_ctx,
4806 get_session_info_system(),
4807 p->msg_ctx,
4808 info2,
4809 Printer->servername,
4810 &r->out.info->info0,
4811 snum);
4812 break;
4813 case 1:
4814 result = construct_printer_info1(p->mem_ctx, info2,
4815 PRINTER_ENUM_ICON8,
4816 Printer->servername,
4817 &r->out.info->info1, snum);
4818 break;
4819 case 2:
4820 result = construct_printer_info2(p->mem_ctx, p->msg_ctx, info2,
4821 Printer->servername,
4822 &r->out.info->info2, snum);
4823 break;
4824 case 3:
4825 result = construct_printer_info3(p->mem_ctx, info2,
4826 Printer->servername,
4827 &r->out.info->info3, snum);
4828 break;
4829 case 4:
4830 result = construct_printer_info4(p->mem_ctx, info2,
4831 Printer->servername,
4832 &r->out.info->info4, snum);
4833 break;
4834 case 5:
4835 result = construct_printer_info5(p->mem_ctx, info2,
4836 Printer->servername,
4837 &r->out.info->info5, snum);
4838 break;
4839 case 6:
4840 result = construct_printer_info6(p->mem_ctx, p->msg_ctx, info2,
4841 Printer->servername,
4842 &r->out.info->info6, snum);
4843 break;
4844 case 7:
4845 result = construct_printer_info7(p->mem_ctx, p->msg_ctx,
4846 Printer->servername,
4847 &r->out.info->info7, snum);
4848 break;
4849 case 8:
4850 result = construct_printer_info8(p->mem_ctx, info2,
4851 Printer->servername,
4852 &r->out.info->info8, snum);
4853 break;
4854 default:
4855 result = WERR_UNKNOWN_LEVEL;
4856 break;
4857 }
4858 TALLOC_FREE(info2);
4859
4860 out:
4861 if (!W_ERROR_IS_OK(result)) {
4862 DEBUG(0, ("_spoolss_GetPrinter: failed to construct printer info level %d - %s\n",
4863 r->in.level, win_errstr(result)));
4864 TALLOC_FREE(r->out.info);
4865 return result;
4866 }
4867
4868 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo,
4869 r->out.info, r->in.level);
4870 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4871
4872 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4873 }
4874
4875 /********************************************************************
4876 ********************************************************************/
4877
4878 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4879 do { \
4880 if (in && strlen(in)) { \
4881 out = talloc_strdup(mem_ctx, in); \
4882 } else { \
4883 out = talloc_strdup(mem_ctx, ""); \
4884 } \
4885 W_ERROR_HAVE_NO_MEMORY(out); \
4886 } while (0);
4887
4888 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, arch, ver, in, out) \
4889 do { \
4890 if (in && strlen(in)) { \
4891 out = talloc_asprintf(mem_ctx, "\\\\%s\\print$\\%s\\%d\\%s", server, get_short_archi(arch), ver, in); \
4892 } else { \
4893 out = talloc_strdup(mem_ctx, ""); \
4894 } \
4895 W_ERROR_HAVE_NO_MEMORY(out); \
4896 } while (0);
4897
4898 static WERROR string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4899 const char **string_array,
4900 const char ***presult,
4901 const char *cservername,
4902 const char *arch,
4903 int version)
4904 {
4905 int i, num_strings = 0;
4906 const char **array = NULL;
4907
4908 if (string_array == NULL) {
4909 return WERR_INVALID_PARAMETER;
4910 }
4911
4912 for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4913 const char *str = NULL;
4914
4915 if (cservername == NULL || arch == NULL) {
4916 FILL_DRIVER_STRING(mem_ctx, string_array[i], str);
4917 } else {
4918 FILL_DRIVER_UNC_STRING(mem_ctx, cservername, arch, version, string_array[i], str);
4919 }
4920
4921 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4922 TALLOC_FREE(array);
4923 return WERR_NOMEM;
4924 }
4925 }
4926
4927 if (i > 0) {
4928 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4929 &array, &num_strings);
4930 }
4931
4932 if (presult != NULL) {
4933 *presult = array;
4934 } else {
4935 talloc_free(array);
4936 }
4937
4938 return WERR_OK;
4939 }
4940
4941 /********************************************************************
4942 * fill a spoolss_DriverInfo1 struct
4943 ********************************************************************/
4944
4945 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4946 struct spoolss_DriverInfo1 *r,
4947 const struct spoolss_DriverInfo8 *driver,
4948 const char *servername)
4949 {
4950 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4951 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4952
4953 return WERR_OK;
4954 }
4955
4956 /********************************************************************
4957 * fill a spoolss_DriverInfo2 struct
4958 ********************************************************************/
4959
4960 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4961 struct spoolss_DriverInfo2 *r,
4962 const struct spoolss_DriverInfo8 *driver,
4963 const char *servername)
4964
4965 {
4966 const char *cservername = canon_servername(servername);
4967
4968 r->version = driver->version;
4969
4970 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4971 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4972 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4973 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4974
4975 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4976 driver->architecture,
4977 driver->version,
4978 driver->driver_path,
4979 r->driver_path);
4980
4981 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4982 driver->architecture,
4983 driver->version,
4984 driver->data_file,
4985 r->data_file);
4986
4987 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4988 driver->architecture,
4989 driver->version,
4990 driver->config_file,
4991 r->config_file);
4992
4993 return WERR_OK;
4994 }
4995
4996 /********************************************************************
4997 * fill a spoolss_DriverInfo3 struct
4998 ********************************************************************/
4999
5000 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
5001 struct spoolss_DriverInfo3 *r,
5002 const struct spoolss_DriverInfo8 *driver,
5003 const char *servername)
5004 {
5005 const char *cservername = canon_servername(servername);
5006
5007 r->version = driver->version;
5008
5009 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
5010 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5011 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
5012 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5013
5014 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5015 driver->architecture,
5016 driver->version,
5017 driver->driver_path,
5018 r->driver_path);
5019
5020 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5021 driver->architecture,
5022 driver->version,
5023 driver->data_file,
5024 r->data_file);
5025
5026 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5027 driver->architecture,
5028 driver->version,
5029 driver->config_file,
5030 r->config_file);
5031
5032 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5033 driver->architecture,
5034 driver->version,
5035 driver->help_file,
5036 r->help_file);
5037
5038 FILL_DRIVER_STRING(mem_ctx,
5039 driver->monitor_name,
5040 r->monitor_name);
5041
5042 FILL_DRIVER_STRING(mem_ctx,
5043 driver->default_datatype,
5044 r->default_datatype);
5045
5046 return string_array_from_driver_info(mem_ctx,
5047 driver->dependent_files,
5048 &r->dependent_files,
5049 cservername,
5050 driver->architecture,
5051 driver->version);
5052 }
5053
5054 /********************************************************************
5055 * fill a spoolss_DriverInfo4 struct
5056 ********************************************************************/
5057
5058 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
5059 struct spoolss_DriverInfo4 *r,
5060 const struct spoolss_DriverInfo8 *driver,
5061 const char *servername)
5062 {
5063 const char *cservername = canon_servername(servername);
5064 WERROR result;
5065
5066 r->version = driver->version;
5067
5068 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
5069 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5070 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
5071 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5072
5073 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5074 driver->architecture,
5075 driver->version,
5076 driver->driver_path,
5077 r->driver_path);
5078
5079 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5080 driver->architecture,
5081 driver->version,
5082 driver->data_file,
5083 r->data_file);
5084
5085 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5086 driver->architecture,
5087 driver->version,
5088 driver->config_file,
5089 r->config_file);
5090
5091 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5092 driver->architecture,
5093 driver->version,
5094 driver->help_file,
5095 r->help_file);
5096
5097 result = string_array_from_driver_info(mem_ctx,
5098 driver->dependent_files,
5099 &r->dependent_files,
5100 cservername,
5101 driver->architecture,
5102 driver->version);
5103 if (!W_ERROR_IS_OK(result)) {
5104 return result;
5105 }
5106
5107 FILL_DRIVER_STRING(mem_ctx,
5108 driver->monitor_name,
5109 r->monitor_name);
5110
5111 FILL_DRIVER_STRING(mem_ctx,
5112 driver->default_datatype,
5113 r->default_datatype);
5114
5115
5116 result = string_array_from_driver_info(mem_ctx,
5117 driver->previous_names,
5118 &r->previous_names,
5119 NULL, NULL, 0);
5120
5121 return result;
5122 }
5123
5124 /********************************************************************
5125 * fill a spoolss_DriverInfo5 struct
5126 ********************************************************************/
5127
5128 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
5129 struct spoolss_DriverInfo5 *r,
5130 const struct spoolss_DriverInfo8 *driver,
5131 const char *servername)
5132 {
5133 const char *cservername = canon_servername(servername);
5134
5135 r->version = driver->version;
5136
5137 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
5138 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5139 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
5140 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5141
5142 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5143 driver->architecture,
5144 driver->version,
5145 driver->driver_path,
5146 r->driver_path);
5147
5148 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5149 driver->architecture,
5150 driver->version,
5151 driver->data_file,
5152 r->data_file);
5153
5154 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5155 driver->architecture,
5156 driver->version,
5157 driver->config_file,
5158 r->config_file);
5159
5160 r->driver_attributes = 0;
5161 r->config_version = 0;
5162 r->driver_version = 0;
5163
5164 return WERR_OK;
5165 }
5166 /********************************************************************
5167 * fill a spoolss_DriverInfo6 struct
5168 ********************************************************************/
5169
5170 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
5171 struct spoolss_DriverInfo6 *r,
5172 const struct spoolss_DriverInfo8 *driver,
5173 const char *servername)
5174 {
5175 const char *cservername = canon_servername(servername);
5176 WERROR result;
5177
5178 r->version = driver->version;
5179
5180 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
5181 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5182 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
5183 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5184
5185 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5186 driver->architecture,
5187 driver->version,
5188 driver->driver_path,
5189 r->driver_path);
5190
5191 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5192 driver->architecture,
5193 driver->version,
5194 driver->data_file,
5195 r->data_file);
5196
5197 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5198 driver->architecture,
5199 driver->version,
5200 driver->config_file,
5201 r->config_file);
5202
5203 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5204 driver->architecture,
5205 driver->version,
5206 driver->help_file,
5207 r->help_file);
5208
5209 FILL_DRIVER_STRING(mem_ctx,
5210 driver->monitor_name,
5211 r->monitor_name);
5212
5213 FILL_DRIVER_STRING(mem_ctx,
5214 driver->default_datatype,
5215 r->default_datatype);
5216
5217 result = string_array_from_driver_info(mem_ctx,
5218 driver->dependent_files,
5219 &r->dependent_files,
5220 cservername,
5221 driver->architecture,
5222 driver->version);
5223 if (!W_ERROR_IS_OK(result)) {
5224 return result;
5225 }
5226
5227 result = string_array_from_driver_info(mem_ctx,
5228 driver->previous_names,
5229 &r->previous_names,
5230 NULL, NULL, 0);
5231 if (!W_ERROR_IS_OK(result)) {
5232 return result;
5233 }
5234
5235 r->driver_date = driver->driver_date;
5236 r->driver_version = driver->driver_version;
5237
5238 FILL_DRIVER_STRING(mem_ctx,
5239 driver->manufacturer_name,
5240 r->manufacturer_name);
5241 FILL_DRIVER_STRING(mem_ctx,
5242 driver->manufacturer_url,
5243 r->manufacturer_url);
5244 FILL_DRIVER_STRING(mem_ctx,
5245 driver->hardware_id,
5246 r->hardware_id);
5247 FILL_DRIVER_STRING(mem_ctx,
5248 driver->provider,
5249 r->provider);
5250
5251 return WERR_OK;
5252 }
5253
5254 /********************************************************************
5255 * fill a spoolss_DriverInfo8 struct
5256 ********************************************************************/
5257
5258 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
5259 struct spoolss_DriverInfo8 *r,
5260 const struct spoolss_DriverInfo8 *driver,
5261 const char *servername)
5262 {
5263 const char *cservername = canon_servername(servername);
5264 WERROR result;
5265
5266 r->version = driver->version;
5267
5268 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
5269 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5270 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
5271 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5272
5273 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5274 driver->architecture,
5275 driver->version,
5276 driver->driver_path,
5277 r->driver_path);
5278
5279 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5280 driver->architecture,
5281 driver->version,
5282 driver->data_file,
5283 r->data_file);
5284
5285 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5286 driver->architecture,
5287 driver->version,
5288 driver->config_file,
5289 r->config_file);
5290
5291 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5292 driver->architecture,
5293 driver->version,
5294 driver->help_file,
5295 r->help_file);
5296
5297 FILL_DRIVER_STRING(mem_ctx,
5298 driver->monitor_name,
5299 r->monitor_name);
5300
5301 FILL_DRIVER_STRING(mem_ctx,
5302 driver->default_datatype,
5303 r->default_datatype);
5304
5305 result = string_array_from_driver_info(mem_ctx,
5306 driver->dependent_files,
5307 &r->dependent_files,
5308 cservername,
5309 driver->architecture,
5310 driver->version);
5311 if (!W_ERROR_IS_OK(result)) {
5312 return result;
5313 }
5314
5315 result = string_array_from_driver_info(mem_ctx,
5316 driver->previous_names,
5317 &r->previous_names,
5318 NULL, NULL, 0);
5319 if (!W_ERROR_IS_OK(result)) {
5320 return result;
5321 }
5322
5323 r->driver_date = driver->driver_date;
5324 r->driver_version = driver->driver_version;
5325
5326 FILL_DRIVER_STRING(mem_ctx,
5327 driver->manufacturer_name,
5328 r->manufacturer_name);
5329 FILL_DRIVER_STRING(mem_ctx,
5330 driver->manufacturer_url,
5331 r->manufacturer_url);
5332 FILL_DRIVER_STRING(mem_ctx,
5333 driver->hardware_id,
5334 r->hardware_id);
5335 FILL_DRIVER_STRING(mem_ctx,
5336 driver->provider,
5337 r->provider);
5338
5339 FILL_DRIVER_STRING(mem_ctx,
5340 driver->print_processor,
5341 r->print_processor);
5342 FILL_DRIVER_STRING(mem_ctx,
5343 driver->vendor_setup,
5344 r->vendor_setup);
5345
5346 result = string_array_from_driver_info(mem_ctx,
5347 driver->color_profiles,
5348 &r->color_profiles,
5349 NULL, NULL, 0);
5350 if (!W_ERROR_IS_OK(result)) {
5351 return result;
5352 }
5353
5354 FILL_DRIVER_STRING(mem_ctx,
5355 driver->inf_path,
5356 r->inf_path);
5357
5358 r->printer_driver_attributes = driver->printer_driver_attributes;
5359
5360 result = string_array_from_driver_info(mem_ctx,
5361 driver->core_driver_dependencies,
5362 &r->core_driver_dependencies,
5363 NULL, NULL, 0);
5364 if (!W_ERROR_IS_OK(result)) {
5365 return result;
5366 }
5367
5368 r->min_inbox_driver_ver_date = driver->min_inbox_driver_ver_date;
5369 r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
5370
5371 return WERR_OK;
5372 }
5373
5374 #if 0 /* disabled until marshalling issues are resolved - gd */
5375 /********************************************************************
5376 ********************************************************************/
5377
5378 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5379 struct spoolss_DriverFileInfo *r,
5380 const char *cservername,
5381 const char *file_name,
5382 enum spoolss_DriverFileType file_type,
5383 uint32_t file_version)
5384 {
5385 r->file_name = talloc_asprintf(mem_ctx, "\\\\%s%s",
5386 cservername, file_name);
5387 W_ERROR_HAVE_NO_MEMORY(r->file_name);
5388 r->file_type = file_type;
5389 r->file_version = file_version;
5390
5391 return WERR_OK;
5392 }
5393
5394 /********************************************************************
5395 ********************************************************************/
5396
5397 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5398 const struct spoolss_DriverInfo8 *driver,
5399 const char *cservername,
5400 struct spoolss_DriverFileInfo **info_p,
5401 uint32_t *count_p)
5402 {
5403 struct spoolss_DriverFileInfo *info = NULL;
5404 uint32_t count = 0;
5405 WERROR result;
5406 uint32_t i;
5407
5408 *info_p = NULL;
5409 *count_p = 0;
5410
5411 if (strlen(driver->driver_path)) {
5412 info = talloc_realloc(mem_ctx, info,
5413 struct spoolss_DriverFileInfo,
5414 count + 1);
5415 W_ERROR_HAVE_NO_MEMORY(info);
5416 result = fill_spoolss_DriverFileInfo(info,
5417 &info[count],
5418 cservername,
5419 driver->driver_path,
5420 SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5421 0);
5422 W_ERROR_NOT_OK_RETURN(result);
5423 count++;
5424 }
5425
5426 if (strlen(driver->config_file)) {
5427 info = talloc_realloc(mem_ctx, info,
5428 struct spoolss_DriverFileInfo,
5429 count + 1);
5430 W_ERROR_HAVE_NO_MEMORY(info);
5431 result = fill_spoolss_DriverFileInfo(info,
5432 &info[count],
5433 cservername,
5434 driver->config_file,
5435 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5436 0);
5437 W_ERROR_NOT_OK_RETURN(result);
5438 count++;
5439 }
5440
5441 if (strlen(driver->data_file)) {
5442 info = talloc_realloc(mem_ctx, info,
5443 struct spoolss_DriverFileInfo,
5444 count + 1);
5445 W_ERROR_HAVE_NO_MEMORY(info);
5446 result = fill_spoolss_DriverFileInfo(info,
5447 &info[count],
5448 cservername,
5449 driver->data_file,
5450 SPOOLSS_DRIVER_FILE_TYPE_DATA,
5451 0);
5452 W_ERROR_NOT_OK_RETURN(result);
5453 count++;
5454 }
5455
5456 if (strlen(driver->help_file)) {
5457 info = talloc_realloc(mem_ctx, info,
5458 struct spoolss_DriverFileInfo,
5459 count + 1);
5460 W_ERROR_HAVE_NO_MEMORY(info);
5461 result = fill_spoolss_DriverFileInfo(info,
5462 &info[count],
5463 cservername,
5464 driver->help_file,
5465 SPOOLSS_DRIVER_FILE_TYPE_HELP,
5466 0);
5467 W_ERROR_NOT_OK_RETURN(result);
5468 count++;
5469 }
5470
5471 for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
5472 info = talloc_realloc(mem_ctx, info,
5473 struct spoolss_DriverFileInfo,
5474 count + 1);
5475 W_ERROR_HAVE_NO_MEMORY(info);
5476 result = fill_spoolss_DriverFileInfo(info,
5477 &info[count],
5478 cservername,
5479 driver->dependent_files[i],
5480 SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5481 0);
5482 W_ERROR_NOT_OK_RETURN(result);
5483 count++;
5484 }
5485
5486 *info_p = info;
5487 *count_p = count;
5488
5489 return WERR_OK;
5490 }
5491
5492 /********************************************************************
5493 * fill a spoolss_DriverInfo101 struct
5494 ********************************************************************/
5495
5496 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5497 struct spoolss_DriverInfo101 *r,
5498 const struct spoolss_DriverInfo8 *driver,
5499 const char *servername)
5500 {
5501 const char *cservername = canon_servername(servername);
5502 WERROR result;
5503
5504 r->version = driver->version;
5505
5506 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
5507 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5508 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
5509 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5510
5511 result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5512 cservername,
5513 &r->file_info,
5514 &r->file_count);
5515 if (!W_ERROR_IS_OK(result)) {
5516 return result;
5517 }
5518
5519 FILL_DRIVER_STRING(mem_ctx,
5520 driver->monitor_name,
5521 r->monitor_name);
5522
5523 FILL_DRIVER_STRING(mem_ctx,
5524 driver->default_datatype,
5525 r->default_datatype);
5526
5527 result = string_array_from_driver_info(mem_ctx,
5528 driver->previous_names,
5529 &r->previous_names,
5530 NULL, NULL, 0);
5531 if (!W_ERROR_IS_OK(result)) {
5532 return result;
5533 }
5534
5535 r->driver_date = driver->driver_date;
5536 r->driver_version = driver->driver_version;
5537
5538 FILL_DRIVER_STRING(mem_ctx,
5539 driver->manufacturer_name,
5540 r->manufacturer_name);
5541 FILL_DRIVER_STRING(mem_ctx,
5542 driver->manufacturer_url,
5543 r->manufacturer_url);
5544 FILL_DRIVER_STRING(mem_ctx,
5545 driver->hardware_id,
5546 r->hardware_id);
5547 FILL_DRIVER_STRING(mem_ctx,
5548 driver->provider,
5549 r->provider);
5550
5551 return WERR_OK;
5552 }
5553 #endif
5554 /********************************************************************
5555 ********************************************************************/
5556
5557 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
5558 const struct auth_session_info *session_info,
5559 struct messaging_context *msg_ctx,
5560 uint32_t level,
5561 union spoolss_DriverInfo *r,
5562 int snum,
5563 const char *servername,
5564 const char *architecture,
5565 uint32_t version)
5566 {
5567 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
5568 struct spoolss_DriverInfo8 *driver;
5569 WERROR result;
5570 struct dcerpc_binding_handle *b;
5571 TALLOC_CTX *tmp_ctx = NULL;
5572
5573 if (level == 101) {
5574 return WERR_UNKNOWN_LEVEL;
5575 }
5576
5577 tmp_ctx = talloc_new(mem_ctx);
5578 if (!tmp_ctx) {
5579 return WERR_NOMEM;
5580 }
5581
5582 result = winreg_printer_binding_handle(tmp_ctx,
5583 session_info,
5584 msg_ctx,
5585 &b);
5586 if (!W_ERROR_IS_OK(result)) {
5587 goto done;
5588 }
5589
5590 result = winreg_get_printer(tmp_ctx, b,
5591 lp_const_servicename(snum),
5592 &pinfo2);
5593
5594 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5595 win_errstr(result)));
5596
5597 if (!W_ERROR_IS_OK(result)) {
5598 result = WERR_INVALID_PRINTER_NAME;
5599 goto done;
5600 }
5601
5602 result = winreg_get_driver(tmp_ctx, b,
5603 architecture,
5604 pinfo2->drivername, version, &driver);
5605
5606 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5607 win_errstr(result)));
5608
5609 if (!W_ERROR_IS_OK(result)) {
5610 /*
5611 * Is this a W2k client ?
5612 */
5613
5614 if (version < 3) {
5615 result = WERR_UNKNOWN_PRINTER_DRIVER;
5616 goto done;
5617 }
5618
5619 /* Yes - try again with a WinNT driver. */
5620 version = 2;
5621 result = winreg_get_driver(tmp_ctx, b,
5622 architecture,
5623 pinfo2->drivername,
5624 version, &driver);
5625 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5626 win_errstr(result)));
5627 if (!W_ERROR_IS_OK(result)) {
5628 result = WERR_UNKNOWN_PRINTER_DRIVER;
5629 goto done;
5630 }
5631 }
5632
5633 /* these are allocated on mem_ctx and not tmp_ctx because they are
5634 * the 'return value' and need to utlive this call */
5635 switch (level) {
5636 case 1:
5637 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5638 break;
5639 case 2:
5640 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5641 break;
5642 case 3:
5643 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5644 break;
5645 case 4:
5646 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5647 break;
5648 case 5:
5649 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5650 break;
5651 case 6:
5652 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5653 break;
5654 case 8:
5655 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5656 break;
5657 #if 0 /* disabled until marshalling issues are resolved - gd */
5658 case 101:
5659 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5660 break;
5661 #endif
5662 default:
5663 result = WERR_UNKNOWN_LEVEL;
5664 break;
5665 }
5666
5667 done:
5668 talloc_free(tmp_ctx);
5669 return result;
5670 }
5671
5672 /****************************************************************
5673 _spoolss_GetPrinterDriver2
5674 ****************************************************************/
5675
5676 WERROR _spoolss_GetPrinterDriver2(struct pipes_struct *p,
5677 struct spoolss_GetPrinterDriver2 *r)
5678 {
5679 struct printer_handle *printer;
5680 WERROR result;
5681 uint32_t version = r->in.client_major_version;
5682
5683 int snum;
5684
5685 /* that's an [in out] buffer */
5686
5687 if (!r->in.buffer && (r->in.offered != 0)) {
5688 return WERR_INVALID_PARAM;
5689 }
5690
5691 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5692
5693 if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5694 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5695 return WERR_INVALID_PRINTER_NAME;
5696 }
5697
5698 *r->out.needed = 0;
5699 *r->out.server_major_version = 0;
5700 *r->out.server_minor_version = 0;
5701
5702 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5703 return WERR_BADFID;
5704 }
5705
5706 if (r->in.client_major_version == SPOOLSS_DRIVER_VERSION_2012) {
5707 DEBUG(3,("_spoolss_GetPrinterDriver2: v4 driver requested, "
5708 "downgrading to v3\n"));
5709 version = SPOOLSS_DRIVER_VERSION_200X;
5710 }
5711
5712 result = construct_printer_driver_info_level(p->mem_ctx,
5713 get_session_info_system(),
5714 p->msg_ctx,
5715 r->in.level, r->out.info,
5716 snum, printer->servername,
5717 r->in.architecture,
5718 version);
5719 if (!W_ERROR_IS_OK(result)) {
5720 TALLOC_FREE(r->out.info);
5721 return result;
5722 }
5723
5724 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo,
5725 r->out.info, r->in.level);
5726 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5727
5728 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5729 }
5730
5731
5732 /****************************************************************
5733 _spoolss_StartPagePrinter
5734 ****************************************************************/
5735
5736 WERROR _spoolss_StartPagePrinter(struct pipes_struct *p,
5737 struct spoolss_StartPagePrinter *r)
5738 {
5739 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5740
5741 if (!Printer) {
5742 DEBUG(3,("_spoolss_StartPagePrinter: "
5743 "Error in startpageprinter printer handle\n"));
5744 return WERR_BADFID;
5745 }
5746
5747 Printer->page_started = true;
5748 return WERR_OK;
5749 }
5750
5751 /****************************************************************
5752 _spoolss_EndPagePrinter
5753 ****************************************************************/
5754
5755 WERROR _spoolss_EndPagePrinter(struct pipes_struct *p,
5756 struct spoolss_EndPagePrinter *r)
5757 {
5758 int snum;
5759
5760 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5761
5762 if (!Printer) {
5763 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5764 OUR_HANDLE(r->in.handle)));
5765 return WERR_BADFID;
5766 }
5767
5768 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5769 return WERR_BADFID;
5770
5771 Printer->page_started = false;
5772 print_job_endpage(p->msg_ctx, snum, Printer->jobid);
5773
5774 return WERR_OK;
5775 }
5776
5777 /****************************************************************
5778 _spoolss_StartDocPrinter
5779 ****************************************************************/
5780
5781 WERROR _spoolss_StartDocPrinter(struct pipes_struct *p,
5782 struct spoolss_StartDocPrinter *r)
5783 {
5784 struct spoolss_DocumentInfo1 *info_1;
5785 int snum;
5786 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5787 WERROR werr;
5788 char *rhost;
5789 int rc;
5790
5791 if (!Printer) {
5792 DEBUG(2,("_spoolss_StartDocPrinter: "
5793 "Invalid handle (%s:%u:%u)\n",
5794 OUR_HANDLE(r->in.handle)));
5795 return WERR_BADFID;
5796 }
5797
5798 if (Printer->jobid) {
5799 DEBUG(2, ("_spoolss_StartDocPrinter: "
5800 "StartDocPrinter called twice! "
5801 "(existing jobid = %d)\n", Printer->jobid));
5802 return WERR_INVALID_HANDLE;
5803 }
5804
5805 if (r->in.info_ctr->level != 1) {
5806 return WERR_UNKNOWN_LEVEL;
5807 }
5808
5809 info_1 = r->in.info_ctr->info.info1;
5810
5811 /*
5812 * a nice thing with NT is it doesn't listen to what you tell it.
5813 * when asked to send _only_ RAW datas, it tries to send datas
5814 * in EMF format.
5815 *
5816 * So I add checks like in NT Server ...
5817 */
5818
5819 if (info_1->datatype) {
5820 /*
5821 * The v4 driver model used in Windows 8 declares print jobs
5822 * intended to bypass the XPS processing layer by setting
5823 * datatype to "XPS_PASS" instead of "RAW".
5824 */
5825 if ((strcmp(info_1->datatype, "RAW") != 0)
5826 && (strcmp(info_1->datatype, "XPS_PASS") != 0)) {
5827 *r->out.job_id = 0;
5828 return WERR_INVALID_DATATYPE;
5829 }
5830 }
5831
5832 /* get the share number of the printer */
5833 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5834 return WERR_BADFID;
5835 }
5836
5837 rc = get_remote_hostname(p->remote_address,
5838 &rhost,
5839 p->mem_ctx);
5840 if (rc < 0) {
5841 return WERR_NOMEM;
5842 }
5843 if (strequal(rhost,"UNKNOWN")) {
5844 rhost = tsocket_address_inet_addr_string(p->remote_address,
5845 p->mem_ctx);
5846 if (rhost == NULL) {
5847 return WERR_NOMEM;
5848 }
5849 }
5850
5851 werr = print_job_start(p->session_info,
5852 p->msg_ctx,
5853 rhost,
5854 snum,
5855 info_1->document_name,
5856 info_1->output_file,
5857 Printer->devmode,
5858 &Printer->jobid);
5859
5860 /* An error occured in print_job_start() so return an appropriate
5861 NT error code. */
5862
5863 if (!W_ERROR_IS_OK(werr)) {
5864 return werr;
5865 }
5866
5867 Printer->document_started = true;
5868 *r->out.job_id = Printer->jobid;
5869
5870 return WERR_OK;
5871 }
5872
5873 /****************************************************************
5874 _spoolss_EndDocPrinter
5875 ****************************************************************/
5876
5877 WERROR _spoolss_EndDocPrinter(struct pipes_struct *p,
5878 struct spoolss_EndDocPrinter *r)
5879 {
5880 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5881 NTSTATUS status;
5882 int snum;
5883
5884 if (!Printer) {
5885 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5886 OUR_HANDLE(r->in.handle)));
5887 return WERR_BADFID;
5888 }
5889
5890 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5891 return WERR_BADFID;
5892 }
5893
5894 Printer->document_started = false;
5895 status = print_job_end(p->msg_ctx, snum, Printer->jobid, NORMAL_CLOSE);
5896 if (!NT_STATUS_IS_OK(status)) {
5897 DEBUG(2, ("_spoolss_EndDocPrinter: "
5898 "print_job_end failed [%s]\n",
5899 nt_errstr(status)));
5900 }
5901
5902 Printer->jobid = 0;
5903 return ntstatus_to_werror(status);
5904 }
5905
5906 /****************************************************************
5907 _spoolss_WritePrinter
5908 ****************************************************************/
5909
5910 WERROR _spoolss_WritePrinter(struct pipes_struct *p,
5911 struct spoolss_WritePrinter *r)
5912 {
5913 ssize_t buffer_written;
5914 int snum;
5915 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5916
5917 if (!Printer) {
5918 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5919 OUR_HANDLE(r->in.handle)));
5920 *r->out.num_written = r->in._data_size;
5921 return WERR_BADFID;
5922 }
5923
5924 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5925 return WERR_BADFID;
5926
5927 /* print_job_write takes care of checking for PJOB_SMBD_SPOOLING */
5928 buffer_written = print_job_write(server_event_context(),p->msg_ctx,
5929 snum, Printer->jobid,
5930 (const char *)r->in.data.data,
5931 (size_t)r->in._data_size);
5932 if (buffer_written == (ssize_t)-1) {
5933 *r->out.num_written = 0;
5934 if (errno == ENOSPC)
5935 return WERR_NO_SPOOL_SPACE;
5936 else
5937 return WERR_ACCESS_DENIED;
5938 }
5939
5940 *r->out.num_written = r->in._data_size;
5941
5942 return WERR_OK;
5943 }
5944
5945 /********************************************************************
5946 * api_spoolss_getprinter
5947 * called from the spoolss dispatcher
5948 *
5949 ********************************************************************/
5950
5951 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5952 struct pipes_struct *p)
5953 {
5954 const struct auth_session_info *session_info = p->session_info;
5955 int snum;
5956 WERROR errcode = WERR_BADFUNC;
5957 struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
5958
5959 if (!Printer) {
5960 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5961 OUR_HANDLE(handle)));
5962 return WERR_BADFID;
5963 }
5964
5965 if (!get_printer_snum(p, handle, &snum, NULL))
5966 return WERR_BADFID;
5967
5968 switch (command) {
5969 case SPOOLSS_PRINTER_CONTROL_PAUSE:
5970 errcode = print_queue_pause(session_info, p->msg_ctx, snum);
5971 break;
5972 case SPOOLSS_PRINTER_CONTROL_RESUME:
5973 case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5974 errcode = print_queue_resume(session_info, p->msg_ctx, snum);
5975 break;
5976 case SPOOLSS_PRINTER_CONTROL_PURGE:
5977 errcode = print_queue_purge(session_info, p->msg_ctx, snum);
5978 break;
5979 default:
5980 return WERR_UNKNOWN_LEVEL;
5981 }
5982
5983 return errcode;
5984 }
5985
5986
5987 /****************************************************************
5988 _spoolss_AbortPrinter
5989 * From MSDN: "Deletes printer's spool file if printer is configured
5990 * for spooling"
5991 ****************************************************************/
5992
5993 WERROR _spoolss_AbortPrinter(struct pipes_struct *p,
5994 struct spoolss_AbortPrinter *r)
5995 {
5996 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5997 int snum;
5998 WERROR errcode = WERR_OK;
5999
6000 if (!Printer) {
6001 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
6002 OUR_HANDLE(r->in.handle)));
6003 return WERR_BADFID;
6004 }
6005
6006 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
6007 return WERR_BADFID;
6008
6009 if (!Printer->document_started) {
6010 return WERR_SPL_NO_STARTDOC;
6011 }
6012
6013 errcode = print_job_delete(p->session_info,
6014 p->msg_ctx,
6015 snum,
6016 Printer->jobid);
6017
6018 return errcode;
6019 }
6020
6021 /********************************************************************
6022 * called by spoolss_api_setprinter
6023 * when updating a printer description
6024 ********************************************************************/
6025
6026 static WERROR update_printer_sec(struct policy_handle *handle,
6027 struct pipes_struct *p,
6028 struct sec_desc_buf *secdesc_ctr)
6029 {
6030 struct spoolss_security_descriptor *new_secdesc = NULL;
6031 struct spoolss_security_descriptor *old_secdesc = NULL;
6032 const char *printer;
6033 WERROR result;
6034 int snum;
6035 struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6036 struct dcerpc_binding_handle *b;
6037 TALLOC_CTX *tmp_ctx = NULL;
6038
6039 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
6040 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
6041 OUR_HANDLE(handle)));
6042
6043 result = WERR_BADFID;
6044 goto done;
6045 }
6046
6047 if (secdesc_ctr == NULL) {
6048 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
6049 result = WERR_INVALID_PARAM;
6050 goto done;
6051 }
6052 printer = lp_const_servicename(snum);
6053
6054 /* Check the user has permissions to change the security
6055 descriptor. By experimentation with two NT machines, the user
6056 requires Full Access to the printer to change security
6057 information. */
6058
6059 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
6060 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
6061 result = WERR_ACCESS_DENIED;
6062 goto done;
6063 }
6064
6065 tmp_ctx = talloc_new(p->mem_ctx);
6066 if (!tmp_ctx) {
6067 return WERR_NOMEM;
6068 }
6069
6070 result = winreg_printer_binding_handle(tmp_ctx,
6071 get_session_info_system(),
6072 p->msg_ctx,
6073 &b);
6074 if (!W_ERROR_IS_OK(result)) {
6075 goto done;
6076 }
6077
6078 /* NT seems to like setting the security descriptor even though
6079 nothing may have actually changed. */
6080 result = winreg_get_printer_secdesc(tmp_ctx, b,
6081 printer,
6082 &old_secdesc);
6083 if (!W_ERROR_IS_OK(result)) {
6084 DEBUG(2,("update_printer_sec: winreg_get_printer_secdesc_internal() failed\n"));
6085 result = WERR_BADFID;
6086 goto done;
6087 }
6088
6089 if (DEBUGLEVEL >= 10) {
6090 struct security_acl *the_acl;
6091 int i;
6092
6093 the_acl = old_secdesc->dacl;
6094 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
6095 printer, the_acl->num_aces));
6096
6097 for (i = 0; i < the_acl->num_aces; i++) {
6098 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6099 &the_acl->aces[i].trustee),
6100 the_acl->aces[i].access_mask));
6101 }
6102
6103 the_acl = secdesc_ctr->sd->dacl;
6104
6105 if (the_acl) {
6106 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
6107 printer, the_acl->num_aces));
6108
6109 for (i = 0; i < the_acl->num_aces; i++) {
6110 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6111 &the_acl->aces[i].trustee),
6112 the_acl->aces[i].access_mask));
6113 }
6114 } else {
6115 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
6116 }
6117 }
6118
6119 new_secdesc = sec_desc_merge(tmp_ctx, secdesc_ctr->sd, old_secdesc);
6120 if (new_secdesc == NULL) {
6121 result = WERR_NOMEM;
6122 goto done;
6123 }
6124
6125 if (security_descriptor_equal(new_secdesc, old_secdesc)) {
6126 result = WERR_OK;
6127 goto done;
6128 }
6129
6130 result = winreg_set_printer_secdesc(tmp_ctx, b,
6131 printer,
6132 new_secdesc);
6133
6134 done:
6135 talloc_free(tmp_ctx);
6136 return result;
6137 }
6138
6139 /********************************************************************
6140 Canonicalize printer info from a client
6141 ********************************************************************/
6142
6143 static bool check_printer_ok(TALLOC_CTX *mem_ctx,
6144 struct spoolss_SetPrinterInfo2 *info2,
6145 int snum)
6146 {
6147 fstring printername;
6148 const char *p;
6149
6150 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
6151 "portname=%s drivername=%s comment=%s location=%s\n",
6152 info2->servername, info2->printername, info2->sharename,
6153 info2->portname, info2->drivername, info2->comment,
6154 info2->location));
6155
6156 /* we force some elements to "correct" values */
6157 info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
6158 if (info2->servername == NULL) {
6159 return false;
6160 }
6161 info2->sharename = talloc_strdup(mem_ctx, lp_const_servicename(snum));
6162 if (info2->sharename == NULL) {
6163 return false;
6164 }
6165
6166 /* check to see if we allow printername != sharename */
6167 if (lp_force_printername(snum)) {
6168 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
6169 lp_netbios_name(), info2->sharename);
6170 } else {
6171 /* make sure printername is in \\server\printername format */
6172 fstrcpy(printername, info2->printername);
6173 p = printername;
6174 if ( printername[0] == '\\' && printername[1] == '\\' ) {
6175 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
6176 p++;
6177 }
6178
6179 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
6180 lp_netbios_name(), p);
6181 }
6182 if (info2->printername == NULL) {
6183 return false;
6184 }
6185
6186 info2->attributes |= PRINTER_ATTRIBUTE_SAMBA;
6187 info2->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
6188
6189 return true;
6190 }
6191
6192 /****************************************************************************
6193 ****************************************************************************/
6194
6195 static WERROR add_port_hook(TALLOC_CTX *ctx, struct security_token *token, const char *portname, const char *uri)
6196 {
6197 char *cmd = lp_addport_command(talloc_tos());
6198 char *command = NULL;
6199 int ret;
6200 bool is_print_op = false;
6201
6202 if ( !*cmd ) {
6203 return WERR_ACCESS_DENIED;
6204 }
6205
6206 command = talloc_asprintf(ctx,
6207 "%s \"%s\" \"%s\"", cmd, portname, uri );
6208 if (!command) {
6209 return WERR_NOMEM;
6210 }
6211
6212 if ( token )
6213 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
6214
6215 DEBUG(10,("Running [%s]\n", command));
6216
6217 /********* BEGIN SePrintOperatorPrivilege **********/
6218
6219 if ( is_print_op )
6220 become_root();
6221
6222 ret = smbrun(command, NULL);
6223
6224 if ( is_print_op )
6225 unbecome_root();
6226
6227 /********* END SePrintOperatorPrivilege **********/
6228
6229 DEBUGADD(10,("returned [%d]\n", ret));
6230
6231 TALLOC_FREE(command);
6232
6233 if ( ret != 0 ) {
6234 return WERR_ACCESS_DENIED;
6235 }
6236
6237 return WERR_OK;
6238 }
6239
6240 /****************************************************************************
6241 ****************************************************************************/
6242
6243 static bool spoolss_conn_snum_used(struct smbd_server_connection *sconn,
6244 int snum)
6245 {
6246 /*
6247 * As we do not know if we are embedded in the file server process
6248 * or not, we have to pretend that all shares are in use.
6249 */
6250 return true;
6251 }
6252
6253 static bool add_printer_hook(TALLOC_CTX *ctx, struct security_token *token,
6254 struct spoolss_SetPrinterInfo2 *info2,
6255 const char *remote_machine,
6256 struct messaging_context *msg_ctx)
6257 {
6258 char *cmd = lp_addprinter_command(talloc_tos());
6259 char **qlines;
6260 char *command = NULL;
6261 int numlines;
6262 int ret;
6263 int fd;
6264 bool is_print_op = false;
6265
6266 if (!remote_machine) {
6267 return false;
6268 }
6269
6270 command = talloc_asprintf(ctx,
6271 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
6272 cmd, info2->printername, info2->sharename,
6273 info2->portname, info2->drivername,
6274 info2->location, info2->comment, remote_machine);
6275 if (!command) {
6276 return false;
6277 }
6278
6279 if ( token )
6280 is_print_op = security_token_has_privilege(token, SEC_PRIV_PRINT_OPERATOR);
6281
6282 DEBUG(10,("Running [%s]\n", command));
6283
6284 /********* BEGIN SePrintOperatorPrivilege **********/
6285
6286 if ( is_print_op )
6287 become_root();
6288
6289 if ( (ret = smbrun(command, &fd)) == 0 ) {
6290 /* Tell everyone we updated smb.conf. */
6291 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6292 }
6293
6294 if ( is_print_op )
6295 unbecome_root();
6296
6297 /********* END SePrintOperatorPrivilege **********/
6298
6299 DEBUGADD(10,("returned [%d]\n", ret));
6300
6301 TALLOC_FREE(command);
6302
6303 if ( ret != 0 ) {
6304 if (fd != -1)
6305 close(fd);
6306 return false;
6307 }
6308
6309 /* reload our services immediately */
6310 become_root();
6311 reload_services(NULL, spoolss_conn_snum_used, false);
6312 unbecome_root();
6313
6314 numlines = 0;
6315 /* Get lines and convert them back to dos-codepage */
6316 qlines = fd_lines_load(fd, &numlines, 0, NULL);
6317 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6318 close(fd);
6319
6320 /* Set the portname to what the script says the portname should be. */
6321 /* but don't require anything to be return from the script exit a good error code */
6322
6323 if (numlines) {
6324 /* Set the portname to what the script says the portname should be. */
6325 info2->portname = talloc_strdup(ctx, qlines[0]);
6326 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6327 }
6328
6329 TALLOC_FREE(qlines);
6330 return true;
6331 }
6332
6333 static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
6334 const struct auth_session_info *session_info,
6335 struct messaging_context *msg_ctx,
6336 int snum,
6337 struct spoolss_SetPrinterInfo2 *printer,
6338 struct spoolss_PrinterInfo2 *old_printer)
6339 {
6340 bool force_update = (old_printer == NULL);
6341 const char *dnsdomname;
6342 const char *longname;
6343 const char *uncname;
6344 const char *spooling;
6345 DATA_BLOB buffer;
6346 WERROR result = WERR_OK;
6347 struct dcerpc_binding_handle *b;
6348 TALLOC_CTX *tmp_ctx;
6349 bool ok;
6350
6351 tmp_ctx = talloc_new(mem_ctx);
6352 if (!tmp_ctx) {
6353 return WERR_NOMEM;
6354 }
6355
6356 result = winreg_printer_binding_handle(tmp_ctx,
6357 session_info,
6358 msg_ctx,
6359 &b);
6360 if (!W_ERROR_IS_OK(result)) {
6361 goto done;
6362 }
6363
6364 if (printer->drivername != NULL &&
6365 (force_update ||
6366 !strequal(printer->drivername, old_printer->drivername))) {
6367 ok = push_reg_sz(tmp_ctx, &buffer, printer->drivername);
6368 if (!ok) {
6369 DEBUG(0, ("%s data corrupted\n", SPOOL_REG_DRIVERNAME));
6370 result = WERR_INVALID_DATA;
6371 goto done;
6372 }
6373 result = winreg_set_printer_dataex(tmp_ctx, b,
6374 printer->sharename,
6375 SPOOL_DSSPOOLER_KEY,
6376 SPOOL_REG_DRIVERNAME,
6377 REG_SZ,
6378 buffer.data,
6379 buffer.length);
6380 if (!W_ERROR_IS_OK(result)) {
6381 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_DRIVERNAME));
6382 goto done;
6383 }
6384
6385 if (!force_update) {
6386 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
6387 printer->drivername));
6388
6389 notify_printer_driver(server_event_context(), msg_ctx,
6390 snum, printer->drivername ?
6391 printer->drivername : "");
6392 }
6393 }
6394
6395 if (printer->comment != NULL &&
6396 (force_update ||
6397 !strequal(printer->comment, old_printer->comment))) {
6398 ok = push_reg_sz(tmp_ctx, &buffer, printer->comment);
6399 if (!ok) {
6400 DEBUG(0, ("comment data corrupted\n"));
6401 result = WERR_INVALID_DATA;
6402 goto done;
6403 }
6404 result = winreg_set_printer_dataex(tmp_ctx, b,
6405 printer->sharename,
6406 SPOOL_DSSPOOLER_KEY,
6407 SPOOL_REG_DESCRIPTION,
6408 REG_SZ,
6409 buffer.data,
6410 buffer.length);
6411 if (!W_ERROR_IS_OK(result)) {
6412 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_DESCRIPTION));
6413 goto done;
6414 }
6415
6416 if (!force_update) {
6417 notify_printer_comment(server_event_context(), msg_ctx,
6418 snum, printer->comment ?
6419 printer->comment : "");
6420 }
6421 }
6422
6423 if (printer->sharename != NULL &&
6424 (force_update ||
6425 !strequal(printer->sharename, old_printer->sharename))) {
6426 ok = push_reg_sz(tmp_ctx, &buffer, printer->sharename);
6427 if (!ok) {
6428 DEBUG(0, ("sharename data corrupted\n"));
6429 result = WERR_INVALID_DATA;
6430 goto done;
6431 }
6432 result = winreg_set_printer_dataex(tmp_ctx, b,
6433 printer->sharename,
6434 SPOOL_DSSPOOLER_KEY,
6435 SPOOL_REG_PRINTSHARENAME,
6436 REG_SZ,
6437 buffer.data,
6438 buffer.length);
6439 if (!W_ERROR_IS_OK(result)) {
6440 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSHARENAME));
6441 goto done;
6442 }
6443
6444 if (!force_update) {
6445 notify_printer_sharename(server_event_context(),
6446 msg_ctx,
6447 snum, printer->sharename ?
6448 printer->sharename : "");
6449 }
6450 }
6451
6452 if (printer->printername != NULL &&
6453 (force_update ||
6454 !strequal(printer->printername, old_printer->printername))) {
6455 const char *p;
6456
6457 p = strrchr(printer->printername, '\\' );
6458 if (p != NULL) {
6459 p++;
6460 } else {
6461 p = printer->printername;
6462 }
6463
6464 ok = push_reg_sz(tmp_ctx, &buffer, p);
6465 if (!ok) {
6466 DEBUG(0, ("printername data corrupted\n"));
6467 result = WERR_INVALID_DATA;
6468 goto done;
6469 }
6470 result = winreg_set_printer_dataex(tmp_ctx, b,
6471 printer->sharename,
6472 SPOOL_DSSPOOLER_KEY,
6473 SPOOL_REG_PRINTERNAME,
6474 REG_SZ,
6475 buffer.data,
6476 buffer.length);
6477 if (!W_ERROR_IS_OK(result)) {
6478 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSHARENAME));
6479 goto done;
6480 }
6481
6482 if (!force_update) {
6483 notify_printer_printername(server_event_context(),
6484 msg_ctx, snum, p ? p : "");
6485 }
6486 }
6487
6488 if (printer->portname != NULL &&
6489 (force_update ||
6490 !strequal(printer->portname, old_printer->portname))) {
6491 ok = push_reg_sz(tmp_ctx, &buffer, printer->portname);
6492 if (!ok) {
6493 DEBUG(0, ("portname data corrupted\n"));
6494 result = WERR_INVALID_DATA;
6495 goto done;
6496 }
6497 result = winreg_set_printer_dataex(tmp_ctx, b,
6498 printer->sharename,
6499 SPOOL_DSSPOOLER_KEY,
6500 SPOOL_REG_PORTNAME,
6501 REG_SZ,
6502 buffer.data,
6503 buffer.length);
6504 if (!W_ERROR_IS_OK(result)) {
6505 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PORTNAME));
6506 goto done;
6507 }
6508
6509 if (!force_update) {
6510 notify_printer_port(server_event_context(),
6511 msg_ctx, snum, printer->portname ?
6512 printer->portname : "");
6513 }
6514 }
6515
6516 if (printer->location != NULL &&
6517 (force_update ||
6518 !strequal(printer->location, old_printer->location))) {
6519 ok = push_reg_sz(tmp_ctx, &buffer, printer->location);
6520 if (!ok) {
6521 DEBUG(0, ("location data corrupted\n"));
6522 result = WERR_INVALID_DATA;
6523 goto done;
6524 }
6525 result = winreg_set_printer_dataex(tmp_ctx, b,
6526 printer->sharename,
6527 SPOOL_DSSPOOLER_KEY,
6528 SPOOL_REG_LOCATION,
6529 REG_SZ,
6530 buffer.data,
6531 buffer.length);
6532 if (!W_ERROR_IS_OK(result)) {
6533 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_LOCATION));
6534 goto done;
6535 }
6536
6537 if (!force_update) {
6538 notify_printer_location(server_event_context(),
6539 msg_ctx, snum,
6540 printer->location ?
6541 printer->location : "");
6542 }
6543 }
6544
6545 if (printer->sepfile != NULL &&
6546 (force_update ||
6547 !strequal(printer->sepfile, old_printer->sepfile))) {
6548 ok = push_reg_sz(tmp_ctx, &buffer, printer->sepfile);
6549 if (!ok) {
6550 DEBUG(0, ("sepfile data corrupted\n"));
6551 result = WERR_INVALID_DATA;
6552 goto done;
6553 }
6554 result = winreg_set_printer_dataex(tmp_ctx, b,
6555 printer->sharename,
6556 SPOOL_DSSPOOLER_KEY,
6557 SPOOL_REG_PRINTSEPARATORFILE,
6558 REG_SZ,
6559 buffer.data,
6560 buffer.length);
6561 if (!W_ERROR_IS_OK(result)) {
6562 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSEPARATORFILE));
6563 goto done;
6564 }
6565
6566 if (!force_update) {
6567 notify_printer_sepfile(server_event_context(),
6568 msg_ctx, snum,
6569 printer->sepfile ?
6570 printer->sepfile : "");
6571 }
6572 }
6573
6574 if (printer->starttime != 0 &&
6575 (force_update ||
6576 printer->starttime != old_printer->starttime)) {
6577 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6578 SIVAL(buffer.data, 0, printer->starttime);
6579 result = winreg_set_printer_dataex(tmp_ctx, b,
6580 printer->sharename,
6581 SPOOL_DSSPOOLER_KEY,
6582 SPOOL_REG_PRINTSTARTTIME,
6583 REG_DWORD,
6584 buffer.data,
6585 buffer.length);
6586 if (!W_ERROR_IS_OK(result)) {
6587 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTSTARTTIME));
6588 goto done;
6589 }
6590 }
6591
6592 if (printer->untiltime != 0 &&
6593 (force_update ||
6594 printer->untiltime != old_printer->untiltime)) {
6595 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6596 SIVAL(buffer.data, 0, printer->untiltime);
6597 result = winreg_set_printer_dataex(tmp_ctx, b,
6598 printer->sharename,
6599 SPOOL_DSSPOOLER_KEY,
6600 SPOOL_REG_PRINTENDTIME,
6601 REG_DWORD,
6602 buffer.data,
6603 buffer.length);
6604 if (!W_ERROR_IS_OK(result)) {
6605 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6606 goto done;
6607 }
6608 }
6609
6610 if (force_update || printer->priority != old_printer->priority) {
6611 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6612 SIVAL(buffer.data, 0, printer->priority);
6613 result = winreg_set_printer_dataex(tmp_ctx, b,
6614 printer->sharename,
6615 SPOOL_DSSPOOLER_KEY,
6616 SPOOL_REG_PRIORITY,
6617 REG_DWORD,
6618 buffer.data,
6619 buffer.length);
6620 if (!W_ERROR_IS_OK(result)) {
6621 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6622 goto done;
6623 }
6624 }
6625
6626 if (force_update || printer->attributes != old_printer->attributes) {
6627 buffer = data_blob_talloc(tmp_ctx, NULL, 4);
6628 SIVAL(buffer.data, 0, (printer->attributes &
6629 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
6630 result = winreg_set_printer_dataex(tmp_ctx, b,
6631 printer->sharename,
6632 SPOOL_DSSPOOLER_KEY,
6633 SPOOL_REG_PRINTKEEPPRINTEDJOBS,
6634 REG_DWORD,
6635 buffer.data,
6636 buffer.length);
6637 if (!W_ERROR_IS_OK(result)) {
6638 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_PRINTENDTIME));
6639 goto done;
6640 }
6641
6642 switch (printer->attributes & 0x3) {
6643 case 0:
6644 spooling = SPOOL_REGVAL_PRINTWHILESPOOLING;
6645 break;
6646 case 1:
6647 spooling = SPOOL_REGVAL_PRINTAFTERSPOOLED;
6648 break;
6649 case 2:
6650 spooling = SPOOL_REGVAL_PRINTDIRECT;
6651 break;
6652 default:
6653 spooling = "unknown";
6654 }
6655 ok = push_reg_sz(tmp_ctx, &buffer, spooling);
6656 if (!ok) {
6657 DEBUG(0, ("printSpooling data corrupted\n"));
6658 result = WERR_INVALID_DATA;
6659 goto done;
6660 }
6661 winreg_set_printer_dataex(tmp_ctx, b,
6662 printer->sharename,
6663 SPOOL_DSSPOOLER_KEY,
6664 SPOOL_REG_PRINTSPOOLING,
6665 REG_SZ,
6666 buffer.data,
6667 buffer.length);
6668 }
6669
6670 ok = push_reg_sz(tmp_ctx, &buffer, lp_netbios_name());
6671 if (!ok) {
6672 DEBUG(0, ("shortServerName data corrupted\n"));
6673 result = WERR_INVALID_DATA;
6674 goto done;
6675 }
6676 result = winreg_set_printer_dataex(tmp_ctx, b,
6677 printer->sharename,
6678 SPOOL_DSSPOOLER_KEY,
6679 SPOOL_REG_SHORTSERVERNAME,
6680 REG_SZ,
6681 buffer.data,
6682 buffer.length);
6683 if (!W_ERROR_IS_OK(result)) {
6684 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_SHORTSERVERNAME));
6685 goto done;
6686 }
6687
6688 dnsdomname = get_mydnsfullname();
6689 if (dnsdomname != NULL && dnsdomname[0] != '\0') {
6690 longname = talloc_strdup(tmp_ctx, dnsdomname);
6691 } else {
6692 longname = talloc_strdup(tmp_ctx, lp_netbios_name());
6693 }
6694 if (longname == NULL) {
6695 result = WERR_NOMEM;
6696 goto done;
6697 }
6698
6699 ok = push_reg_sz(tmp_ctx, &buffer, longname);
6700 if (!ok) {
6701 DEBUG(0, ("longname data corrupted\n"));
6702 result = WERR_INVALID_DATA;
6703 goto done;
6704 }
6705 result = winreg_set_printer_dataex(tmp_ctx, b,
6706 printer->sharename,
6707 SPOOL_DSSPOOLER_KEY,
6708 SPOOL_REG_SERVERNAME,
6709 REG_SZ,
6710 buffer.data,
6711 buffer.length);
6712 if (!W_ERROR_IS_OK(result)) {
6713 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_SERVERNAME));
6714 goto done;
6715 }
6716
6717 uncname = talloc_asprintf(tmp_ctx, "\\\\%s\\%s",
6718 lp_netbios_name(), printer->sharename);
6719 ok = push_reg_sz(tmp_ctx, &buffer, uncname);
6720 if (!ok) {
6721 DEBUG(0, ("uncName data corrupted\n"));
6722 result = WERR_INVALID_DATA;
6723 goto done;
6724 }
6725 result = winreg_set_printer_dataex(tmp_ctx, b,
6726 printer->sharename,
6727 SPOOL_DSSPOOLER_KEY,
6728 SPOOL_REG_UNCNAME,
6729 REG_SZ,
6730 buffer.data,
6731 buffer.length);
6732 if (!W_ERROR_IS_OK(result)) {
6733 DEBUG(0, ("Failed to set %s\n", SPOOL_REG_UNCNAME));
6734 goto done;
6735 }
6736
6737 done:
6738 talloc_free(tmp_ctx);
6739 return result;
6740 }
6741
6742 /********************************************************************
6743 * Called by spoolss_api_setprinter
6744 * when updating a printer description.
6745 ********************************************************************/
6746
6747 static WERROR update_printer(struct pipes_struct *p,
6748 struct policy_handle *handle,
6749 struct spoolss_SetPrinterInfoCtr *info_ctr,
6750 struct spoolss_DeviceMode *devmode)
6751 {
6752 uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
6753 struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
6754 struct spoolss_PrinterInfo2 *old_printer;
6755 struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6756 int snum;
6757 WERROR result = WERR_OK;
6758 TALLOC_CTX *tmp_ctx;
6759 struct dcerpc_binding_handle *b;
6760
6761 DEBUG(8,("update_printer\n"));
6762
6763 tmp_ctx = talloc_new(p->mem_ctx);
6764 if (tmp_ctx == NULL) {
6765 return WERR_NOMEM;
6766 }
6767
6768 if (!Printer) {
6769 result = WERR_BADFID;
6770 goto done;
6771 }
6772
6773 if (!get_printer_snum(p, handle, &snum, NULL)) {
6774 result = WERR_BADFID;
6775 goto done;
6776 }
6777
6778 result = winreg_printer_binding_handle(tmp_ctx,
6779 get_session_info_system(),
6780 p->msg_ctx,
6781 &b);
6782 if (!W_ERROR_IS_OK(result)) {
6783 goto done;
6784 }
6785
6786 result = winreg_get_printer(tmp_ctx, b,
6787 lp_const_servicename(snum),
6788 &old_printer);
6789 if (!W_ERROR_IS_OK(result)) {
6790 result = WERR_BADFID;
6791 goto done;
6792 }
6793
6794 /* Do sanity check on the requested changes for Samba */
6795 if (!check_printer_ok(tmp_ctx, printer, snum)) {
6796 result = WERR_INVALID_PARAM;
6797 goto done;
6798 }
6799
6800 /* FIXME!!! If the driver has changed we really should verify that
6801 it is installed before doing much else --jerry */
6802
6803 /* Check calling user has permission to update printer description */
6804 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6805 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6806 result = WERR_ACCESS_DENIED;
6807 goto done;
6808 }
6809
6810 /* Call addprinter hook */
6811 /* Check changes to see if this is really needed */
6812
6813 if (*lp_addprinter_command(talloc_tos()) &&
6814 (!strequal(printer->drivername, old_printer->drivername) ||
6815 !strequal(printer->comment, old_printer->comment) ||
6816 !strequal(printer->portname, old_printer->portname) ||
6817 !strequal(printer->location, old_printer->location)) )
6818 {
6819 char *raddr;
6820
6821 raddr = tsocket_address_inet_addr_string(p->remote_address,
6822 p->mem_ctx);
6823 if (raddr == NULL) {
6824 return WERR_NOMEM;
6825 }
6826
6827 /* add_printer_hook() will call reload_services() */
6828 if (!add_printer_hook(tmp_ctx, p->session_info->security_token,
6829 printer, raddr,
6830 p->msg_ctx)) {
6831 result = WERR_ACCESS_DENIED;
6832 goto done;
6833 }
6834 }
6835
6836 result = update_dsspooler(tmp_ctx,
6837 get_session_info_system(),
6838 p->msg_ctx,
6839 snum,
6840 printer,
6841 old_printer);
6842 if (!W_ERROR_IS_OK(result)) {
6843 goto done;
6844 }
6845
6846 printer_mask &= ~SPOOLSS_PRINTER_INFO_SECDESC;
6847
6848 if (devmode == NULL) {
6849 printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
6850 }
6851 result = winreg_update_printer(tmp_ctx, b,
6852 printer->sharename,
6853 printer_mask,
6854 printer,
6855 devmode,
6856 NULL);
6857
6858 done:
6859 talloc_free(tmp_ctx);
6860
6861 return result;
6862 }
6863
6864 /****************************************************************************
6865 ****************************************************************************/
6866 static WERROR publish_or_unpublish_printer(struct pipes_struct *p,
6867 struct policy_handle *handle,
6868 struct spoolss_SetPrinterInfo7 *info7)
6869 {
6870 #ifdef HAVE_ADS
6871 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
6872 WERROR result;
6873 int snum;
6874 struct printer_handle *Printer;
6875
6876 if ( lp_security() != SEC_ADS ) {
6877 return WERR_UNKNOWN_LEVEL;
6878 }
6879
6880 Printer = find_printer_index_by_hnd(p, handle);
6881
6882 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6883
6884 if (!Printer)
6885 return WERR_BADFID;
6886
6887 if (!get_printer_snum(p, handle, &snum, NULL))
6888 return WERR_BADFID;
6889
6890 result = winreg_get_printer_internal(p->mem_ctx,
6891 get_session_info_system(),
6892 p->msg_ctx,
6893 lp_servicename(talloc_tos(), snum),
6894 &pinfo2);
6895 if (!W_ERROR_IS_OK(result)) {
6896 return WERR_BADFID;
6897 }
6898
6899 nt_printer_publish(pinfo2,
6900 get_session_info_system(),
6901 p->msg_ctx,
6902 pinfo2,
6903 info7->action);
6904
6905 TALLOC_FREE(pinfo2);
6906 return WERR_OK;
6907 #else
6908 return WERR_UNKNOWN_LEVEL;
6909 #endif
6910 }
6911
6912 /********************************************************************
6913 ********************************************************************/
6914
6915 static WERROR update_printer_devmode(struct pipes_struct *p,
6916 struct policy_handle *handle,
6917 struct spoolss_DeviceMode *devmode)
6918 {
6919 int snum;
6920 struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6921 uint32_t info2_mask = SPOOLSS_PRINTER_INFO_DEVMODE;
6922
6923 DEBUG(8,("update_printer_devmode\n"));
6924
6925 if (!Printer) {
6926 return WERR_BADFID;
6927 }
6928
6929 if (!get_printer_snum(p, handle, &snum, NULL)) {
6930 return WERR_BADFID;
6931 }
6932
6933 /* Check calling user has permission to update printer description */
6934 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6935 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6936 return WERR_ACCESS_DENIED;
6937 }
6938
6939 return winreg_update_printer_internal(p->mem_ctx,
6940 get_session_info_system(),
6941 p->msg_ctx,
6942 lp_const_servicename(snum),
6943 info2_mask,
6944 NULL,
6945 devmode,
6946 NULL);
6947 }
6948
6949
6950 /****************************************************************
6951 _spoolss_SetPrinter
6952 ****************************************************************/
6953
6954 WERROR _spoolss_SetPrinter(struct pipes_struct *p,
6955 struct spoolss_SetPrinter *r)
6956 {
6957 WERROR result;
6958
6959 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
6960
6961 if (!Printer) {
6962 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6963 OUR_HANDLE(r->in.handle)));
6964 return WERR_BADFID;
6965 }
6966
6967 /* check the level */
6968 switch (r->in.info_ctr->level) {
6969 case 0:
6970 return control_printer(r->in.handle, r->in.command, p);
6971 case 2:
6972 result = update_printer(p, r->in.handle,
6973 r->in.info_ctr,
6974 r->in.devmode_ctr->devmode);
6975 if (!W_ERROR_IS_OK(result))
6976 return result;
6977 if (r->in.secdesc_ctr->sd)
6978 result = update_printer_sec(r->in.handle, p,
6979 r->in.secdesc_ctr);
6980 return result;
6981 case 3:
6982 return update_printer_sec(r->in.handle, p,
6983 r->in.secdesc_ctr);
6984 case 7:
6985 return publish_or_unpublish_printer(p, r->in.handle,
6986 r->in.info_ctr->info.info7);
6987 case 8:
6988 return update_printer_devmode(p, r->in.handle,
6989 r->in.devmode_ctr->devmode);
6990 default:
6991 return WERR_UNKNOWN_LEVEL;
6992 }
6993 }
6994
6995 /****************************************************************
6996 _spoolss_FindClosePrinterNotify
6997 ****************************************************************/
6998
6999 WERROR _spoolss_FindClosePrinterNotify(struct pipes_struct *p,
7000 struct spoolss_FindClosePrinterNotify *r)
7001 {
7002 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
7003
7004 if (!Printer) {
7005 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
7006 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
7007 return WERR_BADFID;
7008 }
7009
7010 if (Printer->notify.cli_chan != NULL &&
7011 Printer->notify.cli_chan->active_connections > 0) {
7012 int snum = -1;
7013
7014 if (Printer->printer_type == SPLHND_PRINTER) {
7015 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7016 return WERR_BADFID;
7017 }
7018 }
7019
7020 srv_spoolss_replycloseprinter(snum, Printer);
7021 }
7022
7023 Printer->notify.flags=0;
7024 Printer->notify.options=0;
7025 Printer->notify.localmachine[0]='\0';
7026 Printer->notify.printerlocal=0;
7027 TALLOC_FREE(Printer->notify.option);
7028
7029 return WERR_OK;
7030 }
7031
7032 /****************************************************************
7033 _spoolss_AddJob
7034 ****************************************************************/
7035
7036 WERROR _spoolss_AddJob(struct pipes_struct *p,
7037 struct spoolss_AddJob *r)
7038 {
7039 if (!r->in.buffer && (r->in.offered != 0)) {
7040 return WERR_INVALID_PARAM;
7041 }
7042
7043 /* this is what a NT server returns for AddJob. AddJob must fail on
7044 * non-local printers */
7045
7046 if (r->in.level != 1) {
7047 return WERR_UNKNOWN_LEVEL;
7048 }
7049
7050 return WERR_INVALID_PARAM;
7051 }
7052
7053 /****************************************************************************
7054 fill_job_info1
7055 ****************************************************************************/
7056
7057 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
7058 struct spoolss_JobInfo1 *r,
7059 const print_queue_struct *queue,
7060 uint32_t jobid,
7061 int position, int snum,
7062 struct spoolss_PrinterInfo2 *pinfo2)
7063 {
7064 struct tm *t;
7065
7066 t = gmtime(&queue->time);
7067
7068 r->job_id = jobid;
7069
7070 r->printer_name = lp_servicename(mem_ctx, snum);
7071 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
7072 r->server_name = talloc_strdup(mem_ctx, pinfo2->servername);
7073 W_ERROR_HAVE_NO_MEMORY(r->server_name);
7074 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
7075 W_ERROR_HAVE_NO_MEMORY(r->user_name);
7076 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
7077 W_ERROR_HAVE_NO_MEMORY(r->document_name);
7078 r->data_type = talloc_strdup(mem_ctx, "RAW");
7079 W_ERROR_HAVE_NO_MEMORY(r->data_type);
7080 r->text_status = talloc_strdup(mem_ctx, "");
7081 W_ERROR_HAVE_NO_MEMORY(r->text_status);
7082
7083 r->status = nt_printj_status(queue->status);
7084 r->priority = queue->priority;
7085 r->position = position;
7086 r->total_pages = queue->page_count;
7087 r->pages_printed = 0; /* ??? */
7088
7089 init_systemtime(&r->submitted, t);
7090
7091 return WERR_OK;
7092 }
7093
7094 /****************************************************************************
7095 fill_job_info2
7096 ****************************************************************************/
7097
7098 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
7099 struct spoolss_JobInfo2 *r,
7100 const print_queue_struct *queue,
7101 uint32_t jobid,
7102 int position, int snum,
7103 struct spoolss_PrinterInfo2 *pinfo2,
7104 struct spoolss_DeviceMode *devmode)
7105 {
7106 struct tm *t;
7107
7108 t = gmtime(&queue->time);
7109
7110 r->job_id = jobid;
7111
7112 r->printer_name = lp_servicename(mem_ctx, snum);
7113 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
7114 r->server_name = talloc_strdup(mem_ctx, pinfo2->servername);
7115 W_ERROR_HAVE_NO_MEMORY(r->server_name);
7116 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
7117 W_ERROR_HAVE_NO_MEMORY(r->user_name);
7118 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
7119 W_ERROR_HAVE_NO_MEMORY(r->document_name);
7120 r->notify_name = talloc_strdup(mem_ctx, queue->fs_user);
7121 W_ERROR_HAVE_NO_MEMORY(r->notify_name);
7122 r->data_type = talloc_strdup(mem_ctx, "RAW");
7123 W_ERROR_HAVE_NO_MEMORY(r->data_type);
7124 r->print_processor = talloc_strdup(mem_ctx, "winprint");
7125 W_ERROR_HAVE_NO_MEMORY(r->print_processor);
7126 r->parameters = talloc_strdup(mem_ctx, "");
7127 W_ERROR_HAVE_NO_MEMORY(r->parameters);
7128 r->driver_name = talloc_strdup(mem_ctx, pinfo2->drivername);
7129 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
7130
7131 r->devmode = devmode;
7132
7133 r->text_status = talloc_strdup(mem_ctx, "");
7134 W_ERROR_HAVE_NO_MEMORY(r->text_status);
7135
7136 r->secdesc = NULL;
7137
7138 r->status = nt_printj_status(queue->status);
7139 r->priority = queue->priority;
7140 r->position = position;
7141 r->start_time = 0;
7142 r->until_time = 0;
7143 r->total_pages = queue->page_count;
7144 r->size = queue->size;
7145 init_systemtime(&r->submitted, t);
7146 r->time = 0;
7147 r->pages_printed = 0; /* ??? */
7148
7149 return WERR_OK;
7150 }
7151
7152 /****************************************************************************
7153 fill_job_info3
7154 ****************************************************************************/
7155
7156 static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
7157 struct spoolss_JobInfo3 *r,
7158 const print_queue_struct *queue,
7159 const print_queue_struct *next_queue,
7160 int position, int snum,
7161 struct spoolss_PrinterInfo2 *pinfo2)
7162 {
7163 r->job_id = queue->sysjob;
7164 r->next_job_id = 0;
7165 if (next_queue) {
7166 r->next_job_id = next_queue->sysjob;
7167 }
7168 r->reserved = 0;
7169
7170 return WERR_OK;
7171 }
7172
7173 /****************************************************************************
7174 Enumjobs at level 1.
7175 ****************************************************************************/
7176
7177 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
7178 const print_queue_struct *queue,
7179 uint32_t num_queues, int snum,
7180 struct spoolss_PrinterInfo2 *pinfo2,
7181 union spoolss_JobInfo **info_p,
7182 uint32_t *count)
7183 {
7184 union spoolss_JobInfo *info;
7185 int i;
7186 WERROR result = WERR_OK;
7187 uint32_t num_filled;
7188 struct tdb_print_db *pdb;
7189
7190 info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7191 if (info == NULL) {
7192 result = WERR_NOMEM;
7193 goto err_out;
7194 }
7195
7196 pdb = get_print_db_byname(pinfo2->sharename);
7197 if (pdb == NULL) {
7198 result = WERR_INVALID_PARAM;
7199 goto err_info_free;
7200 }
7201
7202 num_filled = 0;
7203 for (i = 0; i < num_queues; i++) {
7204 uint32_t jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob);
7205 if (jobid == (uint32_t)-1) {
7206 DEBUG(4, ("skipping sysjob %d\n", queue[i].sysjob));
7207 continue;
7208 }
7209
7210 result = fill_job_info1(info,
7211 &info[num_filled].info1,
7212 &queue[i],
7213 jobid,
7214 i,
7215 snum,
7216 pinfo2);
7217 if (!W_ERROR_IS_OK(result)) {
7218 goto err_pdb_drop;
7219 }
7220
7221 num_filled++;
7222 }
7223
7224 release_print_db(pdb);
7225 *info_p = info;
7226 *count = num_filled;
7227
7228 return WERR_OK;
7229
7230 err_pdb_drop:
7231 release_print_db(pdb);
7232 err_info_free:
7233 TALLOC_FREE(info);
7234 err_out:
7235 *count = 0;
7236 return result;
7237 }
7238
7239 /****************************************************************************
7240 Enumjobs at level 2.
7241 ****************************************************************************/
7242
7243 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
7244 const print_queue_struct *queue,
7245 uint32_t num_queues, int snum,
7246 struct spoolss_PrinterInfo2 *pinfo2,
7247 union spoolss_JobInfo **info_p,
7248 uint32_t *count)
7249 {
7250 union spoolss_JobInfo *info;
7251 int i;
7252 WERROR result = WERR_OK;
7253 uint32_t num_filled;
7254 struct tdb_print_db *pdb;
7255
7256 info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7257 if (info == NULL) {
7258 result = WERR_NOMEM;
7259 goto err_out;
7260 }
7261
7262 pdb = get_print_db_byname(pinfo2->sharename);
7263 if (pdb == NULL) {
7264 result = WERR_INVALID_PARAM;
7265 goto err_info_free;
7266 }
7267
7268 num_filled = 0;
7269 for (i = 0; i< num_queues; i++) {
7270 struct spoolss_DeviceMode *devmode;
7271 uint32_t jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob);
7272 if (jobid == (uint32_t)-1) {
7273 DEBUG(4, ("skipping sysjob %d\n", queue[i].sysjob));
7274 continue;
7275 }
7276
7277 result = spoolss_create_default_devmode(info,
7278 pinfo2->printername,
7279 &devmode);
7280 if (!W_ERROR_IS_OK(result)) {
7281 DEBUG(3, ("Can't proceed w/o a devmode!"));
7282 goto err_pdb_drop;
7283 }
7284
7285 result = fill_job_info2(info,
7286 &info[num_filled].info2,
7287 &queue[i],
7288 jobid,
7289 i,
7290 snum,
7291 pinfo2,
7292 devmode);
7293 if (!W_ERROR_IS_OK(result)) {
7294 goto err_pdb_drop;
7295 }
7296 num_filled++;
7297 }
7298
7299 release_print_db(pdb);
7300 *info_p = info;
7301 *count = num_filled;
7302
7303 return WERR_OK;
7304
7305 err_pdb_drop:
7306 release_print_db(pdb);
7307 err_info_free:
7308 TALLOC_FREE(info);
7309 err_out:
7310 *count = 0;
7311 return result;
7312 }
7313
7314 /****************************************************************************
7315 Enumjobs at level 3.
7316 ****************************************************************************/
7317
7318 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
7319 const print_queue_struct *queue,
7320 uint32_t num_queues, int snum,
7321 struct spoolss_PrinterInfo2 *pinfo2,
7322 union spoolss_JobInfo **info_p,
7323 uint32_t *count)
7324 {
7325 union spoolss_JobInfo *info;
7326 int i;
7327 WERROR result = WERR_OK;
7328
7329 info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
7330 W_ERROR_HAVE_NO_MEMORY(info);
7331
7332 *count = num_queues;
7333
7334 for (i=0; i<*count; i++) {
7335 const print_queue_struct *next_queue = NULL;
7336
7337 if (i+1 < *count) {
7338 next_queue = &queue[i+1];
7339 }
7340
7341 result = fill_job_info3(info,
7342 &info[i].info3,
7343 &queue[i],
7344 next_queue,
7345 i,
7346 snum,
7347 pinfo2);
7348 if (!W_ERROR_IS_OK(result)) {
7349 goto out;
7350 }
7351 }
7352
7353 out:
7354 if (!W_ERROR_IS_OK(result)) {
7355 TALLOC_FREE(info);
7356 *count = 0;
7357 return result;
7358 }
7359
7360 *info_p = info;
7361
7362 return WERR_OK;
7363 }
7364
7365 /****************************************************************
7366 _spoolss_EnumJobs
7367 ****************************************************************/
7368
7369 WERROR _spoolss_EnumJobs(struct pipes_struct *p,
7370 struct spoolss_EnumJobs *r)
7371 {
7372 WERROR result;
7373 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
7374 int snum;
7375 print_status_struct prt_status;
7376 print_queue_struct *queue = NULL;
7377 uint32_t count;
7378
7379 /* that's an [in out] buffer */
7380
7381 if (!r->in.buffer && (r->in.offered != 0)) {
7382 return WERR_INVALID_PARAM;
7383 }
7384
7385 if ((r->in.level != 1) && (r->in.level != 2) && (r->in.level != 3)) {
7386 DEBUG(4, ("EnumJobs level %d not supported\n", r->in.level));
7387 return WERR_UNKNOWN_LEVEL;
7388 }
7389
7390 DEBUG(4,("_spoolss_EnumJobs\n"));
7391
7392 *r->out.needed = 0;
7393 *r->out.count = 0;
7394 *r->out.info = NULL;
7395
7396 /* lookup the printer snum and tdb entry */
7397
7398 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7399 return WERR_BADFID;
7400 }
7401
7402 result = winreg_get_printer_internal(p->mem_ctx,
7403 get_session_info_system(),
7404 p->msg_ctx,
7405 lp_const_servicename(snum),
7406 &pinfo2);
7407 if (!W_ERROR_IS_OK(result)) {
7408 return result;
7409 }
7410
7411 count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
7412 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
7413 count, prt_status.status, prt_status.message));
7414
7415 if (count == 0) {
7416 SAFE_FREE(queue);
7417 TALLOC_FREE(pinfo2);
7418 return WERR_OK;
7419 }
7420
7421 switch (r->in.level) {
7422 case 1:
7423 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
7424 pinfo2, r->out.info, r->out.count);
7425 break;
7426 case 2:
7427 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
7428 pinfo2, r->out.info, r->out.count);
7429 break;
7430 case 3:
7431 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
7432 pinfo2, r->out.info, r->out.count);
7433 break;
7434 default:
7435 SMB_ASSERT(false); /* level checked on entry */
7436 break;
7437 }
7438
7439 SAFE_FREE(queue);
7440 TALLOC_FREE(pinfo2);
7441
7442 if (!W_ERROR_IS_OK(result)) {
7443 return result;
7444 }
7445
7446 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7447 spoolss_EnumJobs,
7448 *r->out.info, r->in.level,
7449 *r->out.count);
7450 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7451 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7452
7453 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7454 }
7455
7456 /****************************************************************
7457 _spoolss_ScheduleJob
7458 ****************************************************************/
7459
7460 WERROR _spoolss_ScheduleJob(struct pipes_struct *p,
7461 struct spoolss_ScheduleJob *r)
7462 {
7463 return WERR_OK;
7464 }
7465
7466 /****************************************************************
7467 ****************************************************************/
7468
7469 static WERROR spoolss_setjob_1(TALLOC_CTX *mem_ctx,
7470 struct messaging_context *msg_ctx,
7471 const char *printer_name,
7472 uint32_t job_id,
7473 struct spoolss_SetJobInfo1 *r)
7474 {
7475 char *old_doc_name;
7476
7477 if (!print_job_get_name(mem_ctx, printer_name, job_id, &old_doc_name)) {
7478 return WERR_BADFID;
7479 }
7480
7481 if (strequal(old_doc_name, r->document_name)) {
7482 return WERR_OK;
7483 }
7484
7485 if (!print_job_set_name(server_event_context(), msg_ctx,
7486 printer_name, job_id, r->document_name)) {
7487 return WERR_BADFID;
7488 }
7489
7490 return WERR_OK;
7491 }
7492
7493 /****************************************************************
7494 _spoolss_SetJob
7495 ****************************************************************/
7496
7497 WERROR _spoolss_SetJob(struct pipes_struct *p,
7498 struct spoolss_SetJob *r)
7499 {
7500 const struct auth_session_info *session_info = p->session_info;
7501 int snum;
7502 WERROR errcode = WERR_BADFUNC;
7503
7504 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7505 return WERR_BADFID;
7506 }
7507
7508 if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
7509 return WERR_INVALID_PRINTER_NAME;
7510 }
7511
7512 switch (r->in.command) {
7513 case SPOOLSS_JOB_CONTROL_CANCEL:
7514 case SPOOLSS_JOB_CONTROL_DELETE:
7515 errcode = print_job_delete(session_info, p->msg_ctx,
7516 snum, r->in.job_id);
7517 if (W_ERROR_EQUAL(errcode, WERR_PRINTER_HAS_JOBS_QUEUED)) {
7518 errcode = WERR_OK;
7519 }
7520 break;
7521 case SPOOLSS_JOB_CONTROL_PAUSE:
7522 errcode = print_job_pause(session_info, p->msg_ctx,
7523 snum, r->in.job_id);
7524 break;
7525 case SPOOLSS_JOB_CONTROL_RESTART:
7526 case SPOOLSS_JOB_CONTROL_RESUME:
7527 errcode = print_job_resume(session_info, p->msg_ctx,
7528 snum, r->in.job_id);
7529 break;
7530 case 0:
7531 errcode = WERR_OK;
7532 break;
7533 default:
7534 return WERR_UNKNOWN_LEVEL;
7535 }
7536
7537 if (!W_ERROR_IS_OK(errcode)) {
7538 return errcode;
7539 }
7540
7541 if (r->in.ctr == NULL) {
7542 return errcode;
7543 }
7544
7545 switch (r->in.ctr->level) {
7546 case 1:
7547 errcode = spoolss_setjob_1(p->mem_ctx, p->msg_ctx,
7548 lp_const_servicename(snum),
7549 r->in.job_id,
7550 r->in.ctr->info.info1);
7551 break;
7552 case 2:
7553 case 3:
7554 case 4:
7555 default:
7556 return WERR_UNKNOWN_LEVEL;
7557 }
7558
7559 return errcode;
7560 }
7561
7562 /****************************************************************************
7563 Enumerates all printer drivers by level and architecture.
7564 ****************************************************************************/
7565
7566 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
7567 const struct auth_session_info *session_info,
7568 struct messaging_context *msg_ctx,
7569 const char *servername,
7570 const char *architecture,
7571 uint32_t level,
7572 union spoolss_DriverInfo **info_p,
7573 uint32_t *count_p)
7574 {
7575 int i;
7576 uint32_t version;
7577 struct spoolss_DriverInfo8 *driver;
7578 union spoolss_DriverInfo *info = NULL;
7579 uint32_t count = 0;
7580 WERROR result = WERR_OK;
7581 uint32_t num_drivers;
7582 const char **drivers;
7583 struct dcerpc_binding_handle *b;
7584 TALLOC_CTX *tmp_ctx = NULL;
7585
7586 *count_p = 0;
7587 *info_p = NULL;
7588
7589 tmp_ctx = talloc_new(mem_ctx);
7590 if (!tmp_ctx) {
7591 return WERR_NOMEM;
7592 }
7593
7594 result = winreg_printer_binding_handle(tmp_ctx,
7595 session_info,
7596 msg_ctx,
7597 &b);
7598 if (!W_ERROR_IS_OK(result)) {
7599 goto out;
7600 }
7601
7602 for (version=0; version<DRIVER_MAX_VERSION; version++) {
7603 result = winreg_get_driver_list(tmp_ctx, b,
7604 architecture, version,
7605 &num_drivers, &drivers);
7606 if (!W_ERROR_IS_OK(result)) {
7607 goto out;
7608 }
7609 DEBUG(4, ("we have:[%d] drivers in environment"
7610 " [%s] and version [%d]\n",
7611 num_drivers, architecture, version));
7612
7613 if (num_drivers != 0) {
7614 info = talloc_realloc(tmp_ctx, info,
7615 union spoolss_DriverInfo,
7616 count + num_drivers);
7617 if (!info) {
7618 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
7619 "failed to enlarge driver info buffer!\n"));
7620 result = WERR_NOMEM;
7621 goto out;
7622 }
7623 }
7624
7625 for (i = 0; i < num_drivers; i++) {
7626 DEBUG(5, ("\tdriver: [%s]\n", drivers[i]));
7627
7628 result = winreg_get_driver(tmp_ctx, b,
7629 architecture, drivers[i],
7630 version, &driver);
7631 if (!W_ERROR_IS_OK(result)) {
7632 goto out;
7633 }
7634
7635 switch (level) {
7636 case 1:
7637 result = fill_printer_driver_info1(info, &info[count+i].info1,
7638 driver, servername);
7639 break;
7640 case 2:
7641 result = fill_printer_driver_info2(info, &info[count+i].info2,
7642 driver, servername);
7643 break;
7644 case 3:
7645 result = fill_printer_driver_info3(info, &info[count+i].info3,
7646 driver, servername);
7647 break;
7648 case 4:
7649 result = fill_printer_driver_info4(info, &info[count+i].info4,
7650 driver, servername);
7651 break;
7652 case 5:
7653 result = fill_printer_driver_info5(info, &info[count+i].info5,
7654 driver, servername);
7655 break;
7656 case 6:
7657 result = fill_printer_driver_info6(info, &info[count+i].info6,
7658 driver, servername);
7659 break;
7660 case 8:
7661 result = fill_printer_driver_info8(info, &info[count+i].info8,
7662 driver, servername);
7663 break;
7664 default:
7665 result = WERR_UNKNOWN_LEVEL;
7666 break;
7667 }
7668
7669 TALLOC_FREE(driver);
7670
7671 if (!W_ERROR_IS_OK(result)) {
7672 goto out;
7673 }
7674 }
7675
7676 count += num_drivers;
7677 TALLOC_FREE(drivers);
7678 }
7679
7680 out:
7681 if (W_ERROR_IS_OK(result)) {
7682 *info_p = talloc_move(mem_ctx, &info);
7683 *count_p = count;
7684 }
7685
7686 talloc_free(tmp_ctx);
7687 return result;
7688 }
7689
7690 /****************************************************************************
7691 Enumerates all printer drivers by level.
7692 ****************************************************************************/
7693
7694 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
7695 const struct auth_session_info *session_info,
7696 struct messaging_context *msg_ctx,
7697 const char *servername,
7698 const char *architecture,
7699 uint32_t level,
7700 union spoolss_DriverInfo **info_p,
7701 uint32_t *count_p)
7702 {
7703 uint32_t a,i;
7704 WERROR result = WERR_OK;
7705
7706 if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
7707
7708 for (a=0; archi_table[a].long_archi != NULL; a++) {
7709
7710 union spoolss_DriverInfo *info = NULL;
7711 uint32_t count = 0;
7712
7713 result = enumprinterdrivers_level_by_architecture(mem_ctx,
7714 session_info,
7715 msg_ctx,
7716 servername,
7717 archi_table[a].long_archi,
7718 level,
7719 &info,
7720 &count);
7721 if (!W_ERROR_IS_OK(result)) {
7722 continue;
7723 }
7724
7725 for (i=0; i < count; i++) {
7726 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
7727 info[i], info_p, count_p);
7728 }
7729 }
7730
7731 return result;
7732 }
7733
7734 return enumprinterdrivers_level_by_architecture(mem_ctx,
7735 session_info,
7736 msg_ctx,
7737 servername,
7738 architecture,
7739 level,
7740 info_p,
7741 count_p);
7742 }
7743
7744 /****************************************************************
7745 _spoolss_EnumPrinterDrivers
7746 ****************************************************************/
7747
7748 WERROR _spoolss_EnumPrinterDrivers(struct pipes_struct *p,
7749 struct spoolss_EnumPrinterDrivers *r)
7750 {
7751 const char *cservername;
7752 WERROR result;
7753
7754 /* that's an [in out] buffer */
7755
7756 if (!r->in.buffer && (r->in.offered != 0)) {
7757 return WERR_INVALID_PARAM;
7758 }
7759
7760 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
7761
7762 *r->out.needed = 0;
7763 *r->out.count = 0;
7764 *r->out.info = NULL;
7765
7766 cservername = canon_servername(r->in.server);
7767
7768 if (!is_myname_or_ipaddr(cservername)) {
7769 return WERR_UNKNOWN_PRINTER_DRIVER;
7770 }
7771
7772 result = enumprinterdrivers_level(p->mem_ctx,
7773 get_session_info_system(),
7774 p->msg_ctx,
7775 cservername,
7776 r->in.environment,
7777 r->in.level,
7778 r->out.info,
7779 r->out.count);
7780 if (!W_ERROR_IS_OK(result)) {
7781 return result;
7782 }
7783
7784 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7785 spoolss_EnumPrinterDrivers,
7786 *r->out.info, r->in.level,
7787 *r->out.count);
7788 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7789 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7790
7791 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7792 }
7793
7794 /****************************************************************
7795 _spoolss_EnumForms
7796 ****************************************************************/
7797
7798 WERROR _spoolss_EnumForms(struct pipes_struct *p,
7799 struct spoolss_EnumForms *r)
7800 {
7801 WERROR result;
7802
7803 *r->out.count = 0;
7804 *r->out.needed = 0;
7805 *r->out.info = NULL;
7806
7807 /* that's an [in out] buffer */
7808
7809 if (!r->in.buffer && (r->in.offered != 0) ) {
7810 return WERR_INVALID_PARAM;
7811 }
7812
7813 DEBUG(4,("_spoolss_EnumForms\n"));
7814 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7815 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7816
7817 switch (r->in.level) {
7818 case 1:
7819 result = winreg_printer_enumforms1_internal(p->mem_ctx,
7820 get_session_info_system(),
7821 p->msg_ctx,
7822 r->out.count,
7823 r->out.info);
7824 break;
7825 default:
7826 result = WERR_UNKNOWN_LEVEL;
7827 break;
7828 }
7829
7830 if (!W_ERROR_IS_OK(result)) {
7831 return result;
7832 }
7833
7834 if (*r->out.count == 0) {
7835 return WERR_NO_MORE_ITEMS;
7836 }
7837
7838 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7839 spoolss_EnumForms,
7840 *r->out.info, r->in.level,
7841 *r->out.count);
7842 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7843 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7844
7845 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7846 }
7847
7848 /****************************************************************
7849 _spoolss_GetForm
7850 ****************************************************************/
7851
7852 WERROR _spoolss_GetForm(struct pipes_struct *p,
7853 struct spoolss_GetForm *r)
7854 {
7855 WERROR result;
7856
7857 /* that's an [in out] buffer */
7858
7859 if (!r->in.buffer && (r->in.offered != 0)) {
7860 return WERR_INVALID_PARAM;
7861 }
7862
7863 DEBUG(4,("_spoolss_GetForm\n"));
7864 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7865 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7866
7867 switch (r->in.level) {
7868 case 1:
7869 result = winreg_printer_getform1_internal(p->mem_ctx,
7870 get_session_info_system(),
7871 p->msg_ctx,
7872 r->in.form_name,
7873 &r->out.info->info1);
7874 break;
7875 default:
7876 result = WERR_UNKNOWN_LEVEL;
7877 break;
7878 }
7879
7880 if (!W_ERROR_IS_OK(result)) {
7881 TALLOC_FREE(r->out.info);
7882 return result;
7883 }
7884
7885 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo,
7886 r->out.info, r->in.level);
7887 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7888
7889 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7890 }
7891
7892 /****************************************************************************
7893 ****************************************************************************/
7894
7895 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7896 struct spoolss_PortInfo1 *r,
7897 const char *name)
7898 {
7899 r->port_name = talloc_strdup(mem_ctx, name);
7900 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7901
7902 return WERR_OK;
7903 }
7904
7905 /****************************************************************************
7906 TODO: This probably needs distinguish between TCP/IP and Local ports
7907 somehow.
7908 ****************************************************************************/
7909
7910 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7911 struct spoolss_PortInfo2 *r,
7912 const char *name)
7913 {
7914 r->port_name = talloc_strdup(mem_ctx, name);
7915 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7916
7917 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7918 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7919
7920 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7921 W_ERROR_HAVE_NO_MEMORY(r->description);
7922
7923 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7924 r->reserved = 0;
7925
7926 return WERR_OK;
7927 }
7928
7929
7930 /****************************************************************************
7931 wrapper around the enumer ports command
7932 ****************************************************************************/
7933
7934 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7935 {
7936 char *cmd = lp_enumports_command(talloc_tos());
7937 char **qlines = NULL;
7938 char *command = NULL;
7939 int numlines;
7940 int ret;
7941 int fd;
7942
7943 *count = 0;
7944 *lines = NULL;
7945
7946 /* if no hook then just fill in the default port */
7947
7948 if ( !*cmd ) {
7949 if (!(qlines = talloc_array( NULL, char*, 2 ))) {
7950 return WERR_NOMEM;
7951 }
7952 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7953 TALLOC_FREE(qlines);
7954 return WERR_NOMEM;
7955 }
7956 qlines[1] = NULL;
7957 numlines = 1;
7958 }
7959 else {
7960 /* we have a valid enumport command */
7961
7962 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7963 if (!command) {
7964 return WERR_NOMEM;
7965 }
7966
7967 DEBUG(10,("Running [%s]\n", command));
7968 ret = smbrun(command, &fd);
7969 DEBUG(10,("Returned [%d]\n", ret));
7970 TALLOC_FREE(command);
7971 if (ret != 0) {
7972 if (fd != -1) {
7973 close(fd);
7974 }
7975 return WERR_ACCESS_DENIED;
7976 }
7977
7978 numlines = 0;
7979 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7980 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7981 close(fd);
7982 }
7983
7984 *count = numlines;
7985 *lines = qlines;
7986
7987 return WERR_OK;
7988 }
7989
7990 /****************************************************************************
7991 enumports level 1.
7992 ****************************************************************************/
7993
7994 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7995 union spoolss_PortInfo **info_p,
7996 uint32_t *count)
7997 {
7998 union spoolss_PortInfo *info = NULL;
7999 int i=0;
8000 WERROR result = WERR_OK;
8001 char **qlines = NULL;
8002 int numlines = 0;
8003
8004 result = enumports_hook(talloc_tos(), &numlines, &qlines );
8005 if (!W_ERROR_IS_OK(result)) {
8006 goto out;
8007 }
8008
8009 if (numlines) {
8010 info = talloc_array(mem_ctx, union spoolss_PortInfo, numlines);
8011 if (!info) {
8012 DEBUG(10,("Returning WERR_NOMEM\n"));
8013 result = WERR_NOMEM;
8014 goto out;
8015 }
8016
8017 for (i=0; i<numlines; i++) {
8018 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
8019 result = fill_port_1(info, &info[i].info1, qlines[i]);
8020 if (!W_ERROR_IS_OK(result)) {
8021 goto out;
8022 }
8023 }
8024 }
8025 TALLOC_FREE(qlines);
8026
8027 out:
8028 if (!W_ERROR_IS_OK(result)) {
8029 TALLOC_FREE(info);
8030 TALLOC_FREE(qlines);
8031 *count = 0;
8032 *info_p = NULL;
8033 return result;
8034 }
8035
8036 *info_p = info;
8037 *count = numlines;
8038
8039 return WERR_OK;
8040 }
8041
8042 /****************************************************************************
8043 enumports level 2.
8044 ****************************************************************************/
8045
8046 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
8047 union spoolss_PortInfo **info_p,
8048 uint32_t *count)
8049 {
8050 union spoolss_PortInfo *info = NULL;
8051 int i=0;
8052 WERROR result = WERR_OK;
8053 char **qlines = NULL;
8054 int numlines = 0;
8055
8056 result = enumports_hook(talloc_tos(), &numlines, &qlines );
8057 if (!W_ERROR_IS_OK(result)) {
8058 goto out;
8059 }
8060
8061 if (numlines) {
8062 info = talloc_array(mem_ctx, union spoolss_PortInfo, numlines);
8063 if (!info) {
8064 DEBUG(10,("Returning WERR_NOMEM\n"));
8065 result = WERR_NOMEM;
8066 goto out;
8067 }
8068
8069 for (i=0; i<numlines; i++) {
8070 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
8071 result = fill_port_2(info, &info[i].info2, qlines[i]);
8072 if (!W_ERROR_IS_OK(result)) {
8073 goto out;
8074 }
8075 }
8076 }
8077 TALLOC_FREE(qlines);
8078
8079 out:
8080 if (!W_ERROR_IS_OK(result)) {
8081 TALLOC_FREE(info);
8082 TALLOC_FREE(qlines);
8083 *count = 0;
8084 *info_p = NULL;
8085 return result;
8086 }
8087
8088 *info_p = info;
8089 *count = numlines;
8090
8091 return WERR_OK;
8092 }
8093
8094 /****************************************************************
8095 _spoolss_EnumPorts
8096 ****************************************************************/
8097
8098 WERROR _spoolss_EnumPorts(struct pipes_struct *p,
8099 struct spoolss_EnumPorts *r)
8100 {
8101 WERROR result;
8102
8103 /* that's an [in out] buffer */
8104
8105 if (!r->in.buffer && (r->in.offered != 0)) {
8106 return WERR_INVALID_PARAM;
8107 }
8108
8109 DEBUG(4,("_spoolss_EnumPorts\n"));
8110
8111 *r->out.count = 0;
8112 *r->out.needed = 0;
8113 *r->out.info = NULL;
8114
8115 switch (r->in.level) {
8116 case 1:
8117 result = enumports_level_1(p->mem_ctx, r->out.info,
8118 r->out.count);
8119 break;
8120 case 2:
8121 result = enumports_level_2(p->mem_ctx, r->out.info,
8122 r->out.count);
8123 break;
8124 default:
8125 return WERR_UNKNOWN_LEVEL;
8126 }
8127
8128 if (!W_ERROR_IS_OK(result)) {
8129 return result;
8130 }
8131
8132 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8133 spoolss_EnumPorts,
8134 *r->out.info, r->in.level,
8135 *r->out.count);
8136 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8137 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8138
8139 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8140 }
8141
8142 /****************************************************************************
8143 ****************************************************************************/
8144
8145 static WERROR spoolss_addprinterex_level_2(struct pipes_struct *p,
8146 const char *server,
8147 struct spoolss_SetPrinterInfoCtr *info_ctr,
8148 struct spoolss_DeviceMode *devmode,
8149 struct security_descriptor *secdesc,
8150 struct spoolss_UserLevelCtr *user_ctr,
8151 struct policy_handle *handle)
8152 {
8153 struct spoolss_SetPrinterInfo2 *info2 = info_ctr->info.info2;
8154 uint32_t info2_mask = SPOOLSS_PRINTER_INFO_ALL;
8155 int snum;
8156 WERROR err = WERR_OK;
8157
8158 /* samba does not have a concept of local, non-shared printers yet, so
8159 * make sure we always setup sharename - gd */
8160 if ((info2->sharename == NULL || info2->sharename[0] == '\0') &&
8161 (info2->printername != NULL && info2->printername[0] != '\0')) {
8162 DEBUG(5, ("spoolss_addprinterex_level_2: "
8163 "no sharename has been set, setting printername %s as sharename\n",
8164 info2->printername));
8165 info2->sharename = info2->printername;
8166 }
8167
8168 /* check to see if the printer already exists */
8169 if ((snum = print_queue_snum(info2->sharename)) != -1) {
8170 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
8171 info2->sharename));
8172 return WERR_PRINTER_ALREADY_EXISTS;
8173 }
8174
8175 if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
8176 if ((snum = print_queue_snum(info2->printername)) != -1) {
8177 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
8178 info2->printername));
8179 return WERR_PRINTER_ALREADY_EXISTS;
8180 }
8181 }
8182
8183 /* validate printer info struct */
8184 if (!info2->printername || strlen(info2->printername) == 0) {
8185 return WERR_INVALID_PRINTER_NAME;
8186 }
8187 if (!info2->portname || strlen(info2->portname) == 0) {
8188 return WERR_UNKNOWN_PORT;
8189 }
8190 if (!info2->drivername || strlen(info2->drivername) == 0) {
8191 return WERR_UNKNOWN_PRINTER_DRIVER;
8192 }
8193 if (!info2->printprocessor || strlen(info2->printprocessor) == 0) {
8194 return WERR_UNKNOWN_PRINTPROCESSOR;
8195 }
8196
8197 /* FIXME!!! smbd should check to see if the driver is installed before
8198 trying to add a printer like this --jerry */
8199
8200 if (*lp_addprinter_command(talloc_tos()) ) {
8201 char *raddr;
8202
8203 raddr = tsocket_address_inet_addr_string(p->remote_address,
8204 p->mem_ctx);
8205 if (raddr == NULL) {
8206 return WERR_NOMEM;
8207 }
8208
8209 if ( !add_printer_hook(p->mem_ctx, p->session_info->security_token,
8210 info2, raddr,
8211 p->msg_ctx) ) {
8212 return WERR_ACCESS_DENIED;
8213 }
8214 } else {
8215 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no "
8216 "smb.conf parameter \"addprinter command\" is defined. This "
8217 "parameter must exist for this call to succeed\n",
8218 info2->sharename ));
8219 }
8220
8221 if ((snum = print_queue_snum(info2->sharename)) == -1) {
8222 return WERR_ACCESS_DENIED;
8223 }
8224
8225 /* you must be a printer admin to add a new printer */
8226 if (!W_ERROR_IS_OK(print_access_check(p->session_info,
8227 p->msg_ctx,
8228 snum,
8229 PRINTER_ACCESS_ADMINISTER))) {
8230 return WERR_ACCESS_DENIED;
8231 }
8232
8233 /*
8234 * Do sanity check on the requested changes for Samba.
8235 */
8236
8237 if (!check_printer_ok(p->mem_ctx, info2, snum)) {
8238 return WERR_INVALID_PARAM;
8239 }
8240
8241 if (devmode == NULL) {
8242 info2_mask = ~SPOOLSS_PRINTER_INFO_DEVMODE;
8243 }
8244
8245 err = update_dsspooler(p->mem_ctx,
8246 get_session_info_system(),
8247 p->msg_ctx,
8248 0,
8249 info2,
8250 NULL);
8251 if (!W_ERROR_IS_OK(err)) {
8252 return err;
8253 }
8254
8255 err = winreg_update_printer_internal(p->mem_ctx,
8256 get_session_info_system(),
8257 p->msg_ctx,
8258 info2->sharename,
8259 info2_mask,
8260 info2,
8261 devmode,
8262 secdesc);
8263 if (!W_ERROR_IS_OK(err)) {
8264 return err;
8265 }
8266
8267 err = open_printer_hnd(p, handle, info2->printername, PRINTER_ACCESS_ADMINISTER);
8268 if (!W_ERROR_IS_OK(err)) {
8269 /* Handle open failed - remove addition. */
8270 ZERO_STRUCTP(handle);
8271 return err;
8272 }
8273
8274 return WERR_OK;
8275 }
8276
8277 /****************************************************************
8278 _spoolss_AddPrinterEx
8279 ****************************************************************/
8280
8281 WERROR _spoolss_AddPrinterEx(struct pipes_struct *p,
8282 struct spoolss_AddPrinterEx *r)
8283 {
8284 switch (r->in.info_ctr->level) {
8285 case 1:
8286 /* we don't handle yet */
8287 /* but I know what to do ... */
8288 return WERR_UNKNOWN_LEVEL;
8289 case 2:
8290 return spoolss_addprinterex_level_2(p, r->in.server,
8291 r->in.info_ctr,
8292 r->in.devmode_ctr->devmode,
8293 r->in.secdesc_ctr->sd,
8294 r->in.userlevel_ctr,
8295 r->out.handle);
8296 default:
8297 return WERR_UNKNOWN_LEVEL;
8298 }
8299 }
8300
8301 /****************************************************************
8302 _spoolss_AddPrinter
8303 ****************************************************************/
8304
8305 WERROR _spoolss_AddPrinter(struct pipes_struct *p,
8306 struct spoolss_AddPrinter *r)
8307 {
8308 struct spoolss_AddPrinterEx a;
8309 struct spoolss_UserLevelCtr userlevel_ctr;
8310
8311 ZERO_STRUCT(userlevel_ctr);
8312
8313 userlevel_ctr.level = 1;
8314
8315 a.in.server = r->in.server;
8316 a.in.info_ctr = r->in.info_ctr;
8317 a.in.devmode_ctr = r->in.devmode_ctr;
8318 a.in.secdesc_ctr = r->in.secdesc_ctr;
8319 a.in.userlevel_ctr = &userlevel_ctr;
8320 a.out.handle = r->out.handle;
8321
8322 return _spoolss_AddPrinterEx(p, &a);
8323 }
8324
8325 /****************************************************************
8326 _spoolss_AddPrinterDriverEx
8327 ****************************************************************/
8328
8329 WERROR _spoolss_AddPrinterDriverEx(struct pipes_struct *p,
8330 struct spoolss_AddPrinterDriverEx *r)
8331 {
8332 WERROR err = WERR_OK;
8333 const char *driver_name = NULL;
8334 uint32_t version;
8335 const char *fn;
8336
8337 switch (p->opnum) {
8338 case NDR_SPOOLSS_ADDPRINTERDRIVER:
8339 fn = "_spoolss_AddPrinterDriver";
8340 break;
8341 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
8342 fn = "_spoolss_AddPrinterDriverEx";
8343 break;
8344 default:
8345 return WERR_INVALID_PARAM;
8346 }
8347
8348 /*
8349 * we only support the semantics of AddPrinterDriver()
8350 * i.e. only copy files that are newer than existing ones
8351 */
8352
8353 if (r->in.flags == 0) {
8354 return WERR_INVALID_PARAM;
8355 }
8356
8357 if (r->in.flags != APD_COPY_NEW_FILES) {
8358 return WERR_ACCESS_DENIED;
8359 }
8360
8361 /* FIXME */
8362 if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
8363 /* Clever hack from Martin Zielinski <mz@seh.de>
8364 * to allow downgrade from level 8 (Vista).
8365 */
8366 DEBUG(0,("%s: level %d not yet implemented\n", fn,
8367 r->in.info_ctr->level));
8368 return WERR_UNKNOWN_LEVEL;
8369 }
8370
8371 DEBUG(5,("Cleaning driver's information\n"));
8372 err = clean_up_driver_struct(p->mem_ctx, p->session_info, r->in.info_ctr);
8373 if (!W_ERROR_IS_OK(err))
8374 goto done;
8375
8376 DEBUG(5,("Moving driver to final destination\n"));
8377 err = move_driver_to_download_area(p->session_info, r->in.info_ctr);
8378 if (!W_ERROR_IS_OK(err)) {
8379 goto done;
8380 }
8381
8382 err = winreg_add_driver_internal(p->mem_ctx,
8383 get_session_info_system(),
8384 p->msg_ctx,
8385 r->in.info_ctr,
8386 &driver_name,
8387 &version);
8388 if (!W_ERROR_IS_OK(err)) {
8389 goto done;
8390 }
8391
8392 /*
8393 * I think this is where he DrvUpgradePrinter() hook would be
8394 * be called in a driver's interface DLL on a Windows NT 4.0/2k
8395 * server. Right now, we just need to send ourselves a message
8396 * to update each printer bound to this driver. --jerry
8397 */
8398
8399 if (!srv_spoolss_drv_upgrade_printer(driver_name, p->msg_ctx)) {
8400 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
8401 fn, driver_name));
8402 }
8403
8404 done:
8405 return err;
8406 }
8407
8408 /****************************************************************
8409 _spoolss_AddPrinterDriver
8410 ****************************************************************/
8411
8412 WERROR _spoolss_AddPrinterDriver(struct pipes_struct *p,
8413 struct spoolss_AddPrinterDriver *r)
8414 {
8415 struct spoolss_AddPrinterDriverEx a;
8416
8417 switch (r->in.info_ctr->level) {
8418 case 2:
8419 case 3:
8420 case 4:
8421 case 5:
8422 break;
8423 default:
8424 return WERR_UNKNOWN_LEVEL;
8425 }
8426
8427 a.in.servername = r->in.servername;
8428 a.in.info_ctr = r->in.info_ctr;
8429 a.in.flags = APD_COPY_NEW_FILES;
8430
8431 return _spoolss_AddPrinterDriverEx(p, &a);
8432 }
8433
8434 /****************************************************************************
8435 ****************************************************************************/
8436
8437 struct _spoolss_paths {
8438 int type;
8439 const char *share;
8440 const char *dir;
8441 };
8442
8443 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
8444
8445 static const struct _spoolss_paths spoolss_paths[]= {
8446 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
8447 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
8448 };
8449
8450 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
8451 const char *servername,
8452 const char *environment,
8453 int component,
8454 char **path)
8455 {
8456 const char *pservername = NULL;
8457 const char *long_archi;
8458 const char *short_archi;
8459
8460 *path = NULL;
8461
8462 /* environment may be empty */
8463 if (environment && strlen(environment)) {
8464 long_archi = environment;
8465 } else {
8466 long_archi = lp_parm_const_string(GLOBAL_SECTION_SNUM,
8467 "spoolss", "architecture",
8468 SPOOLSS_ARCHITECTURE_NT_X86);
8469 }
8470
8471 /* servername may be empty */
8472 if (servername && strlen(servername)) {
8473 pservername = canon_servername(servername);
8474
8475 if (!is_myname_or_ipaddr(pservername)) {
8476 return WERR_INVALID_PARAM;
8477 }
8478 }
8479
8480 if (!(short_archi = get_short_archi(long_archi))) {
8481 return WERR_INVALID_ENVIRONMENT;
8482 }
8483
8484 switch (component) {
8485 case SPOOLSS_PRTPROCS_PATH:
8486 case SPOOLSS_DRIVER_PATH:
8487 if (pservername) {
8488 *path = talloc_asprintf(mem_ctx,
8489 "\\\\%s\\%s\\%s",
8490 pservername,
8491 spoolss_paths[component].share,
8492 short_archi);
8493 } else {
8494 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
8495 SPOOLSS_DEFAULT_SERVER_PATH,
8496 spoolss_paths[component].dir,
8497 short_archi);
8498 }
8499 break;
8500 default:
8501 return WERR_INVALID_PARAM;
8502 }
8503
8504 if (!*path) {
8505 return WERR_NOMEM;
8506 }
8507
8508 return WERR_OK;
8509 }
8510
8511 /****************************************************************************
8512 ****************************************************************************/
8513
8514 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
8515 const char *servername,
8516 const char *environment,
8517 struct spoolss_DriverDirectoryInfo1 *r)
8518 {
8519 WERROR werr;
8520 char *path = NULL;
8521
8522 werr = compose_spoolss_server_path(mem_ctx,
8523 servername,
8524 environment,
8525 SPOOLSS_DRIVER_PATH,
8526 &path);
8527 if (!W_ERROR_IS_OK(werr)) {
8528 return werr;
8529 }
8530
8531 DEBUG(4,("printer driver directory: [%s]\n", path));
8532
8533 r->directory_name = path;
8534
8535 return WERR_OK;
8536 }
8537
8538 /****************************************************************
8539 _spoolss_GetPrinterDriverDirectory
8540 ****************************************************************/
8541
8542 WERROR _spoolss_GetPrinterDriverDirectory(struct pipes_struct *p,
8543 struct spoolss_GetPrinterDriverDirectory *r)
8544 {
8545 WERROR werror;
8546
8547 /* that's an [in out] buffer */
8548
8549 if (!r->in.buffer && (r->in.offered != 0)) {
8550 return WERR_INVALID_PARAM;
8551 }
8552
8553 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
8554 r->in.level));
8555
8556 *r->out.needed = 0;
8557
8558 /* r->in.level is ignored */
8559
8560 werror = getprinterdriverdir_level_1(p->mem_ctx,
8561 r->in.server,
8562 r->in.environment,
8563 &r->out.info->info1);
8564 if (!W_ERROR_IS_OK(werror)) {
8565 TALLOC_FREE(r->out.info);
8566 return werror;
8567 }
8568
8569 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo,
8570 r->out.info, r->in.level);
8571 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8572
8573 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8574 }
8575
8576 /****************************************************************
8577 _spoolss_EnumPrinterData
8578 ****************************************************************/
8579
8580 WERROR _spoolss_EnumPrinterData(struct pipes_struct *p,
8581 struct spoolss_EnumPrinterData *r)
8582 {
8583 WERROR result;
8584 struct spoolss_EnumPrinterDataEx r2;
8585 uint32_t count;
8586 struct spoolss_PrinterEnumValues *info, *val = NULL;
8587 uint32_t needed;
8588
8589 r2.in.handle = r->in.handle;
8590 r2.in.key_name = "PrinterDriverData";
8591 r2.in.offered = 0;
8592 r2.out.count = &count;
8593 r2.out.info = &info;
8594 r2.out.needed = &needed;
8595
8596 result = _spoolss_EnumPrinterDataEx(p, &r2);
8597 if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
8598 r2.in.offered = needed;
8599 result = _spoolss_EnumPrinterDataEx(p, &r2);
8600 }
8601 if (!W_ERROR_IS_OK(result)) {
8602 return result;
8603 }
8604
8605 /*
8606 * The NT machine wants to know the biggest size of value and data
8607 *
8608 * cf: MSDN EnumPrinterData remark section
8609 */
8610
8611 if (!r->in.value_offered && !r->in.data_offered) {
8612 uint32_t biggest_valuesize = 0;
8613 uint32_t biggest_datasize = 0;
8614 int i, name_length;
8615
8616 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8617
8618 for (i=0; i<count; i++) {
8619
8620 name_length = strlen(info[i].value_name);
8621 if (strlen(info[i].value_name) > biggest_valuesize) {
8622 biggest_valuesize = name_length;
8623 }
8624
8625 if (info[i].data_length > biggest_datasize) {
8626 biggest_datasize = info[i].data_length;
8627 }
8628
8629 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8630 biggest_datasize));
8631 }
8632
8633 /* the value is an UNICODE string but real_value_size is the length
8634 in bytes including the trailing 0 */
8635
8636 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8637 *r->out.data_needed = biggest_datasize;
8638
8639 DEBUG(6,("final values: [%d], [%d]\n",
8640 *r->out.value_needed, *r->out.data_needed));
8641
8642 return WERR_OK;
8643 }
8644
8645 if (r->in.enum_index < count) {
8646 val = &info[r->in.enum_index];
8647 }
8648
8649 if (val == NULL) {
8650 /* out_value should default to "" or else NT4 has
8651 problems unmarshalling the response */
8652
8653 if (r->in.value_offered) {
8654 *r->out.value_needed = 1;
8655 r->out.value_name = talloc_strdup(r, "");
8656 if (!r->out.value_name) {
8657 return WERR_NOMEM;
8658 }
8659 } else {
8660 r->out.value_name = NULL;
8661 *r->out.value_needed = 0;
8662 }
8663
8664 /* the data is counted in bytes */
8665
8666 *r->out.data_needed = r->in.data_offered;
8667
8668 result = WERR_NO_MORE_ITEMS;
8669 } else {
8670 /*
8671 * the value is:
8672 * - counted in bytes in the request
8673 * - counted in UNICODE chars in the max reply
8674 * - counted in bytes in the real size
8675 *
8676 * take a pause *before* coding not *during* coding
8677 */
8678
8679 /* name */
8680 if (r->in.value_offered) {
8681 r->out.value_name = talloc_strdup(r, val->value_name);
8682 if (!r->out.value_name) {
8683 return WERR_NOMEM;
8684 }
8685 *r->out.value_needed = val->value_name_len;
8686 } else {
8687 r->out.value_name = NULL;
8688 *r->out.value_needed = 0;
8689 }
8690
8691 /* type */
8692
8693 *r->out.type = val->type;
8694
8695 /* data - counted in bytes */
8696
8697 /*
8698 * See the section "Dynamically Typed Query Parameters"
8699 * in MS-RPRN.
8700 */
8701
8702 if (r->out.data && val->data && val->data->data &&
8703 val->data_length && r->in.data_offered) {
8704 memcpy(r->out.data, val->data->data,
8705 MIN(val->data_length,r->in.data_offered));
8706 }
8707
8708 *r->out.data_needed = val->data_length;
8709
8710 result = WERR_OK;
8711 }
8712
8713 return result;
8714 }
8715
8716 /****************************************************************
8717 _spoolss_SetPrinterData
8718 ****************************************************************/
8719
8720 WERROR _spoolss_SetPrinterData(struct pipes_struct *p,
8721 struct spoolss_SetPrinterData *r)
8722 {
8723 struct spoolss_SetPrinterDataEx r2;
8724
8725 r2.in.handle = r->in.handle;
8726 r2.in.key_name = "PrinterDriverData";
8727 r2.in.value_name = r->in.value_name;
8728 r2.in.type = r->in.type;
8729 r2.in.data = r->in.data;
8730 r2.in.offered = r->in.offered;
8731
8732 return _spoolss_SetPrinterDataEx(p, &r2);
8733 }
8734
8735 /****************************************************************
8736 _spoolss_ResetPrinter
8737 ****************************************************************/
8738
8739 WERROR _spoolss_ResetPrinter(struct pipes_struct *p,
8740 struct spoolss_ResetPrinter *r)
8741 {
8742 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8743 int snum;
8744
8745 DEBUG(5,("_spoolss_ResetPrinter\n"));
8746
8747 /*
8748 * All we do is to check to see if the handle and queue is valid.
8749 * This call really doesn't mean anything to us because we only
8750 * support RAW printing. --jerry
8751 */
8752
8753 if (!Printer) {
8754 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8755 OUR_HANDLE(r->in.handle)));
8756 return WERR_BADFID;
8757 }
8758
8759 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8760 return WERR_BADFID;
8761
8762
8763 /* blindly return success */
8764 return WERR_OK;
8765 }
8766
8767 /****************************************************************
8768 _spoolss_DeletePrinterData
8769 ****************************************************************/
8770
8771 WERROR _spoolss_DeletePrinterData(struct pipes_struct *p,
8772 struct spoolss_DeletePrinterData *r)
8773 {
8774 struct spoolss_DeletePrinterDataEx r2;
8775
8776 r2.in.handle = r->in.handle;
8777 r2.in.key_name = "PrinterDriverData";
8778 r2.in.value_name = r->in.value_name;
8779
8780 return _spoolss_DeletePrinterDataEx(p, &r2);
8781 }
8782
8783 /****************************************************************
8784 _spoolss_AddForm
8785 ****************************************************************/
8786
8787 WERROR _spoolss_AddForm(struct pipes_struct *p,
8788 struct spoolss_AddForm *r)
8789 {
8790 struct spoolss_AddFormInfo1 *form;
8791 int snum = -1;
8792 WERROR status = WERR_OK;
8793 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8794 struct dcerpc_binding_handle *b;
8795 TALLOC_CTX *tmp_ctx = NULL;
8796
8797 DEBUG(5,("_spoolss_AddForm\n"));
8798
8799 if (!Printer) {
8800 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8801 OUR_HANDLE(r->in.handle)));
8802 return WERR_BADFID;
8803 }
8804
8805 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8806 and not a printer admin, then fail */
8807
8808 if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
8809 !security_token_has_privilege(p->session_info->security_token,
8810 SEC_PRIV_PRINT_OPERATOR)) {
8811 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8812 return WERR_ACCESS_DENIED;
8813 }
8814
8815 if (r->in.info_ctr->level != 1) {
8816 return WERR_INVALID_LEVEL;
8817 }
8818
8819 form = r->in.info_ctr->info.info1;
8820 if (!form) {
8821 return WERR_INVALID_PARAM;
8822 }
8823
8824 switch (form->flags) {
8825 case SPOOLSS_FORM_USER:
8826 case SPOOLSS_FORM_BUILTIN:
8827 case SPOOLSS_FORM_PRINTER:
8828 break;
8829 default:
8830 return WERR_INVALID_PARAM;
8831 }
8832
8833 tmp_ctx = talloc_new(p->mem_ctx);
8834 if (!tmp_ctx) {
8835 return WERR_NOMEM;
8836 }
8837
8838 status = winreg_printer_binding_handle(tmp_ctx,
8839 get_session_info_system(),
8840 p->msg_ctx,
8841 &b);
8842 if (!W_ERROR_IS_OK(status)) {
8843 goto done;
8844 }
8845
8846 status = winreg_printer_addform1(tmp_ctx, b, form);
8847 if (!W_ERROR_IS_OK(status)) {
8848 goto done;
8849 }
8850
8851 /*
8852 * ChangeID must always be set if this is a printer
8853 */
8854 if (Printer->printer_type == SPLHND_PRINTER) {
8855 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8856 status = WERR_BADFID;
8857 goto done;
8858 }
8859
8860 status = winreg_printer_update_changeid(tmp_ctx, b,
8861 lp_const_servicename(snum));
8862 }
8863
8864 done:
8865 talloc_free(tmp_ctx);
8866 return status;
8867 }
8868
8869 /****************************************************************
8870 _spoolss_DeleteForm
8871 ****************************************************************/
8872
8873 WERROR _spoolss_DeleteForm(struct pipes_struct *p,
8874 struct spoolss_DeleteForm *r)
8875 {
8876 const char *form_name = r->in.form_name;
8877 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8878 int snum = -1;
8879 WERROR status = WERR_OK;
8880 struct dcerpc_binding_handle *b;
8881 TALLOC_CTX *tmp_ctx = NULL;
8882
8883 DEBUG(5,("_spoolss_DeleteForm\n"));
8884
8885 if (!Printer) {
8886 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8887 OUR_HANDLE(r->in.handle)));
8888 return WERR_BADFID;
8889 }
8890
8891 if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
8892 !security_token_has_privilege(p->session_info->security_token,
8893 SEC_PRIV_PRINT_OPERATOR)) {
8894 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8895 return WERR_ACCESS_DENIED;
8896 }
8897
8898 tmp_ctx = talloc_new(p->mem_ctx);
8899 if (!tmp_ctx) {
8900 return WERR_NOMEM;
8901 }
8902
8903 status = winreg_printer_binding_handle(tmp_ctx,
8904 get_session_info_system(),
8905 p->msg_ctx,
8906 &b);
8907 if (!W_ERROR_IS_OK(status)) {
8908 goto done;
8909 }
8910
8911 status = winreg_printer_deleteform1(tmp_ctx, b, form_name);
8912 if (!W_ERROR_IS_OK(status)) {
8913 goto done;
8914 }
8915
8916 /*
8917 * ChangeID must always be set if this is a printer
8918 */
8919 if (Printer->printer_type == SPLHND_PRINTER) {
8920 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8921 status = WERR_BADFID;
8922 goto done;
8923 }
8924
8925 status = winreg_printer_update_changeid(tmp_ctx, b,
8926 lp_const_servicename(snum));
8927 }
8928
8929 done:
8930 talloc_free(tmp_ctx);
8931 return status;
8932 }
8933
8934 /****************************************************************
8935 _spoolss_SetForm
8936 ****************************************************************/
8937
8938 WERROR _spoolss_SetForm(struct pipes_struct *p,
8939 struct spoolss_SetForm *r)
8940 {
8941 struct spoolss_AddFormInfo1 *form;
8942 const char *form_name = r->in.form_name;
8943 int snum = -1;
8944 WERROR status = WERR_OK;
8945 struct dcerpc_binding_handle *b;
8946 TALLOC_CTX *tmp_ctx = NULL;
8947
8948 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8949
8950 DEBUG(5,("_spoolss_SetForm\n"));
8951
8952 if (!Printer) {
8953 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8954 OUR_HANDLE(r->in.handle)));
8955 return WERR_BADFID;
8956 }
8957
8958 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8959 and not a printer admin, then fail */
8960
8961 if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
8962 !security_token_has_privilege(p->session_info->security_token,
8963 SEC_PRIV_PRINT_OPERATOR)) {
8964 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8965 return WERR_ACCESS_DENIED;
8966 }
8967
8968 if (r->in.info_ctr->level != 1) {
8969 return WERR_INVALID_LEVEL;
8970 }
8971
8972 form = r->in.info_ctr->info.info1;
8973 if (!form) {
8974 return WERR_INVALID_PARAM;
8975 }
8976
8977 tmp_ctx = talloc_new(p->mem_ctx);
8978 if (!tmp_ctx) {
8979 return WERR_NOMEM;
8980 }
8981
8982 status = winreg_printer_binding_handle(tmp_ctx,
8983 get_session_info_system(),
8984 p->msg_ctx,
8985 &b);
8986 if (!W_ERROR_IS_OK(status)) {
8987 goto done;
8988 }
8989
8990 status = winreg_printer_setform1(tmp_ctx, b,
8991 form_name,
8992 form);
8993 if (!W_ERROR_IS_OK(status)) {
8994 goto done;
8995 }
8996
8997 /*
8998 * ChangeID must always be set if this is a printer
8999 */
9000 if (Printer->printer_type == SPLHND_PRINTER) {
9001 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9002 status = WERR_BADFID;
9003 goto done;
9004 }
9005
9006 status = winreg_printer_update_changeid(tmp_ctx, b,
9007 lp_const_servicename(snum));
9008 }
9009
9010 done:
9011 talloc_free(tmp_ctx);
9012 return status;
9013 }
9014
9015 /****************************************************************************
9016 fill_print_processor1
9017 ****************************************************************************/
9018
9019 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
9020 struct spoolss_PrintProcessorInfo1 *r,
9021 const char *print_processor_name)
9022 {
9023 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
9024 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
9025
9026 return WERR_OK;
9027 }
9028
9029 /****************************************************************************
9030 enumprintprocessors level 1.
9031 ****************************************************************************/
9032
9033 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
9034 union spoolss_PrintProcessorInfo **info_p,
9035 uint32_t *count)
9036 {
9037 union spoolss_PrintProcessorInfo *info;
9038 WERROR result;
9039
9040 info = talloc_array(mem_ctx, union spoolss_PrintProcessorInfo, 1);
9041 W_ERROR_HAVE_NO_MEMORY(info);
9042
9043 *count = 1;
9044
9045 result = fill_print_processor1(info, &info[0].info1, "winprint");
9046 if (!W_ERROR_IS_OK(result)) {
9047 goto out;
9048 }
9049
9050 out:
9051 if (!W_ERROR_IS_OK(result)) {
9052 TALLOC_FREE(info);
9053 *count = 0;
9054 return result;
9055 }
9056
9057 *info_p = info;
9058
9059 return WERR_OK;
9060 }
9061
9062 /****************************************************************
9063 _spoolss_EnumPrintProcessors
9064 ****************************************************************/
9065
9066 WERROR _spoolss_EnumPrintProcessors(struct pipes_struct *p,
9067 struct spoolss_EnumPrintProcessors *r)
9068 {
9069 WERROR result;
9070
9071 /* that's an [in out] buffer */
9072
9073 if (!r->in.buffer && (r->in.offered != 0)) {
9074 return WERR_INVALID_PARAM;
9075 }
9076
9077 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
9078
9079 /*
9080 * Enumerate the print processors ...
9081 *
9082 * Just reply with "winprint", to keep NT happy
9083 * and I can use my nice printer checker.
9084 */
9085
9086 *r->out.count = 0;
9087 *r->out.needed = 0;
9088 *r->out.info = NULL;
9089
9090 if (!get_short_archi(r->in.environment)) {
9091 return WERR_INVALID_ENVIRONMENT;
9092 }
9093
9094 switch (r->in.level) {
9095 case 1:
9096 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
9097 r->out.count);
9098 break;
9099 default:
9100 return WERR_UNKNOWN_LEVEL;
9101 }
9102
9103 if (!W_ERROR_IS_OK(result)) {
9104 return result;
9105 }
9106
9107 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9108 spoolss_EnumPrintProcessors,
9109 *r->out.info, r->in.level,
9110 *r->out.count);
9111 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9112 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9113
9114 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9115 }
9116
9117 /****************************************************************************
9118 fill_printprocdatatype1
9119 ****************************************************************************/
9120
9121 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
9122 struct spoolss_PrintProcDataTypesInfo1 *r,
9123 const char *name_array)
9124 {
9125 r->name_array = talloc_strdup(mem_ctx, name_array);
9126 W_ERROR_HAVE_NO_MEMORY(r->name_array);
9127
9128 return WERR_OK;
9129 }
9130
9131 /****************************************************************************
9132 enumprintprocdatatypes level 1.
9133 ****************************************************************************/
9134
9135 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
9136 union spoolss_PrintProcDataTypesInfo **info_p,
9137 uint32_t *count)
9138 {
9139 WERROR result;
9140 union spoolss_PrintProcDataTypesInfo *info;
9141
9142 info = talloc_array(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
9143 W_ERROR_HAVE_NO_MEMORY(info);
9144
9145 *count = 1;
9146
9147 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
9148 if (!W_ERROR_IS_OK(result)) {
9149 goto out;
9150 }
9151
9152 out:
9153 if (!W_ERROR_IS_OK(result)) {
9154 TALLOC_FREE(info);
9155 *count = 0;
9156 return result;
9157 }
9158
9159 *info_p = info;
9160
9161 return WERR_OK;
9162 }
9163
9164 /****************************************************************
9165 _spoolss_EnumPrintProcDataTypes
9166 ****************************************************************/
9167
9168 WERROR _spoolss_EnumPrintProcDataTypes(struct pipes_struct *p,
9169 struct spoolss_EnumPrintProcDataTypes *r)
9170 {
9171 WERROR result;
9172
9173 /* that's an [in out] buffer */
9174
9175 if (!r->in.buffer && (r->in.offered != 0)) {
9176 return WERR_INVALID_PARAM;
9177 }
9178
9179 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
9180
9181 *r->out.count = 0;
9182 *r->out.needed = 0;
9183 *r->out.info = NULL;
9184
9185 if (r->in.print_processor_name == NULL ||
9186 !strequal(r->in.print_processor_name, "winprint")) {
9187 return WERR_UNKNOWN_PRINTPROCESSOR;
9188 }
9189
9190 switch (r->in.level) {
9191 case 1:
9192 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
9193 r->out.count);
9194 break;
9195 default:
9196 return WERR_UNKNOWN_LEVEL;
9197 }
9198
9199 if (!W_ERROR_IS_OK(result)) {
9200 return result;
9201 }
9202
9203 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9204 spoolss_EnumPrintProcDataTypes,
9205 *r->out.info, r->in.level,
9206 *r->out.count);
9207 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9208 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9209
9210 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9211 }
9212
9213 /****************************************************************************
9214 fill_monitor_1
9215 ****************************************************************************/
9216
9217 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
9218 struct spoolss_MonitorInfo1 *r,
9219 const char *monitor_name)
9220 {
9221 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
9222 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
9223
9224 return WERR_OK;
9225 }
9226
9227 /****************************************************************************
9228 fill_monitor_2
9229 ****************************************************************************/
9230
9231 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
9232 struct spoolss_MonitorInfo2 *r,
9233 const char *monitor_name,
9234 const char *environment,
9235 const char *dll_name)
9236 {
9237 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
9238 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
9239 r->environment = talloc_strdup(mem_ctx, environment);
9240 W_ERROR_HAVE_NO_MEMORY(r->environment);
9241 r->dll_name = talloc_strdup(mem_ctx, dll_name);
9242 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
9243
9244 return WERR_OK;
9245 }
9246
9247 /****************************************************************************
9248 enumprintmonitors level 1.
9249 ****************************************************************************/
9250
9251 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
9252 union spoolss_MonitorInfo **info_p,
9253 uint32_t *count)
9254 {
9255 union spoolss_MonitorInfo *info;
9256 WERROR result = WERR_OK;
9257
9258 info = talloc_array(mem_ctx, union spoolss_MonitorInfo, 2);
9259 W_ERROR_HAVE_NO_MEMORY(info);
9260
9261 *count = 2;
9262
9263 result = fill_monitor_1(info, &info[0].info1,
9264 SPL_LOCAL_PORT);
9265 if (!W_ERROR_IS_OK(result)) {
9266 goto out;
9267 }
9268
9269 result = fill_monitor_1(info, &info[1].info1,
9270 SPL_TCPIP_PORT);
9271 if (!W_ERROR_IS_OK(result)) {
9272 goto out;
9273 }
9274
9275 out:
9276 if (!W_ERROR_IS_OK(result)) {
9277 TALLOC_FREE(info);
9278 *count = 0;
9279 return result;
9280 }
9281
9282 *info_p = info;
9283
9284 return WERR_OK;
9285 }
9286
9287 /****************************************************************************
9288 enumprintmonitors level 2.
9289 ****************************************************************************/
9290
9291 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
9292 union spoolss_MonitorInfo **info_p,
9293 uint32_t *count)
9294 {
9295 union spoolss_MonitorInfo *info;
9296 WERROR result = WERR_OK;
9297
9298 info = talloc_array(mem_ctx, union spoolss_MonitorInfo, 2);
9299 W_ERROR_HAVE_NO_MEMORY(info);
9300
9301 *count = 2;
9302
9303 result = fill_monitor_2(info, &info[0].info2,
9304 SPL_LOCAL_PORT,
9305 "Windows NT X86", /* FIXME */
9306 "localmon.dll");
9307 if (!W_ERROR_IS_OK(result)) {
9308 goto out;
9309 }
9310
9311 result = fill_monitor_2(info, &info[1].info2,
9312 SPL_TCPIP_PORT,
9313 "Windows NT X86", /* FIXME */
9314 "tcpmon.dll");
9315 if (!W_ERROR_IS_OK(result)) {
9316 goto out;
9317 }
9318
9319 out:
9320 if (!W_ERROR_IS_OK(result)) {
9321 TALLOC_FREE(info);
9322 *count = 0;
9323 return result;
9324 }
9325
9326 *info_p = info;
9327
9328 return WERR_OK;
9329 }
9330
9331 /****************************************************************
9332 _spoolss_EnumMonitors
9333 ****************************************************************/
9334
9335 WERROR _spoolss_EnumMonitors(struct pipes_struct *p,
9336 struct spoolss_EnumMonitors *r)
9337 {
9338 WERROR result;
9339
9340 /* that's an [in out] buffer */
9341
9342 if (!r->in.buffer && (r->in.offered != 0)) {
9343 return WERR_INVALID_PARAM;
9344 }
9345
9346 DEBUG(5,("_spoolss_EnumMonitors\n"));
9347
9348 /*
9349 * Enumerate the print monitors ...
9350 *
9351 * Just reply with "Local Port", to keep NT happy
9352 * and I can use my nice printer checker.
9353 */
9354
9355 *r->out.count = 0;
9356 *r->out.needed = 0;
9357 *r->out.info = NULL;
9358
9359 switch (r->in.level) {
9360 case 1:
9361 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
9362 r->out.count);
9363 break;
9364 case 2:
9365 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
9366 r->out.count);
9367 break;
9368 default:
9369 return WERR_UNKNOWN_LEVEL;
9370 }
9371
9372 if (!W_ERROR_IS_OK(result)) {
9373 return result;
9374 }
9375
9376 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
9377 spoolss_EnumMonitors,
9378 *r->out.info, r->in.level,
9379 *r->out.count);
9380 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9381 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
9382
9383 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9384 }
9385
9386 /****************************************************************************
9387 ****************************************************************************/
9388
9389 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
9390 const print_queue_struct *queue,
9391 int count, int snum,
9392 struct spoolss_PrinterInfo2 *pinfo2,
9393 uint32_t jobid,
9394 int sysjob,
9395 struct spoolss_JobInfo1 *r)
9396 {
9397 int i = 0;
9398 bool found = false;
9399
9400 for (i=0; i<count; i++) {
9401 if (queue[i].sysjob == sysjob) {
9402 found = true;
9403 break;
9404 }
9405 }
9406
9407 if (found == false) {
9408 /* NT treats not found as bad param... yet another bad choice */
9409 return WERR_INVALID_PARAM;
9410 }
9411
9412 return fill_job_info1(mem_ctx,
9413 r,
9414 &queue[i],
9415 jobid,
9416 i,
9417 snum,
9418 pinfo2);
9419 }
9420
9421 /****************************************************************************
9422 ****************************************************************************/
9423
9424 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
9425 const print_queue_struct *queue,
9426 int count, int snum,
9427 struct spoolss_PrinterInfo2 *pinfo2,
9428 uint32_t jobid,
9429 int sysjob,
9430 struct spoolss_JobInfo2 *r)
9431 {
9432 int i = 0;
9433 bool found = false;
9434 struct spoolss_DeviceMode *devmode;
9435 WERROR result;
9436
9437 for (i=0; i<count; i++) {
9438 if (queue[i].sysjob == sysjob) {
9439 found = true;
9440 break;
9441 }
9442 }
9443
9444 if (found == false) {
9445 /* NT treats not found as bad param... yet another bad
9446 choice */
9447 return WERR_INVALID_PARAM;
9448 }
9449
9450 /*
9451 * if the print job does not have a DEVMODE associated with it,
9452 * just use the one for the printer. A NULL devicemode is not
9453 * a failure condition
9454 */
9455
9456 devmode = print_job_devmode(mem_ctx, lp_const_servicename(snum), jobid);
9457 if (!devmode) {
9458 result = spoolss_create_default_devmode(mem_ctx,
9459 pinfo2->printername,
9460 &devmode);
9461 if (!W_ERROR_IS_OK(result)) {
9462 DEBUG(3, ("Can't proceed w/o a devmode!"));
9463 return result;
9464 }
9465 }
9466
9467 return fill_job_info2(mem_ctx,
9468 r,
9469 &queue[i],
9470 jobid,
9471 i,
9472 snum,
9473 pinfo2,
9474 devmode);
9475 }
9476
9477 /****************************************************************
9478 _spoolss_GetJob
9479 ****************************************************************/
9480
9481 WERROR _spoolss_GetJob(struct pipes_struct *p,
9482 struct spoolss_GetJob *r)
9483 {
9484 WERROR result = WERR_OK;
9485 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
9486 const char *svc_name;
9487 int sysjob;
9488 int snum;
9489 int count;
9490 struct tdb_print_db *pdb;
9491 print_queue_struct *queue = NULL;
9492 print_status_struct prt_status;
9493
9494 /* that's an [in out] buffer */
9495
9496 if (!r->in.buffer && (r->in.offered != 0)) {
9497 return WERR_INVALID_PARAM;
9498 }
9499
9500 DEBUG(5,("_spoolss_GetJob\n"));
9501
9502 *r->out.needed = 0;
9503
9504 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9505 return WERR_BADFID;
9506 }
9507
9508 svc_name = lp_const_servicename(snum);
9509 if (svc_name == NULL) {
9510 return WERR_INVALID_PARAM;
9511 }
9512
9513 result = winreg_get_printer_internal(p->mem_ctx,
9514 get_session_info_system(),
9515 p->msg_ctx,
9516 svc_name,
9517 &pinfo2);
9518 if (!W_ERROR_IS_OK(result)) {
9519 return result;
9520 }
9521
9522 pdb = get_print_db_byname(svc_name);
9523 if (pdb == NULL) {
9524 DEBUG(3, ("failed to get print db for svc %s\n", svc_name));
9525 TALLOC_FREE(pinfo2);
9526 return WERR_INVALID_PARAM;
9527 }
9528
9529 sysjob = jobid_to_sysjob_pdb(pdb, r->in.job_id);
9530 release_print_db(pdb);
9531 if (sysjob == -1) {
9532 DEBUG(3, ("no sysjob for spoolss jobid %u\n", r->in.job_id));
9533 TALLOC_FREE(pinfo2);
9534 return WERR_INVALID_PARAM;
9535 }
9536
9537 count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
9538
9539 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
9540 count, prt_status.status, prt_status.message));
9541
9542 switch (r->in.level) {
9543 case 1:
9544 result = getjob_level_1(p->mem_ctx,
9545 queue, count, snum, pinfo2,
9546 r->in.job_id, sysjob,
9547 &r->out.info->info1);
9548 break;
9549 case 2:
9550 result = getjob_level_2(p->mem_ctx,
9551 queue, count, snum, pinfo2,
9552 r->in.job_id, sysjob,
9553 &r->out.info->info2);
9554 break;
9555 default:
9556 result = WERR_UNKNOWN_LEVEL;
9557 break;
9558 }
9559
9560 SAFE_FREE(queue);
9561 TALLOC_FREE(pinfo2);
9562
9563 if (!W_ERROR_IS_OK(result)) {
9564 TALLOC_FREE(r->out.info);
9565 return result;
9566 }
9567
9568 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, r->out.info,
9569 r->in.level);
9570 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9571
9572 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9573 }
9574
9575 /****************************************************************
9576 _spoolss_GetPrinterDataEx
9577 ****************************************************************/
9578
9579 WERROR _spoolss_GetPrinterDataEx(struct pipes_struct *p,
9580 struct spoolss_GetPrinterDataEx *r)
9581 {
9582
9583 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9584 const char *printer;
9585 int snum = 0;
9586 WERROR result = WERR_OK;
9587 DATA_BLOB blob;
9588 enum winreg_Type val_type = REG_NONE;
9589 uint8_t *val_data = NULL;
9590 uint32_t val_size = 0;
9591 struct dcerpc_binding_handle *b;
9592 TALLOC_CTX *tmp_ctx;
9593
9594 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9595
9596 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9597 r->in.key_name, r->in.value_name));
9598
9599 /* in case of problem, return some default values */
9600
9601 *r->out.needed = 0;
9602 *r->out.type = REG_NONE;
9603
9604 tmp_ctx = talloc_new(p->mem_ctx);
9605 if (!tmp_ctx) {
9606 return WERR_NOMEM;
9607 }
9608
9609 if (!Printer) {
9610 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9611 OUR_HANDLE(r->in.handle)));
9612 result = WERR_BADFID;
9613 goto done;
9614 }
9615
9616 /* check to see if the keyname is valid */
9617 if (!strlen(r->in.key_name)) {
9618 result = WERR_INVALID_PARAM;
9619 goto done;
9620 }
9621
9622 /* Is the handle to a printer or to the server? */
9623
9624 if (Printer->printer_type == SPLHND_SERVER) {
9625
9626 union spoolss_PrinterData data;
9627
9628 result = getprinterdata_printer_server(tmp_ctx,
9629 r->in.value_name,
9630 r->out.type,
9631 &data);
9632 if (!W_ERROR_IS_OK(result)) {
9633 goto done;
9634 }
9635
9636 result = push_spoolss_PrinterData(tmp_ctx, &blob,
9637 *r->out.type, &data);
9638 if (!W_ERROR_IS_OK(result)) {
9639 goto done;
9640 }
9641
9642 *r->out.needed = blob.length;
9643
9644 if (r->in.offered >= *r->out.needed) {
9645 memcpy(r->out.data, blob.data, blob.length);
9646 }
9647
9648 result = WERR_OK;
9649 goto done;
9650 }
9651
9652 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9653 result = WERR_BADFID;
9654 goto done;
9655 }
9656 printer = lp_const_servicename(snum);
9657
9658 result = winreg_printer_binding_handle(tmp_ctx,
9659 get_session_info_system(),
9660 p->msg_ctx,
9661 &b);
9662 if (!W_ERROR_IS_OK(result)) {
9663 goto done;
9664 }
9665
9666 /* XP sends this and wants the ChangeID value from PRINTER_INFO_0 */
9667 if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
9668 strequal(r->in.value_name, "ChangeId")) {
9669 *r->out.type = REG_DWORD;
9670 *r->out.needed = 4;
9671 if (r->in.offered >= *r->out.needed) {
9672 uint32_t changeid = 0;
9673
9674 result = winreg_printer_get_changeid(tmp_ctx, b,
9675 printer,
9676 &changeid);
9677 if (!W_ERROR_IS_OK(result)) {
9678 goto done;
9679 }
9680
9681 SIVAL(r->out.data, 0, changeid);
9682 result = WERR_OK;
9683 }
9684 goto done;
9685 }
9686
9687 result = winreg_get_printer_dataex(tmp_ctx, b,
9688 printer,
9689 r->in.key_name,
9690 r->in.value_name,
9691 &val_type,
9692 &val_data,
9693 &val_size);
9694 if (!W_ERROR_IS_OK(result)) {
9695 goto done;
9696 }
9697
9698 *r->out.needed = val_size;
9699 *r->out.type = val_type;
9700
9701 if (r->in.offered >= *r->out.needed) {
9702 memcpy(r->out.data, val_data, val_size);
9703 }
9704
9705 done:
9706 /* NOTE: do not replace type when returning WERR_MORE_DATA */
9707
9708 if (W_ERROR_IS_OK(result)) {
9709 result = SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9710 }
9711
9712 talloc_free(tmp_ctx);
9713 return result;
9714 }
9715
9716 /****************************************************************
9717 _spoolss_SetPrinterDataEx
9718 ****************************************************************/
9719
9720 WERROR _spoolss_SetPrinterDataEx(struct pipes_struct *p,
9721 struct spoolss_SetPrinterDataEx *r)
9722 {
9723 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
9724 int snum = 0;
9725 WERROR result = WERR_OK;
9726 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9727 char *oid_string;
9728 struct dcerpc_binding_handle *b;
9729 TALLOC_CTX *tmp_ctx;
9730
9731 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9732
9733 /* From MSDN documentation of SetPrinterDataEx: pass request to
9734 SetPrinterData if key is "PrinterDriverData" */
9735
9736 if (!Printer) {
9737 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9738 OUR_HANDLE(r->in.handle)));
9739 return WERR_BADFID;
9740 }
9741
9742 if (Printer->printer_type == SPLHND_SERVER) {
9743 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9744 "Not implemented for server handles yet\n"));
9745 return WERR_INVALID_PARAM;
9746 }
9747
9748 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9749 return WERR_BADFID;
9750 }
9751
9752 /*
9753 * Access check : NT returns "access denied" if you make a
9754 * SetPrinterData call without the necessary privildge.
9755 * we were originally returning OK if nothing changed
9756 * which made Win2k issue **a lot** of SetPrinterData
9757 * when connecting to a printer --jerry
9758 */
9759
9760 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9761 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9762 "change denied by handle access permissions\n"));
9763 return WERR_ACCESS_DENIED;
9764 }
9765
9766 tmp_ctx = talloc_new(p->mem_ctx);
9767 if (!tmp_ctx) {
9768 return WERR_NOMEM;
9769 }
9770
9771 result = winreg_printer_binding_handle(tmp_ctx,
9772 get_session_info_system(),
9773 p->msg_ctx,
9774 &b);
9775 if (!W_ERROR_IS_OK(result)) {
9776 goto done;
9777 }
9778
9779 result = winreg_get_printer(tmp_ctx, b,
9780 lp_servicename(talloc_tos(), snum),
9781 &pinfo2);
9782 if (!W_ERROR_IS_OK(result)) {
9783 goto done;
9784 }
9785
9786 /* check for OID in valuename */
9787
9788 oid_string = strchr(r->in.value_name, ',');
9789 if (oid_string) {
9790 *oid_string = '\0';
9791 oid_string++;
9792 }
9793
9794 /* save the registry data */
9795
9796 result = winreg_set_printer_dataex(tmp_ctx, b,
9797 pinfo2->sharename,
9798 r->in.key_name,
9799 r->in.value_name,
9800 r->in.type,
9801 r->in.data,
9802 r->in.offered);
9803
9804 if (W_ERROR_IS_OK(result)) {
9805 /* save the OID if one was specified */
9806 if (oid_string) {
9807 char *str = talloc_asprintf(tmp_ctx, "%s\\%s",
9808 r->in.key_name, SPOOL_OID_KEY);
9809 if (!str) {
9810 result = WERR_NOMEM;
9811 goto done;
9812 }
9813
9814 /*
9815 * I'm not checking the status here on purpose. Don't know
9816 * if this is right, but I'm returning the status from the
9817 * previous set_printer_dataex() call. I have no idea if
9818 * this is right. --jerry
9819 */
9820 winreg_set_printer_dataex(tmp_ctx, b,
9821 pinfo2->sharename,
9822 str,
9823 r->in.value_name,
9824 REG_SZ,
9825 (uint8_t *) oid_string,
9826 strlen(oid_string) + 1);
9827 }
9828
9829 result = winreg_printer_update_changeid(tmp_ctx, b,
9830 lp_const_servicename(snum));
9831
9832 }
9833
9834 done:
9835 talloc_free(tmp_ctx);
9836 return result;
9837 }
9838
9839 /****************************************************************
9840 _spoolss_DeletePrinterDataEx
9841 ****************************************************************/
9842
9843 WERROR _spoolss_DeletePrinterDataEx(struct pipes_struct *p,
9844 struct spoolss_DeletePrinterDataEx *r)
9845 {
9846 const char *printer;
9847 int snum=0;
9848 WERROR status = WERR_OK;
9849 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9850
9851 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9852
9853 if (!Printer) {
9854 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9855 "Invalid handle (%s:%u:%u).\n",
9856 OUR_HANDLE(r->in.handle)));
9857 return WERR_BADFID;
9858 }
9859
9860 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9861 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9862 "printer properties change denied by handle\n"));
9863 return WERR_ACCESS_DENIED;
9864 }
9865
9866 if (!r->in.value_name || !r->in.key_name) {
9867 return WERR_NOMEM;
9868 }
9869
9870 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9871 return WERR_BADFID;
9872 }
9873 printer = lp_const_servicename(snum);
9874
9875 status = winreg_delete_printer_dataex_internal(p->mem_ctx,
9876 get_session_info_system(),
9877 p->msg_ctx,
9878 printer,
9879 r->in.key_name,
9880 r->in.value_name);
9881 if (W_ERROR_IS_OK(status)) {
9882 status = winreg_printer_update_changeid_internal(p->mem_ctx,
9883 get_session_info_system(),
9884 p->msg_ctx,
9885 printer);
9886 }
9887
9888 return status;
9889 }
9890
9891 /****************************************************************
9892 _spoolss_EnumPrinterKey
9893 ****************************************************************/
9894
9895 WERROR _spoolss_EnumPrinterKey(struct pipes_struct *p,
9896 struct spoolss_EnumPrinterKey *r)
9897 {
9898 uint32_t num_keys;
9899 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9900 int snum = 0;
9901 WERROR result = WERR_BADFILE;
9902 const char **array = NULL;
9903 DATA_BLOB blob;
9904
9905 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9906
9907 if (!Printer) {
9908 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9909 OUR_HANDLE(r->in.handle)));
9910 return WERR_BADFID;
9911 }
9912
9913 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9914 return WERR_BADFID;
9915 }
9916
9917 result = winreg_enum_printer_key_internal(p->mem_ctx,
9918 get_session_info_system(),
9919 p->msg_ctx,
9920 lp_const_servicename(snum),
9921 r->in.key_name,
9922 &num_keys,
9923 &array);
9924 if (!W_ERROR_IS_OK(result)) {
9925 goto done;
9926 }
9927
9928 if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
9929 result = WERR_NOMEM;
9930 goto done;
9931 }
9932
9933 *r->out._ndr_size = r->in.offered / 2;
9934 *r->out.needed = blob.length;
9935
9936 if (r->in.offered < *r->out.needed) {
9937 result = WERR_MORE_DATA;
9938 } else {
9939 result = WERR_OK;
9940 r->out.key_buffer->string_array = array;
9941 }
9942
9943 done:
9944 if (!W_ERROR_IS_OK(result)) {
9945 TALLOC_FREE(array);
9946 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
9947 *r->out.needed = 0;
9948 }
9949 }
9950
9951 return result;
9952 }
9953
9954 /****************************************************************
9955 _spoolss_DeletePrinterKey
9956 ****************************************************************/
9957
9958 WERROR _spoolss_DeletePrinterKey(struct pipes_struct *p,
9959 struct spoolss_DeletePrinterKey *r)
9960 {
9961 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9962 int snum=0;
9963 WERROR status;
9964 const char *printer;
9965 struct dcerpc_binding_handle *b;
9966 TALLOC_CTX *tmp_ctx;
9967
9968 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9969
9970 if (!Printer) {
9971 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9972 OUR_HANDLE(r->in.handle)));
9973 return WERR_BADFID;
9974 }
9975
9976 /* if keyname == NULL, return error */
9977 if ( !r->in.key_name )
9978 return WERR_INVALID_PARAM;
9979
9980 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9981 return WERR_BADFID;
9982 }
9983
9984 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9985 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9986 "printer properties change denied by handle\n"));
9987 return WERR_ACCESS_DENIED;
9988 }
9989
9990 printer = lp_const_servicename(snum);
9991
9992 tmp_ctx = talloc_new(p->mem_ctx);
9993 if (!tmp_ctx) {
9994 return WERR_NOMEM;
9995 }
9996
9997 status = winreg_printer_binding_handle(tmp_ctx,
9998 get_session_info_system(),
9999 p->msg_ctx,
10000 &b);
10001 if (!W_ERROR_IS_OK(status)) {
10002 goto done;
10003 }
10004
10005 /* delete the key and all subkeys */
10006 status = winreg_delete_printer_key(tmp_ctx, b,
10007 printer,
10008 r->in.key_name);
10009 if (W_ERROR_IS_OK(status)) {
10010 status = winreg_printer_update_changeid(tmp_ctx, b,
10011 printer);
10012 }
10013
10014 done:
10015 talloc_free(tmp_ctx);
10016 return status;
10017 }
10018
10019 /****************************************************************
10020 _spoolss_EnumPrinterDataEx
10021 ****************************************************************/
10022
10023 WERROR _spoolss_EnumPrinterDataEx(struct pipes_struct *p,
10024 struct spoolss_EnumPrinterDataEx *r)
10025 {
10026 uint32_t count = 0;
10027 struct spoolss_PrinterEnumValues *info = NULL;
10028 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
10029 int snum;
10030 WERROR result;
10031
10032 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
10033
10034 *r->out.count = 0;
10035 *r->out.needed = 0;
10036 *r->out.info = NULL;
10037
10038 if (!Printer) {
10039 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
10040 OUR_HANDLE(r->in.handle)));
10041 return WERR_BADFID;
10042 }
10043
10044 /*
10045 * first check for a keyname of NULL or "". Win2k seems to send
10046 * this a lot and we should send back WERR_INVALID_PARAM
10047 * no need to spend time looking up the printer in this case.
10048 * --jerry
10049 */
10050
10051 if (!strlen(r->in.key_name)) {
10052 result = WERR_INVALID_PARAM;
10053 goto done;
10054 }
10055
10056 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
10057 return WERR_BADFID;
10058 }
10059
10060 /* now look for a match on the key name */
10061 result = winreg_enum_printer_dataex_internal(p->mem_ctx,
10062 get_session_info_system(),
10063 p->msg_ctx,
10064 lp_const_servicename(snum),
10065 r->in.key_name,
10066 &count,
10067 &info);
10068 if (!W_ERROR_IS_OK(result)) {
10069 goto done;
10070 }
10071
10072 #if 0 /* FIXME - gd */
10073 /* housekeeping information in the reply */
10074
10075 /* Fix from Martin Zielinski <mz@seh.de> - ensure
10076 * the hand marshalled container size is a multiple
10077 * of 4 bytes for RPC alignment.
10078 */
10079
10080 if (needed % 4) {
10081 needed += 4-(needed % 4);
10082 }
10083 #endif
10084 *r->out.count = count;
10085 *r->out.info = info;
10086
10087 done:
10088 if (!W_ERROR_IS_OK(result)) {
10089 return result;
10090 }
10091
10092 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
10093 spoolss_EnumPrinterDataEx,
10094 *r->out.info,
10095 *r->out.count);
10096 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
10097 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
10098
10099 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
10100 }
10101
10102 /****************************************************************************
10103 ****************************************************************************/
10104
10105 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
10106 const char *servername,
10107 const char *environment,
10108 struct spoolss_PrintProcessorDirectoryInfo1 *r)
10109 {
10110 WERROR werr;
10111 char *path = NULL;
10112
10113 werr = compose_spoolss_server_path(mem_ctx,
10114 servername,
10115 environment,
10116 SPOOLSS_PRTPROCS_PATH,
10117 &path);
10118 if (!W_ERROR_IS_OK(werr)) {
10119 return werr;
10120 }
10121
10122 DEBUG(4,("print processor directory: [%s]\n", path));
10123
10124 r->directory_name = path;
10125
10126 return WERR_OK;
10127 }
10128
10129 /****************************************************************
10130 _spoolss_GetPrintProcessorDirectory
10131 ****************************************************************/
10132
10133 WERROR _spoolss_GetPrintProcessorDirectory(struct pipes_struct *p,
10134 struct spoolss_GetPrintProcessorDirectory *r)
10135 {
10136 WERROR result;
10137 char *prnproc_share = NULL;
10138 bool prnproc_share_exists = false;
10139 int snum;
10140
10141 /* that's an [in out] buffer */
10142
10143 if (!r->in.buffer && (r->in.offered != 0)) {
10144 return WERR_INVALID_PARAM;
10145 }
10146
10147 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
10148 r->in.level));
10149
10150 *r->out.needed = 0;
10151
10152 /* r->in.level is ignored */
10153
10154 /* We always should reply with a local print processor directory so that
10155 * users are not forced to have a [prnproc$] share on the Samba spoolss
10156 * server, if users decide to do so, lets announce it though - Guenther */
10157
10158 snum = find_service(talloc_tos(), "prnproc$", &prnproc_share);
10159 if (!prnproc_share) {
10160 return WERR_NOMEM;
10161 }
10162 if (snum != -1) {
10163 prnproc_share_exists = true;
10164 }
10165
10166 result = getprintprocessordirectory_level_1(p->mem_ctx,
10167 prnproc_share_exists ? r->in.server : NULL,
10168 r->in.environment,
10169 &r->out.info->info1);
10170 if (!W_ERROR_IS_OK(result)) {
10171 TALLOC_FREE(r->out.info);
10172 return result;
10173 }
10174
10175 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo,
10176 r->out.info, r->in.level);
10177 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
10178
10179 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
10180 }
10181
10182 /*******************************************************************
10183 ********************************************************************/
10184
10185 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
10186 const char *dllname)
10187 {
10188 enum ndr_err_code ndr_err;
10189 struct spoolss_MonitorUi ui;
10190
10191 ui.dll_name = dllname;
10192
10193 ndr_err = ndr_push_struct_blob(buf, mem_ctx, &ui,
10194 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
10195 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10196 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
10197 }
10198 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10199 }
10200
10201 /*******************************************************************
10202 Streams the monitor UI DLL name in UNICODE
10203 *******************************************************************/
10204
10205 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
10206 struct security_token *token, DATA_BLOB *in,
10207 DATA_BLOB *out, uint32_t *needed)
10208 {
10209 const char *dllname = "tcpmonui.dll";
10210
10211 *needed = (strlen(dllname)+1) * 2;
10212
10213 if (out->length < *needed) {
10214 return WERR_INSUFFICIENT_BUFFER;
10215 }
10216
10217 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
10218 return WERR_NOMEM;
10219 }
10220
10221 return WERR_OK;
10222 }
10223
10224 /*******************************************************************
10225 ********************************************************************/
10226
10227 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
10228 struct spoolss_PortData1 *port1,
10229 const DATA_BLOB *buf)
10230 {
10231 enum ndr_err_code ndr_err;
10232 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port1,
10233 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
10234 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10235 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
10236 }
10237 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10238 }
10239
10240 /*******************************************************************
10241 ********************************************************************/
10242
10243 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
10244 struct spoolss_PortData2 *port2,
10245 const DATA_BLOB *buf)
10246 {
10247 enum ndr_err_code ndr_err;
10248 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port2,
10249 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
10250 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
10251 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
10252 }
10253 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
10254 }
10255
10256 /*******************************************************************
10257 Create a new TCP/IP port
10258 *******************************************************************/
10259
10260 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
10261 struct security_token *token, DATA_BLOB *in,
10262 DATA_BLOB *out, uint32_t *needed)
10263 {
10264 struct spoolss_PortData1 port1;
10265 struct spoolss_PortData2 port2;
10266 char *device_uri = NULL;
10267 uint32_t version;
10268
10269 const char *portname;
10270 const char *hostaddress;
10271 const char *queue;
10272 uint32_t port_number;
10273 uint32_t protocol;
10274
10275 /* peek for spoolss_PortData version */
10276
10277 if (!in || (in->length < (128 + 4))) {
10278 return WERR_GENERAL_FAILURE;
10279 }
10280
10281 version = IVAL(in->data, 128);
10282
10283 switch (version) {
10284 case 1:
10285 ZERO_STRUCT(port1);
10286
10287 if (!pull_port_data_1(mem_ctx, &port1, in)) {
10288 return WERR_NOMEM;
10289 }
10290
10291 portname = port1.portname;
10292 hostaddress = port1.hostaddress;
10293 queue = port1.queue;
10294 protocol = port1.protocol;
10295 port_number = port1.port_number;
10296
10297 break;
10298 case 2:
10299 ZERO_STRUCT(port2);
10300
10301 if (!pull_port_data_2(mem_ctx, &port2, in)) {
10302 return WERR_NOMEM;
10303 }
10304
10305 portname = port2.portname;
10306 hostaddress = port2.hostaddress;
10307 queue = port2.queue;
10308 protocol = port2.protocol;
10309 port_number = port2.port_number;
10310
10311 break;
10312 default:
10313 DEBUG(1,("xcvtcp_addport: "
10314 "unknown version of port_data: %d\n", version));
10315 return WERR_UNKNOWN_PORT;
10316 }
10317
10318 /* create the device URI and call the add_port_hook() */
10319
10320 switch (protocol) {
10321 case PROTOCOL_RAWTCP_TYPE:
10322 device_uri = talloc_asprintf(mem_ctx,
10323 "socket://%s:%d/", hostaddress,
10324 port_number);
10325 break;
10326
10327 case PROTOCOL_LPR_TYPE:
10328 device_uri = talloc_asprintf(mem_ctx,
10329 "lpr://%s/%s", hostaddress, queue );
10330 break;
10331
10332 default:
10333 return WERR_UNKNOWN_PORT;
10334 }
10335
10336 if (!device_uri) {
10337 return WERR_NOMEM;
10338 }
10339
10340 return add_port_hook(mem_ctx, token, portname, device_uri);
10341 }
10342
10343 /*******************************************************************
10344 *******************************************************************/
10345
10346 struct xcv_api_table xcvtcp_cmds[] = {
10347 { "MonitorUI", xcvtcp_monitorui },
10348 { "AddPort", xcvtcp_addport},
10349 { NULL, NULL }
10350 };
10351
10352 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
10353 struct security_token *token, const char *command,
10354 DATA_BLOB *inbuf,
10355 DATA_BLOB *outbuf,
10356 uint32_t *needed )
10357 {
10358 int i;
10359
10360 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
10361
10362 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
10363 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
10364 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
10365 }
10366
10367 return WERR_BADFUNC;
10368 }
10369
10370 /*******************************************************************
10371 *******************************************************************/
10372 #if 0 /* don't support management using the "Local Port" monitor */
10373
10374 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
10375 struct security_token *token, DATA_BLOB *in,
10376 DATA_BLOB *out, uint32_t *needed)
10377 {
10378 const char *dllname = "localui.dll";
10379
10380 *needed = (strlen(dllname)+1) * 2;
10381
10382 if (out->length < *needed) {
10383 return WERR_INSUFFICIENT_BUFFER;
10384 }
10385
10386 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
10387 return WERR_NOMEM;
10388 }
10389
10390 return WERR_OK;
10391 }
10392
10393 /*******************************************************************
10394 *******************************************************************/
10395
10396 struct xcv_api_table xcvlocal_cmds[] = {
10397 { "MonitorUI", xcvlocal_monitorui },
10398 { NULL, NULL }
10399 };
10400 #else
10401 struct xcv_api_table xcvlocal_cmds[] = {
10402 { NULL, NULL }
10403 };
10404 #endif
10405
10406
10407
10408 /*******************************************************************
10409 *******************************************************************/
10410
10411 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
10412 struct security_token *token, const char *command,
10413 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
10414 uint32_t *needed)
10415 {
10416 int i;
10417
10418 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
10419
10420 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
10421 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
10422 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
10423 }
10424 return WERR_BADFUNC;
10425 }
10426
10427 /****************************************************************
10428 _spoolss_XcvData
10429 ****************************************************************/
10430
10431 WERROR _spoolss_XcvData(struct pipes_struct *p,
10432 struct spoolss_XcvData *r)
10433 {
10434 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
10435 DATA_BLOB out_data = data_blob_null;
10436 WERROR werror;
10437
10438 if (!Printer) {
10439 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
10440 OUR_HANDLE(r->in.handle)));
10441 return WERR_BADFID;
10442 }
10443
10444 /* Has to be a handle to the TCP/IP port monitor */
10445
10446 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
10447 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
10448 return WERR_BADFID;
10449 }
10450
10451 /* requires administrative access to the server */
10452
10453 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
10454 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
10455 return WERR_ACCESS_DENIED;
10456 }
10457
10458 /* Allocate the outgoing buffer */
10459
10460 if (r->in.out_data_size) {
10461 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
10462 if (out_data.data == NULL) {
10463 return WERR_NOMEM;
10464 }
10465 }
10466
10467 switch ( Printer->printer_type ) {
10468 case SPLHND_PORTMON_TCP:
10469 werror = process_xcvtcp_command(p->mem_ctx,
10470 p->session_info->security_token,
10471 r->in.function_name,
10472 &r->in.in_data, &out_data,
10473 r->out.needed);
10474 break;
10475 case SPLHND_PORTMON_LOCAL:
10476 werror = process_xcvlocal_command(p->mem_ctx,
10477 p->session_info->security_token,
10478 r->in.function_name,
10479 &r->in.in_data, &out_data,
10480 r->out.needed);
10481 break;
10482 default:
10483 werror = WERR_INVALID_PRINT_MONITOR;
10484 }
10485
10486 if (!W_ERROR_IS_OK(werror)) {
10487 return werror;
10488 }
10489
10490 *r->out.status_code = 0;
10491
10492 if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
10493 memcpy(r->out.out_data, out_data.data,
10494 MIN(r->in.out_data_size, out_data.length));
10495 }
10496
10497 return WERR_OK;
10498 }
10499
10500 /****************************************************************
10501 _spoolss_AddPrintProcessor
10502 ****************************************************************/
10503
10504 WERROR _spoolss_AddPrintProcessor(struct pipes_struct *p,
10505 struct spoolss_AddPrintProcessor *r)
10506 {
10507 /* for now, just indicate success and ignore the add. We'll
10508 automatically set the winprint processor for printer
10509 entries later. Used to debug the LexMark Optra S 1855 PCL
10510 driver --jerry */
10511
10512 return WERR_OK;
10513 }
10514
10515 /****************************************************************
10516 _spoolss_AddPort
10517 ****************************************************************/
10518
10519 WERROR _spoolss_AddPort(struct pipes_struct *p,
10520 struct spoolss_AddPort *r)
10521 {
10522 /* do what w2k3 does */
10523
10524 return WERR_NOT_SUPPORTED;
10525 }
10526
10527 /****************************************************************
10528 _spoolss_GetPrinterDriver
10529 ****************************************************************/
10530
10531 WERROR _spoolss_GetPrinterDriver(struct pipes_struct *p,
10532 struct spoolss_GetPrinterDriver *r)
10533 {
10534 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10535 return WERR_NOT_SUPPORTED;
10536 }
10537
10538 /****************************************************************
10539 _spoolss_ReadPrinter
10540 ****************************************************************/
10541
10542 WERROR _spoolss_ReadPrinter(struct pipes_struct *p,
10543 struct spoolss_ReadPrinter *r)
10544 {
10545 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10546 return WERR_NOT_SUPPORTED;
10547 }
10548
10549 /****************************************************************
10550 _spoolss_WaitForPrinterChange
10551 ****************************************************************/
10552
10553 WERROR _spoolss_WaitForPrinterChange(struct pipes_struct *p,
10554 struct spoolss_WaitForPrinterChange *r)
10555 {
10556 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10557 return WERR_NOT_SUPPORTED;
10558 }
10559
10560 /****************************************************************
10561 _spoolss_ConfigurePort
10562 ****************************************************************/
10563
10564 WERROR _spoolss_ConfigurePort(struct pipes_struct *p,
10565 struct spoolss_ConfigurePort *r)
10566 {
10567 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10568 return WERR_NOT_SUPPORTED;
10569 }
10570
10571 /****************************************************************
10572 _spoolss_DeletePort
10573 ****************************************************************/
10574
10575 WERROR _spoolss_DeletePort(struct pipes_struct *p,
10576 struct spoolss_DeletePort *r)
10577 {
10578 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10579 return WERR_NOT_SUPPORTED;
10580 }
10581
10582 /****************************************************************
10583 _spoolss_CreatePrinterIC
10584 ****************************************************************/
10585
10586 WERROR _spoolss_CreatePrinterIC(struct pipes_struct *p,
10587 struct spoolss_CreatePrinterIC *r)
10588 {
10589 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10590 return WERR_NOT_SUPPORTED;
10591 }
10592
10593 /****************************************************************
10594 _spoolss_PlayGDIScriptOnPrinterIC
10595 ****************************************************************/
10596
10597 WERROR _spoolss_PlayGDIScriptOnPrinterIC(struct pipes_struct *p,
10598 struct spoolss_PlayGDIScriptOnPrinterIC *r)
10599 {
10600 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10601 return WERR_NOT_SUPPORTED;
10602 }
10603
10604 /****************************************************************
10605 _spoolss_DeletePrinterIC
10606 ****************************************************************/
10607
10608 WERROR _spoolss_DeletePrinterIC(struct pipes_struct *p,
10609 struct spoolss_DeletePrinterIC *r)
10610 {
10611 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10612 return WERR_NOT_SUPPORTED;
10613 }
10614
10615 /****************************************************************
10616 _spoolss_AddPrinterConnection
10617 ****************************************************************/
10618
10619 WERROR _spoolss_AddPrinterConnection(struct pipes_struct *p,
10620 struct spoolss_AddPrinterConnection *r)
10621 {
10622 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10623 return WERR_NOT_SUPPORTED;
10624 }
10625
10626 /****************************************************************
10627 _spoolss_DeletePrinterConnection
10628 ****************************************************************/
10629
10630 WERROR _spoolss_DeletePrinterConnection(struct pipes_struct *p,
10631 struct spoolss_DeletePrinterConnection *r)
10632 {
10633 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10634 return WERR_NOT_SUPPORTED;
10635 }
10636
10637 /****************************************************************
10638 _spoolss_PrinterMessageBox
10639 ****************************************************************/
10640
10641 WERROR _spoolss_PrinterMessageBox(struct pipes_struct *p,
10642 struct spoolss_PrinterMessageBox *r)
10643 {
10644 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10645 return WERR_NOT_SUPPORTED;
10646 }
10647
10648 /****************************************************************
10649 _spoolss_AddMonitor
10650 ****************************************************************/
10651
10652 WERROR _spoolss_AddMonitor(struct pipes_struct *p,
10653 struct spoolss_AddMonitor *r)
10654 {
10655 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10656 return WERR_NOT_SUPPORTED;
10657 }
10658
10659 /****************************************************************
10660 _spoolss_DeleteMonitor
10661 ****************************************************************/
10662
10663 WERROR _spoolss_DeleteMonitor(struct pipes_struct *p,
10664 struct spoolss_DeleteMonitor *r)
10665 {
10666 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10667 return WERR_NOT_SUPPORTED;
10668 }
10669
10670 /****************************************************************
10671 _spoolss_DeletePrintProcessor
10672 ****************************************************************/
10673
10674 WERROR _spoolss_DeletePrintProcessor(struct pipes_struct *p,
10675 struct spoolss_DeletePrintProcessor *r)
10676 {
10677 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10678 return WERR_NOT_SUPPORTED;
10679 }
10680
10681 /****************************************************************
10682 _spoolss_AddPrintProvidor
10683 ****************************************************************/
10684
10685 WERROR _spoolss_AddPrintProvidor(struct pipes_struct *p,
10686 struct spoolss_AddPrintProvidor *r)
10687 {
10688 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10689 return WERR_NOT_SUPPORTED;
10690 }
10691
10692 /****************************************************************
10693 _spoolss_DeletePrintProvidor
10694 ****************************************************************/
10695
10696 WERROR _spoolss_DeletePrintProvidor(struct pipes_struct *p,
10697 struct spoolss_DeletePrintProvidor *r)
10698 {
10699 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10700 return WERR_NOT_SUPPORTED;
10701 }
10702
10703 /****************************************************************
10704 _spoolss_FindFirstPrinterChangeNotification
10705 ****************************************************************/
10706
10707 WERROR _spoolss_FindFirstPrinterChangeNotification(struct pipes_struct *p,
10708 struct spoolss_FindFirstPrinterChangeNotification *r)
10709 {
10710 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10711 return WERR_NOT_SUPPORTED;
10712 }
10713
10714 /****************************************************************
10715 _spoolss_FindNextPrinterChangeNotification
10716 ****************************************************************/
10717
10718 WERROR _spoolss_FindNextPrinterChangeNotification(struct pipes_struct *p,
10719 struct spoolss_FindNextPrinterChangeNotification *r)
10720 {
10721 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10722 return WERR_NOT_SUPPORTED;
10723 }
10724
10725 /****************************************************************
10726 _spoolss_RouterFindFirstPrinterChangeNotificationOld
10727 ****************************************************************/
10728
10729 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(struct pipes_struct *p,
10730 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10731 {
10732 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10733 return WERR_NOT_SUPPORTED;
10734 }
10735
10736 /****************************************************************
10737 _spoolss_ReplyOpenPrinter
10738 ****************************************************************/
10739
10740 WERROR _spoolss_ReplyOpenPrinter(struct pipes_struct *p,
10741 struct spoolss_ReplyOpenPrinter *r)
10742 {
10743 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10744 return WERR_NOT_SUPPORTED;
10745 }
10746
10747 /****************************************************************
10748 _spoolss_RouterReplyPrinter
10749 ****************************************************************/
10750
10751 WERROR _spoolss_RouterReplyPrinter(struct pipes_struct *p,
10752 struct spoolss_RouterReplyPrinter *r)
10753 {
10754 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10755 return WERR_NOT_SUPPORTED;
10756 }
10757
10758 /****************************************************************
10759 _spoolss_ReplyClosePrinter
10760 ****************************************************************/
10761
10762 WERROR _spoolss_ReplyClosePrinter(struct pipes_struct *p,
10763 struct spoolss_ReplyClosePrinter *r)
10764 {
10765 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10766 return WERR_NOT_SUPPORTED;
10767 }
10768
10769 /****************************************************************
10770 _spoolss_AddPortEx
10771 ****************************************************************/
10772
10773 WERROR _spoolss_AddPortEx(struct pipes_struct *p,
10774 struct spoolss_AddPortEx *r)
10775 {
10776 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10777 return WERR_NOT_SUPPORTED;
10778 }
10779
10780 /****************************************************************
10781 _spoolss_RouterFindFirstPrinterChangeNotification
10782 ****************************************************************/
10783
10784 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(struct pipes_struct *p,
10785 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10786 {
10787 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10788 return WERR_NOT_SUPPORTED;
10789 }
10790
10791 /****************************************************************
10792 _spoolss_SpoolerInit
10793 ****************************************************************/
10794
10795 WERROR _spoolss_SpoolerInit(struct pipes_struct *p,
10796 struct spoolss_SpoolerInit *r)
10797 {
10798 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10799 return WERR_NOT_SUPPORTED;
10800 }
10801
10802 /****************************************************************
10803 _spoolss_ResetPrinterEx
10804 ****************************************************************/
10805
10806 WERROR _spoolss_ResetPrinterEx(struct pipes_struct *p,
10807 struct spoolss_ResetPrinterEx *r)
10808 {
10809 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10810 return WERR_NOT_SUPPORTED;
10811 }
10812
10813 /****************************************************************
10814 _spoolss_RouterReplyPrinterEx
10815 ****************************************************************/
10816
10817 WERROR _spoolss_RouterReplyPrinterEx(struct pipes_struct *p,
10818 struct spoolss_RouterReplyPrinterEx *r)
10819 {
10820 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10821 return WERR_NOT_SUPPORTED;
10822 }
10823
10824 /****************************************************************
10825 _spoolss_44
10826 ****************************************************************/
10827
10828 WERROR _spoolss_44(struct pipes_struct *p,
10829 struct spoolss_44 *r)
10830 {
10831 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10832 return WERR_NOT_SUPPORTED;
10833 }
10834
10835 /****************************************************************
10836 _spoolss_SetPort
10837 ****************************************************************/
10838
10839 WERROR _spoolss_SetPort(struct pipes_struct *p,
10840 struct spoolss_SetPort *r)
10841 {
10842 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10843 return WERR_NOT_SUPPORTED;
10844 }
10845
10846 /****************************************************************
10847 _spoolss_4a
10848 ****************************************************************/
10849
10850 WERROR _spoolss_4a(struct pipes_struct *p,
10851 struct spoolss_4a *r)
10852 {
10853 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10854 return WERR_NOT_SUPPORTED;
10855 }
10856
10857 /****************************************************************
10858 _spoolss_4b
10859 ****************************************************************/
10860
10861 WERROR _spoolss_4b(struct pipes_struct *p,
10862 struct spoolss_4b *r)
10863 {
10864 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10865 return WERR_NOT_SUPPORTED;
10866 }
10867
10868 /****************************************************************
10869 _spoolss_4c
10870 ****************************************************************/
10871
10872 WERROR _spoolss_4c(struct pipes_struct *p,
10873 struct spoolss_4c *r)
10874 {
10875 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10876 return WERR_NOT_SUPPORTED;
10877 }
10878
10879 /****************************************************************
10880 _spoolss_53
10881 ****************************************************************/
10882
10883 WERROR _spoolss_53(struct pipes_struct *p,
10884 struct spoolss_53 *r)
10885 {
10886 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10887 return WERR_NOT_SUPPORTED;
10888 }
10889
10890 /****************************************************************
10891 _spoolss_AddPerMachineConnection
10892 ****************************************************************/
10893
10894 WERROR _spoolss_AddPerMachineConnection(struct pipes_struct *p,
10895 struct spoolss_AddPerMachineConnection *r)
10896 {
10897 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10898 return WERR_NOT_SUPPORTED;
10899 }
10900
10901 /****************************************************************
10902 _spoolss_DeletePerMachineConnection
10903 ****************************************************************/
10904
10905 WERROR _spoolss_DeletePerMachineConnection(struct pipes_struct *p,
10906 struct spoolss_DeletePerMachineConnection *r)
10907 {
10908 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10909 return WERR_NOT_SUPPORTED;
10910 }
10911
10912 /****************************************************************
10913 _spoolss_EnumPerMachineConnections
10914 ****************************************************************/
10915
10916 WERROR _spoolss_EnumPerMachineConnections(struct pipes_struct *p,
10917 struct spoolss_EnumPerMachineConnections *r)
10918 {
10919 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10920 return WERR_NOT_SUPPORTED;
10921 }
10922
10923 /****************************************************************
10924 _spoolss_5a
10925 ****************************************************************/
10926
10927 WERROR _spoolss_5a(struct pipes_struct *p,
10928 struct spoolss_5a *r)
10929 {
10930 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10931 return WERR_NOT_SUPPORTED;
10932 }
10933
10934 /****************************************************************
10935 _spoolss_5b
10936 ****************************************************************/
10937
10938 WERROR _spoolss_5b(struct pipes_struct *p,
10939 struct spoolss_5b *r)
10940 {
10941 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10942 return WERR_NOT_SUPPORTED;
10943 }
10944
10945 /****************************************************************
10946 _spoolss_5c
10947 ****************************************************************/
10948
10949 WERROR _spoolss_5c(struct pipes_struct *p,
10950 struct spoolss_5c *r)
10951 {
10952 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10953 return WERR_NOT_SUPPORTED;
10954 }
10955
10956 /****************************************************************
10957 _spoolss_5d
10958 ****************************************************************/
10959
10960 WERROR _spoolss_5d(struct pipes_struct *p,
10961 struct spoolss_5d *r)
10962 {
10963 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10964 return WERR_NOT_SUPPORTED;
10965 }
10966
10967 /****************************************************************
10968 _spoolss_5e
10969 ****************************************************************/
10970
10971 WERROR _spoolss_5e(struct pipes_struct *p,
10972 struct spoolss_5e *r)
10973 {
10974 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10975 return WERR_NOT_SUPPORTED;
10976 }
10977
10978 /****************************************************************
10979 _spoolss_5f
10980 ****************************************************************/
10981
10982 WERROR _spoolss_5f(struct pipes_struct *p,
10983 struct spoolss_5f *r)
10984 {
10985 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10986 return WERR_NOT_SUPPORTED;
10987 }
10988
10989 /****************************************************************
10990 _spoolss_60
10991 ****************************************************************/
10992
10993 WERROR _spoolss_60(struct pipes_struct *p,
10994 struct spoolss_60 *r)
10995 {
10996 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
10997 return WERR_NOT_SUPPORTED;
10998 }
10999
11000 /****************************************************************
11001 _spoolss_RpcSendRecvBidiData
11002 ****************************************************************/
11003
11004 WERROR _spoolss_RpcSendRecvBidiData(struct pipes_struct *p,
11005 struct spoolss_RpcSendRecvBidiData *r)
11006 {
11007 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11008 return WERR_NOT_SUPPORTED;
11009 }
11010
11011 /****************************************************************
11012 _spoolss_62
11013 ****************************************************************/
11014
11015 WERROR _spoolss_62(struct pipes_struct *p,
11016 struct spoolss_62 *r)
11017 {
11018 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11019 return WERR_NOT_SUPPORTED;
11020 }
11021
11022 /****************************************************************
11023 _spoolss_63
11024 ****************************************************************/
11025
11026 WERROR _spoolss_63(struct pipes_struct *p,
11027 struct spoolss_63 *r)
11028 {
11029 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11030 return WERR_NOT_SUPPORTED;
11031 }
11032
11033 /****************************************************************
11034 _spoolss_64
11035 ****************************************************************/
11036
11037 WERROR _spoolss_64(struct pipes_struct *p,
11038 struct spoolss_64 *r)
11039 {
11040 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11041 return WERR_NOT_SUPPORTED;
11042 }
11043
11044 /****************************************************************
11045 _spoolss_65
11046 ****************************************************************/
11047
11048 WERROR _spoolss_65(struct pipes_struct *p,
11049 struct spoolss_65 *r)
11050 {
11051 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11052 return WERR_NOT_SUPPORTED;
11053 }
11054
11055 /****************************************************************
11056 _spoolss_GetCorePrinterDrivers
11057 ****************************************************************/
11058
11059 WERROR _spoolss_GetCorePrinterDrivers(struct pipes_struct *p,
11060 struct spoolss_GetCorePrinterDrivers *r)
11061 {
11062 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11063 return WERR_NOT_SUPPORTED;
11064 }
11065
11066 /****************************************************************
11067 _spoolss_67
11068 ****************************************************************/
11069
11070 WERROR _spoolss_67(struct pipes_struct *p,
11071 struct spoolss_67 *r)
11072 {
11073 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11074 return WERR_NOT_SUPPORTED;
11075 }
11076
11077 /****************************************************************
11078 _spoolss_GetPrinterDriverPackagePath
11079 ****************************************************************/
11080
11081 WERROR _spoolss_GetPrinterDriverPackagePath(struct pipes_struct *p,
11082 struct spoolss_GetPrinterDriverPackagePath *r)
11083 {
11084 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11085 return WERR_NOT_SUPPORTED;
11086 }
11087
11088 /****************************************************************
11089 _spoolss_69
11090 ****************************************************************/
11091
11092 WERROR _spoolss_69(struct pipes_struct *p,
11093 struct spoolss_69 *r)
11094 {
11095 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11096 return WERR_NOT_SUPPORTED;
11097 }
11098
11099 /****************************************************************
11100 _spoolss_6a
11101 ****************************************************************/
11102
11103 WERROR _spoolss_6a(struct pipes_struct *p,
11104 struct spoolss_6a *r)
11105 {
11106 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11107 return WERR_NOT_SUPPORTED;
11108 }
11109
11110 /****************************************************************
11111 _spoolss_6b
11112 ****************************************************************/
11113
11114 WERROR _spoolss_6b(struct pipes_struct *p,
11115 struct spoolss_6b *r)
11116 {
11117 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11118 return WERR_NOT_SUPPORTED;
11119 }
11120
11121 /****************************************************************
11122 _spoolss_6c
11123 ****************************************************************/
11124
11125 WERROR _spoolss_6c(struct pipes_struct *p,
11126 struct spoolss_6c *r)
11127 {
11128 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11129 return WERR_NOT_SUPPORTED;
11130 }
11131
11132 /****************************************************************
11133 _spoolss_6d
11134 ****************************************************************/
11135
11136 WERROR _spoolss_6d(struct pipes_struct *p,
11137 struct spoolss_6d *r)
11138 {
11139 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11140 return WERR_NOT_SUPPORTED;
11141 }
11142
11143 /****************************************************************
11144 _spoolss_RpcGetJobNamedPropertyValue
11145 ****************************************************************/
11146
11147 WERROR _spoolss_RpcGetJobNamedPropertyValue(struct pipes_struct *p,
11148 struct spoolss_RpcGetJobNamedPropertyValue *r)
11149 {
11150 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11151 return WERR_NOT_SUPPORTED;
11152 }
11153
11154 /****************************************************************
11155 _spoolss_RpcSetJobNamedProperty
11156 ****************************************************************/
11157
11158 WERROR _spoolss_RpcSetJobNamedProperty(struct pipes_struct *p,
11159 struct spoolss_RpcSetJobNamedProperty *r)
11160 {
11161 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11162 return WERR_NOT_SUPPORTED;
11163 }
11164
11165 /****************************************************************
11166 _spoolss_RpcDeleteJobNamedProperty
11167 ****************************************************************/
11168
11169 WERROR _spoolss_RpcDeleteJobNamedProperty(struct pipes_struct *p,
11170 struct spoolss_RpcDeleteJobNamedProperty *r)
11171 {
11172 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11173 return WERR_NOT_SUPPORTED;
11174 }
11175
11176 /****************************************************************
11177 _spoolss_RpcEnumJobNamedProperties
11178 ****************************************************************/
11179
11180 WERROR _spoolss_RpcEnumJobNamedProperties(struct pipes_struct *p,
11181 struct spoolss_RpcEnumJobNamedProperties *r)
11182 {
11183 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
11184 return WERR_NOT_SUPPORTED;
11185 }
Samba GIT mirror