?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-spoolss: Fix _spoolss_GetPrinter().
[Samba.git] / source3 / rpc_server / srv_spoolss_nt.c
blob881f0e55553d7041be4bd0a3eae6697f290392f8
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 "nt_printing.h"
32 #include "srv_spoolss_util.h"
33 #include "../librpc/gen_ndr/srv_spoolss.h"
34 #include "../librpc/gen_ndr/cli_spoolss.h"
35 #include "rpc_client/init_spoolss.h"
36 #include "librpc/gen_ndr/messaging.h"
37 #include "librpc/gen_ndr/ndr_security.h"
38 #include "registry.h"
39 #include "registry/reg_objects.h"
40 #include "include/printing.h"
41 #include "secrets.h"
42 #include "../librpc/gen_ndr/netlogon.h"
43 #include "rpc_misc.h"
44
45 /* macros stolen from s4 spoolss server */
46 #define SPOOLSS_BUFFER_UNION(fn,info,level) \
47 ((info)?ndr_size_##fn(info, level, 0):0)
48
49 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,info,level,count) \
50 ((info)?ndr_size_##fn##_info(mem_ctx, level, count, info):0)
51
52 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,info,count) \
53 ((info)?ndr_size_##fn##_info(mem_ctx, count, info):0)
54
55 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
56
57 #undef DBGC_CLASS
58 #define DBGC_CLASS DBGC_RPC_SRV
59
60 #ifndef MAX_OPEN_PRINTER_EXS
61 #define MAX_OPEN_PRINTER_EXS 50
62 #endif
63
64 struct notify_back_channel;
65
66 /* structure to store the printer handles */
67 /* and a reference to what it's pointing to */
68 /* and the notify info asked about */
69 /* that's the central struct */
70 struct printer_handle {
71 struct printer_handle *prev, *next;
72 bool document_started;
73 bool page_started;
74 uint32 jobid; /* jobid in printing backend */
75 int printer_type;
76 fstring servername;
77 fstring sharename;
78 uint32 type;
79 uint32 access_granted;
80 struct {
81 uint32 flags;
82 uint32 options;
83 fstring localmachine;
84 uint32 printerlocal;
85 struct spoolss_NotifyOption *option;
86 struct policy_handle cli_hnd;
87 struct notify_back_channel *cli_chan;
88 uint32 change;
89 /* are we in a FindNextPrinterChangeNotify() call? */
90 bool fnpcn;
91 struct messaging_context *msg_ctx;
92 } notify;
93 struct {
94 fstring machine;
95 fstring user;
96 } client;
97
98 /* devmode sent in the OpenPrinter() call */
99 struct spoolss_DeviceMode *devmode;
100
101 /* TODO cache the printer info2 structure */
102 struct spoolss_PrinterInfo2 *info2;
103
104 };
105
106 static struct printer_handle *printers_list;
107
108 struct printer_session_counter {
109 struct printer_session_counter *next;
110 struct printer_session_counter *prev;
111
112 int snum;
113 uint32_t counter;
114 };
115
116 static struct printer_session_counter *counter_list;
117
118 struct notify_back_channel {
119 struct notify_back_channel *prev, *next;
120
121 /* associated client */
122 struct sockaddr_storage client_address;
123
124 /* print notify back-channel pipe handle*/
125 struct rpc_pipe_client *cli_pipe;
126 uint32_t active_connections;
127 };
128
129 static struct notify_back_channel *back_channels;
130
131 /* Map generic permissions to printer object specific permissions */
132
133 const struct standard_mapping printer_std_mapping = {
134 PRINTER_READ,
135 PRINTER_WRITE,
136 PRINTER_EXECUTE,
137 PRINTER_ALL_ACCESS
138 };
139
140 /* Map generic permissions to print server object specific permissions */
141
142 const struct standard_mapping printserver_std_mapping = {
143 SERVER_READ,
144 SERVER_WRITE,
145 SERVER_EXECUTE,
146 SERVER_ALL_ACCESS
147 };
148
149 /* API table for Xcv Monitor functions */
150
151 struct xcv_api_table {
152 const char *name;
153 WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
154 };
155
156 static void prune_printername_cache(void);
157
158 /********************************************************************
159 * Canonicalize servername.
160 ********************************************************************/
161
162 static const char *canon_servername(const char *servername)
163 {
164 const char *pservername = servername;
165 while (*pservername == '\\') {
166 pservername++;
167 }
168 return pservername;
169 }
170
171 /* translate between internal status numbers and NT status numbers */
172 static int nt_printj_status(int v)
173 {
174 switch (v) {
175 case LPQ_QUEUED:
176 return 0;
177 case LPQ_PAUSED:
178 return JOB_STATUS_PAUSED;
179 case LPQ_SPOOLING:
180 return JOB_STATUS_SPOOLING;
181 case LPQ_PRINTING:
182 return JOB_STATUS_PRINTING;
183 case LPQ_ERROR:
184 return JOB_STATUS_ERROR;
185 case LPQ_DELETING:
186 return JOB_STATUS_DELETING;
187 case LPQ_OFFLINE:
188 return JOB_STATUS_OFFLINE;
189 case LPQ_PAPEROUT:
190 return JOB_STATUS_PAPEROUT;
191 case LPQ_PRINTED:
192 return JOB_STATUS_PRINTED;
193 case LPQ_DELETED:
194 return JOB_STATUS_DELETED;
195 case LPQ_BLOCKED:
196 return JOB_STATUS_BLOCKED_DEVQ;
197 case LPQ_USER_INTERVENTION:
198 return JOB_STATUS_USER_INTERVENTION;
199 }
200 return 0;
201 }
202
203 static int nt_printq_status(int v)
204 {
205 switch (v) {
206 case LPQ_PAUSED:
207 return PRINTER_STATUS_PAUSED;
208 case LPQ_QUEUED:
209 case LPQ_SPOOLING:
210 case LPQ_PRINTING:
211 return 0;
212 }
213 return 0;
214 }
215
216 /***************************************************************************
217 Disconnect from the client
218 ****************************************************************************/
219
220 static void srv_spoolss_replycloseprinter(int snum,
221 struct printer_handle *prn_hnd)
222 {
223 WERROR result;
224 NTSTATUS status;
225
226 /*
227 * Tell the specific printing tdb we no longer want messages for this printer
228 * by deregistering our PID.
229 */
230
231 if (!print_notify_deregister_pid(snum)) {
232 DEBUG(0, ("Failed to register our pid for printer %s\n",
233 lp_const_servicename(snum)));
234 }
235
236 /* weird if the test succeeds !!! */
237 if (prn_hnd->notify.cli_chan == NULL ||
238 prn_hnd->notify.cli_chan->active_connections == 0) {
239 DEBUG(0, ("Trying to close unexisting backchannel!\n"));
240 DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
241 TALLOC_FREE(prn_hnd->notify.cli_chan);
242 return;
243 }
244
245 status = rpccli_spoolss_ReplyClosePrinter(
246 prn_hnd->notify.cli_chan->cli_pipe,
247 talloc_tos(),
248 &prn_hnd->notify.cli_hnd,
249 &result);
250 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
251 DEBUG(0, ("reply_close_printer failed [%s].\n",
252 win_errstr(result)));
253 }
254
255 /* if it's the last connection, deconnect the IPC$ share */
256 if (prn_hnd->notify.cli_chan->active_connections == 1) {
257
258 cli_shutdown(rpc_pipe_np_smb_conn(prn_hnd->notify.cli_chan->cli_pipe));
259 DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
260 TALLOC_FREE(prn_hnd->notify.cli_chan);
261
262 if (prn_hnd->notify.msg_ctx != NULL) {
263 messaging_deregister(prn_hnd->notify.msg_ctx,
264 MSG_PRINTER_NOTIFY2, NULL);
265
266 /*
267 * Tell the serverid.tdb we're no longer
268 * interested in printer notify messages.
269 */
270
271 serverid_register_msg_flags(
272 messaging_server_id(prn_hnd->notify.msg_ctx),
273 false, FLAG_MSG_PRINT_NOTIFY);
274 }
275 }
276
277 if (prn_hnd->notify.cli_chan) {
278 prn_hnd->notify.cli_chan->active_connections--;
279 }
280 }
281
282 /****************************************************************************
283 Functions to free a printer entry datastruct.
284 ****************************************************************************/
285
286 static int printer_entry_destructor(struct printer_handle *Printer)
287 {
288 if (Printer->notify.cli_chan != NULL &&
289 Printer->notify.cli_chan->active_connections > 0) {
290 int snum = -1;
291
292 switch(Printer->printer_type) {
293 case SPLHND_SERVER:
294 srv_spoolss_replycloseprinter(snum, Printer);
295 break;
296
297 case SPLHND_PRINTER:
298 snum = print_queue_snum(Printer->sharename);
299 if (snum != -1) {
300 srv_spoolss_replycloseprinter(snum, Printer);
301 }
302 break;
303 default:
304 break;
305 }
306 }
307
308 Printer->notify.flags=0;
309 Printer->notify.options=0;
310 Printer->notify.localmachine[0]='\0';
311 Printer->notify.printerlocal=0;
312 TALLOC_FREE(Printer->notify.option);
313 TALLOC_FREE(Printer->devmode);
314
315 /* Remove from the internal list. */
316 DLIST_REMOVE(printers_list, Printer);
317 return 0;
318 }
319
320 /****************************************************************************
321 find printer index by handle
322 ****************************************************************************/
323
324 static struct printer_handle *find_printer_index_by_hnd(struct pipes_struct *p,
325 struct policy_handle *hnd)
326 {
327 struct printer_handle *find_printer = NULL;
328
329 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
330 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
331 return NULL;
332 }
333
334 return find_printer;
335 }
336
337 /****************************************************************************
338 Close printer index by handle.
339 ****************************************************************************/
340
341 static bool close_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
342 {
343 struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
344
345 if (!Printer) {
346 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
347 OUR_HANDLE(hnd)));
348 return false;
349 }
350
351 close_policy_hnd(p, hnd);
352
353 return true;
354 }
355
356 /****************************************************************************
357 Delete a printer given a handle.
358 ****************************************************************************/
359
360 static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
361 const char *sharename,
362 struct messaging_context *msg_ctx)
363 {
364 char *cmd = lp_deleteprinter_cmd();
365 char *command = NULL;
366 int ret;
367 SE_PRIV se_printop = SE_PRINT_OPERATOR;
368 bool is_print_op = false;
369
370 /* can't fail if we don't try */
371
372 if ( !*cmd )
373 return WERR_OK;
374
375 command = talloc_asprintf(ctx,
376 "%s \"%s\"",
377 cmd, sharename);
378 if (!command) {
379 return WERR_NOMEM;
380 }
381 if ( token )
382 is_print_op = user_has_privileges( token, &se_printop );
383
384 DEBUG(10,("Running [%s]\n", command));
385
386 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
387
388 if ( is_print_op )
389 become_root();
390
391 if ( (ret = smbrun(command, NULL)) == 0 ) {
392 /* Tell everyone we updated smb.conf. */
393 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
394 }
395
396 if ( is_print_op )
397 unbecome_root();
398
399 /********** END SePrintOperatorPrivlege BLOCK **********/
400
401 DEBUGADD(10,("returned [%d]\n", ret));
402
403 TALLOC_FREE(command);
404
405 if (ret != 0)
406 return WERR_BADFID; /* What to return here? */
407
408 /* go ahead and re-read the services immediately */
409 become_root();
410 reload_services(msg_ctx, -1, false);
411 unbecome_root();
412
413 if ( lp_servicenumber( sharename ) > 0 )
414 return WERR_ACCESS_DENIED;
415
416 return WERR_OK;
417 }
418
419 /****************************************************************************
420 Delete a printer given a handle.
421 ****************************************************************************/
422
423 static WERROR delete_printer_handle(struct pipes_struct *p, struct policy_handle *hnd)
424 {
425 struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
426 WERROR result;
427
428 if (!Printer) {
429 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
430 OUR_HANDLE(hnd)));
431 return WERR_BADFID;
432 }
433
434 /*
435 * It turns out that Windows allows delete printer on a handle
436 * opened by an admin user, then used on a pipe handle created
437 * by an anonymous user..... but they're working on security.... riiight !
438 * JRA.
439 */
440
441 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
442 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
443 return WERR_ACCESS_DENIED;
444 }
445
446 /* this does not need a become root since the access check has been
447 done on the handle already */
448
449 result = winreg_delete_printer_key(p->mem_ctx,
450 get_server_info_system(),
451 p->msg_ctx,
452 Printer->sharename,
453 "");
454 if (!W_ERROR_IS_OK(result)) {
455 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
456 return WERR_BADFID;
457 }
458
459 result = delete_printer_hook(p->mem_ctx, p->server_info->ptok,
460 Printer->sharename, p->msg_ctx);
461 if (!W_ERROR_IS_OK(result)) {
462 return result;
463 }
464 prune_printername_cache();
465 return WERR_OK;
466 }
467
468 /****************************************************************************
469 Return the snum of a printer corresponding to an handle.
470 ****************************************************************************/
471
472 static bool get_printer_snum(struct pipes_struct *p, struct policy_handle *hnd,
473 int *number, struct share_params **params)
474 {
475 struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
476
477 if (!Printer) {
478 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
479 OUR_HANDLE(hnd)));
480 return false;
481 }
482
483 switch (Printer->printer_type) {
484 case SPLHND_PRINTER:
485 DEBUG(4,("short name:%s\n", Printer->sharename));
486 *number = print_queue_snum(Printer->sharename);
487 return (*number != -1);
488 case SPLHND_SERVER:
489 return false;
490 default:
491 return false;
492 }
493 }
494
495 /****************************************************************************
496 Set printer handle type.
497 Check if it's \\server or \\server\printer
498 ****************************************************************************/
499
500 static bool set_printer_hnd_printertype(struct printer_handle *Printer, const char *handlename)
501 {
502 DEBUG(3,("Setting printer type=%s\n", handlename));
503
504 /* it's a print server */
505 if (handlename && *handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
506 DEBUGADD(4,("Printer is a print server\n"));
507 Printer->printer_type = SPLHND_SERVER;
508 }
509 /* it's a printer (set_printer_hnd_name() will handle port monitors */
510 else {
511 DEBUGADD(4,("Printer is a printer\n"));
512 Printer->printer_type = SPLHND_PRINTER;
513 }
514
515 return true;
516 }
517
518 static void prune_printername_cache_fn(const char *key, const char *value,
519 time_t timeout, void *private_data)
520 {
521 gencache_del(key);
522 }
523
524 static void prune_printername_cache(void)
525 {
526 gencache_iterate(prune_printername_cache_fn, NULL, "PRINTERNAME/*");
527 }
528
529 /****************************************************************************
530 Set printer handle name.. Accept names like \\server, \\server\printer,
531 \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port" See
532 the MSDN docs regarding OpenPrinter() for details on the XcvData() and
533 XcvDataPort() interface.
534 ****************************************************************************/
535
536 static bool set_printer_hnd_name(TALLOC_CTX *mem_ctx,
537 const struct auth_serversupplied_info *server_info,
538 struct messaging_context *msg_ctx,
539 struct printer_handle *Printer,
540 const char *handlename)
541 {
542 int snum;
543 int n_services=lp_numservices();
544 char *aprinter;
545 const char *printername;
546 const char *servername = NULL;
547 fstring sname;
548 bool found = false;
549 struct spoolss_PrinterInfo2 *info2 = NULL;
550 WERROR result;
551
552 /*
553 * Hopefully nobody names his printers like this. Maybe \ or ,
554 * are illegal in printer names even?
555 */
556 const char printer_not_found[] = "Printer \\, !@#$%^&*( not found";
557 char *cache_key;
558 char *tmp;
559
560 DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
561 (unsigned long)strlen(handlename)));
562
563 aprinter = CONST_DISCARD(char *, handlename);
564 if ( *handlename == '\\' ) {
565 servername = canon_servername(handlename);
566 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
567 *aprinter = '\0';
568 aprinter++;
569 }
570 if (!is_myname_or_ipaddr(servername)) {
571 return false;
572 }
573
574 fstrcpy(Printer->servername, servername);
575 }
576
577 if (Printer->printer_type == SPLHND_SERVER) {
578 return true;
579 }
580
581 if (Printer->printer_type != SPLHND_PRINTER) {
582 return false;
583 }
584
585 DEBUGADD(5, ("searching for [%s]\n", aprinter));
586
587 /* check for the Port Monitor Interface */
588 if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
589 Printer->printer_type = SPLHND_PORTMON_TCP;
590 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
591 found = true;
592 }
593 else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
594 Printer->printer_type = SPLHND_PORTMON_LOCAL;
595 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
596 found = true;
597 }
598
599 /*
600 * With hundreds of printers, the "for" loop iterating all
601 * shares can be quite expensive, as it is done on every
602 * OpenPrinter. The loop maps "aprinter" to "sname", the
603 * result of which we cache in gencache.
604 */
605
606 cache_key = talloc_asprintf(talloc_tos(), "PRINTERNAME/%s",
607 aprinter);
608 if ((cache_key != NULL) && gencache_get(cache_key, &tmp, NULL)) {
609
610 found = (strcmp(tmp, printer_not_found) != 0);
611 if (!found) {
612 DEBUG(4, ("Printer %s not found\n", aprinter));
613 SAFE_FREE(tmp);
614 return false;
615 }
616 fstrcpy(sname, tmp);
617 SAFE_FREE(tmp);
618 }
619
620 /* Search all sharenames first as this is easier than pulling
621 the printer_info_2 off of disk. Don't use find_service() since
622 that calls out to map_username() */
623
624 /* do another loop to look for printernames */
625 for (snum = 0; !found && snum < n_services; snum++) {
626 const char *printer = lp_const_servicename(snum);
627
628 /* no point going on if this is not a printer */
629 if (!(lp_snum_ok(snum) && lp_print_ok(snum))) {
630 continue;
631 }
632
633 /* ignore [printers] share */
634 if (strequal(printer, "printers")) {
635 continue;
636 }
637
638 fstrcpy(sname, printer);
639 if (strequal(aprinter, printer)) {
640 found = true;
641 break;
642 }
643
644 /* no point looking up the printer object if
645 we aren't allowing printername != sharename */
646 if (lp_force_printername(snum)) {
647 continue;
648 }
649
650 result = winreg_get_printer(mem_ctx,
651 server_info,
652 msg_ctx,
653 servername,
654 sname,
655 &info2);
656 if ( !W_ERROR_IS_OK(result) ) {
657 DEBUG(2,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
658 sname, win_errstr(result)));
659 continue;
660 }
661
662 printername = strrchr(info2->printername, '\\');
663 if (printername == NULL) {
664 printername = info2->printername;
665 } else {
666 printername++;
667 }
668
669 if (strequal(printername, aprinter)) {
670 found = true;
671 break;
672 }
673
674 DEBUGADD(10, ("printername: %s\n", printername));
675
676 TALLOC_FREE(info2);
677 }
678
679 if ( !found ) {
680 if (cache_key != NULL) {
681 gencache_set(cache_key, printer_not_found,
682 time(NULL)+300);
683 TALLOC_FREE(cache_key);
684 }
685 DEBUGADD(4,("Printer not found\n"));
686 return false;
687 }
688
689 if (cache_key != NULL) {
690 gencache_set(cache_key, sname, time(NULL)+300);
691 TALLOC_FREE(cache_key);
692 }
693
694 DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
695
696 fstrcpy(Printer->sharename, sname);
697
698 return true;
699 }
700
701 /****************************************************************************
702 Find first available printer slot. creates a printer handle for you.
703 ****************************************************************************/
704
705 static bool open_printer_hnd(struct pipes_struct *p, struct policy_handle *hnd,
706 const char *name, uint32_t access_granted)
707 {
708 struct printer_handle *new_printer;
709
710 DEBUG(10,("open_printer_hnd: name [%s]\n", name));
711
712 new_printer = talloc_zero(p->mem_ctx, struct printer_handle);
713 if (new_printer == NULL) {
714 return false;
715 }
716 talloc_set_destructor(new_printer, printer_entry_destructor);
717
718 /* This also steals the printer_handle on the policy_handle */
719 if (!create_policy_hnd(p, hnd, new_printer)) {
720 TALLOC_FREE(new_printer);
721 return false;
722 }
723
724 /* Add to the internal list. */
725 DLIST_ADD(printers_list, new_printer);
726
727 new_printer->notify.option=NULL;
728
729 if (!set_printer_hnd_printertype(new_printer, name)) {
730 close_printer_handle(p, hnd);
731 return false;
732 }
733
734 if (!set_printer_hnd_name(p->mem_ctx,
735 get_server_info_system(),
736 p->msg_ctx,
737 new_printer, name)) {
738 close_printer_handle(p, hnd);
739 return false;
740 }
741
742 new_printer->access_granted = access_granted;
743
744 DEBUG(5, ("%d printer handles active\n",
745 (int)num_pipe_handles(p)));
746
747 return true;
748 }
749
750 /***************************************************************************
751 check to see if the client motify handle is monitoring the notification
752 given by (notify_type, notify_field).
753 **************************************************************************/
754
755 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
756 uint16_t notify_field)
757 {
758 return true;
759 }
760
761 static bool is_monitoring_event(struct printer_handle *p, uint16_t notify_type,
762 uint16_t notify_field)
763 {
764 struct spoolss_NotifyOption *option = p->notify.option;
765 uint32_t i, j;
766
767 /*
768 * Flags should always be zero when the change notify
769 * is registered by the client's spooler. A user Win32 app
770 * might use the flags though instead of the NOTIFY_OPTION_INFO
771 * --jerry
772 */
773
774 if (!option) {
775 return false;
776 }
777
778 if (p->notify.flags)
779 return is_monitoring_event_flags(
780 p->notify.flags, notify_type, notify_field);
781
782 for (i = 0; i < option->count; i++) {
783
784 /* Check match for notify_type */
785
786 if (option->types[i].type != notify_type)
787 continue;
788
789 /* Check match for field */
790
791 for (j = 0; j < option->types[i].count; j++) {
792 if (option->types[i].fields[j].field == notify_field) {
793 return true;
794 }
795 }
796 }
797
798 DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
799 p->servername, p->sharename, notify_type, notify_field));
800
801 return false;
802 }
803
804 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
805 _data->data.integer[0] = _integer; \
806 _data->data.integer[1] = 0;
807
808
809 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
810 _data->data.string.string = talloc_strdup(mem_ctx, _p); \
811 if (!_data->data.string.string) {\
812 _data->data.string.size = 0; \
813 } \
814 _data->data.string.size = strlen_m_term(_p) * 2;
815
816 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
817 _data->data.devmode.devmode = _devmode;
818
819 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _sd) \
820 _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
821 if (!_data->data.sd.sd) { \
822 _data->data.sd.sd_size = 0; \
823 } \
824 _data->data.sd.sd_size = \
825 ndr_size_security_descriptor(_data->data.sd.sd, 0);
826
827 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
828 struct tm *t,
829 const char **pp,
830 uint32_t *plen)
831 {
832 struct spoolss_Time st;
833 uint32_t len = 16;
834 char *p;
835
836 if (!init_systemtime(&st, t)) {
837 return;
838 }
839
840 p = talloc_array(mem_ctx, char, len);
841 if (!p) {
842 return;
843 }
844
845 /*
846 * Systemtime must be linearized as a set of UINT16's.
847 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
848 */
849
850 SSVAL(p, 0, st.year);
851 SSVAL(p, 2, st.month);
852 SSVAL(p, 4, st.day_of_week);
853 SSVAL(p, 6, st.day);
854 SSVAL(p, 8, st.hour);
855 SSVAL(p, 10, st.minute);
856 SSVAL(p, 12, st.second);
857 SSVAL(p, 14, st.millisecond);
858
859 *pp = p;
860 *plen = len;
861 }
862
863 /* Convert a notification message to a struct spoolss_Notify */
864
865 static void notify_one_value(struct spoolss_notify_msg *msg,
866 struct spoolss_Notify *data,
867 TALLOC_CTX *mem_ctx)
868 {
869 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
870 }
871
872 static void notify_string(struct spoolss_notify_msg *msg,
873 struct spoolss_Notify *data,
874 TALLOC_CTX *mem_ctx)
875 {
876 /* The length of the message includes the trailing \0 */
877
878 data->data.string.size = msg->len * 2;
879 data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
880 if (!data->data.string.string) {
881 data->data.string.size = 0;
882 return;
883 }
884 }
885
886 static void notify_system_time(struct spoolss_notify_msg *msg,
887 struct spoolss_Notify *data,
888 TALLOC_CTX *mem_ctx)
889 {
890 data->data.string.string = NULL;
891 data->data.string.size = 0;
892
893 if (msg->len != sizeof(time_t)) {
894 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
895 msg->len));
896 return;
897 }
898
899 init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
900 &data->data.string.string,
901 &data->data.string.size);
902 }
903
904 struct notify2_message_table {
905 const char *name;
906 void (*fn)(struct spoolss_notify_msg *msg,
907 struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
908 };
909
910 static struct notify2_message_table printer_notify_table[] = {
911 /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
912 /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
913 /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
914 /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
915 /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
916 /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
917 /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
918 /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
919 /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
920 /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
921 /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
922 /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
923 /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
924 /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
925 /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
926 /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
927 /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
928 /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
929 /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
930 };
931
932 static struct notify2_message_table job_notify_table[] = {
933 /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
934 /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
935 /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
936 /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
937 /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
938 /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
939 /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
940 /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
941 /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
942 /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
943 /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
944 /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
945 /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
946 /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
947 /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
948 /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
949 /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
950 /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
951 /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
952 /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
953 /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
954 /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
955 /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
956 /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
957 };
958
959
960 /***********************************************************************
961 Allocate talloc context for container object
962 **********************************************************************/
963
964 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
965 {
966 if ( !ctr )
967 return;
968
969 ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
970
971 return;
972 }
973
974 /***********************************************************************
975 release all allocated memory and zero out structure
976 **********************************************************************/
977
978 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
979 {
980 if ( !ctr )
981 return;
982
983 if ( ctr->ctx )
984 talloc_destroy(ctr->ctx);
985
986 ZERO_STRUCTP(ctr);
987
988 return;
989 }
990
991 /***********************************************************************
992 **********************************************************************/
993
994 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
995 {
996 if ( !ctr )
997 return NULL;
998
999 return ctr->ctx;
1000 }
1001
1002 /***********************************************************************
1003 **********************************************************************/
1004
1005 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
1006 {
1007 if ( !ctr || !ctr->msg_groups )
1008 return NULL;
1009
1010 if ( idx >= ctr->num_groups )
1011 return NULL;
1012
1013 return &ctr->msg_groups[idx];
1014
1015 }
1016
1017 /***********************************************************************
1018 How many groups of change messages do we have ?
1019 **********************************************************************/
1020
1021 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
1022 {
1023 if ( !ctr )
1024 return 0;
1025
1026 return ctr->num_groups;
1027 }
1028
1029 /***********************************************************************
1030 Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
1031 **********************************************************************/
1032
1033 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
1034 {
1035 SPOOLSS_NOTIFY_MSG_GROUP *groups = NULL;
1036 SPOOLSS_NOTIFY_MSG_GROUP *msg_grp = NULL;
1037 SPOOLSS_NOTIFY_MSG *msg_list = NULL;
1038 int i, new_slot;
1039
1040 if ( !ctr || !msg )
1041 return 0;
1042
1043 /* loop over all groups looking for a matching printer name */
1044
1045 for ( i=0; i<ctr->num_groups; i++ ) {
1046 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
1047 break;
1048 }
1049
1050 /* add a new group? */
1051
1052 if ( i == ctr->num_groups ) {
1053 ctr->num_groups++;
1054
1055 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
1056 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
1057 return 0;
1058 }
1059 ctr->msg_groups = groups;
1060
1061 /* clear the new entry and set the printer name */
1062
1063 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
1064 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
1065 }
1066
1067 /* add the change messages; 'i' is the correct index now regardless */
1068
1069 msg_grp = &ctr->msg_groups[i];
1070
1071 msg_grp->num_msgs++;
1072
1073 if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
1074 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
1075 return 0;
1076 }
1077 msg_grp->msgs = msg_list;
1078
1079 new_slot = msg_grp->num_msgs-1;
1080 memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
1081
1082 /* need to allocate own copy of data */
1083
1084 if ( msg->len != 0 )
1085 msg_grp->msgs[new_slot].notify.data = (char *)
1086 TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
1087
1088 return ctr->num_groups;
1089 }
1090
1091 static void construct_info_data(struct spoolss_Notify *info_data,
1092 enum spoolss_NotifyType type,
1093 uint16_t field, int id);
1094
1095 /***********************************************************************
1096 Send a change notication message on all handles which have a call
1097 back registered
1098 **********************************************************************/
1099
1100 static int build_notify2_messages(TALLOC_CTX *mem_ctx,
1101 struct printer_handle *prn_hnd,
1102 SPOOLSS_NOTIFY_MSG *messages,
1103 uint32_t num_msgs,
1104 struct spoolss_Notify **_notifies,
1105 int *_count)
1106 {
1107 struct spoolss_Notify *notifies;
1108 SPOOLSS_NOTIFY_MSG *msg;
1109 int count = 0;
1110 uint32_t id;
1111 int i;
1112
1113 notifies = talloc_zero_array(mem_ctx,
1114 struct spoolss_Notify, num_msgs);
1115 if (!notifies) {
1116 return ENOMEM;
1117 }
1118
1119 for (i = 0; i < num_msgs; i++) {
1120
1121 msg = &messages[i];
1122
1123 /* Are we monitoring this event? */
1124
1125 if (!is_monitoring_event(prn_hnd, msg->type, msg->field)) {
1126 continue;
1127 }
1128
1129 DEBUG(10, ("Sending message type [0x%x] field [0x%2x] "
1130 "for printer [%s]\n",
1131 msg->type, msg->field, prn_hnd->sharename));
1132
1133 /*
1134 * if the is a printer notification handle and not a job
1135 * notification type, then set the id to 0.
1136 * Otherwise just use what was specified in the message.
1137 *
1138 * When registering change notification on a print server
1139 * handle we always need to send back the id (snum) matching
1140 * the printer for which the change took place.
1141 * For change notify registered on a printer handle,
1142 * this does not matter and the id should be 0.
1143 *
1144 * --jerry
1145 */
1146
1147 if ((msg->type == PRINTER_NOTIFY_TYPE) &&
1148 (prn_hnd->printer_type == SPLHND_PRINTER)) {
1149 id = 0;
1150 } else {
1151 id = msg->id;
1152 }
1153
1154 /* Convert unix jobid to smb jobid */
1155
1156 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1157 id = sysjob_to_jobid(msg->id);
1158
1159 if (id == -1) {
1160 DEBUG(3, ("no such unix jobid %d\n",
1161 msg->id));
1162 continue;
1163 }
1164 }
1165
1166 construct_info_data(&notifies[count],
1167 msg->type, msg->field, id);
1168
1169 switch(msg->type) {
1170 case PRINTER_NOTIFY_TYPE:
1171 if (printer_notify_table[msg->field].fn) {
1172 printer_notify_table[msg->field].fn(msg,
1173 &notifies[count], mem_ctx);
1174 }
1175 break;
1176
1177 case JOB_NOTIFY_TYPE:
1178 if (job_notify_table[msg->field].fn) {
1179 job_notify_table[msg->field].fn(msg,
1180 &notifies[count], mem_ctx);
1181 }
1182 break;
1183
1184 default:
1185 DEBUG(5, ("Unknown notification type %d\n",
1186 msg->type));
1187 continue;
1188 }
1189
1190 count++;
1191 }
1192
1193 *_notifies = notifies;
1194 *_count = count;
1195
1196 return 0;
1197 }
1198
1199 static int send_notify2_printer(TALLOC_CTX *mem_ctx,
1200 struct printer_handle *prn_hnd,
1201 SPOOLSS_NOTIFY_MSG_GROUP *msg_group)
1202 {
1203 struct spoolss_Notify *notifies;
1204 int count = 0;
1205 union spoolss_ReplyPrinterInfo info;
1206 struct spoolss_NotifyInfo info0;
1207 uint32_t reply_result;
1208 NTSTATUS status;
1209 WERROR werr;
1210 int ret;
1211
1212 /* Is there notification on this handle? */
1213 if (prn_hnd->notify.cli_chan == NULL ||
1214 prn_hnd->notify.cli_chan->active_connections == 0) {
1215 return 0;
1216 }
1217
1218 DEBUG(10, ("Client connected! [\\\\%s\\%s]\n",
1219 prn_hnd->servername, prn_hnd->sharename));
1220
1221 /* For this printer? Print servers always receive notifications. */
1222 if ((prn_hnd->printer_type == SPLHND_PRINTER) &&
1223 (!strequal(msg_group->printername, prn_hnd->sharename))) {
1224 return 0;
1225 }
1226
1227 DEBUG(10,("Our printer\n"));
1228
1229 /* build the array of change notifications */
1230 ret = build_notify2_messages(mem_ctx, prn_hnd,
1231 msg_group->msgs,
1232 msg_group->num_msgs,
1233 &notifies, &count);
1234 if (ret) {
1235 return ret;
1236 }
1237
1238 info0.version = 0x2;
1239 info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1240 info0.count = count;
1241 info0.notifies = notifies;
1242
1243 info.info0 = &info0;
1244
1245 status = rpccli_spoolss_RouterReplyPrinterEx(
1246 prn_hnd->notify.cli_chan->cli_pipe,
1247 mem_ctx,
1248 &prn_hnd->notify.cli_hnd,
1249 prn_hnd->notify.change, /* color */
1250 prn_hnd->notify.flags,
1251 &reply_result,
1252 0, /* reply_type, must be 0 */
1253 info, &werr);
1254 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1255 DEBUG(1, ("RouterReplyPrinterEx to client: %s "
1256 "failed: %s\n",
1257 prn_hnd->notify.cli_chan->cli_pipe->srv_name_slash,
1258 win_errstr(werr)));
1259 }
1260 switch (reply_result) {
1261 case 0:
1262 break;
1263 case PRINTER_NOTIFY_INFO_DISCARDED:
1264 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1265 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1266 break;
1267 default:
1268 break;
1269 }
1270
1271 return 0;
1272 }
1273
1274 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
1275 {
1276 struct printer_handle *p;
1277 TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
1278 SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
1279 int ret;
1280
1281 if ( !msg_group ) {
1282 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
1283 return;
1284 }
1285
1286 if (!msg_group->msgs) {
1287 DEBUG(5, ("send_notify2_changes() called with no messages!\n"));
1288 return;
1289 }
1290
1291 DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
1292
1293 /* loop over all printers */
1294
1295 for (p = printers_list; p; p = p->next) {
1296 ret = send_notify2_printer(mem_ctx, p, msg_group);
1297 if (ret) {
1298 goto done;
1299 }
1300 }
1301
1302 done:
1303 DEBUG(8,("send_notify2_changes: Exit...\n"));
1304 return;
1305 }
1306
1307 /***********************************************************************
1308 **********************************************************************/
1309
1310 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1311 {
1312
1313 uint32_t tv_sec, tv_usec;
1314 size_t offset = 0;
1315
1316 /* Unpack message */
1317
1318 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1319 msg->printer);
1320
1321 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1322 &tv_sec, &tv_usec,
1323 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1324
1325 if (msg->len == 0)
1326 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1327 &msg->notify.value[0], &msg->notify.value[1]);
1328 else
1329 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1330 &msg->len, &msg->notify.data);
1331
1332 DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1333 msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1334
1335 tv->tv_sec = tv_sec;
1336 tv->tv_usec = tv_usec;
1337
1338 if (msg->len == 0)
1339 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1340 msg->notify.value[1]));
1341 else
1342 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1343
1344 return true;
1345 }
1346
1347 /********************************************************************
1348 Receive a notify2 message list
1349 ********************************************************************/
1350
1351 static void receive_notify2_message_list(struct messaging_context *msg,
1352 void *private_data,
1353 uint32_t msg_type,
1354 struct server_id server_id,
1355 DATA_BLOB *data)
1356 {
1357 size_t msg_count, i;
1358 char *buf = (char *)data->data;
1359 char *msg_ptr;
1360 size_t msg_len;
1361 SPOOLSS_NOTIFY_MSG notify;
1362 SPOOLSS_NOTIFY_MSG_CTR messages;
1363 int num_groups;
1364
1365 if (data->length < 4) {
1366 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1367 return;
1368 }
1369
1370 msg_count = IVAL(buf, 0);
1371 msg_ptr = buf + 4;
1372
1373 DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1374
1375 if (msg_count == 0) {
1376 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1377 return;
1378 }
1379
1380 /* initialize the container */
1381
1382 ZERO_STRUCT( messages );
1383 notify_msg_ctr_init( &messages );
1384
1385 /*
1386 * build message groups for each printer identified
1387 * in a change_notify msg. Remember that a PCN message
1388 * includes the handle returned for the srv_spoolss_replyopenprinter()
1389 * call. Therefore messages are grouped according to printer handle.
1390 */
1391
1392 for ( i=0; i<msg_count; i++ ) {
1393 struct timeval msg_tv;
1394
1395 if (msg_ptr + 4 - buf > data->length) {
1396 DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1397 return;
1398 }
1399
1400 msg_len = IVAL(msg_ptr,0);
1401 msg_ptr += 4;
1402
1403 if (msg_ptr + msg_len - buf > data->length) {
1404 DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1405 return;
1406 }
1407
1408 /* unpack messages */
1409
1410 ZERO_STRUCT( notify );
1411 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1412 msg_ptr += msg_len;
1413
1414 /* add to correct list in container */
1415
1416 notify_msg_ctr_addmsg( &messages, &notify );
1417
1418 /* free memory that might have been allocated by notify2_unpack_msg() */
1419
1420 if ( notify.len != 0 )
1421 SAFE_FREE( notify.notify.data );
1422 }
1423
1424 /* process each group of messages */
1425
1426 num_groups = notify_msg_ctr_numgroups( &messages );
1427 for ( i=0; i<num_groups; i++ )
1428 send_notify2_changes( &messages, i );
1429
1430
1431 /* cleanup */
1432
1433 DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1434 (uint32_t)msg_count ));
1435
1436 notify_msg_ctr_destroy( &messages );
1437
1438 return;
1439 }
1440
1441 /********************************************************************
1442 Send a message to ourself about new driver being installed
1443 so we can upgrade the information for each printer bound to this
1444 driver
1445 ********************************************************************/
1446
1447 static bool srv_spoolss_drv_upgrade_printer(const char *drivername,
1448 struct messaging_context *msg_ctx)
1449 {
1450 int len = strlen(drivername);
1451
1452 if (!len)
1453 return false;
1454
1455 DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1456 drivername));
1457
1458 messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
1459 MSG_PRINTER_DRVUPGRADE,
1460 (uint8_t *)drivername, len+1);
1461
1462 return true;
1463 }
1464
1465 void srv_spoolss_cleanup(void)
1466 {
1467 struct printer_session_counter *session_counter;
1468
1469 for (session_counter = counter_list;
1470 session_counter != NULL;
1471 session_counter = counter_list) {
1472 DLIST_REMOVE(counter_list, session_counter);
1473 TALLOC_FREE(session_counter);
1474 }
1475 }
1476
1477 /**********************************************************************
1478 callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1479 over all printers, upgrading ones as necessary
1480 **********************************************************************/
1481
1482 void do_drv_upgrade_printer(struct messaging_context *msg,
1483 void *private_data,
1484 uint32_t msg_type,
1485 struct server_id server_id,
1486 DATA_BLOB *data)
1487 {
1488 TALLOC_CTX *tmp_ctx;
1489 struct auth_serversupplied_info *server_info = NULL;
1490 struct spoolss_PrinterInfo2 *pinfo2;
1491 NTSTATUS status;
1492 WERROR result;
1493 const char *drivername;
1494 int snum;
1495 int n_services = lp_numservices();
1496 size_t len;
1497
1498 tmp_ctx = talloc_new(NULL);
1499 if (!tmp_ctx) return;
1500
1501 status = make_server_info_system(tmp_ctx, &server_info);
1502 if (!NT_STATUS_IS_OK(status)) {
1503 DEBUG(0, ("do_drv_upgrade_printer: "
1504 "Could not create system server_info\n"));
1505 goto done;
1506 }
1507
1508 len = MIN(data->length,sizeof(drivername)-1);
1509 drivername = talloc_strndup(tmp_ctx, (const char *)data->data, len);
1510 if (!drivername) {
1511 DEBUG(0, ("do_drv_upgrade_printer: Out of memoery ?!\n"));
1512 goto done;
1513 }
1514
1515 DEBUG(10, ("do_drv_upgrade_printer: "
1516 "Got message for new driver [%s]\n", drivername));
1517
1518 /* Iterate the printer list */
1519
1520 for (snum = 0; snum < n_services; snum++) {
1521 if (!lp_snum_ok(snum) || !lp_print_ok(snum)) {
1522 continue;
1523 }
1524
1525 result = winreg_get_printer(tmp_ctx, server_info, msg,
1526 NULL,
1527 lp_const_servicename(snum),
1528 &pinfo2);
1529
1530 if (!W_ERROR_IS_OK(result)) {
1531 continue;
1532 }
1533
1534 if (!pinfo2->drivername) {
1535 continue;
1536 }
1537
1538 if (strcmp(drivername, pinfo2->drivername) != 0) {
1539 continue;
1540 }
1541
1542 DEBUG(6,("Updating printer [%s]\n", pinfo2->printername));
1543
1544 /* all we care about currently is the change_id */
1545 result = winreg_printer_update_changeid(tmp_ctx,
1546 server_info,
1547 msg,
1548 pinfo2->printername);
1549
1550 if (!W_ERROR_IS_OK(result)) {
1551 DEBUG(3, ("do_drv_upgrade_printer: "
1552 "Failed to update changeid [%s]\n",
1553 win_errstr(result)));
1554 }
1555 }
1556
1557 /* all done */
1558 done:
1559 talloc_free(tmp_ctx);
1560 }
1561
1562 /********************************************************************
1563 Update the cache for all printq's with a registered client
1564 connection
1565 ********************************************************************/
1566
1567 void update_monitored_printq_cache(struct messaging_context *msg_ctx)
1568 {
1569 struct printer_handle *printer = printers_list;
1570 int snum;
1571
1572 /* loop through all printers and update the cache where
1573 a client is connected */
1574 while (printer) {
1575 if ((printer->printer_type == SPLHND_PRINTER) &&
1576 ((printer->notify.cli_chan != NULL) &&
1577 (printer->notify.cli_chan->active_connections > 0))) {
1578 snum = print_queue_snum(printer->sharename);
1579 print_queue_status(msg_ctx, snum, NULL, NULL);
1580 }
1581
1582 printer = printer->next;
1583 }
1584
1585 return;
1586 }
1587
1588 /****************************************************************
1589 _spoolss_OpenPrinter
1590 ****************************************************************/
1591
1592 WERROR _spoolss_OpenPrinter(struct pipes_struct *p,
1593 struct spoolss_OpenPrinter *r)
1594 {
1595 struct spoolss_OpenPrinterEx e;
1596 WERROR werr;
1597
1598 ZERO_STRUCT(e.in.userlevel);
1599
1600 e.in.printername = r->in.printername;
1601 e.in.datatype = r->in.datatype;
1602 e.in.devmode_ctr = r->in.devmode_ctr;
1603 e.in.access_mask = r->in.access_mask;
1604 e.in.level = 0;
1605
1606 e.out.handle = r->out.handle;
1607
1608 werr = _spoolss_OpenPrinterEx(p, &e);
1609
1610 if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1611 /* OpenPrinterEx returns this for a bad
1612 * printer name. We must return WERR_INVALID_PRINTER_NAME
1613 * instead.
1614 */
1615 werr = WERR_INVALID_PRINTER_NAME;
1616 }
1617
1618 return werr;
1619 }
1620
1621 static WERROR copy_devicemode(TALLOC_CTX *mem_ctx,
1622 struct spoolss_DeviceMode *orig,
1623 struct spoolss_DeviceMode **dest)
1624 {
1625 struct spoolss_DeviceMode *dm;
1626
1627 dm = talloc(mem_ctx, struct spoolss_DeviceMode);
1628 if (!dm) {
1629 return WERR_NOMEM;
1630 }
1631
1632 /* copy all values, then duplicate strings and structs */
1633 *dm = *orig;
1634
1635 dm->devicename = talloc_strdup(dm, orig->devicename);
1636 if (!dm->devicename) {
1637 return WERR_NOMEM;
1638 }
1639 dm->formname = talloc_strdup(dm, orig->formname);
1640 if (!dm->formname) {
1641 return WERR_NOMEM;
1642 }
1643 if (orig->driverextra_data.data) {
1644 dm->driverextra_data.data =
1645 (uint8_t *) talloc_memdup(dm, orig->driverextra_data.data,
1646 orig->driverextra_data.length);
1647 if (!dm->driverextra_data.data) {
1648 return WERR_NOMEM;
1649 }
1650 }
1651
1652 *dest = dm;
1653 return WERR_OK;
1654 }
1655
1656 /****************************************************************
1657 _spoolss_OpenPrinterEx
1658 ****************************************************************/
1659
1660 WERROR _spoolss_OpenPrinterEx(struct pipes_struct *p,
1661 struct spoolss_OpenPrinterEx *r)
1662 {
1663 int snum;
1664 struct printer_handle *Printer=NULL;
1665
1666 if (!r->in.printername) {
1667 return WERR_INVALID_PARAM;
1668 }
1669
1670 /* some sanity check because you can open a printer or a print server */
1671 /* aka: \\server\printer or \\server */
1672
1673 DEBUGADD(3,("checking name: %s\n", r->in.printername));
1674
1675 if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1676 DEBUG(0,("_spoolss_OpenPrinterEx: Cannot open a printer handle "
1677 "for printer %s\n", r->in.printername));
1678 ZERO_STRUCTP(r->out.handle);
1679 return WERR_INVALID_PARAM;
1680 }
1681
1682 Printer = find_printer_index_by_hnd(p, r->out.handle);
1683 if ( !Printer ) {
1684 DEBUG(0,("_spoolss_OpenPrinterEx: logic error. Can't find printer "
1685 "handle we created for printer %s\n", r->in.printername));
1686 close_printer_handle(p, r->out.handle);
1687 ZERO_STRUCTP(r->out.handle);
1688 return WERR_INVALID_PARAM;
1689 }
1690
1691 /*
1692 * First case: the user is opening the print server:
1693 *
1694 * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1695 * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1696 *
1697 * Then both Win2k and WinNT clients try an OpenPrinterEx with
1698 * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1699 * or if the user is listed in the smb.conf printer admin parameter.
1700 *
1701 * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1702 * client view printer folder, but does not show the MSAPW.
1703 *
1704 * Note: this test needs code to check access rights here too. Jeremy
1705 * could you look at this?
1706 *
1707 * Second case: the user is opening a printer:
1708 * NT doesn't let us connect to a printer if the connecting user
1709 * doesn't have print permission.
1710 *
1711 * Third case: user is opening a Port Monitor
1712 * access checks same as opening a handle to the print server.
1713 */
1714
1715 switch (Printer->printer_type )
1716 {
1717 case SPLHND_SERVER:
1718 case SPLHND_PORTMON_TCP:
1719 case SPLHND_PORTMON_LOCAL:
1720 /* Printserver handles use global struct... */
1721
1722 snum = -1;
1723
1724 /* Map standard access rights to object specific access rights */
1725
1726 se_map_standard(&r->in.access_mask,
1727 &printserver_std_mapping);
1728
1729 /* Deny any object specific bits that don't apply to print
1730 servers (i.e printer and job specific bits) */
1731
1732 r->in.access_mask &= SEC_MASK_SPECIFIC;
1733
1734 if (r->in.access_mask &
1735 ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1736 DEBUG(3, ("access DENIED for non-printserver bits\n"));
1737 close_printer_handle(p, r->out.handle);
1738 ZERO_STRUCTP(r->out.handle);
1739 return WERR_ACCESS_DENIED;
1740 }
1741
1742 /* Allow admin access */
1743
1744 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1745 {
1746 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1747
1748 if (!lp_ms_add_printer_wizard()) {
1749 close_printer_handle(p, r->out.handle);
1750 ZERO_STRUCTP(r->out.handle);
1751 return WERR_ACCESS_DENIED;
1752 }
1753
1754 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1755 and not a printer admin, then fail */
1756
1757 if ((p->server_info->utok.uid != sec_initial_uid()) &&
1758 !user_has_privileges(p->server_info->ptok,
1759 &se_printop ) &&
1760 !token_contains_name_in_list(
1761 uidtoname(p->server_info->utok.uid),
1762 p->server_info->info3->base.domain.string,
1763 NULL,
1764 p->server_info->ptok,
1765 lp_printer_admin(snum))) {
1766 close_printer_handle(p, r->out.handle);
1767 ZERO_STRUCTP(r->out.handle);
1768 return WERR_ACCESS_DENIED;
1769 }
1770
1771 r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1772 }
1773 else
1774 {
1775 r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1776 }
1777
1778 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1779 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1780
1781 /* We fall through to return WERR_OK */
1782 break;
1783
1784 case SPLHND_PRINTER:
1785 /* NT doesn't let us connect to a printer if the connecting user
1786 doesn't have print permission. */
1787
1788 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1789 close_printer_handle(p, r->out.handle);
1790 ZERO_STRUCTP(r->out.handle);
1791 return WERR_BADFID;
1792 }
1793
1794 if (r->in.access_mask == SEC_FLAG_MAXIMUM_ALLOWED) {
1795 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1796 }
1797
1798 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1799
1800 /* map an empty access mask to the minimum access mask */
1801 if (r->in.access_mask == 0x0)
1802 r->in.access_mask = PRINTER_ACCESS_USE;
1803
1804 /*
1805 * If we are not serving the printer driver for this printer,
1806 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1807 * will keep NT clients happy --jerry
1808 */
1809
1810 if (lp_use_client_driver(snum)
1811 && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1812 {
1813 r->in.access_mask = PRINTER_ACCESS_USE;
1814 }
1815
1816 /* check smb.conf parameters and the the sec_desc */
1817
1818 if (!allow_access(lp_hostsdeny(snum), lp_hostsallow(snum),
1819 p->client_id->name, p->client_id->addr)) {
1820 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1821 ZERO_STRUCTP(r->out.handle);
1822 return WERR_ACCESS_DENIED;
1823 }
1824
1825 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1826 p->server_info->ptok, snum) ||
1827 !print_access_check(get_server_info_system(),
1828 p->msg_ctx,
1829 snum,
1830 r->in.access_mask)) {
1831 DEBUG(3, ("access DENIED for printer open\n"));
1832 close_printer_handle(p, r->out.handle);
1833 ZERO_STRUCTP(r->out.handle);
1834 return WERR_ACCESS_DENIED;
1835 }
1836
1837 if ((r->in.access_mask & SEC_MASK_SPECIFIC)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1838 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1839 close_printer_handle(p, r->out.handle);
1840 ZERO_STRUCTP(r->out.handle);
1841 return WERR_ACCESS_DENIED;
1842 }
1843
1844 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1845 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1846 else
1847 r->in.access_mask = PRINTER_ACCESS_USE;
1848
1849 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1850 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1851
1852 winreg_create_printer(p->mem_ctx,
1853 get_server_info_system(),
1854 p->msg_ctx,
1855 Printer->servername,
1856 lp_const_servicename(snum));
1857
1858 break;
1859
1860 default:
1861 /* sanity check to prevent programmer error */
1862 ZERO_STRUCTP(r->out.handle);
1863 return WERR_BADFID;
1864 }
1865
1866 Printer->access_granted = r->in.access_mask;
1867
1868 /*
1869 * If the client sent a devmode in the OpenPrinter() call, then
1870 * save it here in case we get a job submission on this handle
1871 */
1872
1873 if ((Printer->printer_type != SPLHND_SERVER) &&
1874 r->in.devmode_ctr.devmode) {
1875 copy_devicemode(NULL, r->in.devmode_ctr.devmode,
1876 &Printer->devmode);
1877 }
1878
1879 #if 0 /* JERRY -- I'm doubtful this is really effective */
1880 /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1881 optimization in Windows 2000 clients --jerry */
1882
1883 if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1884 && (RA_WIN2K == get_remote_arch()) )
1885 {
1886 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1887 sys_usleep( 500000 );
1888 }
1889 #endif
1890
1891 return WERR_OK;
1892 }
1893
1894 /****************************************************************
1895 _spoolss_ClosePrinter
1896 ****************************************************************/
1897
1898 WERROR _spoolss_ClosePrinter(struct pipes_struct *p,
1899 struct spoolss_ClosePrinter *r)
1900 {
1901 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
1902
1903 if (Printer && Printer->document_started) {
1904 struct spoolss_EndDocPrinter e;
1905
1906 e.in.handle = r->in.handle;
1907
1908 _spoolss_EndDocPrinter(p, &e);
1909 }
1910
1911 if (!close_printer_handle(p, r->in.handle))
1912 return WERR_BADFID;
1913
1914 /* clear the returned printer handle. Observed behavior
1915 from Win2k server. Don't think this really matters.
1916 Previous code just copied the value of the closed
1917 handle. --jerry */
1918
1919 ZERO_STRUCTP(r->out.handle);
1920
1921 return WERR_OK;
1922 }
1923
1924 /****************************************************************
1925 _spoolss_DeletePrinter
1926 ****************************************************************/
1927
1928 WERROR _spoolss_DeletePrinter(struct pipes_struct *p,
1929 struct spoolss_DeletePrinter *r)
1930 {
1931 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
1932 WERROR result;
1933 int snum;
1934
1935 if (Printer && Printer->document_started) {
1936 struct spoolss_EndDocPrinter e;
1937
1938 e.in.handle = r->in.handle;
1939
1940 _spoolss_EndDocPrinter(p, &e);
1941 }
1942
1943 if (get_printer_snum(p, r->in.handle, &snum, NULL)) {
1944 winreg_delete_printer_key(p->mem_ctx,
1945 get_server_info_system(),
1946 p->msg_ctx,
1947 lp_const_servicename(snum),
1948 "");
1949 }
1950
1951 result = delete_printer_handle(p, r->in.handle);
1952
1953 return result;
1954 }
1955
1956 /*******************************************************************
1957 * static function to lookup the version id corresponding to an
1958 * long architecture string
1959 ******************************************************************/
1960
1961 static const struct print_architecture_table_node archi_table[]= {
1962
1963 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
1964 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
1965 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
1966 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
1967 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
1968 {"Windows IA64", SPL_ARCH_IA64, 3 },
1969 {"Windows x64", SPL_ARCH_X64, 3 },
1970 {NULL, "", -1 }
1971 };
1972
1973 static int get_version_id(const char *arch)
1974 {
1975 int i;
1976
1977 for (i=0; archi_table[i].long_archi != NULL; i++)
1978 {
1979 if (strcmp(arch, archi_table[i].long_archi) == 0)
1980 return (archi_table[i].version);
1981 }
1982
1983 return -1;
1984 }
1985
1986 /****************************************************************
1987 _spoolss_DeletePrinterDriver
1988 ****************************************************************/
1989
1990 WERROR _spoolss_DeletePrinterDriver(struct pipes_struct *p,
1991 struct spoolss_DeletePrinterDriver *r)
1992 {
1993
1994 struct spoolss_DriverInfo8 *info = NULL;
1995 struct spoolss_DriverInfo8 *info_win2k = NULL;
1996 int version;
1997 WERROR status;
1998 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1999
2000 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2001 and not a printer admin, then fail */
2002
2003 if ( (p->server_info->utok.uid != sec_initial_uid())
2004 && !user_has_privileges(p->server_info->ptok, &se_printop )
2005 && !token_contains_name_in_list(
2006 uidtoname(p->server_info->utok.uid),
2007 p->server_info->info3->base.domain.string,
2008 NULL,
2009 p->server_info->ptok,
2010 lp_printer_admin(-1)) )
2011 {
2012 return WERR_ACCESS_DENIED;
2013 }
2014
2015 /* check that we have a valid driver name first */
2016
2017 if ((version = get_version_id(r->in.architecture)) == -1)
2018 return WERR_INVALID_ENVIRONMENT;
2019
2020 status = winreg_get_driver(p->mem_ctx,
2021 get_server_info_system(),
2022 p->msg_ctx,
2023 r->in.architecture, r->in.driver,
2024 version, &info);
2025 if (!W_ERROR_IS_OK(status)) {
2026 /* try for Win2k driver if "Windows NT x86" */
2027
2028 if ( version == 2 ) {
2029 version = 3;
2030
2031 status = winreg_get_driver(p->mem_ctx,
2032 get_server_info_system(),
2033 p->msg_ctx,
2034 r->in.architecture,
2035 r->in.driver,
2036 version, &info);
2037 if (!W_ERROR_IS_OK(status)) {
2038 status = WERR_UNKNOWN_PRINTER_DRIVER;
2039 goto done;
2040 }
2041 }
2042 /* otherwise it was a failure */
2043 else {
2044 status = WERR_UNKNOWN_PRINTER_DRIVER;
2045 goto done;
2046 }
2047
2048 }
2049
2050 if (printer_driver_in_use(p->mem_ctx,
2051 get_server_info_system(),
2052 p->msg_ctx,
2053 info)) {
2054 status = WERR_PRINTER_DRIVER_IN_USE;
2055 goto done;
2056 }
2057
2058 if (version == 2) {
2059 status = winreg_get_driver(p->mem_ctx,
2060 get_server_info_system(),
2061 p->msg_ctx,
2062 r->in.architecture,
2063 r->in.driver, 3, &info_win2k);
2064 if (W_ERROR_IS_OK(status)) {
2065 /* if we get to here, we now have 2 driver info structures to remove */
2066 /* remove the Win2k driver first*/
2067
2068 status = winreg_del_driver(p->mem_ctx,
2069 get_server_info_system(),
2070 p->msg_ctx,
2071 info_win2k, 3);
2072 talloc_free(info_win2k);
2073
2074 /* this should not have failed---if it did, report to client */
2075 if (!W_ERROR_IS_OK(status)) {
2076 goto done;
2077 }
2078 }
2079 }
2080
2081 status = winreg_del_driver(p->mem_ctx,
2082 get_server_info_system(),
2083 p->msg_ctx,
2084 info, version);
2085
2086 done:
2087 talloc_free(info);
2088
2089 return status;
2090 }
2091
2092 /****************************************************************
2093 _spoolss_DeletePrinterDriverEx
2094 ****************************************************************/
2095
2096 WERROR _spoolss_DeletePrinterDriverEx(struct pipes_struct *p,
2097 struct spoolss_DeletePrinterDriverEx *r)
2098 {
2099 struct spoolss_DriverInfo8 *info = NULL;
2100 struct spoolss_DriverInfo8 *info_win2k = NULL;
2101 int version;
2102 bool delete_files;
2103 WERROR status;
2104 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2105
2106 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2107 and not a printer admin, then fail */
2108
2109 if ( (p->server_info->utok.uid != sec_initial_uid())
2110 && !user_has_privileges(p->server_info->ptok, &se_printop )
2111 && !token_contains_name_in_list(
2112 uidtoname(p->server_info->utok.uid),
2113 p->server_info->info3->base.domain.string,
2114 NULL,
2115 p->server_info->ptok, lp_printer_admin(-1)) )
2116 {
2117 return WERR_ACCESS_DENIED;
2118 }
2119
2120 /* check that we have a valid driver name first */
2121 if ((version = get_version_id(r->in.architecture)) == -1) {
2122 /* this is what NT returns */
2123 return WERR_INVALID_ENVIRONMENT;
2124 }
2125
2126 if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2127 version = r->in.version;
2128
2129 status = winreg_get_driver(p->mem_ctx,
2130 get_server_info_system(),
2131 p->msg_ctx,
2132 r->in.architecture,
2133 r->in.driver,
2134 version,
2135 &info);
2136 if (!W_ERROR_IS_OK(status)) {
2137 status = WERR_UNKNOWN_PRINTER_DRIVER;
2138
2139 /*
2140 * if the client asked for a specific version,
2141 * or this is something other than Windows NT x86,
2142 * then we've failed
2143 */
2144
2145 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2146 goto done;
2147
2148 /* try for Win2k driver if "Windows NT x86" */
2149
2150 version = 3;
2151 status = winreg_get_driver(info,
2152 get_server_info_system(),
2153 p->msg_ctx,
2154 r->in.architecture,
2155 r->in.driver,
2156 version, &info);
2157 if (!W_ERROR_IS_OK(status)) {
2158 status = WERR_UNKNOWN_PRINTER_DRIVER;
2159 goto done;
2160 }
2161 }
2162
2163 if (printer_driver_in_use(info,
2164 get_server_info_system(),
2165 p->msg_ctx,
2166 info)) {
2167 status = WERR_PRINTER_DRIVER_IN_USE;
2168 goto done;
2169 }
2170
2171 /*
2172 * we have a couple of cases to consider.
2173 * (1) Are any files in use? If so and DPD_DELTE_ALL_FILE is set,
2174 * then the delete should fail if **any** files overlap with
2175 * other drivers
2176 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2177 * non-overlapping files
2178 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2179 * is set, the do not delete any files
2180 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2181 */
2182
2183 delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2184
2185 /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2186
2187 if (delete_files &&
2188 (r->in.delete_flags & DPD_DELETE_ALL_FILES) &&
2189 printer_driver_files_in_use(info,
2190 get_server_info_system(),
2191 p->msg_ctx,
2192 info)) {
2193 /* no idea of the correct error here */
2194 status = WERR_ACCESS_DENIED;
2195 goto done;
2196 }
2197
2198
2199 /* also check for W32X86/3 if necessary; maybe we already have? */
2200
2201 if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
2202 status = winreg_get_driver(info,
2203 get_server_info_system(),
2204 p->msg_ctx,
2205 r->in.architecture,
2206 r->in.driver, 3, &info_win2k);
2207 if (W_ERROR_IS_OK(status)) {
2208
2209 if (delete_files &&
2210 (r->in.delete_flags & DPD_DELETE_ALL_FILES) &&
2211 printer_driver_files_in_use(info,
2212 get_server_info_system(),
2213 p->msg_ctx,
2214 info_win2k)) {
2215 /* no idea of the correct error here */
2216 talloc_free(info_win2k);
2217 status = WERR_ACCESS_DENIED;
2218 goto done;
2219 }
2220
2221 /* if we get to here, we now have 2 driver info structures to remove */
2222 /* remove the Win2k driver first*/
2223
2224 status = winreg_del_driver(info,
2225 get_server_info_system(),
2226 p->msg_ctx,
2227 info_win2k,
2228 3);
2229
2230 /* this should not have failed---if it did, report to client */
2231
2232 if (!W_ERROR_IS_OK(status)) {
2233 goto done;
2234 }
2235
2236 /*
2237 * now delete any associated files if delete_files is
2238 * true. Even if this part failes, we return succes
2239 * because the driver doesn not exist any more
2240 */
2241 if (delete_files) {
2242 delete_driver_files(get_server_info_system(),
2243 info_win2k);
2244 }
2245 }
2246 }
2247
2248 status = winreg_del_driver(info,
2249 get_server_info_system(),
2250 p->msg_ctx,
2251 info,
2252 version);
2253 if (!W_ERROR_IS_OK(status)) {
2254 goto done;
2255 }
2256
2257 /*
2258 * now delete any associated files if delete_files is
2259 * true. Even if this part failes, we return succes
2260 * because the driver doesn not exist any more
2261 */
2262 if (delete_files) {
2263 delete_driver_files(get_server_info_system(), info);
2264 }
2265
2266 done:
2267 talloc_free(info);
2268 return status;
2269 }
2270
2271
2272 /********************************************************************
2273 GetPrinterData on a printer server Handle.
2274 ********************************************************************/
2275
2276 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2277 const char *value,
2278 enum winreg_Type *type,
2279 union spoolss_PrinterData *data)
2280 {
2281 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2282
2283 if (!StrCaseCmp(value, "W3SvcInstalled")) {
2284 *type = REG_DWORD;
2285 data->value = 0x00;
2286 return WERR_OK;
2287 }
2288
2289 if (!StrCaseCmp(value, "BeepEnabled")) {
2290 *type = REG_DWORD;
2291 data->value = 0x00;
2292 return WERR_OK;
2293 }
2294
2295 if (!StrCaseCmp(value, "EventLog")) {
2296 *type = REG_DWORD;
2297 /* formally was 0x1b */
2298 data->value = 0x00;
2299 return WERR_OK;
2300 }
2301
2302 if (!StrCaseCmp(value, "NetPopup")) {
2303 *type = REG_DWORD;
2304 data->value = 0x00;
2305 return WERR_OK;
2306 }
2307
2308 if (!StrCaseCmp(value, "MajorVersion")) {
2309 *type = REG_DWORD;
2310
2311 /* Windows NT 4.0 seems to not allow uploading of drivers
2312 to a server that reports 0x3 as the MajorVersion.
2313 need to investigate more how Win2k gets around this .
2314 -- jerry */
2315
2316 if (RA_WINNT == get_remote_arch()) {
2317 data->value = 0x02;
2318 } else {
2319 data->value = 0x03;
2320 }
2321
2322 return WERR_OK;
2323 }
2324
2325 if (!StrCaseCmp(value, "MinorVersion")) {
2326 *type = REG_DWORD;
2327 data->value = 0x00;
2328 return WERR_OK;
2329 }
2330
2331 /* REG_BINARY
2332 * uint32_t size = 0x114
2333 * uint32_t major = 5
2334 * uint32_t minor = [0|1]
2335 * uint32_t build = [2195|2600]
2336 * extra unicode string = e.g. "Service Pack 3"
2337 */
2338 if (!StrCaseCmp(value, "OSVersion")) {
2339 DATA_BLOB blob;
2340 enum ndr_err_code ndr_err;
2341 struct spoolss_OSVersion os;
2342
2343 os.major = 5; /* Windows 2000 == 5.0 */
2344 os.minor = 0;
2345 os.build = 2195; /* build */
2346 os.extra_string = ""; /* leave extra string empty */
2347
2348 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &os,
2349 (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2350 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2351 return WERR_GENERAL_FAILURE;
2352 }
2353
2354 *type = REG_BINARY;
2355 data->binary = blob;
2356
2357 return WERR_OK;
2358 }
2359
2360
2361 if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2362 *type = REG_SZ;
2363
2364 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2365 W_ERROR_HAVE_NO_MEMORY(data->string);
2366
2367 return WERR_OK;
2368 }
2369
2370 if (!StrCaseCmp(value, "Architecture")) {
2371 *type = REG_SZ;
2372 data->string = talloc_strdup(mem_ctx,
2373 lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", SPOOLSS_ARCHITECTURE_NT_X86));
2374 W_ERROR_HAVE_NO_MEMORY(data->string);
2375
2376 return WERR_OK;
2377 }
2378
2379 if (!StrCaseCmp(value, "DsPresent")) {
2380 *type = REG_DWORD;
2381
2382 /* only show the publish check box if we are a
2383 member of a AD domain */
2384
2385 if (lp_security() == SEC_ADS) {
2386 data->value = 0x01;
2387 } else {
2388 data->value = 0x00;
2389 }
2390 return WERR_OK;
2391 }
2392
2393 if (!StrCaseCmp(value, "DNSMachineName")) {
2394 const char *hostname = get_mydnsfullname();
2395
2396 if (!hostname) {
2397 return WERR_BADFILE;
2398 }
2399
2400 *type = REG_SZ;
2401 data->string = talloc_strdup(mem_ctx, hostname);
2402 W_ERROR_HAVE_NO_MEMORY(data->string);
2403
2404 return WERR_OK;
2405 }
2406
2407 *type = REG_NONE;
2408
2409 return WERR_INVALID_PARAM;
2410 }
2411
2412 /****************************************************************
2413 _spoolss_GetPrinterData
2414 ****************************************************************/
2415
2416 WERROR _spoolss_GetPrinterData(struct pipes_struct *p,
2417 struct spoolss_GetPrinterData *r)
2418 {
2419 struct spoolss_GetPrinterDataEx r2;
2420
2421 r2.in.handle = r->in.handle;
2422 r2.in.key_name = "PrinterDriverData";
2423 r2.in.value_name = r->in.value_name;
2424 r2.in.offered = r->in.offered;
2425 r2.out.type = r->out.type;
2426 r2.out.data = r->out.data;
2427 r2.out.needed = r->out.needed;
2428
2429 return _spoolss_GetPrinterDataEx(p, &r2);
2430 }
2431
2432 /*********************************************************
2433 Connect to the client machine.
2434 **********************************************************/
2435
2436 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2437 struct sockaddr_storage *client_ss, const char *remote_machine)
2438 {
2439 NTSTATUS ret;
2440 struct cli_state *the_cli;
2441 struct sockaddr_storage rm_addr;
2442 char addr[INET6_ADDRSTRLEN];
2443
2444 if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2445 DEBUG(2,("spoolss_connect_to_client: resolving %s\n",
2446 remote_machine));
2447 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2448 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2449 return false;
2450 }
2451 print_sockaddr(addr, sizeof(addr), &rm_addr);
2452 } else {
2453 rm_addr = *client_ss;
2454 print_sockaddr(addr, sizeof(addr), &rm_addr);
2455 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2456 addr));
2457 }
2458
2459 if (ismyaddr((struct sockaddr *)(void *)&rm_addr)) {
2460 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n",
2461 addr));
2462 return false;
2463 }
2464
2465 /* setup the connection */
2466 ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2467 &rm_addr, 0, "IPC$", "IPC",
2468 "", /* username */
2469 "", /* domain */
2470 "", /* password */
2471 0, lp_client_signing(), NULL );
2472
2473 if ( !NT_STATUS_IS_OK( ret ) ) {
2474 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2475 remote_machine ));
2476 return false;
2477 }
2478
2479 if ( the_cli->protocol != PROTOCOL_NT1 ) {
2480 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2481 cli_shutdown(the_cli);
2482 return false;
2483 }
2484
2485 /*
2486 * Ok - we have an anonymous connection to the IPC$ share.
2487 * Now start the NT Domain stuff :-).
2488 */
2489
2490 ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2491 if (!NT_STATUS_IS_OK(ret)) {
2492 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2493 remote_machine, nt_errstr(ret)));
2494 cli_shutdown(the_cli);
2495 return false;
2496 }
2497
2498 return true;
2499 }
2500
2501 /***************************************************************************
2502 Connect to the client.
2503 ****************************************************************************/
2504
2505 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2506 uint32_t localprinter,
2507 enum winreg_Type type,
2508 struct policy_handle *handle,
2509 struct notify_back_channel **_chan,
2510 struct sockaddr_storage *client_ss,
2511 struct messaging_context *msg_ctx)
2512 {
2513 WERROR result;
2514 NTSTATUS status;
2515 struct notify_back_channel *chan;
2516
2517 for (chan = back_channels; chan; chan = chan->next) {
2518 if (memcmp(&chan->client_address, client_ss,
2519 sizeof(struct sockaddr_storage)) == 0) {
2520 break;
2521 }
2522 }
2523
2524 /*
2525 * If it's the first connection, contact the client
2526 * and connect to the IPC$ share anonymously
2527 */
2528 if (!chan) {
2529 fstring unix_printer;
2530
2531 /* the +2 is to strip the leading 2 backslashs */
2532 fstrcpy(unix_printer, printer + 2);
2533
2534 chan = talloc_zero(back_channels, struct notify_back_channel);
2535 if (!chan) {
2536 return false;
2537 }
2538 chan->client_address = *client_ss;
2539
2540 if (!spoolss_connect_to_client(&chan->cli_pipe, client_ss, unix_printer)) {
2541 TALLOC_FREE(chan);
2542 return false;
2543 }
2544
2545 DLIST_ADD(back_channels, chan);
2546
2547 messaging_register(msg_ctx, NULL, MSG_PRINTER_NOTIFY2,
2548 receive_notify2_message_list);
2549 /* Tell the connections db we're now interested in printer
2550 * notify messages. */
2551 serverid_register_msg_flags(messaging_server_id(msg_ctx),
2552 true, FLAG_MSG_PRINT_NOTIFY);
2553 }
2554
2555 /*
2556 * Tell the specific printing tdb we want messages for this printer
2557 * by registering our PID.
2558 */
2559
2560 if (!print_notify_register_pid(snum)) {
2561 DEBUG(0, ("Failed to register our pid for printer %s\n",
2562 printer));
2563 }
2564
2565 status = rpccli_spoolss_ReplyOpenPrinter(chan->cli_pipe, talloc_tos(),
2566 printer,
2567 localprinter,
2568 type,
2569 0,
2570 NULL,
2571 handle,
2572 &result);
2573 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
2574 DEBUG(5, ("Client RPC returned [%s]\n", win_errstr(result)));
2575 }
2576
2577 chan->active_connections++;
2578 *_chan = chan;
2579
2580 return (W_ERROR_IS_OK(result));
2581 }
2582
2583 /****************************************************************
2584 ****************************************************************/
2585
2586 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2587 const struct spoolss_NotifyOption *r)
2588 {
2589 struct spoolss_NotifyOption *option;
2590 uint32_t i,k;
2591
2592 if (!r) {
2593 return NULL;
2594 }
2595
2596 option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2597 if (!option) {
2598 return NULL;
2599 }
2600
2601 *option = *r;
2602
2603 if (!option->count) {
2604 return option;
2605 }
2606
2607 option->types = talloc_zero_array(option,
2608 struct spoolss_NotifyOptionType, option->count);
2609 if (!option->types) {
2610 talloc_free(option);
2611 return NULL;
2612 }
2613
2614 for (i=0; i < option->count; i++) {
2615 option->types[i] = r->types[i];
2616
2617 if (option->types[i].count) {
2618 option->types[i].fields = talloc_zero_array(option,
2619 union spoolss_Field, option->types[i].count);
2620 if (!option->types[i].fields) {
2621 talloc_free(option);
2622 return NULL;
2623 }
2624 for (k=0; k<option->types[i].count; k++) {
2625 option->types[i].fields[k] =
2626 r->types[i].fields[k];
2627 }
2628 }
2629 }
2630
2631 return option;
2632 }
2633
2634 /****************************************************************
2635 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2636 *
2637 * before replying OK: status=0 a rpc call is made to the workstation
2638 * asking ReplyOpenPrinter
2639 *
2640 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2641 * called from api_spoolss_rffpcnex
2642 ****************************************************************/
2643
2644 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct pipes_struct *p,
2645 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2646 {
2647 int snum = -1;
2648 struct spoolss_NotifyOption *option = r->in.notify_options;
2649 struct sockaddr_storage client_ss;
2650
2651 /* store the notify value in the printer struct */
2652
2653 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
2654
2655 if (!Printer) {
2656 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2657 "Invalid handle (%s:%u:%u).\n",
2658 OUR_HANDLE(r->in.handle)));
2659 return WERR_BADFID;
2660 }
2661
2662 Printer->notify.flags = r->in.flags;
2663 Printer->notify.options = r->in.options;
2664 Printer->notify.printerlocal = r->in.printer_local;
2665 Printer->notify.msg_ctx = p->msg_ctx;
2666
2667 TALLOC_FREE(Printer->notify.option);
2668 Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2669
2670 fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2671
2672 /* Connect to the client machine and send a ReplyOpenPrinter */
2673
2674 if ( Printer->printer_type == SPLHND_SERVER)
2675 snum = -1;
2676 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2677 !get_printer_snum(p, r->in.handle, &snum, NULL) )
2678 return WERR_BADFID;
2679
2680 DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2681 "client_address is %s\n", p->client_id->addr));
2682
2683 if (!interpret_string_addr(&client_ss, p->client_id->addr,
2684 AI_NUMERICHOST)) {
2685 return WERR_SERVER_UNAVAILABLE;
2686 }
2687
2688 if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2689 Printer->notify.printerlocal, REG_SZ,
2690 &Printer->notify.cli_hnd,
2691 &Printer->notify.cli_chan,
2692 &client_ss, p->msg_ctx)) {
2693 return WERR_SERVER_UNAVAILABLE;
2694 }
2695
2696 return WERR_OK;
2697 }
2698
2699 /*******************************************************************
2700 * fill a notify_info_data with the servername
2701 ********************************************************************/
2702
2703 static void spoolss_notify_server_name(struct messaging_context *msg_ctx,
2704 int snum,
2705 struct spoolss_Notify *data,
2706 print_queue_struct *queue,
2707 struct spoolss_PrinterInfo2 *pinfo2,
2708 TALLOC_CTX *mem_ctx)
2709 {
2710 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->servername);
2711 }
2712
2713 /*******************************************************************
2714 * fill a notify_info_data with the printername (not including the servername).
2715 ********************************************************************/
2716
2717 static void spoolss_notify_printer_name(struct messaging_context *msg_ctx,
2718 int snum,
2719 struct spoolss_Notify *data,
2720 print_queue_struct *queue,
2721 struct spoolss_PrinterInfo2 *pinfo2,
2722 TALLOC_CTX *mem_ctx)
2723 {
2724 /* the notify name should not contain the \\server\ part */
2725 const char *p = strrchr(pinfo2->printername, '\\');
2726
2727 if (!p) {
2728 p = pinfo2->printername;
2729 } else {
2730 p++;
2731 }
2732
2733 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2734 }
2735
2736 /*******************************************************************
2737 * fill a notify_info_data with the servicename
2738 ********************************************************************/
2739
2740 static void spoolss_notify_share_name(struct messaging_context *msg_ctx,
2741 int snum,
2742 struct spoolss_Notify *data,
2743 print_queue_struct *queue,
2744 struct spoolss_PrinterInfo2 *pinfo2,
2745 TALLOC_CTX *mem_ctx)
2746 {
2747 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2748 }
2749
2750 /*******************************************************************
2751 * fill a notify_info_data with the port name
2752 ********************************************************************/
2753
2754 static void spoolss_notify_port_name(struct messaging_context *msg_ctx,
2755 int snum,
2756 struct spoolss_Notify *data,
2757 print_queue_struct *queue,
2758 struct spoolss_PrinterInfo2 *pinfo2,
2759 TALLOC_CTX *mem_ctx)
2760 {
2761 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->portname);
2762 }
2763
2764 /*******************************************************************
2765 * fill a notify_info_data with the printername
2766 * but it doesn't exist, have to see what to do
2767 ********************************************************************/
2768
2769 static void spoolss_notify_driver_name(struct messaging_context *msg_ctx,
2770 int snum,
2771 struct spoolss_Notify *data,
2772 print_queue_struct *queue,
2773 struct spoolss_PrinterInfo2 *pinfo2,
2774 TALLOC_CTX *mem_ctx)
2775 {
2776 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->drivername);
2777 }
2778
2779 /*******************************************************************
2780 * fill a notify_info_data with the comment
2781 ********************************************************************/
2782
2783 static void spoolss_notify_comment(struct messaging_context *msg_ctx,
2784 int snum,
2785 struct spoolss_Notify *data,
2786 print_queue_struct *queue,
2787 struct spoolss_PrinterInfo2 *pinfo2,
2788 TALLOC_CTX *mem_ctx)
2789 {
2790 const char *p;
2791
2792 if (*pinfo2->comment == '\0') {
2793 p = lp_comment(snum);
2794 } else {
2795 p = pinfo2->comment;
2796 }
2797
2798 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2799 }
2800
2801 /*******************************************************************
2802 * fill a notify_info_data with the comment
2803 * location = "Room 1, floor 2, building 3"
2804 ********************************************************************/
2805
2806 static void spoolss_notify_location(struct messaging_context *msg_ctx,
2807 int snum,
2808 struct spoolss_Notify *data,
2809 print_queue_struct *queue,
2810 struct spoolss_PrinterInfo2 *pinfo2,
2811 TALLOC_CTX *mem_ctx)
2812 {
2813 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->location);
2814 }
2815
2816 /*******************************************************************
2817 * fill a notify_info_data with the device mode
2818 * jfm:xxxx don't to it for know but that's a real problem !!!
2819 ********************************************************************/
2820
2821 static void spoolss_notify_devmode(struct messaging_context *msg_ctx,
2822 int snum,
2823 struct spoolss_Notify *data,
2824 print_queue_struct *queue,
2825 struct spoolss_PrinterInfo2 *pinfo2,
2826 TALLOC_CTX *mem_ctx)
2827 {
2828 /* for a dummy implementation we have to zero the fields */
2829 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2830 }
2831
2832 /*******************************************************************
2833 * fill a notify_info_data with the separator file name
2834 ********************************************************************/
2835
2836 static void spoolss_notify_sepfile(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 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->sepfile);
2844 }
2845
2846 /*******************************************************************
2847 * fill a notify_info_data with the print processor
2848 * jfm:xxxx return always winprint to indicate we don't do anything to it
2849 ********************************************************************/
2850
2851 static void spoolss_notify_print_processor(struct messaging_context *msg_ctx,
2852 int snum,
2853 struct spoolss_Notify *data,
2854 print_queue_struct *queue,
2855 struct spoolss_PrinterInfo2 *pinfo2,
2856 TALLOC_CTX *mem_ctx)
2857 {
2858 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->printprocessor);
2859 }
2860
2861 /*******************************************************************
2862 * fill a notify_info_data with the print processor options
2863 * jfm:xxxx send an empty string
2864 ********************************************************************/
2865
2866 static void spoolss_notify_parameters(struct messaging_context *msg_ctx,
2867 int snum,
2868 struct spoolss_Notify *data,
2869 print_queue_struct *queue,
2870 struct spoolss_PrinterInfo2 *pinfo2,
2871 TALLOC_CTX *mem_ctx)
2872 {
2873 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->parameters);
2874 }
2875
2876 /*******************************************************************
2877 * fill a notify_info_data with the data type
2878 * jfm:xxxx always send RAW as data type
2879 ********************************************************************/
2880
2881 static void spoolss_notify_datatype(struct messaging_context *msg_ctx,
2882 int snum,
2883 struct spoolss_Notify *data,
2884 print_queue_struct *queue,
2885 struct spoolss_PrinterInfo2 *pinfo2,
2886 TALLOC_CTX *mem_ctx)
2887 {
2888 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, pinfo2->datatype);
2889 }
2890
2891 /*******************************************************************
2892 * fill a notify_info_data with the security descriptor
2893 * jfm:xxxx send an null pointer to say no security desc
2894 * have to implement security before !
2895 ********************************************************************/
2896
2897 static void spoolss_notify_security_desc(struct messaging_context *msg_ctx,
2898 int snum,
2899 struct spoolss_Notify *data,
2900 print_queue_struct *queue,
2901 struct spoolss_PrinterInfo2 *pinfo2,
2902 TALLOC_CTX *mem_ctx)
2903 {
2904 SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data, pinfo2->secdesc);
2905 }
2906
2907 /*******************************************************************
2908 * fill a notify_info_data with the attributes
2909 * jfm:xxxx a samba printer is always shared
2910 ********************************************************************/
2911
2912 static void spoolss_notify_attributes(struct messaging_context *msg_ctx,
2913 int snum,
2914 struct spoolss_Notify *data,
2915 print_queue_struct *queue,
2916 struct spoolss_PrinterInfo2 *pinfo2,
2917 TALLOC_CTX *mem_ctx)
2918 {
2919 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->attributes);
2920 }
2921
2922 /*******************************************************************
2923 * fill a notify_info_data with the priority
2924 ********************************************************************/
2925
2926 static void spoolss_notify_priority(struct messaging_context *msg_ctx,
2927 int snum,
2928 struct spoolss_Notify *data,
2929 print_queue_struct *queue,
2930 struct spoolss_PrinterInfo2 *pinfo2,
2931 TALLOC_CTX *mem_ctx)
2932 {
2933 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->priority);
2934 }
2935
2936 /*******************************************************************
2937 * fill a notify_info_data with the default priority
2938 ********************************************************************/
2939
2940 static void spoolss_notify_default_priority(struct messaging_context *msg_ctx,
2941 int snum,
2942 struct spoolss_Notify *data,
2943 print_queue_struct *queue,
2944 struct spoolss_PrinterInfo2 *pinfo2,
2945 TALLOC_CTX *mem_ctx)
2946 {
2947 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->defaultpriority);
2948 }
2949
2950 /*******************************************************************
2951 * fill a notify_info_data with the start time
2952 ********************************************************************/
2953
2954 static void spoolss_notify_start_time(struct messaging_context *msg_ctx,
2955 int snum,
2956 struct spoolss_Notify *data,
2957 print_queue_struct *queue,
2958 struct spoolss_PrinterInfo2 *pinfo2,
2959 TALLOC_CTX *mem_ctx)
2960 {
2961 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->starttime);
2962 }
2963
2964 /*******************************************************************
2965 * fill a notify_info_data with the until time
2966 ********************************************************************/
2967
2968 static void spoolss_notify_until_time(struct messaging_context *msg_ctx,
2969 int snum,
2970 struct spoolss_Notify *data,
2971 print_queue_struct *queue,
2972 struct spoolss_PrinterInfo2 *pinfo2,
2973 TALLOC_CTX *mem_ctx)
2974 {
2975 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->untiltime);
2976 }
2977
2978 /*******************************************************************
2979 * fill a notify_info_data with the status
2980 ********************************************************************/
2981
2982 static void spoolss_notify_status(struct messaging_context *msg_ctx,
2983 int snum,
2984 struct spoolss_Notify *data,
2985 print_queue_struct *queue,
2986 struct spoolss_PrinterInfo2 *pinfo2,
2987 TALLOC_CTX *mem_ctx)
2988 {
2989 print_status_struct status;
2990
2991 print_queue_length(msg_ctx, snum, &status);
2992 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
2993 }
2994
2995 /*******************************************************************
2996 * fill a notify_info_data with the number of jobs queued
2997 ********************************************************************/
2998
2999 static void spoolss_notify_cjobs(struct messaging_context *msg_ctx,
3000 int snum,
3001 struct spoolss_Notify *data,
3002 print_queue_struct *queue,
3003 struct spoolss_PrinterInfo2 *pinfo2,
3004 TALLOC_CTX *mem_ctx)
3005 {
3006 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(
3007 data, print_queue_length(msg_ctx, snum, NULL));
3008 }
3009
3010 /*******************************************************************
3011 * fill a notify_info_data with the average ppm
3012 ********************************************************************/
3013
3014 static void spoolss_notify_average_ppm(struct messaging_context *msg_ctx,
3015 int snum,
3016 struct spoolss_Notify *data,
3017 print_queue_struct *queue,
3018 struct spoolss_PrinterInfo2 *pinfo2,
3019 TALLOC_CTX *mem_ctx)
3020 {
3021 /* always respond 8 pages per minutes */
3022 /* a little hard ! */
3023 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, pinfo2->averageppm);
3024 }
3025
3026 /*******************************************************************
3027 * fill a notify_info_data with username
3028 ********************************************************************/
3029
3030 static void spoolss_notify_username(struct messaging_context *msg_ctx,
3031 int snum,
3032 struct spoolss_Notify *data,
3033 print_queue_struct *queue,
3034 struct spoolss_PrinterInfo2 *pinfo2,
3035 TALLOC_CTX *mem_ctx)
3036 {
3037 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3038 }
3039
3040 /*******************************************************************
3041 * fill a notify_info_data with job status
3042 ********************************************************************/
3043
3044 static void spoolss_notify_job_status(struct messaging_context *msg_ctx,
3045 int snum,
3046 struct spoolss_Notify *data,
3047 print_queue_struct *queue,
3048 struct spoolss_PrinterInfo2 *pinfo2,
3049 TALLOC_CTX *mem_ctx)
3050 {
3051 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3052 }
3053
3054 /*******************************************************************
3055 * fill a notify_info_data with job name
3056 ********************************************************************/
3057
3058 static void spoolss_notify_job_name(struct messaging_context *msg_ctx,
3059 int snum,
3060 struct spoolss_Notify *data,
3061 print_queue_struct *queue,
3062 struct spoolss_PrinterInfo2 *pinfo2,
3063 TALLOC_CTX *mem_ctx)
3064 {
3065 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3066 }
3067
3068 /*******************************************************************
3069 * fill a notify_info_data with job status
3070 ********************************************************************/
3071
3072 static void spoolss_notify_job_status_string(struct messaging_context *msg_ctx,
3073 int snum,
3074 struct spoolss_Notify *data,
3075 print_queue_struct *queue,
3076 struct spoolss_PrinterInfo2 *pinfo2,
3077 TALLOC_CTX *mem_ctx)
3078 {
3079 /*
3080 * Now we're returning job status codes we just return a "" here. JRA.
3081 */
3082
3083 const char *p = "";
3084
3085 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3086 p = "unknown";
3087
3088 switch (queue->status) {
3089 case LPQ_QUEUED:
3090 p = "Queued";
3091 break;
3092 case LPQ_PAUSED:
3093 p = ""; /* NT provides the paused string */
3094 break;
3095 case LPQ_SPOOLING:
3096 p = "Spooling";
3097 break;
3098 case LPQ_PRINTING:
3099 p = "Printing";
3100 break;
3101 }
3102 #endif /* NO LONGER NEEDED. */
3103
3104 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3105 }
3106
3107 /*******************************************************************
3108 * fill a notify_info_data with job time
3109 ********************************************************************/
3110
3111 static void spoolss_notify_job_time(struct messaging_context *msg_ctx,
3112 int snum,
3113 struct spoolss_Notify *data,
3114 print_queue_struct *queue,
3115 struct spoolss_PrinterInfo2 *pinfo2,
3116 TALLOC_CTX *mem_ctx)
3117 {
3118 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3119 }
3120
3121 /*******************************************************************
3122 * fill a notify_info_data with job size
3123 ********************************************************************/
3124
3125 static void spoolss_notify_job_size(struct messaging_context *msg_ctx,
3126 int snum,
3127 struct spoolss_Notify *data,
3128 print_queue_struct *queue,
3129 struct spoolss_PrinterInfo2 *pinfo2,
3130 TALLOC_CTX *mem_ctx)
3131 {
3132 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3133 }
3134
3135 /*******************************************************************
3136 * fill a notify_info_data with page info
3137 ********************************************************************/
3138 static void spoolss_notify_total_pages(struct messaging_context *msg_ctx,
3139 int snum,
3140 struct spoolss_Notify *data,
3141 print_queue_struct *queue,
3142 struct spoolss_PrinterInfo2 *pinfo2,
3143 TALLOC_CTX *mem_ctx)
3144 {
3145 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3146 }
3147
3148 /*******************************************************************
3149 * fill a notify_info_data with pages printed info.
3150 ********************************************************************/
3151 static void spoolss_notify_pages_printed(struct messaging_context *msg_ctx,
3152 int snum,
3153 struct spoolss_Notify *data,
3154 print_queue_struct *queue,
3155 struct spoolss_PrinterInfo2 *pinfo2,
3156 TALLOC_CTX *mem_ctx)
3157 {
3158 /* Add code when back-end tracks this */
3159 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3160 }
3161
3162 /*******************************************************************
3163 Fill a notify_info_data with job position.
3164 ********************************************************************/
3165
3166 static void spoolss_notify_job_position(struct messaging_context *msg_ctx,
3167 int snum,
3168 struct spoolss_Notify *data,
3169 print_queue_struct *queue,
3170 struct spoolss_PrinterInfo2 *pinfo2,
3171 TALLOC_CTX *mem_ctx)
3172 {
3173 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3174 }
3175
3176 /*******************************************************************
3177 Fill a notify_info_data with submitted time.
3178 ********************************************************************/
3179
3180 static void spoolss_notify_submitted_time(struct messaging_context *msg_ctx,
3181 int snum,
3182 struct spoolss_Notify *data,
3183 print_queue_struct *queue,
3184 struct spoolss_PrinterInfo2 *pinfo2,
3185 TALLOC_CTX *mem_ctx)
3186 {
3187 data->data.string.string = NULL;
3188 data->data.string.size = 0;
3189
3190 init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3191 &data->data.string.string,
3192 &data->data.string.size);
3193
3194 }
3195
3196 struct s_notify_info_data_table
3197 {
3198 enum spoolss_NotifyType type;
3199 uint16_t field;
3200 const char *name;
3201 enum spoolss_NotifyTable variable_type;
3202 void (*fn) (struct messaging_context *msg_ctx,
3203 int snum, struct spoolss_Notify *data,
3204 print_queue_struct *queue,
3205 struct spoolss_PrinterInfo2 *pinfo2,
3206 TALLOC_CTX *mem_ctx);
3207 };
3208
3209 /* A table describing the various print notification constants and
3210 whether the notification data is a pointer to a variable sized
3211 buffer, a one value uint32_t or a two value uint32_t. */
3212
3213 static const struct s_notify_info_data_table notify_info_data_table[] =
3214 {
3215 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3216 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3217 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_share_name },
3218 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3219 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3220 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING, spoolss_notify_comment },
3221 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING, spoolss_notify_location },
3222 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3223 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING, spoolss_notify_sepfile },
3224 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3225 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3226 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3227 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, spoolss_notify_security_desc },
3228 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD, spoolss_notify_attributes },
3229 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3230 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_default_priority },
3231 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3232 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3233 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_status },
3234 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, NULL },
3235 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD, spoolss_notify_cjobs },
3236 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD, spoolss_notify_average_ppm },
3237 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, NULL },
3238 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3239 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, NULL },
3240 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3241 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINTER_NAME, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3242 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_MACHINE_NAME, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3243 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PORT_NAME, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3244 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3245 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_NOTIFY_NAME, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3246 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DATATYPE, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3247 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINT_PROCESSOR, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3248 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PARAMETERS, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3249 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DRIVER_NAME, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3250 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DEVMODE, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3251 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_job_status },
3252 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS_STRING, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, spoolss_notify_job_status_string },
3253 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, NULL },
3254 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING, spoolss_notify_job_name },
3255 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRIORITY, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3256 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_POSITION, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD, spoolss_notify_job_position },
3257 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME, spoolss_notify_submitted_time },
3258 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_START_TIME, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3259 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_UNTIL_TIME, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3260 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TIME, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_job_time },
3261 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_PAGES, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, spoolss_notify_total_pages },
3262 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PAGES_PRINTED, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, spoolss_notify_pages_printed },
3263 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_BYTES, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, spoolss_notify_job_size },
3264 };
3265
3266 /*******************************************************************
3267 Return the variable_type of info_data structure.
3268 ********************************************************************/
3269
3270 static enum spoolss_NotifyTable variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3271 uint16_t field)
3272 {
3273 int i=0;
3274
3275 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3276 if ( (notify_info_data_table[i].type == type) &&
3277 (notify_info_data_table[i].field == field) ) {
3278 return notify_info_data_table[i].variable_type;
3279 }
3280 }
3281
3282 DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3283
3284 return (enum spoolss_NotifyTable) 0;
3285 }
3286
3287 /****************************************************************************
3288 ****************************************************************************/
3289
3290 static bool search_notify(enum spoolss_NotifyType type,
3291 uint16_t field,
3292 int *value)
3293 {
3294 int i;
3295
3296 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3297 if (notify_info_data_table[i].type == type &&
3298 notify_info_data_table[i].field == field &&
3299 notify_info_data_table[i].fn != NULL) {
3300 *value = i;
3301 return true;
3302 }
3303 }
3304
3305 return false;
3306 }
3307
3308 /****************************************************************************
3309 ****************************************************************************/
3310
3311 static void construct_info_data(struct spoolss_Notify *info_data,
3312 enum spoolss_NotifyType type,
3313 uint16_t field, int id)
3314 {
3315 info_data->type = type;
3316 info_data->field.field = field;
3317 info_data->variable_type = variable_type_of_notify_info_data(type, field);
3318 info_data->job_id = id;
3319 }
3320
3321 /*******************************************************************
3322 *
3323 * fill a notify_info struct with info asked
3324 *
3325 ********************************************************************/
3326
3327 static bool construct_notify_printer_info(struct messaging_context *msg_ctx,
3328 struct printer_handle *print_hnd,
3329 struct spoolss_NotifyInfo *info,
3330 struct spoolss_PrinterInfo2 *pinfo2,
3331 int snum,
3332 const struct spoolss_NotifyOptionType *option_type,
3333 uint32_t id,
3334 TALLOC_CTX *mem_ctx)
3335 {
3336 int field_num,j;
3337 enum spoolss_NotifyType type;
3338 uint16_t field;
3339
3340 struct spoolss_Notify *current_data;
3341 print_queue_struct *queue=NULL;
3342
3343 type = option_type->type;
3344
3345 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3346 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3347 option_type->count, lp_servicename(snum)));
3348
3349 for(field_num=0; field_num < option_type->count; field_num++) {
3350 field = option_type->fields[field_num].field;
3351
3352 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3353
3354 if (!search_notify(type, field, &j) )
3355 continue;
3356
3357 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3358 struct spoolss_Notify,
3359 info->count + 1);
3360 if (info->notifies == NULL) {
3361 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3362 return false;
3363 }
3364
3365 current_data = &info->notifies[info->count];
3366
3367 construct_info_data(current_data, type, field, id);
3368
3369 DEBUG(10, ("construct_notify_printer_info: "
3370 "calling [%s] snum=%d printername=[%s])\n",
3371 notify_info_data_table[j].name, snum,
3372 pinfo2->printername));
3373
3374 notify_info_data_table[j].fn(msg_ctx, snum, current_data,
3375 queue, pinfo2, mem_ctx);
3376
3377 info->count++;
3378 }
3379
3380 return true;
3381 }
3382
3383 /*******************************************************************
3384 *
3385 * fill a notify_info struct with info asked
3386 *
3387 ********************************************************************/
3388
3389 static bool construct_notify_jobs_info(struct messaging_context *msg_ctx,
3390 print_queue_struct *queue,
3391 struct spoolss_NotifyInfo *info,
3392 struct spoolss_PrinterInfo2 *pinfo2,
3393 int snum,
3394 const struct spoolss_NotifyOptionType *option_type,
3395 uint32_t id,
3396 TALLOC_CTX *mem_ctx)
3397 {
3398 int field_num,j;
3399 enum spoolss_NotifyType type;
3400 uint16_t field;
3401 struct spoolss_Notify *current_data;
3402
3403 DEBUG(4,("construct_notify_jobs_info\n"));
3404
3405 type = option_type->type;
3406
3407 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3408 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3409 option_type->count));
3410
3411 for(field_num=0; field_num<option_type->count; field_num++) {
3412 field = option_type->fields[field_num].field;
3413
3414 if (!search_notify(type, field, &j) )
3415 continue;
3416
3417 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3418 struct spoolss_Notify,
3419 info->count + 1);
3420 if (info->notifies == NULL) {
3421 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3422 return false;
3423 }
3424
3425 current_data=&(info->notifies[info->count]);
3426
3427 construct_info_data(current_data, type, field, id);
3428 notify_info_data_table[j].fn(msg_ctx, snum, current_data,
3429 queue, pinfo2, mem_ctx);
3430 info->count++;
3431 }
3432
3433 return true;
3434 }
3435
3436 /*
3437 * JFM: The enumeration is not that simple, it's even non obvious.
3438 *
3439 * let's take an example: I want to monitor the PRINTER SERVER for
3440 * the printer's name and the number of jobs currently queued.
3441 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3442 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3443 *
3444 * I have 3 printers on the back of my server.
3445 *
3446 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3447 * structures.
3448 * Number Data Id
3449 * 1 printer 1 name 1
3450 * 2 printer 1 cjob 1
3451 * 3 printer 2 name 2
3452 * 4 printer 2 cjob 2
3453 * 5 printer 3 name 3
3454 * 6 printer 3 name 3
3455 *
3456 * that's the print server case, the printer case is even worse.
3457 */
3458
3459 /*******************************************************************
3460 *
3461 * enumerate all printers on the printserver
3462 * fill a notify_info struct with info asked
3463 *
3464 ********************************************************************/
3465
3466 static WERROR printserver_notify_info(struct pipes_struct *p,
3467 struct policy_handle *hnd,
3468 struct spoolss_NotifyInfo *info,
3469 TALLOC_CTX *mem_ctx)
3470 {
3471 int snum;
3472 struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
3473 int n_services=lp_numservices();
3474 int i;
3475 struct spoolss_NotifyOption *option;
3476 struct spoolss_NotifyOptionType option_type;
3477 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3478 WERROR result;
3479
3480 DEBUG(4,("printserver_notify_info\n"));
3481
3482 if (!Printer)
3483 return WERR_BADFID;
3484
3485 option = Printer->notify.option;
3486
3487 info->version = 2;
3488 info->notifies = NULL;
3489 info->count = 0;
3490
3491 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3492 sending a ffpcn() request first */
3493
3494 if ( !option )
3495 return WERR_BADFID;
3496
3497 for (i=0; i<option->count; i++) {
3498 option_type = option->types[i];
3499
3500 if (option_type.type != PRINTER_NOTIFY_TYPE)
3501 continue;
3502
3503 for (snum = 0; snum < n_services; snum++) {
3504 if (!lp_browseable(snum) ||
3505 !lp_snum_ok(snum) ||
3506 !lp_print_ok(snum)) {
3507 continue; /* skip */
3508 }
3509
3510 /* Maybe we should use the SYSTEM server_info here... */
3511 result = winreg_get_printer(mem_ctx,
3512 get_server_info_system(),
3513 p->msg_ctx,
3514 Printer->servername,
3515 lp_servicename(snum),
3516 &pinfo2);
3517 if (!W_ERROR_IS_OK(result)) {
3518 DEBUG(4, ("printserver_notify_info: "
3519 "Failed to get printer [%s]\n",
3520 lp_servicename(snum)));
3521 continue;
3522 }
3523
3524
3525 construct_notify_printer_info(p->msg_ctx,
3526 Printer, info,
3527 pinfo2, snum,
3528 &option_type, snum,
3529 mem_ctx);
3530
3531 TALLOC_FREE(pinfo2);
3532 }
3533 }
3534
3535 #if 0
3536 /*
3537 * Debugging information, don't delete.
3538 */
3539
3540 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3541 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3542 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3543
3544 for (i=0; i<info->count; i++) {
3545 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3546 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3547 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3548 }
3549 #endif
3550
3551 return WERR_OK;
3552 }
3553
3554 /*******************************************************************
3555 *
3556 * fill a notify_info struct with info asked
3557 *
3558 ********************************************************************/
3559
3560 static WERROR printer_notify_info(struct pipes_struct *p,
3561 struct policy_handle *hnd,
3562 struct spoolss_NotifyInfo *info,
3563 TALLOC_CTX *mem_ctx)
3564 {
3565 int snum;
3566 struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
3567 int i;
3568 uint32_t id;
3569 struct spoolss_NotifyOption *option;
3570 struct spoolss_NotifyOptionType option_type;
3571 int count,j;
3572 print_queue_struct *queue=NULL;
3573 print_status_struct status;
3574 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
3575 WERROR result;
3576
3577 DEBUG(4,("printer_notify_info\n"));
3578
3579 if (!Printer)
3580 return WERR_BADFID;
3581
3582 option = Printer->notify.option;
3583 id = 0x0;
3584
3585 info->version = 2;
3586 info->notifies = NULL;
3587 info->count = 0;
3588
3589 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3590 sending a ffpcn() request first */
3591
3592 if ( !option )
3593 return WERR_BADFID;
3594
3595 get_printer_snum(p, hnd, &snum, NULL);
3596
3597 /* Maybe we should use the SYSTEM server_info here... */
3598 result = winreg_get_printer(mem_ctx,
3599 get_server_info_system(),
3600 p->msg_ctx,
3601 Printer->servername,
3602 lp_servicename(snum), &pinfo2);
3603 if (!W_ERROR_IS_OK(result)) {
3604 return WERR_BADFID;
3605 }
3606
3607 for (i=0; i<option->count; i++) {
3608 option_type = option->types[i];
3609
3610 switch (option_type.type) {
3611 case PRINTER_NOTIFY_TYPE:
3612 if (construct_notify_printer_info(p->msg_ctx,
3613 Printer, info,
3614 pinfo2, snum,
3615 &option_type, id,
3616 mem_ctx)) {
3617 id--;
3618 }
3619 break;
3620
3621 case JOB_NOTIFY_TYPE:
3622
3623 count = print_queue_status(p->msg_ctx, snum, &queue,
3624 &status);
3625
3626 for (j=0; j<count; j++) {
3627 construct_notify_jobs_info(p->msg_ctx,
3628 &queue[j], info,
3629 pinfo2, snum,
3630 &option_type,
3631 queue[j].job,
3632 mem_ctx);
3633 }
3634
3635 SAFE_FREE(queue);
3636 break;
3637 }
3638 }
3639
3640 /*
3641 * Debugging information, don't delete.
3642 */
3643 /*
3644 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3645 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3646 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3647
3648 for (i=0; i<info->count; i++) {
3649 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3650 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3651 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3652 }
3653 */
3654
3655 talloc_free(pinfo2);
3656 return WERR_OK;
3657 }
3658
3659 /****************************************************************
3660 _spoolss_RouterRefreshPrinterChangeNotify
3661 ****************************************************************/
3662
3663 WERROR _spoolss_RouterRefreshPrinterChangeNotify(struct pipes_struct *p,
3664 struct spoolss_RouterRefreshPrinterChangeNotify *r)
3665 {
3666 struct spoolss_NotifyInfo *info;
3667
3668 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
3669 WERROR result = WERR_BADFID;
3670
3671 /* we always have a spoolss_NotifyInfo struct */
3672 info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3673 if (!info) {
3674 result = WERR_NOMEM;
3675 goto done;
3676 }
3677
3678 *r->out.info = info;
3679
3680 if (!Printer) {
3681 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3682 "Invalid handle (%s:%u:%u).\n",
3683 OUR_HANDLE(r->in.handle)));
3684 goto done;
3685 }
3686
3687 DEBUG(4,("Printer type %x\n",Printer->printer_type));
3688
3689 /*
3690 * We are now using the change value, and
3691 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3692 * I don't have a global notification system, I'm sending back all the
3693 * informations even when _NOTHING_ has changed.
3694 */
3695
3696 /* We need to keep track of the change value to send back in
3697 RRPCN replies otherwise our updates are ignored. */
3698
3699 Printer->notify.fnpcn = true;
3700
3701 if (Printer->notify.cli_chan != NULL &&
3702 Printer->notify.cli_chan->active_connections > 0) {
3703 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3704 "Saving change value in request [%x]\n",
3705 r->in.change_low));
3706 Printer->notify.change = r->in.change_low;
3707 }
3708
3709 /* just ignore the spoolss_NotifyOption */
3710
3711 switch (Printer->printer_type) {
3712 case SPLHND_SERVER:
3713 result = printserver_notify_info(p, r->in.handle,
3714 info, p->mem_ctx);
3715 break;
3716
3717 case SPLHND_PRINTER:
3718 result = printer_notify_info(p, r->in.handle,
3719 info, p->mem_ctx);
3720 break;
3721 }
3722
3723 Printer->notify.fnpcn = false;
3724
3725 done:
3726 return result;
3727 }
3728
3729 /********************************************************************
3730 * construct_printer_info_0
3731 * fill a printer_info_0 struct
3732 ********************************************************************/
3733
3734 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3735 const struct auth_serversupplied_info *server_info,
3736 struct messaging_context *msg_ctx,
3737 struct spoolss_PrinterInfo2 *info2,
3738 struct spoolss_PrinterInfo0 *r,
3739 int snum)
3740 {
3741 int count;
3742 struct printer_session_counter *session_counter;
3743 struct timeval setuptime;
3744 print_status_struct status;
3745
3746 r->printername = talloc_strdup(mem_ctx, info2->printername);
3747 W_ERROR_HAVE_NO_MEMORY(r->printername);
3748
3749 r->servername = talloc_strdup(mem_ctx, info2->servername);
3750 W_ERROR_HAVE_NO_MEMORY(r->servername);
3751
3752 count = print_queue_length(msg_ctx, snum, &status);
3753
3754 /* check if we already have a counter for this printer */
3755 for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3756 if (session_counter->snum == snum)
3757 break;
3758 }
3759
3760 /* it's the first time, add it to the list */
3761 if (session_counter == NULL) {
3762 session_counter = talloc_zero(counter_list, struct printer_session_counter);
3763 W_ERROR_HAVE_NO_MEMORY(session_counter);
3764 session_counter->snum = snum;
3765 session_counter->counter = 0;
3766 DLIST_ADD(counter_list, session_counter);
3767 }
3768
3769 /* increment it */
3770 session_counter->counter++;
3771
3772 r->cjobs = count;
3773 r->total_jobs = 0;
3774 r->total_bytes = 0;
3775
3776 get_startup_time(&setuptime);
3777 init_systemtime(&r->time, gmtime(&setuptime.tv_sec));
3778
3779 /* JFM:
3780 * the global_counter should be stored in a TDB as it's common to all the clients
3781 * and should be zeroed on samba startup
3782 */
3783 r->global_counter = session_counter->counter;
3784 r->total_pages = 0;
3785 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3786 SSVAL(&r->version, 0, 0x0005); /* NT 5 */
3787 SSVAL(&r->version, 2, 0x0893); /* build 2195 */
3788 r->free_build = SPOOLSS_RELEASE_BUILD;
3789 r->spooling = 0;
3790 r->max_spooling = 0;
3791 r->session_counter = session_counter->counter;
3792 r->num_error_out_of_paper = 0x0;
3793 r->num_error_not_ready = 0x0; /* number of print failure */
3794 r->job_error = 0x0;
3795 r->number_of_processors = 0x1;
3796 r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3797 r->high_part_total_bytes = 0x0;
3798
3799 /* ChangeID in milliseconds*/
3800 winreg_printer_get_changeid(mem_ctx, server_info, msg_ctx,
3801 info2->sharename, &r->change_id);
3802
3803 r->last_error = WERR_OK;
3804 r->status = nt_printq_status(status.status);
3805 r->enumerate_network_printers = 0x0;
3806 r->c_setprinter = 0x0;
3807 r->processor_architecture = PROCESSOR_ARCHITECTURE_INTEL;
3808 r->processor_level = 0x6; /* 6 ???*/
3809 r->ref_ic = 0;
3810 r->reserved2 = 0;
3811 r->reserved3 = 0;
3812
3813 return WERR_OK;
3814 }
3815
3816
3817 /********************************************************************
3818 * construct_printer_info1
3819 * fill a spoolss_PrinterInfo1 struct
3820 ********************************************************************/
3821
3822 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
3823 const struct spoolss_PrinterInfo2 *info2,
3824 uint32_t flags,
3825 struct spoolss_PrinterInfo1 *r,
3826 int snum)
3827 {
3828 r->flags = flags;
3829
3830 r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
3831 info2->printername,
3832 info2->drivername,
3833 info2->location);
3834 W_ERROR_HAVE_NO_MEMORY(r->description);
3835
3836 if (info2->comment == NULL || info2->comment[0] == '\0') {
3837 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
3838 } else {
3839 r->comment = talloc_strdup(mem_ctx, info2->comment); /* saved comment */
3840 }
3841 W_ERROR_HAVE_NO_MEMORY(r->comment);
3842
3843 r->name = talloc_strdup(mem_ctx, info2->printername);
3844 W_ERROR_HAVE_NO_MEMORY(r->name);
3845
3846 return WERR_OK;
3847 }
3848
3849 /********************************************************************
3850 * construct_printer_info2
3851 * fill a spoolss_PrinterInfo2 struct
3852 ********************************************************************/
3853
3854 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
3855 struct messaging_context *msg_ctx,
3856 const struct spoolss_PrinterInfo2 *info2,
3857 struct spoolss_PrinterInfo2 *r,
3858 int snum)
3859 {
3860 int count;
3861 print_status_struct status;
3862
3863 count = print_queue_length(msg_ctx, snum, &status);
3864
3865 r->servername = talloc_strdup(mem_ctx, info2->servername);
3866 W_ERROR_HAVE_NO_MEMORY(r->servername);
3867 r->printername = talloc_strdup(mem_ctx, info2->printername);
3868 W_ERROR_HAVE_NO_MEMORY(r->printername);
3869 r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
3870 W_ERROR_HAVE_NO_MEMORY(r->sharename);
3871 r->portname = talloc_strdup(mem_ctx, info2->portname);
3872 W_ERROR_HAVE_NO_MEMORY(r->portname);
3873 r->drivername = talloc_strdup(mem_ctx, info2->drivername);
3874 W_ERROR_HAVE_NO_MEMORY(r->drivername);
3875
3876 if (info2->comment[0] == '\0') {
3877 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
3878 } else {
3879 r->comment = talloc_strdup(mem_ctx, info2->comment);
3880 }
3881 W_ERROR_HAVE_NO_MEMORY(r->comment);
3882
3883 r->location = talloc_strdup(mem_ctx, info2->location);
3884 W_ERROR_HAVE_NO_MEMORY(r->location);
3885 r->sepfile = talloc_strdup(mem_ctx, info2->sepfile);
3886 W_ERROR_HAVE_NO_MEMORY(r->sepfile);
3887 r->printprocessor = talloc_strdup(mem_ctx, info2->printprocessor);
3888 W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
3889 r->datatype = talloc_strdup(mem_ctx, info2->datatype);
3890 W_ERROR_HAVE_NO_MEMORY(r->datatype);
3891 r->parameters = talloc_strdup(mem_ctx, info2->parameters);
3892 W_ERROR_HAVE_NO_MEMORY(r->parameters);
3893
3894 r->attributes = info2->attributes;
3895
3896 r->priority = info2->priority;
3897 r->defaultpriority = info2->defaultpriority;
3898 r->starttime = info2->starttime;
3899 r->untiltime = info2->untiltime;
3900 r->status = nt_printq_status(status.status);
3901 r->cjobs = count;
3902 r->averageppm = info2->averageppm;
3903
3904 copy_devicemode(mem_ctx, info2->devmode, &r->devmode);
3905 if (!r->devmode) {
3906 DEBUG(8,("Returning NULL Devicemode!\n"));
3907 }
3908
3909 r->secdesc = NULL;
3910
3911 if (info2->secdesc != NULL) {
3912 /* don't use talloc_steal() here unless you do a deep steal of all
3913 the SEC_DESC members */
3914
3915 r->secdesc = dup_sec_desc(mem_ctx, info2->secdesc);
3916 }
3917
3918 return WERR_OK;
3919 }
3920
3921 /********************************************************************
3922 * construct_printer_info3
3923 * fill a spoolss_PrinterInfo3 struct
3924 ********************************************************************/
3925
3926 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3927 const struct spoolss_PrinterInfo2 *info2,
3928 struct spoolss_PrinterInfo3 *r,
3929 int snum)
3930 {
3931 /* These are the components of the SD we are returning. */
3932
3933 if (info2->secdesc != NULL) {
3934 /* don't use talloc_steal() here unless you do a deep steal of all
3935 the SEC_DESC members */
3936
3937 r->secdesc = dup_sec_desc(mem_ctx, info2->secdesc);
3938 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3939 }
3940
3941 return WERR_OK;
3942 }
3943
3944 /********************************************************************
3945 * construct_printer_info4
3946 * fill a spoolss_PrinterInfo4 struct
3947 ********************************************************************/
3948
3949 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
3950 const struct spoolss_PrinterInfo2 *info2,
3951 struct spoolss_PrinterInfo4 *r,
3952 int snum)
3953 {
3954 r->printername = talloc_strdup(mem_ctx, info2->printername);
3955 W_ERROR_HAVE_NO_MEMORY(r->printername);
3956 r->servername = talloc_strdup(mem_ctx, info2->servername);
3957 W_ERROR_HAVE_NO_MEMORY(r->servername);
3958
3959 r->attributes = info2->attributes;
3960
3961 return WERR_OK;
3962 }
3963
3964 /********************************************************************
3965 * construct_printer_info5
3966 * fill a spoolss_PrinterInfo5 struct
3967 ********************************************************************/
3968
3969 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
3970 const struct spoolss_PrinterInfo2 *info2,
3971 struct spoolss_PrinterInfo5 *r,
3972 int snum)
3973 {
3974 r->printername = talloc_strdup(mem_ctx, info2->printername);
3975 W_ERROR_HAVE_NO_MEMORY(r->printername);
3976 r->portname = talloc_strdup(mem_ctx, info2->portname);
3977 W_ERROR_HAVE_NO_MEMORY(r->portname);
3978
3979 r->attributes = info2->attributes;
3980
3981 /* these two are not used by NT+ according to MSDN */
3982 r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
3983 r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
3984
3985 return WERR_OK;
3986 }
3987
3988 /********************************************************************
3989 * construct_printer_info_6
3990 * fill a spoolss_PrinterInfo6 struct
3991 ********************************************************************/
3992
3993 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
3994 struct messaging_context *msg_ctx,
3995 const struct spoolss_PrinterInfo2 *info2,
3996 struct spoolss_PrinterInfo6 *r,
3997 int snum)
3998 {
3999 int count;
4000 print_status_struct status;
4001
4002 count = print_queue_length(msg_ctx, snum, &status);
4003
4004 r->status = nt_printq_status(status.status);
4005
4006 return WERR_OK;
4007 }
4008
4009 /********************************************************************
4010 * construct_printer_info7
4011 * fill a spoolss_PrinterInfo7 struct
4012 ********************************************************************/
4013
4014 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4015 struct messaging_context *msg_ctx,
4016 struct printer_handle *print_hnd,
4017 struct spoolss_PrinterInfo7 *r,
4018 int snum)
4019 {
4020 struct auth_serversupplied_info *server_info;
4021 struct GUID guid;
4022 NTSTATUS status;
4023
4024 status = make_server_info_system(mem_ctx, &server_info);
4025 if (!NT_STATUS_IS_OK(status)) {
4026 DEBUG(0, ("construct_printer_info7: "
4027 "Could not create system server_info\n"));
4028 return WERR_NOMEM;
4029 }
4030
4031 if (is_printer_published(mem_ctx, server_info, msg_ctx,
4032 print_hnd->servername,
4033 lp_servicename(snum), &guid, NULL)) {
4034 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
4035 r->action = DSPRINT_PUBLISH;
4036 } else {
4037 r->guid = talloc_strdup(mem_ctx, "");
4038 r->action = DSPRINT_UNPUBLISH;
4039 }
4040 W_ERROR_HAVE_NO_MEMORY(r->guid);
4041
4042 TALLOC_FREE(server_info);
4043 return WERR_OK;
4044 }
4045
4046 /********************************************************************
4047 * construct_printer_info8
4048 * fill a spoolss_PrinterInfo8 struct
4049 ********************************************************************/
4050
4051 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4052 const struct spoolss_PrinterInfo2 *info2,
4053 struct spoolss_DeviceModeInfo *r,
4054 int snum)
4055 {
4056 copy_devicemode(mem_ctx, info2->devmode, &r->devmode);
4057 if (!r->devmode) {
4058 DEBUG(8,("Returning NULL Devicemode!\n"));
4059 }
4060
4061 return WERR_OK;
4062 }
4063
4064
4065 /********************************************************************
4066 ********************************************************************/
4067
4068 static bool snum_is_shared_printer(int snum)
4069 {
4070 return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
4071 }
4072
4073 /********************************************************************
4074 Spoolss_enumprinters.
4075 ********************************************************************/
4076
4077 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4078 const struct auth_serversupplied_info *server_info,
4079 struct messaging_context *msg_ctx,
4080 uint32_t level,
4081 uint32_t flags,
4082 union spoolss_PrinterInfo **info_p,
4083 uint32_t *count_p)
4084 {
4085 int snum;
4086 int n_services = lp_numservices();
4087 union spoolss_PrinterInfo *info = NULL;
4088 uint32_t count = 0;
4089 WERROR result = WERR_OK;
4090
4091 *count_p = 0;
4092 *info_p = NULL;
4093
4094 for (snum = 0; snum < n_services; snum++) {
4095
4096 const char *printer;
4097 struct spoolss_PrinterInfo2 *info2;
4098
4099 if (!snum_is_shared_printer(snum)) {
4100 continue;
4101 }
4102
4103 printer = lp_const_servicename(snum);
4104
4105 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4106 printer, snum));
4107
4108 result = winreg_create_printer(mem_ctx,
4109 server_info,
4110 msg_ctx,
4111 NULL,
4112 printer);
4113 if (!W_ERROR_IS_OK(result)) {
4114 goto out;
4115 }
4116
4117 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4118 union spoolss_PrinterInfo,
4119 count + 1);
4120 if (!info) {
4121 result = WERR_NOMEM;
4122 goto out;
4123 }
4124
4125 result = winreg_get_printer(mem_ctx, server_info, msg_ctx,
4126 NULL, printer, &info2);
4127 if (!W_ERROR_IS_OK(result)) {
4128 goto out;
4129 }
4130
4131 switch (level) {
4132 case 0:
4133 result = construct_printer_info0(info, server_info,
4134 msg_ctx, info2,
4135 &info[count].info0, snum);
4136 break;
4137 case 1:
4138 result = construct_printer_info1(info, info2, flags,
4139 &info[count].info1, snum);
4140 break;
4141 case 2:
4142 result = construct_printer_info2(info, msg_ctx, info2,
4143 &info[count].info2, snum);
4144 break;
4145 case 4:
4146 result = construct_printer_info4(info, info2,
4147 &info[count].info4, snum);
4148 break;
4149 case 5:
4150 result = construct_printer_info5(info, info2,
4151 &info[count].info5, snum);
4152 break;
4153
4154 default:
4155 result = WERR_UNKNOWN_LEVEL;
4156 goto out;
4157 }
4158
4159 if (!W_ERROR_IS_OK(result)) {
4160 goto out;
4161 }
4162
4163 count++;
4164 }
4165
4166 *count_p = count;
4167 *info_p = info;
4168
4169 out:
4170 if (!W_ERROR_IS_OK(result)) {
4171 TALLOC_FREE(info);
4172 return result;
4173 }
4174
4175 *info_p = info;
4176
4177 return WERR_OK;
4178 }
4179
4180 /********************************************************************
4181 * handle enumeration of printers at level 0
4182 ********************************************************************/
4183
4184 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4185 const struct auth_serversupplied_info *server_info,
4186 struct messaging_context *msg_ctx,
4187 uint32_t flags,
4188 const char *servername,
4189 union spoolss_PrinterInfo **info,
4190 uint32_t *count)
4191 {
4192 DEBUG(4,("enum_all_printers_info_0\n"));
4193
4194 return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
4195 0, flags, info, count);
4196 }
4197
4198
4199 /********************************************************************
4200 ********************************************************************/
4201
4202 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4203 const struct auth_serversupplied_info *server_info,
4204 struct messaging_context *msg_ctx,
4205 uint32_t flags,
4206 union spoolss_PrinterInfo **info,
4207 uint32_t *count)
4208 {
4209 DEBUG(4,("enum_all_printers_info_1\n"));
4210
4211 return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
4212 1, flags, info, count);
4213 }
4214
4215 /********************************************************************
4216 enum_all_printers_info_1_local.
4217 *********************************************************************/
4218
4219 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4220 const struct auth_serversupplied_info *server_info,
4221 struct messaging_context *msg_ctx,
4222 union spoolss_PrinterInfo **info,
4223 uint32_t *count)
4224 {
4225 DEBUG(4,("enum_all_printers_info_1_local\n"));
4226
4227 return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
4228 PRINTER_ENUM_ICON8, info, count);
4229 }
4230
4231 /********************************************************************
4232 enum_all_printers_info_1_name.
4233 *********************************************************************/
4234
4235 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4236 const struct auth_serversupplied_info *server_info,
4237 struct messaging_context *msg_ctx,
4238 const char *name,
4239 union spoolss_PrinterInfo **info,
4240 uint32_t *count)
4241 {
4242 const char *s = name;
4243
4244 DEBUG(4,("enum_all_printers_info_1_name\n"));
4245
4246 if ((name[0] == '\\') && (name[1] == '\\')) {
4247 s = name + 2;
4248 }
4249
4250 if (!is_myname_or_ipaddr(s)) {
4251 return WERR_INVALID_NAME;
4252 }
4253
4254 return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
4255 PRINTER_ENUM_ICON8, info, count);
4256 }
4257
4258 /********************************************************************
4259 enum_all_printers_info_1_network.
4260 *********************************************************************/
4261
4262 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4263 const struct auth_serversupplied_info *server_info,
4264 struct messaging_context *msg_ctx,
4265 const char *name,
4266 union spoolss_PrinterInfo **info,
4267 uint32_t *count)
4268 {
4269 const char *s = name;
4270
4271 DEBUG(4,("enum_all_printers_info_1_network\n"));
4272
4273 /* If we respond to a enum_printers level 1 on our name with flags
4274 set to PRINTER_ENUM_REMOTE with a list of printers then these
4275 printers incorrectly appear in the APW browse list.
4276 Specifically the printers for the server appear at the workgroup
4277 level where all the other servers in the domain are
4278 listed. Windows responds to this call with a
4279 WERR_CAN_NOT_COMPLETE so we should do the same. */
4280
4281 if (name[0] == '\\' && name[1] == '\\') {
4282 s = name + 2;
4283 }
4284
4285 if (is_myname_or_ipaddr(s)) {
4286 return WERR_CAN_NOT_COMPLETE;
4287 }
4288
4289 return enum_all_printers_info_1(mem_ctx, server_info, msg_ctx,
4290 PRINTER_ENUM_NAME, info, count);
4291 }
4292
4293 /********************************************************************
4294 * api_spoolss_enumprinters
4295 *
4296 * called from api_spoolss_enumprinters (see this to understand)
4297 ********************************************************************/
4298
4299 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4300 const struct auth_serversupplied_info *server_info,
4301 struct messaging_context *msg_ctx,
4302 union spoolss_PrinterInfo **info,
4303 uint32_t *count)
4304 {
4305 DEBUG(4,("enum_all_printers_info_2\n"));
4306
4307 return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
4308 2, 0, info, count);
4309 }
4310
4311 /********************************************************************
4312 * handle enumeration of printers at level 1
4313 ********************************************************************/
4314
4315 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4316 const struct auth_serversupplied_info *server_info,
4317 struct messaging_context *msg_ctx,
4318 uint32_t flags,
4319 const char *name,
4320 union spoolss_PrinterInfo **info,
4321 uint32_t *count)
4322 {
4323 /* Not all the flags are equals */
4324
4325 if (flags & PRINTER_ENUM_LOCAL) {
4326 return enum_all_printers_info_1_local(mem_ctx, server_info,
4327 msg_ctx, info, count);
4328 }
4329
4330 if (flags & PRINTER_ENUM_NAME) {
4331 return enum_all_printers_info_1_name(mem_ctx, server_info,
4332 msg_ctx, name, info,
4333 count);
4334 }
4335
4336 if (flags & PRINTER_ENUM_NETWORK) {
4337 return enum_all_printers_info_1_network(mem_ctx, server_info,
4338 msg_ctx, name, info,
4339 count);
4340 }
4341
4342 return WERR_OK; /* NT4sp5 does that */
4343 }
4344
4345 /********************************************************************
4346 * handle enumeration of printers at level 2
4347 ********************************************************************/
4348
4349 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4350 const struct auth_serversupplied_info *server_info,
4351 struct messaging_context *msg_ctx,
4352 uint32_t flags,
4353 const char *servername,
4354 union spoolss_PrinterInfo **info,
4355 uint32_t *count)
4356 {
4357 if (flags & PRINTER_ENUM_LOCAL) {
4358 return enum_all_printers_info_2(mem_ctx, server_info, msg_ctx,
4359 info, count);
4360 }
4361
4362 if (flags & PRINTER_ENUM_NAME) {
4363 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4364 return WERR_INVALID_NAME;
4365 }
4366
4367 return enum_all_printers_info_2(mem_ctx, server_info, msg_ctx,
4368 info, count);
4369 }
4370
4371 if (flags & PRINTER_ENUM_REMOTE) {
4372 return WERR_UNKNOWN_LEVEL;
4373 }
4374
4375 return WERR_OK;
4376 }
4377
4378 /********************************************************************
4379 * handle enumeration of printers at level 4
4380 ********************************************************************/
4381
4382 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4383 const struct auth_serversupplied_info *server_info,
4384 struct messaging_context *msg_ctx,
4385 uint32_t flags,
4386 const char *servername,
4387 union spoolss_PrinterInfo **info,
4388 uint32_t *count)
4389 {
4390 DEBUG(4,("enum_all_printers_info_4\n"));
4391
4392 return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
4393 4, flags, info, count);
4394 }
4395
4396
4397 /********************************************************************
4398 * handle enumeration of printers at level 5
4399 ********************************************************************/
4400
4401 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4402 const struct auth_serversupplied_info *server_info,
4403 struct messaging_context *msg_ctx,
4404 uint32_t flags,
4405 const char *servername,
4406 union spoolss_PrinterInfo **info,
4407 uint32_t *count)
4408 {
4409 DEBUG(4,("enum_all_printers_info_5\n"));
4410
4411 return enum_all_printers_info_level(mem_ctx, server_info, msg_ctx,
4412 5, flags, info, count);
4413 }
4414
4415 /****************************************************************
4416 _spoolss_EnumPrinters
4417 ****************************************************************/
4418
4419 WERROR _spoolss_EnumPrinters(struct pipes_struct *p,
4420 struct spoolss_EnumPrinters *r)
4421 {
4422 const struct auth_serversupplied_info *server_info = get_server_info_system();
4423 const char *name = NULL;
4424 WERROR result;
4425
4426 /* that's an [in out] buffer */
4427
4428 if (!r->in.buffer && (r->in.offered != 0)) {
4429 return WERR_INVALID_PARAM;
4430 }
4431
4432 DEBUG(4,("_spoolss_EnumPrinters\n"));
4433
4434 *r->out.needed = 0;
4435 *r->out.count = 0;
4436 *r->out.info = NULL;
4437
4438 /*
4439 * Level 1:
4440 * flags==PRINTER_ENUM_NAME
4441 * if name=="" then enumerates all printers
4442 * if name!="" then enumerate the printer
4443 * flags==PRINTER_ENUM_REMOTE
4444 * name is NULL, enumerate printers
4445 * Level 2: name!="" enumerates printers, name can't be NULL
4446 * Level 3: doesn't exist
4447 * Level 4: does a local registry lookup
4448 * Level 5: same as Level 2
4449 */
4450
4451 if (r->in.server) {
4452 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4453 W_ERROR_HAVE_NO_MEMORY(name);
4454 }
4455
4456 switch (r->in.level) {
4457 case 0:
4458 result = enumprinters_level0(p->mem_ctx, server_info,
4459 p->msg_ctx, r->in.flags, name,
4460 r->out.info, r->out.count);
4461 break;
4462 case 1:
4463 result = enumprinters_level1(p->mem_ctx, server_info,
4464 p->msg_ctx, r->in.flags, name,
4465 r->out.info, r->out.count);
4466 break;
4467 case 2:
4468 result = enumprinters_level2(p->mem_ctx, server_info,
4469 p->msg_ctx, r->in.flags, name,
4470 r->out.info, r->out.count);
4471 break;
4472 case 4:
4473 result = enumprinters_level4(p->mem_ctx, server_info,
4474 p->msg_ctx, r->in.flags, name,
4475 r->out.info, r->out.count);
4476 break;
4477 case 5:
4478 result = enumprinters_level5(p->mem_ctx, server_info,
4479 p->msg_ctx, r->in.flags, name,
4480 r->out.info, r->out.count);
4481 break;
4482 default:
4483 return WERR_UNKNOWN_LEVEL;
4484 }
4485
4486 if (!W_ERROR_IS_OK(result)) {
4487 return result;
4488 }
4489
4490 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4491 spoolss_EnumPrinters,
4492 *r->out.info, r->in.level,
4493 *r->out.count);
4494 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4495 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4496
4497 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4498 }
4499
4500 /****************************************************************
4501 _spoolss_GetPrinter
4502 ****************************************************************/
4503
4504 WERROR _spoolss_GetPrinter(struct pipes_struct *p,
4505 struct spoolss_GetPrinter *r)
4506 {
4507 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
4508 struct spoolss_PrinterInfo2 *info2 = NULL;
4509 WERROR result = WERR_OK;
4510 const char *servername = NULL;
4511 int snum;
4512
4513 /* that's an [in out] buffer */
4514
4515 if (!r->in.buffer && (r->in.offered != 0)) {
4516 return WERR_INVALID_PARAM;
4517 }
4518
4519 *r->out.needed = 0;
4520
4521 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4522 return WERR_BADFID;
4523 }
4524
4525 if (Printer != NULL || Printer->servername != NULL) {
4526 servername = Printer->servername;
4527 }
4528
4529 result = winreg_get_printer(p->mem_ctx,
4530 get_server_info_system(),
4531 p->msg_ctx,
4532 servername,
4533 lp_const_servicename(snum),
4534 &info2);
4535 if (!W_ERROR_IS_OK(result)) {
4536 goto out;
4537 }
4538
4539 switch (r->in.level) {
4540 case 0:
4541 result = construct_printer_info0(p->mem_ctx,
4542 get_server_info_system(),
4543 p->msg_ctx,
4544 info2,
4545 &r->out.info->info0,
4546 snum);
4547 break;
4548 case 1:
4549 result = construct_printer_info1(p->mem_ctx, info2,
4550 PRINTER_ENUM_ICON8,
4551 &r->out.info->info1, snum);
4552 break;
4553 case 2:
4554 result = construct_printer_info2(p->mem_ctx, p->msg_ctx, info2,
4555 &r->out.info->info2, snum);
4556 break;
4557 case 3:
4558 result = construct_printer_info3(p->mem_ctx, info2,
4559 &r->out.info->info3, snum);
4560 break;
4561 case 4:
4562 result = construct_printer_info4(p->mem_ctx, info2,
4563 &r->out.info->info4, snum);
4564 break;
4565 case 5:
4566 result = construct_printer_info5(p->mem_ctx, info2,
4567 &r->out.info->info5, snum);
4568 break;
4569 case 6:
4570 result = construct_printer_info6(p->mem_ctx, p->msg_ctx, info2,
4571 &r->out.info->info6, snum);
4572 break;
4573 case 7:
4574 result = construct_printer_info7(p->mem_ctx, p->msg_ctx,
4575 Printer,
4576 &r->out.info->info7, snum);
4577 break;
4578 case 8:
4579 result = construct_printer_info8(p->mem_ctx, info2,
4580 &r->out.info->info8, snum);
4581 break;
4582 default:
4583 result = WERR_UNKNOWN_LEVEL;
4584 break;
4585 }
4586
4587 out:
4588 if (!W_ERROR_IS_OK(result)) {
4589 DEBUG(0, ("_spoolss_GetPrinter: failed to construct printer info level %d - %s\n",
4590 r->in.level, win_errstr(result)));
4591 TALLOC_FREE(r->out.info);
4592 return result;
4593 }
4594
4595 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo,
4596 r->out.info, r->in.level);
4597 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4598
4599 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4600 }
4601
4602 /********************************************************************
4603 ********************************************************************/
4604
4605 #define FILL_DRIVER_STRING(mem_ctx, in, out) \
4606 do { \
4607 if (in && strlen(in)) { \
4608 out = talloc_strdup(mem_ctx, in); \
4609 } else { \
4610 out = talloc_strdup(mem_ctx, ""); \
4611 } \
4612 W_ERROR_HAVE_NO_MEMORY(out); \
4613 } while (0);
4614
4615 #define FILL_DRIVER_UNC_STRING(mem_ctx, server, arch, ver, in, out) \
4616 do { \
4617 if (in && strlen(in)) { \
4618 out = talloc_asprintf(mem_ctx, "\\\\%s\\print$\\%s\\%d\\%s", server, get_short_archi(arch), ver, in); \
4619 } else { \
4620 out = talloc_strdup(mem_ctx, ""); \
4621 } \
4622 W_ERROR_HAVE_NO_MEMORY(out); \
4623 } while (0);
4624
4625 static WERROR string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4626 const char **string_array,
4627 const char ***presult,
4628 const char *cservername,
4629 const char *arch,
4630 int version)
4631 {
4632 int i, num_strings = 0;
4633 const char **array = NULL;
4634
4635 if (string_array == NULL) {
4636 return WERR_INVALID_PARAMETER;;
4637 }
4638
4639 for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
4640 const char *str = NULL;
4641
4642 if (cservername == NULL || arch == NULL) {
4643 FILL_DRIVER_STRING(mem_ctx, string_array[i], str);
4644 } else {
4645 FILL_DRIVER_UNC_STRING(mem_ctx, cservername, arch, version, string_array[i], str);
4646 }
4647
4648 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4649 TALLOC_FREE(array);
4650 return WERR_NOMEM;
4651 }
4652 }
4653
4654 if (i > 0) {
4655 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4656 &array, &num_strings);
4657 }
4658
4659 if (presult) {
4660 *presult = array;
4661 }
4662
4663 return WERR_OK;
4664 }
4665
4666 /********************************************************************
4667 * fill a spoolss_DriverInfo1 struct
4668 ********************************************************************/
4669
4670 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4671 struct spoolss_DriverInfo1 *r,
4672 const struct spoolss_DriverInfo8 *driver,
4673 const char *servername)
4674 {
4675 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4676 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4677
4678 return WERR_OK;
4679 }
4680
4681 /********************************************************************
4682 * fill a spoolss_DriverInfo2 struct
4683 ********************************************************************/
4684
4685 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4686 struct spoolss_DriverInfo2 *r,
4687 const struct spoolss_DriverInfo8 *driver,
4688 const char *servername)
4689
4690 {
4691 const char *cservername = canon_servername(servername);
4692
4693 r->version = driver->version;
4694
4695 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4696 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4697 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4698 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4699
4700 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4701 driver->architecture,
4702 driver->version,
4703 driver->driver_path,
4704 r->driver_path);
4705
4706 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4707 driver->architecture,
4708 driver->version,
4709 driver->data_file,
4710 r->data_file);
4711
4712 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4713 driver->architecture,
4714 driver->version,
4715 driver->config_file,
4716 r->config_file);
4717
4718 return WERR_OK;
4719 }
4720
4721 /********************************************************************
4722 * fill a spoolss_DriverInfo3 struct
4723 ********************************************************************/
4724
4725 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4726 struct spoolss_DriverInfo3 *r,
4727 const struct spoolss_DriverInfo8 *driver,
4728 const char *servername)
4729 {
4730 const char *cservername = canon_servername(servername);
4731
4732 r->version = driver->version;
4733
4734 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4735 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4736 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4737 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4738
4739 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4740 driver->architecture,
4741 driver->version,
4742 driver->driver_path,
4743 r->driver_path);
4744
4745 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4746 driver->architecture,
4747 driver->version,
4748 driver->data_file,
4749 r->data_file);
4750
4751 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4752 driver->architecture,
4753 driver->version,
4754 driver->config_file,
4755 r->config_file);
4756
4757 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4758 driver->architecture,
4759 driver->version,
4760 driver->help_file,
4761 r->help_file);
4762
4763 FILL_DRIVER_STRING(mem_ctx,
4764 driver->monitor_name,
4765 r->monitor_name);
4766
4767 FILL_DRIVER_STRING(mem_ctx,
4768 driver->default_datatype,
4769 r->default_datatype);
4770
4771 return string_array_from_driver_info(mem_ctx,
4772 driver->dependent_files,
4773 &r->dependent_files,
4774 cservername,
4775 driver->architecture,
4776 driver->version);
4777 }
4778
4779 /********************************************************************
4780 * fill a spoolss_DriverInfo4 struct
4781 ********************************************************************/
4782
4783 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4784 struct spoolss_DriverInfo4 *r,
4785 const struct spoolss_DriverInfo8 *driver,
4786 const char *servername)
4787 {
4788 const char *cservername = canon_servername(servername);
4789 WERROR result;
4790
4791 r->version = driver->version;
4792
4793 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4794 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4795 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4796 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4797
4798 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4799 driver->architecture,
4800 driver->version,
4801 driver->driver_path,
4802 r->driver_path);
4803
4804 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4805 driver->architecture,
4806 driver->version,
4807 driver->data_file,
4808 r->data_file);
4809
4810 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4811 driver->architecture,
4812 driver->version,
4813 driver->config_file,
4814 r->config_file);
4815
4816 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4817 driver->architecture,
4818 driver->version,
4819 driver->help_file,
4820 r->help_file);
4821
4822 result = string_array_from_driver_info(mem_ctx,
4823 driver->dependent_files,
4824 &r->dependent_files,
4825 cservername,
4826 driver->architecture,
4827 driver->version);
4828 if (!W_ERROR_IS_OK(result)) {
4829 return result;
4830 }
4831
4832 FILL_DRIVER_STRING(mem_ctx,
4833 driver->monitor_name,
4834 r->monitor_name);
4835
4836 FILL_DRIVER_STRING(mem_ctx,
4837 driver->default_datatype,
4838 r->default_datatype);
4839
4840
4841 result = string_array_from_driver_info(mem_ctx,
4842 driver->previous_names,
4843 &r->previous_names,
4844 NULL, NULL, 0);
4845
4846 return result;
4847 }
4848
4849 /********************************************************************
4850 * fill a spoolss_DriverInfo5 struct
4851 ********************************************************************/
4852
4853 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4854 struct spoolss_DriverInfo5 *r,
4855 const struct spoolss_DriverInfo8 *driver,
4856 const char *servername)
4857 {
4858 const char *cservername = canon_servername(servername);
4859
4860 r->version = driver->version;
4861
4862 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4863 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4864 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4865 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4866
4867 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4868 driver->architecture,
4869 driver->version,
4870 driver->driver_path,
4871 r->driver_path);
4872
4873 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4874 driver->architecture,
4875 driver->version,
4876 driver->data_file,
4877 r->data_file);
4878
4879 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4880 driver->architecture,
4881 driver->version,
4882 driver->config_file,
4883 r->config_file);
4884
4885 r->driver_attributes = 0;
4886 r->config_version = 0;
4887 r->driver_version = 0;
4888
4889 return WERR_OK;
4890 }
4891 /********************************************************************
4892 * fill a spoolss_DriverInfo6 struct
4893 ********************************************************************/
4894
4895 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4896 struct spoolss_DriverInfo6 *r,
4897 const struct spoolss_DriverInfo8 *driver,
4898 const char *servername)
4899 {
4900 const char *cservername = canon_servername(servername);
4901 WERROR result;
4902
4903 r->version = driver->version;
4904
4905 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4906 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4907 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4908 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4909
4910 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4911 driver->architecture,
4912 driver->version,
4913 driver->driver_path,
4914 r->driver_path);
4915
4916 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4917 driver->architecture,
4918 driver->version,
4919 driver->data_file,
4920 r->data_file);
4921
4922 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4923 driver->architecture,
4924 driver->version,
4925 driver->config_file,
4926 r->config_file);
4927
4928 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4929 driver->architecture,
4930 driver->version,
4931 driver->help_file,
4932 r->help_file);
4933
4934 FILL_DRIVER_STRING(mem_ctx,
4935 driver->monitor_name,
4936 r->monitor_name);
4937
4938 FILL_DRIVER_STRING(mem_ctx,
4939 driver->default_datatype,
4940 r->default_datatype);
4941
4942 result = string_array_from_driver_info(mem_ctx,
4943 driver->dependent_files,
4944 &r->dependent_files,
4945 cservername,
4946 driver->architecture,
4947 driver->version);
4948 if (!W_ERROR_IS_OK(result)) {
4949 return result;
4950 }
4951
4952 result = string_array_from_driver_info(mem_ctx,
4953 driver->previous_names,
4954 &r->previous_names,
4955 NULL, NULL, 0);
4956 if (!W_ERROR_IS_OK(result)) {
4957 return result;
4958 }
4959
4960 r->driver_date = driver->driver_date;
4961 r->driver_version = driver->driver_version;
4962
4963 FILL_DRIVER_STRING(mem_ctx,
4964 driver->manufacturer_name,
4965 r->manufacturer_name);
4966 FILL_DRIVER_STRING(mem_ctx,
4967 driver->manufacturer_url,
4968 r->manufacturer_url);
4969 FILL_DRIVER_STRING(mem_ctx,
4970 driver->hardware_id,
4971 r->hardware_id);
4972 FILL_DRIVER_STRING(mem_ctx,
4973 driver->provider,
4974 r->provider);
4975
4976 return WERR_OK;
4977 }
4978
4979 /********************************************************************
4980 * fill a spoolss_DriverInfo8 struct
4981 ********************************************************************/
4982
4983 static WERROR fill_printer_driver_info8(TALLOC_CTX *mem_ctx,
4984 struct spoolss_DriverInfo8 *r,
4985 const struct spoolss_DriverInfo8 *driver,
4986 const char *servername)
4987 {
4988 const char *cservername = canon_servername(servername);
4989 WERROR result;
4990
4991 r->version = driver->version;
4992
4993 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
4994 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4995 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
4996 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4997
4998 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
4999 driver->architecture,
5000 driver->version,
5001 driver->driver_path,
5002 r->driver_path);
5003
5004 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5005 driver->architecture,
5006 driver->version,
5007 driver->data_file,
5008 r->data_file);
5009
5010 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5011 driver->architecture,
5012 driver->version,
5013 driver->config_file,
5014 r->config_file);
5015
5016 FILL_DRIVER_UNC_STRING(mem_ctx, cservername,
5017 driver->architecture,
5018 driver->version,
5019 driver->help_file,
5020 r->help_file);
5021
5022 FILL_DRIVER_STRING(mem_ctx,
5023 driver->monitor_name,
5024 r->monitor_name);
5025
5026 FILL_DRIVER_STRING(mem_ctx,
5027 driver->default_datatype,
5028 r->default_datatype);
5029
5030 result = string_array_from_driver_info(mem_ctx,
5031 driver->dependent_files,
5032 &r->dependent_files,
5033 cservername,
5034 driver->architecture,
5035 driver->version);
5036 if (!W_ERROR_IS_OK(result)) {
5037 return result;
5038 }
5039
5040 result = string_array_from_driver_info(mem_ctx,
5041 driver->previous_names,
5042 &r->previous_names,
5043 NULL, NULL, 0);
5044 if (!W_ERROR_IS_OK(result)) {
5045 return result;
5046 }
5047
5048 r->driver_date = driver->driver_date;
5049 r->driver_version = driver->driver_version;
5050
5051 FILL_DRIVER_STRING(mem_ctx,
5052 driver->manufacturer_name,
5053 r->manufacturer_name);
5054 FILL_DRIVER_STRING(mem_ctx,
5055 driver->manufacturer_url,
5056 r->manufacturer_url);
5057 FILL_DRIVER_STRING(mem_ctx,
5058 driver->hardware_id,
5059 r->hardware_id);
5060 FILL_DRIVER_STRING(mem_ctx,
5061 driver->provider,
5062 r->provider);
5063
5064 FILL_DRIVER_STRING(mem_ctx,
5065 driver->print_processor,
5066 r->print_processor);
5067 FILL_DRIVER_STRING(mem_ctx,
5068 driver->vendor_setup,
5069 r->vendor_setup);
5070
5071 result = string_array_from_driver_info(mem_ctx,
5072 driver->color_profiles,
5073 &r->color_profiles,
5074 NULL, NULL, 0);
5075 if (!W_ERROR_IS_OK(result)) {
5076 return result;
5077 }
5078
5079 FILL_DRIVER_STRING(mem_ctx,
5080 driver->inf_path,
5081 r->inf_path);
5082
5083 r->printer_driver_attributes = driver->printer_driver_attributes;
5084
5085 result = string_array_from_driver_info(mem_ctx,
5086 driver->core_driver_dependencies,
5087 &r->core_driver_dependencies,
5088 NULL, NULL, 0);
5089 if (!W_ERROR_IS_OK(result)) {
5090 return result;
5091 }
5092
5093 r->min_inbox_driver_ver_date = driver->min_inbox_driver_ver_date;
5094 r->min_inbox_driver_ver_version = driver->min_inbox_driver_ver_version;
5095
5096 return WERR_OK;
5097 }
5098
5099 #if 0 /* disabled until marshalling issues are resolved - gd */
5100 /********************************************************************
5101 ********************************************************************/
5102
5103 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5104 struct spoolss_DriverFileInfo *r,
5105 const char *cservername,
5106 const char *file_name,
5107 enum spoolss_DriverFileType file_type,
5108 uint32_t file_version)
5109 {
5110 r->file_name = talloc_asprintf(mem_ctx, "\\\\%s%s",
5111 cservername, file_name);
5112 W_ERROR_HAVE_NO_MEMORY(r->file_name);
5113 r->file_type = file_type;
5114 r->file_version = file_version;
5115
5116 return WERR_OK;
5117 }
5118
5119 /********************************************************************
5120 ********************************************************************/
5121
5122 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5123 const struct spoolss_DriverInfo8 *driver,
5124 const char *cservername,
5125 struct spoolss_DriverFileInfo **info_p,
5126 uint32_t *count_p)
5127 {
5128 struct spoolss_DriverFileInfo *info = NULL;
5129 uint32_t count = 0;
5130 WERROR result;
5131 uint32_t i;
5132
5133 *info_p = NULL;
5134 *count_p = 0;
5135
5136 if (strlen(driver->driver_path)) {
5137 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5138 struct spoolss_DriverFileInfo,
5139 count + 1);
5140 W_ERROR_HAVE_NO_MEMORY(info);
5141 result = fill_spoolss_DriverFileInfo(info,
5142 &info[count],
5143 cservername,
5144 driver->driver_path,
5145 SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5146 0);
5147 W_ERROR_NOT_OK_RETURN(result);
5148 count++;
5149 }
5150
5151 if (strlen(driver->config_file)) {
5152 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5153 struct spoolss_DriverFileInfo,
5154 count + 1);
5155 W_ERROR_HAVE_NO_MEMORY(info);
5156 result = fill_spoolss_DriverFileInfo(info,
5157 &info[count],
5158 cservername,
5159 driver->config_file,
5160 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5161 0);
5162 W_ERROR_NOT_OK_RETURN(result);
5163 count++;
5164 }
5165
5166 if (strlen(driver->data_file)) {
5167 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5168 struct spoolss_DriverFileInfo,
5169 count + 1);
5170 W_ERROR_HAVE_NO_MEMORY(info);
5171 result = fill_spoolss_DriverFileInfo(info,
5172 &info[count],
5173 cservername,
5174 driver->data_file,
5175 SPOOLSS_DRIVER_FILE_TYPE_DATA,
5176 0);
5177 W_ERROR_NOT_OK_RETURN(result);
5178 count++;
5179 }
5180
5181 if (strlen(driver->help_file)) {
5182 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5183 struct spoolss_DriverFileInfo,
5184 count + 1);
5185 W_ERROR_HAVE_NO_MEMORY(info);
5186 result = fill_spoolss_DriverFileInfo(info,
5187 &info[count],
5188 cservername,
5189 driver->help_file,
5190 SPOOLSS_DRIVER_FILE_TYPE_HELP,
5191 0);
5192 W_ERROR_NOT_OK_RETURN(result);
5193 count++;
5194 }
5195
5196 for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
5197 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5198 struct spoolss_DriverFileInfo,
5199 count + 1);
5200 W_ERROR_HAVE_NO_MEMORY(info);
5201 result = fill_spoolss_DriverFileInfo(info,
5202 &info[count],
5203 cservername,
5204 driver->dependent_files[i],
5205 SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5206 0);
5207 W_ERROR_NOT_OK_RETURN(result);
5208 count++;
5209 }
5210
5211 *info_p = info;
5212 *count_p = count;
5213
5214 return WERR_OK;
5215 }
5216
5217 /********************************************************************
5218 * fill a spoolss_DriverInfo101 struct
5219 ********************************************************************/
5220
5221 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5222 struct spoolss_DriverInfo101 *r,
5223 const struct spoolss_DriverInfo8 *driver,
5224 const char *servername)
5225 {
5226 const char *cservername = canon_servername(servername);
5227 WERROR result;
5228
5229 r->version = driver->version;
5230
5231 r->driver_name = talloc_strdup(mem_ctx, driver->driver_name);
5232 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5233 r->architecture = talloc_strdup(mem_ctx, driver->architecture);
5234 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5235
5236 result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5237 cservername,
5238 &r->file_info,
5239 &r->file_count);
5240 if (!W_ERROR_IS_OK(result)) {
5241 return result;
5242 }
5243
5244 FILL_DRIVER_STRING(mem_ctx,
5245 driver->monitor_name,
5246 r->monitor_name);
5247
5248 FILL_DRIVER_STRING(mem_ctx,
5249 driver->default_datatype,
5250 r->default_datatype);
5251
5252 result = string_array_from_driver_info(mem_ctx,
5253 driver->previous_names,
5254 &r->previous_names,
5255 NULL, NULL, 0);
5256 if (!W_ERROR_IS_OK(result)) {
5257 return result;
5258 }
5259
5260 r->driver_date = driver->driver_date;
5261 r->driver_version = driver->driver_version;
5262
5263 FILL_DRIVER_STRING(mem_ctx,
5264 driver->manufacturer_name,
5265 r->manufacturer_name);
5266 FILL_DRIVER_STRING(mem_ctx,
5267 driver->manufacturer_url,
5268 r->manufacturer_url);
5269 FILL_DRIVER_STRING(mem_ctx,
5270 driver->hardware_id,
5271 r->hardware_id);
5272 FILL_DRIVER_STRING(mem_ctx,
5273 driver->provider,
5274 r->provider);
5275
5276 return WERR_OK;
5277 }
5278 #endif
5279 /********************************************************************
5280 ********************************************************************/
5281
5282 static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
5283 const struct auth_serversupplied_info *server_info,
5284 struct messaging_context *msg_ctx,
5285 uint32_t level,
5286 union spoolss_DriverInfo *r,
5287 int snum,
5288 const char *servername,
5289 const char *architecture,
5290 uint32_t version)
5291 {
5292 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
5293 struct spoolss_DriverInfo8 *driver;
5294 WERROR result;
5295
5296 result = winreg_get_printer(mem_ctx,
5297 server_info,
5298 msg_ctx,
5299 servername,
5300 lp_const_servicename(snum),
5301 &pinfo2);
5302
5303 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5304 win_errstr(result)));
5305
5306 if (!W_ERROR_IS_OK(result)) {
5307 return WERR_INVALID_PRINTER_NAME;
5308 }
5309
5310 result = winreg_get_driver(mem_ctx, server_info, msg_ctx,
5311 architecture,
5312 pinfo2->drivername, version, &driver);
5313
5314 DEBUG(8,("construct_printer_driver_info_level: status: %s\n",
5315 win_errstr(result)));
5316
5317 if (!W_ERROR_IS_OK(result)) {
5318 /*
5319 * Is this a W2k client ?
5320 */
5321
5322 if (version < 3) {
5323 talloc_free(pinfo2);
5324 return WERR_UNKNOWN_PRINTER_DRIVER;
5325 }
5326
5327 /* Yes - try again with a WinNT driver. */
5328 version = 2;
5329 result = winreg_get_driver(mem_ctx, server_info, msg_ctx,
5330 architecture,
5331 pinfo2->drivername,
5332 version, &driver);
5333 DEBUG(8,("construct_printer_driver_level: status: %s\n",
5334 win_errstr(result)));
5335 if (!W_ERROR_IS_OK(result)) {
5336 talloc_free(pinfo2);
5337 return WERR_UNKNOWN_PRINTER_DRIVER;
5338 }
5339 }
5340
5341 switch (level) {
5342 case 1:
5343 result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
5344 break;
5345 case 2:
5346 result = fill_printer_driver_info2(mem_ctx, &r->info2, driver, servername);
5347 break;
5348 case 3:
5349 result = fill_printer_driver_info3(mem_ctx, &r->info3, driver, servername);
5350 break;
5351 case 4:
5352 result = fill_printer_driver_info4(mem_ctx, &r->info4, driver, servername);
5353 break;
5354 case 5:
5355 result = fill_printer_driver_info5(mem_ctx, &r->info5, driver, servername);
5356 break;
5357 case 6:
5358 result = fill_printer_driver_info6(mem_ctx, &r->info6, driver, servername);
5359 break;
5360 case 8:
5361 result = fill_printer_driver_info8(mem_ctx, &r->info8, driver, servername);
5362 break;
5363 #if 0 /* disabled until marshalling issues are resolved - gd */
5364 case 101:
5365 result = fill_printer_driver_info101(mem_ctx, &r->info101, driver, servername);
5366 break;
5367 #endif
5368 default:
5369 result = WERR_UNKNOWN_LEVEL;
5370 break;
5371 }
5372
5373 talloc_free(pinfo2);
5374 talloc_free(driver);
5375
5376 return result;
5377 }
5378
5379 /****************************************************************
5380 _spoolss_GetPrinterDriver2
5381 ****************************************************************/
5382
5383 WERROR _spoolss_GetPrinterDriver2(struct pipes_struct *p,
5384 struct spoolss_GetPrinterDriver2 *r)
5385 {
5386 struct printer_handle *printer;
5387 WERROR result;
5388
5389 int snum;
5390
5391 /* that's an [in out] buffer */
5392
5393 if (!r->in.buffer && (r->in.offered != 0)) {
5394 return WERR_INVALID_PARAM;
5395 }
5396
5397 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5398
5399 if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5400 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5401 return WERR_INVALID_PRINTER_NAME;
5402 }
5403
5404 *r->out.needed = 0;
5405 *r->out.server_major_version = 0;
5406 *r->out.server_minor_version = 0;
5407
5408 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5409 return WERR_BADFID;
5410 }
5411
5412 result = construct_printer_driver_info_level(p->mem_ctx,
5413 get_server_info_system(),
5414 p->msg_ctx,
5415 r->in.level, r->out.info,
5416 snum, printer->servername,
5417 r->in.architecture,
5418 r->in.client_major_version);
5419 if (!W_ERROR_IS_OK(result)) {
5420 TALLOC_FREE(r->out.info);
5421 return result;
5422 }
5423
5424 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo,
5425 r->out.info, r->in.level);
5426 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5427
5428 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5429 }
5430
5431
5432 /****************************************************************
5433 _spoolss_StartPagePrinter
5434 ****************************************************************/
5435
5436 WERROR _spoolss_StartPagePrinter(struct pipes_struct *p,
5437 struct spoolss_StartPagePrinter *r)
5438 {
5439 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5440
5441 if (!Printer) {
5442 DEBUG(3,("_spoolss_StartPagePrinter: "
5443 "Error in startpageprinter printer handle\n"));
5444 return WERR_BADFID;
5445 }
5446
5447 Printer->page_started = true;
5448 return WERR_OK;
5449 }
5450
5451 /****************************************************************
5452 _spoolss_EndPagePrinter
5453 ****************************************************************/
5454
5455 WERROR _spoolss_EndPagePrinter(struct pipes_struct *p,
5456 struct spoolss_EndPagePrinter *r)
5457 {
5458 int snum;
5459
5460 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5461
5462 if (!Printer) {
5463 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5464 OUR_HANDLE(r->in.handle)));
5465 return WERR_BADFID;
5466 }
5467
5468 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5469 return WERR_BADFID;
5470
5471 Printer->page_started = false;
5472 print_job_endpage(p->msg_ctx, snum, Printer->jobid);
5473
5474 return WERR_OK;
5475 }
5476
5477 /****************************************************************
5478 _spoolss_StartDocPrinter
5479 ****************************************************************/
5480
5481 WERROR _spoolss_StartDocPrinter(struct pipes_struct *p,
5482 struct spoolss_StartDocPrinter *r)
5483 {
5484 struct spoolss_DocumentInfo1 *info_1;
5485 int snum;
5486 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5487 WERROR werr;
5488
5489 if (!Printer) {
5490 DEBUG(2,("_spoolss_StartDocPrinter: "
5491 "Invalid handle (%s:%u:%u)\n",
5492 OUR_HANDLE(r->in.handle)));
5493 return WERR_BADFID;
5494 }
5495
5496 if (Printer->jobid) {
5497 DEBUG(2, ("_spoolss_StartDocPrinter: "
5498 "StartDocPrinter called twice! "
5499 "(existing jobid = %d)\n", Printer->jobid));
5500 return WERR_INVALID_HANDLE;
5501 }
5502
5503 if (r->in.level != 1) {
5504 return WERR_UNKNOWN_LEVEL;
5505 }
5506
5507 info_1 = r->in.info.info1;
5508
5509 /*
5510 * a nice thing with NT is it doesn't listen to what you tell it.
5511 * when asked to send _only_ RAW datas, it tries to send datas
5512 * in EMF format.
5513 *
5514 * So I add checks like in NT Server ...
5515 */
5516
5517 if (info_1->datatype) {
5518 if (strcmp(info_1->datatype, "RAW") != 0) {
5519 *r->out.job_id = 0;
5520 return WERR_INVALID_DATATYPE;
5521 }
5522 }
5523
5524 /* get the share number of the printer */
5525 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5526 return WERR_BADFID;
5527 }
5528
5529 werr = print_job_start(get_server_info_system(),
5530 p->msg_ctx,
5531 p->client_id->name,
5532 snum,
5533 info_1->document_name,
5534 info_1->output_file,
5535 Printer->devmode,
5536 &Printer->jobid);
5537
5538 /* An error occured in print_job_start() so return an appropriate
5539 NT error code. */
5540
5541 if (!W_ERROR_IS_OK(werr)) {
5542 return werr;
5543 }
5544
5545 Printer->document_started = true;
5546 *r->out.job_id = Printer->jobid;
5547
5548 return WERR_OK;
5549 }
5550
5551 /****************************************************************
5552 _spoolss_EndDocPrinter
5553 ****************************************************************/
5554
5555 WERROR _spoolss_EndDocPrinter(struct pipes_struct *p,
5556 struct spoolss_EndDocPrinter *r)
5557 {
5558 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5559 NTSTATUS status;
5560 int snum;
5561
5562 if (!Printer) {
5563 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5564 OUR_HANDLE(r->in.handle)));
5565 return WERR_BADFID;
5566 }
5567
5568 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5569 return WERR_BADFID;
5570 }
5571
5572 Printer->document_started = false;
5573 status = print_job_end(p->msg_ctx, snum, Printer->jobid, NORMAL_CLOSE);
5574 if (!NT_STATUS_IS_OK(status)) {
5575 DEBUG(2, ("_spoolss_EndDocPrinter: "
5576 "print_job_end failed [%s]\n",
5577 nt_errstr(status)));
5578 }
5579
5580 Printer->jobid = 0;
5581 return ntstatus_to_werror(status);
5582 }
5583
5584 /****************************************************************
5585 _spoolss_WritePrinter
5586 ****************************************************************/
5587
5588 WERROR _spoolss_WritePrinter(struct pipes_struct *p,
5589 struct spoolss_WritePrinter *r)
5590 {
5591 ssize_t buffer_written;
5592 int snum;
5593 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5594
5595 if (!Printer) {
5596 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5597 OUR_HANDLE(r->in.handle)));
5598 *r->out.num_written = r->in._data_size;
5599 return WERR_BADFID;
5600 }
5601
5602 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5603 return WERR_BADFID;
5604
5605 /* print_job_write takes care of checking for PJOB_SMBD_SPOOLING */
5606 buffer_written = print_job_write(server_event_context(),p->msg_ctx,
5607 snum, Printer->jobid,
5608 (const char *)r->in.data.data,
5609 (size_t)r->in._data_size);
5610 if (buffer_written == (ssize_t)-1) {
5611 *r->out.num_written = 0;
5612 if (errno == ENOSPC)
5613 return WERR_NO_SPOOL_SPACE;
5614 else
5615 return WERR_ACCESS_DENIED;
5616 }
5617
5618 *r->out.num_written = r->in._data_size;
5619
5620 return WERR_OK;
5621 }
5622
5623 /********************************************************************
5624 * api_spoolss_getprinter
5625 * called from the spoolss dispatcher
5626 *
5627 ********************************************************************/
5628
5629 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5630 struct pipes_struct *p)
5631 {
5632 const struct auth_serversupplied_info *server_info = get_server_info_system();
5633 int snum;
5634 WERROR errcode = WERR_BADFUNC;
5635 struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
5636
5637 if (!Printer) {
5638 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5639 OUR_HANDLE(handle)));
5640 return WERR_BADFID;
5641 }
5642
5643 if (!get_printer_snum(p, handle, &snum, NULL))
5644 return WERR_BADFID;
5645
5646 switch (command) {
5647 case SPOOLSS_PRINTER_CONTROL_PAUSE:
5648 errcode = print_queue_pause(server_info, p->msg_ctx, snum);
5649 break;
5650 case SPOOLSS_PRINTER_CONTROL_RESUME:
5651 case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5652 errcode = print_queue_resume(server_info, p->msg_ctx, snum);
5653 break;
5654 case SPOOLSS_PRINTER_CONTROL_PURGE:
5655 errcode = print_queue_purge(server_info, p->msg_ctx, snum);
5656 break;
5657 default:
5658 return WERR_UNKNOWN_LEVEL;
5659 }
5660
5661 return errcode;
5662 }
5663
5664
5665 /****************************************************************
5666 _spoolss_AbortPrinter
5667 * From MSDN: "Deletes printer's spool file if printer is configured
5668 * for spooling"
5669 ****************************************************************/
5670
5671 WERROR _spoolss_AbortPrinter(struct pipes_struct *p,
5672 struct spoolss_AbortPrinter *r)
5673 {
5674 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
5675 int snum;
5676 WERROR errcode = WERR_OK;
5677
5678 if (!Printer) {
5679 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5680 OUR_HANDLE(r->in.handle)));
5681 return WERR_BADFID;
5682 }
5683
5684 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5685 return WERR_BADFID;
5686
5687 if (!Printer->document_started) {
5688 return WERR_SPL_NO_STARTDOC;
5689 }
5690
5691 errcode = print_job_delete(get_server_info_system(),
5692 p->msg_ctx,
5693 snum,
5694 Printer->jobid);
5695
5696 return errcode;
5697 }
5698
5699 /********************************************************************
5700 * called by spoolss_api_setprinter
5701 * when updating a printer description
5702 ********************************************************************/
5703
5704 static WERROR update_printer_sec(struct policy_handle *handle,
5705 struct pipes_struct *p,
5706 struct sec_desc_buf *secdesc_ctr)
5707 {
5708 struct spoolss_security_descriptor *new_secdesc = NULL;
5709 struct spoolss_security_descriptor *old_secdesc = NULL;
5710 const char *printer;
5711 WERROR result;
5712 int snum;
5713
5714 struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
5715
5716 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5717 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5718 OUR_HANDLE(handle)));
5719
5720 result = WERR_BADFID;
5721 goto done;
5722 }
5723
5724 if (secdesc_ctr == NULL) {
5725 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5726 result = WERR_INVALID_PARAM;
5727 goto done;
5728 }
5729 printer = lp_const_servicename(snum);
5730
5731 /* Check the user has permissions to change the security
5732 descriptor. By experimentation with two NT machines, the user
5733 requires Full Access to the printer to change security
5734 information. */
5735
5736 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5737 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5738 result = WERR_ACCESS_DENIED;
5739 goto done;
5740 }
5741
5742 /* NT seems to like setting the security descriptor even though
5743 nothing may have actually changed. */
5744 result = winreg_get_printer_secdesc(p->mem_ctx,
5745 get_server_info_system(),
5746 p->msg_ctx,
5747 printer,
5748 &old_secdesc);
5749 if (!W_ERROR_IS_OK(result)) {
5750 DEBUG(2,("update_printer_sec: winreg_get_printer_secdesc() failed\n"));
5751 result = WERR_BADFID;
5752 goto done;
5753 }
5754
5755 if (DEBUGLEVEL >= 10) {
5756 struct security_acl *the_acl;
5757 int i;
5758
5759 the_acl = old_secdesc->dacl;
5760 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5761 printer, the_acl->num_aces));
5762
5763 for (i = 0; i < the_acl->num_aces; i++) {
5764 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5765 &the_acl->aces[i].trustee),
5766 the_acl->aces[i].access_mask));
5767 }
5768
5769 the_acl = secdesc_ctr->sd->dacl;
5770
5771 if (the_acl) {
5772 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5773 printer, the_acl->num_aces));
5774
5775 for (i = 0; i < the_acl->num_aces; i++) {
5776 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5777 &the_acl->aces[i].trustee),
5778 the_acl->aces[i].access_mask));
5779 }
5780 } else {
5781 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5782 }
5783 }
5784
5785 new_secdesc = sec_desc_merge(p->mem_ctx, secdesc_ctr->sd, old_secdesc);
5786 if (new_secdesc == NULL) {
5787 result = WERR_NOMEM;
5788 goto done;
5789 }
5790
5791 if (security_descriptor_equal(new_secdesc, old_secdesc)) {
5792 result = WERR_OK;
5793 goto done;
5794 }
5795
5796 result = winreg_set_printer_secdesc(p->mem_ctx,
5797 get_server_info_system(),
5798 p->msg_ctx,
5799 printer,
5800 new_secdesc);
5801
5802 done:
5803 return result;
5804 }
5805
5806 /********************************************************************
5807 Canonicalize printer info from a client
5808 ********************************************************************/
5809
5810 static bool check_printer_ok(TALLOC_CTX *mem_ctx,
5811 struct spoolss_SetPrinterInfo2 *info2,
5812 int snum)
5813 {
5814 fstring printername;
5815 const char *p;
5816
5817 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5818 "portname=%s drivername=%s comment=%s location=%s\n",
5819 info2->servername, info2->printername, info2->sharename,
5820 info2->portname, info2->drivername, info2->comment,
5821 info2->location));
5822
5823 /* we force some elements to "correct" values */
5824 info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
5825 if (info2->servername == NULL) {
5826 return false;
5827 }
5828 info2->sharename = talloc_strdup(mem_ctx, lp_const_servicename(snum));
5829 if (info2->sharename == NULL) {
5830 return false;
5831 }
5832
5833 /* check to see if we allow printername != sharename */
5834 if (lp_force_printername(snum)) {
5835 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
5836 global_myname(), info2->sharename);
5837 } else {
5838 /* make sure printername is in \\server\printername format */
5839 fstrcpy(printername, info2->printername);
5840 p = printername;
5841 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5842 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5843 p++;
5844 }
5845
5846 info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
5847 global_myname(), p);
5848 }
5849 if (info2->printername == NULL) {
5850 return false;
5851 }
5852
5853 info2->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5854 info2->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5855
5856 return true;
5857 }
5858
5859 /****************************************************************************
5860 ****************************************************************************/
5861
5862 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5863 {
5864 char *cmd = lp_addport_cmd();
5865 char *command = NULL;
5866 int ret;
5867 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5868 bool is_print_op = false;
5869
5870 if ( !*cmd ) {
5871 return WERR_ACCESS_DENIED;
5872 }
5873
5874 command = talloc_asprintf(ctx,
5875 "%s \"%s\" \"%s\"", cmd, portname, uri );
5876 if (!command) {
5877 return WERR_NOMEM;
5878 }
5879
5880 if ( token )
5881 is_print_op = user_has_privileges( token, &se_printop );
5882
5883 DEBUG(10,("Running [%s]\n", command));
5884
5885 /********* BEGIN SePrintOperatorPrivilege **********/
5886
5887 if ( is_print_op )
5888 become_root();
5889
5890 ret = smbrun(command, NULL);
5891
5892 if ( is_print_op )
5893 unbecome_root();
5894
5895 /********* END SePrintOperatorPrivilege **********/
5896
5897 DEBUGADD(10,("returned [%d]\n", ret));
5898
5899 TALLOC_FREE(command);
5900
5901 if ( ret != 0 ) {
5902 return WERR_ACCESS_DENIED;
5903 }
5904
5905 return WERR_OK;
5906 }
5907
5908 /****************************************************************************
5909 ****************************************************************************/
5910
5911 static bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token,
5912 struct spoolss_SetPrinterInfo2 *info2,
5913 const char *remote_machine,
5914 struct messaging_context *msg_ctx)
5915 {
5916 char *cmd = lp_addprinter_cmd();
5917 char **qlines;
5918 char *command = NULL;
5919 int numlines;
5920 int ret;
5921 int fd;
5922 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5923 bool is_print_op = false;
5924
5925 if (!remote_machine) {
5926 return false;
5927 }
5928
5929 command = talloc_asprintf(ctx,
5930 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5931 cmd, info2->printername, info2->sharename,
5932 info2->portname, info2->drivername,
5933 info2->location, info2->comment, remote_machine);
5934 if (!command) {
5935 return false;
5936 }
5937
5938 if ( token )
5939 is_print_op = user_has_privileges( token, &se_printop );
5940
5941 DEBUG(10,("Running [%s]\n", command));
5942
5943 /********* BEGIN SePrintOperatorPrivilege **********/
5944
5945 if ( is_print_op )
5946 become_root();
5947
5948 if ( (ret = smbrun(command, &fd)) == 0 ) {
5949 /* Tell everyone we updated smb.conf. */
5950 message_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
5951 }
5952
5953 if ( is_print_op )
5954 unbecome_root();
5955
5956 /********* END SePrintOperatorPrivilege **********/
5957
5958 DEBUGADD(10,("returned [%d]\n", ret));
5959
5960 TALLOC_FREE(command);
5961
5962 if ( ret != 0 ) {
5963 if (fd != -1)
5964 close(fd);
5965 return false;
5966 }
5967
5968 /* reload our services immediately */
5969 become_root();
5970 reload_services(msg_ctx, -1, false);
5971 unbecome_root();
5972
5973 numlines = 0;
5974 /* Get lines and convert them back to dos-codepage */
5975 qlines = fd_lines_load(fd, &numlines, 0, NULL);
5976 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
5977 close(fd);
5978
5979 /* Set the portname to what the script says the portname should be. */
5980 /* but don't require anything to be return from the script exit a good error code */
5981
5982 if (numlines) {
5983 /* Set the portname to what the script says the portname should be. */
5984 info2->portname = talloc_strdup(ctx, qlines[0]);
5985 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
5986 }
5987
5988 TALLOC_FREE(qlines);
5989 return true;
5990 }
5991
5992 static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
5993 const struct auth_serversupplied_info *server_info,
5994 struct messaging_context *msg_ctx,
5995 int snum,
5996 struct spoolss_SetPrinterInfo2 *printer,
5997 struct spoolss_PrinterInfo2 *old_printer)
5998 {
5999 bool force_update = (old_printer == NULL);
6000 const char *dnsdomname;
6001 const char *longname;
6002 const char *uncname;
6003 const char *spooling;
6004 DATA_BLOB buffer;
6005 WERROR result = WERR_OK;
6006
6007 if (force_update || !strequal(printer->drivername, old_printer->drivername)) {
6008 push_reg_sz(mem_ctx, &buffer, printer->drivername);
6009 winreg_set_printer_dataex(mem_ctx,
6010 server_info,
6011 msg_ctx,
6012 printer->sharename,
6013 SPOOL_DSSPOOLER_KEY,
6014 SPOOL_REG_DRIVERNAME,
6015 REG_SZ,
6016 buffer.data,
6017 buffer.length);
6018
6019 if (!force_update) {
6020 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
6021 printer->drivername));
6022
6023 notify_printer_driver(server_event_context(), msg_ctx,
6024 snum, printer->drivername);
6025 }
6026 }
6027
6028 if (force_update || !strequal(printer->comment, old_printer->comment)) {
6029 push_reg_sz(mem_ctx, &buffer, printer->comment);
6030 winreg_set_printer_dataex(mem_ctx,
6031 server_info,
6032 msg_ctx,
6033 printer->sharename,
6034 SPOOL_DSSPOOLER_KEY,
6035 SPOOL_REG_DESCRIPTION,
6036 REG_SZ,
6037 buffer.data,
6038 buffer.length);
6039
6040 if (!force_update) {
6041 notify_printer_comment(server_event_context(), msg_ctx,
6042 snum, printer->comment);
6043 }
6044 }
6045
6046 if (force_update || !strequal(printer->sharename, old_printer->sharename)) {
6047 push_reg_sz(mem_ctx, &buffer, printer->sharename);
6048 winreg_set_printer_dataex(mem_ctx,
6049 server_info,
6050 msg_ctx,
6051 printer->sharename,
6052 SPOOL_DSSPOOLER_KEY,
6053 SPOOL_REG_PRINTSHARENAME,
6054 REG_SZ,
6055 buffer.data,
6056 buffer.length);
6057
6058 if (!force_update) {
6059 notify_printer_sharename(server_event_context(),
6060 msg_ctx,
6061 snum, printer->sharename);
6062 }
6063 }
6064
6065 if (force_update || !strequal(printer->printername, old_printer->printername)) {
6066 const char *p;
6067
6068 p = strrchr(printer->printername, '\\' );
6069 if (p != NULL) {
6070 p++;
6071 } else {
6072 p = printer->printername;
6073 }
6074
6075 push_reg_sz(mem_ctx, &buffer, p);
6076 winreg_set_printer_dataex(mem_ctx,
6077 server_info,
6078 msg_ctx,
6079 printer->sharename,
6080 SPOOL_DSSPOOLER_KEY,
6081 SPOOL_REG_PRINTERNAME,
6082 REG_SZ,
6083 buffer.data,
6084 buffer.length);
6085
6086 if (!force_update) {
6087 notify_printer_printername(server_event_context(),
6088 msg_ctx, snum, p);
6089 }
6090 }
6091
6092 if (force_update || !strequal(printer->portname, old_printer->portname)) {
6093 push_reg_sz(mem_ctx, &buffer, printer->portname);
6094 winreg_set_printer_dataex(mem_ctx,
6095 server_info,
6096 msg_ctx,
6097 printer->sharename,
6098 SPOOL_DSSPOOLER_KEY,
6099 SPOOL_REG_PORTNAME,
6100 REG_SZ,
6101 buffer.data,
6102 buffer.length);
6103
6104 if (!force_update) {
6105 notify_printer_port(server_event_context(),
6106 msg_ctx, snum, printer->portname);
6107 }
6108 }
6109
6110 if (force_update || !strequal(printer->location, old_printer->location)) {
6111 push_reg_sz(mem_ctx, &buffer, printer->location);
6112 winreg_set_printer_dataex(mem_ctx,
6113 server_info,
6114 msg_ctx,
6115 printer->sharename,
6116 SPOOL_DSSPOOLER_KEY,
6117 SPOOL_REG_LOCATION,
6118 REG_SZ,
6119 buffer.data,
6120 buffer.length);
6121
6122 if (!force_update) {
6123 notify_printer_location(server_event_context(),
6124 msg_ctx, snum,
6125 printer->location);
6126 }
6127 }
6128
6129 if (force_update || !strequal(printer->sepfile, old_printer->sepfile)) {
6130 push_reg_sz(mem_ctx, &buffer, printer->sepfile);
6131 winreg_set_printer_dataex(mem_ctx,
6132 server_info,
6133 msg_ctx,
6134 printer->sharename,
6135 SPOOL_DSSPOOLER_KEY,
6136 SPOOL_REG_PRINTSEPARATORFILE,
6137 REG_SZ,
6138 buffer.data,
6139 buffer.length);
6140
6141 if (!force_update) {
6142 notify_printer_location(server_event_context(),
6143 msg_ctx, snum,
6144 printer->location);
6145 }
6146 }
6147
6148 if (force_update || printer->starttime != old_printer->starttime) {
6149 buffer = data_blob_talloc(mem_ctx, NULL, 4);
6150 SIVAL(buffer.data, 0, printer->starttime);
6151 winreg_set_printer_dataex(mem_ctx,
6152 server_info,
6153 msg_ctx,
6154 printer->sharename,
6155 SPOOL_DSSPOOLER_KEY,
6156 SPOOL_REG_PRINTSTARTTIME,
6157 REG_DWORD,
6158 buffer.data,
6159 buffer.length);
6160 }
6161
6162 if (force_update || printer->untiltime != old_printer->untiltime) {
6163 buffer = data_blob_talloc(mem_ctx, NULL, 4);
6164 SIVAL(buffer.data, 0, printer->untiltime);
6165 winreg_set_printer_dataex(mem_ctx,
6166 server_info,
6167 msg_ctx,
6168 printer->sharename,
6169 SPOOL_DSSPOOLER_KEY,
6170 SPOOL_REG_PRINTENDTIME,
6171 REG_DWORD,
6172 buffer.data,
6173 buffer.length);
6174 }
6175
6176 if (force_update || printer->priority != old_printer->priority) {
6177 buffer = data_blob_talloc(mem_ctx, NULL, 4);
6178 SIVAL(buffer.data, 0, printer->priority);
6179 winreg_set_printer_dataex(mem_ctx,
6180 server_info,
6181 msg_ctx,
6182 printer->sharename,
6183 SPOOL_DSSPOOLER_KEY,
6184 SPOOL_REG_PRIORITY,
6185 REG_DWORD,
6186 buffer.data,
6187 buffer.length);
6188 }
6189
6190 if (force_update || printer->attributes != old_printer->attributes) {
6191 buffer = data_blob_talloc(mem_ctx, NULL, 4);
6192 SIVAL(buffer.data, 0, (printer->attributes &
6193 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
6194 winreg_set_printer_dataex(mem_ctx,
6195 server_info,
6196 msg_ctx,
6197 printer->sharename,
6198 SPOOL_DSSPOOLER_KEY,
6199 SPOOL_REG_PRINTKEEPPRINTEDJOBS,
6200 REG_DWORD,
6201 buffer.data,
6202 buffer.length);
6203
6204 switch (printer->attributes & 0x3) {
6205 case 0:
6206 spooling = SPOOL_REGVAL_PRINTWHILESPOOLING;
6207 break;
6208 case 1:
6209 spooling = SPOOL_REGVAL_PRINTAFTERSPOOLED;
6210 break;
6211 case 2:
6212 spooling = SPOOL_REGVAL_PRINTDIRECT;
6213 break;
6214 default:
6215 spooling = "unknown";
6216 }
6217 push_reg_sz(mem_ctx, &buffer, spooling);
6218 winreg_set_printer_dataex(mem_ctx,
6219 server_info,
6220 msg_ctx,
6221 printer->sharename,
6222 SPOOL_DSSPOOLER_KEY,
6223 SPOOL_REG_PRINTSPOOLING,
6224 REG_SZ,
6225 buffer.data,
6226 buffer.length);
6227 }
6228
6229 push_reg_sz(mem_ctx, &buffer, global_myname());
6230 winreg_set_printer_dataex(mem_ctx,
6231 server_info,
6232 msg_ctx,
6233 printer->sharename,
6234 SPOOL_DSSPOOLER_KEY,
6235 SPOOL_REG_SHORTSERVERNAME,
6236 REG_SZ,
6237 buffer.data,
6238 buffer.length);
6239
6240 dnsdomname = get_mydnsfullname();
6241 if (dnsdomname != NULL && dnsdomname[0] != '\0') {
6242 longname = talloc_strdup(mem_ctx, dnsdomname);
6243 } else {
6244 longname = talloc_strdup(mem_ctx, global_myname());
6245 }
6246 if (longname == NULL) {
6247 result = WERR_NOMEM;
6248 goto done;
6249 }
6250
6251 push_reg_sz(mem_ctx, &buffer, longname);
6252 winreg_set_printer_dataex(mem_ctx,
6253 server_info,
6254 msg_ctx,
6255 printer->sharename,
6256 SPOOL_DSSPOOLER_KEY,
6257 SPOOL_REG_SERVERNAME,
6258 REG_SZ,
6259 buffer.data,
6260 buffer.length);
6261
6262 uncname = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
6263 global_myname(), printer->sharename);
6264 push_reg_sz(mem_ctx, &buffer, uncname);
6265 winreg_set_printer_dataex(mem_ctx,
6266 server_info,
6267 msg_ctx,
6268 printer->sharename,
6269 SPOOL_DSSPOOLER_KEY,
6270 SPOOL_REG_UNCNAME,
6271 REG_SZ,
6272 buffer.data,
6273 buffer.length);
6274
6275 done:
6276 return result;
6277 }
6278
6279 /********************************************************************
6280 * Called by spoolss_api_setprinter
6281 * when updating a printer description.
6282 ********************************************************************/
6283
6284 static WERROR update_printer(struct pipes_struct *p,
6285 struct policy_handle *handle,
6286 struct spoolss_SetPrinterInfoCtr *info_ctr,
6287 struct spoolss_DeviceMode *devmode)
6288 {
6289 uint32_t printer_mask = SPOOLSS_PRINTER_INFO_ALL;
6290 struct spoolss_SetPrinterInfo2 *printer = info_ctr->info.info2;
6291 struct spoolss_PrinterInfo2 *old_printer;
6292 struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6293 const char *servername = NULL;
6294 int snum;
6295 WERROR result = WERR_OK;
6296 TALLOC_CTX *tmp_ctx;
6297
6298 DEBUG(8,("update_printer\n"));
6299
6300 tmp_ctx = talloc_new(p->mem_ctx);
6301 if (tmp_ctx == NULL) {
6302 return WERR_NOMEM;
6303 }
6304
6305 if (!Printer) {
6306 result = WERR_BADFID;
6307 goto done;
6308 }
6309
6310 if (!get_printer_snum(p, handle, &snum, NULL)) {
6311 result = WERR_BADFID;
6312 goto done;
6313 }
6314
6315 if (Printer != NULL || Printer->servername != NULL) {
6316 servername = Printer->servername;
6317 }
6318
6319 result = winreg_get_printer(tmp_ctx,
6320 get_server_info_system(),
6321 p->msg_ctx,
6322 servername,
6323 lp_const_servicename(snum),
6324 &old_printer);
6325 if (!W_ERROR_IS_OK(result)) {
6326 result = WERR_BADFID;
6327 goto done;
6328 }
6329
6330 /* Do sanity check on the requested changes for Samba */
6331 if (!check_printer_ok(tmp_ctx, printer, snum)) {
6332 result = WERR_INVALID_PARAM;
6333 goto done;
6334 }
6335
6336 /* FIXME!!! If the driver has changed we really should verify that
6337 it is installed before doing much else --jerry */
6338
6339 /* Check calling user has permission to update printer description */
6340 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6341 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6342 result = WERR_ACCESS_DENIED;
6343 goto done;
6344 }
6345
6346 /* Call addprinter hook */
6347 /* Check changes to see if this is really needed */
6348
6349 if (*lp_addprinter_cmd() &&
6350 (!strequal(printer->drivername, old_printer->drivername) ||
6351 !strequal(printer->comment, old_printer->comment) ||
6352 !strequal(printer->portname, old_printer->portname) ||
6353 !strequal(printer->location, old_printer->location)) )
6354 {
6355 /* add_printer_hook() will call reload_services() */
6356 if (!add_printer_hook(tmp_ctx, p->server_info->ptok,
6357 printer, p->client_id->addr,
6358 p->msg_ctx)) {
6359 result = WERR_ACCESS_DENIED;
6360 goto done;
6361 }
6362 }
6363
6364 update_dsspooler(tmp_ctx,
6365 get_server_info_system(),
6366 p->msg_ctx,
6367 snum,
6368 printer,
6369 old_printer);
6370
6371 printer_mask &= ~SPOOLSS_PRINTER_INFO_SECDESC;
6372
6373 if (devmode == NULL) {
6374 printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
6375 }
6376 result = winreg_update_printer(tmp_ctx,
6377 get_server_info_system(),
6378 p->msg_ctx,
6379 printer->sharename,
6380 printer_mask,
6381 printer,
6382 devmode,
6383 NULL);
6384
6385 done:
6386 talloc_free(tmp_ctx);
6387
6388 return result;
6389 }
6390
6391 /****************************************************************************
6392 ****************************************************************************/
6393 static WERROR publish_or_unpublish_printer(struct pipes_struct *p,
6394 struct policy_handle *handle,
6395 struct spoolss_SetPrinterInfo7 *info7)
6396 {
6397 #ifdef HAVE_ADS
6398 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
6399 WERROR result;
6400 int snum;
6401 struct printer_handle *Printer;
6402
6403 if ( lp_security() != SEC_ADS ) {
6404 return WERR_UNKNOWN_LEVEL;
6405 }
6406
6407 Printer = find_printer_index_by_hnd(p, handle);
6408
6409 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6410
6411 if (!Printer)
6412 return WERR_BADFID;
6413
6414 if (!get_printer_snum(p, handle, &snum, NULL))
6415 return WERR_BADFID;
6416
6417 result = winreg_get_printer(p->mem_ctx,
6418 get_server_info_system(),
6419 p->msg_ctx,
6420 Printer->servername,
6421 lp_servicename(snum),
6422 &pinfo2);
6423 if (!W_ERROR_IS_OK(result)) {
6424 return WERR_BADFID;
6425 }
6426
6427 nt_printer_publish(pinfo2,
6428 get_server_info_system(),
6429 p->msg_ctx,
6430 pinfo2,
6431 info7->action);
6432
6433 TALLOC_FREE(pinfo2);
6434 return WERR_OK;
6435 #else
6436 return WERR_UNKNOWN_LEVEL;
6437 #endif
6438 }
6439
6440 /********************************************************************
6441 ********************************************************************/
6442
6443 static WERROR update_printer_devmode(struct pipes_struct *p,
6444 struct policy_handle *handle,
6445 struct spoolss_DeviceMode *devmode)
6446 {
6447 int snum;
6448 struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
6449 uint32_t info2_mask = SPOOLSS_PRINTER_INFO_DEVMODE;
6450
6451 DEBUG(8,("update_printer_devmode\n"));
6452
6453 if (!Printer) {
6454 return WERR_BADFID;
6455 }
6456
6457 if (!get_printer_snum(p, handle, &snum, NULL)) {
6458 return WERR_BADFID;
6459 }
6460
6461 /* Check calling user has permission to update printer description */
6462 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6463 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6464 return WERR_ACCESS_DENIED;
6465 }
6466
6467 return winreg_update_printer(p->mem_ctx,
6468 get_server_info_system(),
6469 p->msg_ctx,
6470 lp_const_servicename(snum),
6471 info2_mask,
6472 NULL,
6473 devmode,
6474 NULL);
6475 }
6476
6477
6478 /****************************************************************
6479 _spoolss_SetPrinter
6480 ****************************************************************/
6481
6482 WERROR _spoolss_SetPrinter(struct pipes_struct *p,
6483 struct spoolss_SetPrinter *r)
6484 {
6485 WERROR result;
6486
6487 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
6488
6489 if (!Printer) {
6490 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6491 OUR_HANDLE(r->in.handle)));
6492 return WERR_BADFID;
6493 }
6494
6495 /* check the level */
6496 switch (r->in.info_ctr->level) {
6497 case 0:
6498 return control_printer(r->in.handle, r->in.command, p);
6499 case 2:
6500 result = update_printer(p, r->in.handle,
6501 r->in.info_ctr,
6502 r->in.devmode_ctr->devmode);
6503 if (!W_ERROR_IS_OK(result))
6504 return result;
6505 if (r->in.secdesc_ctr->sd)
6506 result = update_printer_sec(r->in.handle, p,
6507 r->in.secdesc_ctr);
6508 return result;
6509 case 3:
6510 return update_printer_sec(r->in.handle, p,
6511 r->in.secdesc_ctr);
6512 case 7:
6513 return publish_or_unpublish_printer(p, r->in.handle,
6514 r->in.info_ctr->info.info7);
6515 case 8:
6516 return update_printer_devmode(p, r->in.handle,
6517 r->in.devmode_ctr->devmode);
6518 default:
6519 return WERR_UNKNOWN_LEVEL;
6520 }
6521 }
6522
6523 /****************************************************************
6524 _spoolss_FindClosePrinterNotify
6525 ****************************************************************/
6526
6527 WERROR _spoolss_FindClosePrinterNotify(struct pipes_struct *p,
6528 struct spoolss_FindClosePrinterNotify *r)
6529 {
6530 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
6531
6532 if (!Printer) {
6533 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6534 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6535 return WERR_BADFID;
6536 }
6537
6538 if (Printer->notify.cli_chan != NULL &&
6539 Printer->notify.cli_chan->active_connections > 0) {
6540 int snum = -1;
6541
6542 if (Printer->printer_type == SPLHND_PRINTER) {
6543 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6544 return WERR_BADFID;
6545 }
6546 }
6547
6548 srv_spoolss_replycloseprinter(snum, Printer);
6549 }
6550
6551 Printer->notify.flags=0;
6552 Printer->notify.options=0;
6553 Printer->notify.localmachine[0]='\0';
6554 Printer->notify.printerlocal=0;
6555 TALLOC_FREE(Printer->notify.option);
6556
6557 return WERR_OK;
6558 }
6559
6560 /****************************************************************
6561 _spoolss_AddJob
6562 ****************************************************************/
6563
6564 WERROR _spoolss_AddJob(struct pipes_struct *p,
6565 struct spoolss_AddJob *r)
6566 {
6567 if (!r->in.buffer && (r->in.offered != 0)) {
6568 return WERR_INVALID_PARAM;
6569 }
6570
6571 /* this is what a NT server returns for AddJob. AddJob must fail on
6572 * non-local printers */
6573
6574 if (r->in.level != 1) {
6575 return WERR_UNKNOWN_LEVEL;
6576 }
6577
6578 return WERR_INVALID_PARAM;
6579 }
6580
6581 /****************************************************************************
6582 fill_job_info1
6583 ****************************************************************************/
6584
6585 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6586 struct spoolss_JobInfo1 *r,
6587 const print_queue_struct *queue,
6588 int position, int snum,
6589 struct spoolss_PrinterInfo2 *pinfo2)
6590 {
6591 struct tm *t;
6592
6593 t = gmtime(&queue->time);
6594
6595 r->job_id = queue->job;
6596
6597 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6598 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6599 r->server_name = talloc_strdup(mem_ctx, pinfo2->servername);
6600 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6601 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6602 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6603 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6604 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6605 r->data_type = talloc_strdup(mem_ctx, "RAW");
6606 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6607 r->text_status = talloc_strdup(mem_ctx, "");
6608 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6609
6610 r->status = nt_printj_status(queue->status);
6611 r->priority = queue->priority;
6612 r->position = position;
6613 r->total_pages = queue->page_count;
6614 r->pages_printed = 0; /* ??? */
6615
6616 init_systemtime(&r->submitted, t);
6617
6618 return WERR_OK;
6619 }
6620
6621 /****************************************************************************
6622 fill_job_info2
6623 ****************************************************************************/
6624
6625 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6626 struct spoolss_JobInfo2 *r,
6627 const print_queue_struct *queue,
6628 int position, int snum,
6629 struct spoolss_PrinterInfo2 *pinfo2,
6630 struct spoolss_DeviceMode *devmode)
6631 {
6632 struct tm *t;
6633
6634 t = gmtime(&queue->time);
6635
6636 r->job_id = queue->job;
6637
6638 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6639 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6640 r->server_name = talloc_strdup(mem_ctx, pinfo2->servername);
6641 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6642 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6643 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6644 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6645 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6646 r->notify_name = talloc_strdup(mem_ctx, queue->fs_user);
6647 W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6648 r->data_type = talloc_strdup(mem_ctx, "RAW");
6649 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6650 r->print_processor = talloc_strdup(mem_ctx, "winprint");
6651 W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6652 r->parameters = talloc_strdup(mem_ctx, "");
6653 W_ERROR_HAVE_NO_MEMORY(r->parameters);
6654 r->driver_name = talloc_strdup(mem_ctx, pinfo2->drivername);
6655 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6656
6657 r->devmode = devmode;
6658
6659 r->text_status = talloc_strdup(mem_ctx, "");
6660 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6661
6662 r->secdesc = NULL;
6663
6664 r->status = nt_printj_status(queue->status);
6665 r->priority = queue->priority;
6666 r->position = position;
6667 r->start_time = 0;
6668 r->until_time = 0;
6669 r->total_pages = queue->page_count;
6670 r->size = queue->size;
6671 init_systemtime(&r->submitted, t);
6672 r->time = 0;
6673 r->pages_printed = 0; /* ??? */
6674
6675 return WERR_OK;
6676 }
6677
6678 /****************************************************************************
6679 fill_job_info3
6680 ****************************************************************************/
6681
6682 static WERROR fill_job_info3(TALLOC_CTX *mem_ctx,
6683 struct spoolss_JobInfo3 *r,
6684 const print_queue_struct *queue,
6685 const print_queue_struct *next_queue,
6686 int position, int snum,
6687 struct spoolss_PrinterInfo2 *pinfo2)
6688 {
6689 r->job_id = queue->job;
6690 r->next_job_id = 0;
6691 if (next_queue) {
6692 r->next_job_id = next_queue->job;
6693 }
6694 r->reserved = 0;
6695
6696 return WERR_OK;
6697 }
6698
6699 /****************************************************************************
6700 Enumjobs at level 1.
6701 ****************************************************************************/
6702
6703 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6704 const print_queue_struct *queue,
6705 uint32_t num_queues, int snum,
6706 struct spoolss_PrinterInfo2 *pinfo2,
6707 union spoolss_JobInfo **info_p,
6708 uint32_t *count)
6709 {
6710 union spoolss_JobInfo *info;
6711 int i;
6712 WERROR result = WERR_OK;
6713
6714 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6715 W_ERROR_HAVE_NO_MEMORY(info);
6716
6717 *count = num_queues;
6718
6719 for (i=0; i<*count; i++) {
6720 result = fill_job_info1(info,
6721 &info[i].info1,
6722 &queue[i],
6723 i,
6724 snum,
6725 pinfo2);
6726 if (!W_ERROR_IS_OK(result)) {
6727 goto out;
6728 }
6729 }
6730
6731 out:
6732 if (!W_ERROR_IS_OK(result)) {
6733 TALLOC_FREE(info);
6734 *count = 0;
6735 return result;
6736 }
6737
6738 *info_p = info;
6739
6740 return WERR_OK;
6741 }
6742
6743 /****************************************************************************
6744 Enumjobs at level 2.
6745 ****************************************************************************/
6746
6747 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6748 const print_queue_struct *queue,
6749 uint32_t num_queues, int snum,
6750 struct spoolss_PrinterInfo2 *pinfo2,
6751 union spoolss_JobInfo **info_p,
6752 uint32_t *count)
6753 {
6754 union spoolss_JobInfo *info;
6755 int i;
6756 WERROR result = WERR_OK;
6757
6758 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6759 W_ERROR_HAVE_NO_MEMORY(info);
6760
6761 *count = num_queues;
6762
6763 for (i=0; i<*count; i++) {
6764 struct spoolss_DeviceMode *devmode;
6765
6766 result = spoolss_create_default_devmode(info,
6767 pinfo2->printername,
6768 &devmode);
6769 if (!W_ERROR_IS_OK(result)) {
6770 DEBUG(3, ("Can't proceed w/o a devmode!"));
6771 goto out;
6772 }
6773
6774 result = fill_job_info2(info,
6775 &info[i].info2,
6776 &queue[i],
6777 i,
6778 snum,
6779 pinfo2,
6780 devmode);
6781 if (!W_ERROR_IS_OK(result)) {
6782 goto out;
6783 }
6784 }
6785
6786 out:
6787 if (!W_ERROR_IS_OK(result)) {
6788 TALLOC_FREE(info);
6789 *count = 0;
6790 return result;
6791 }
6792
6793 *info_p = info;
6794
6795 return WERR_OK;
6796 }
6797
6798 /****************************************************************************
6799 Enumjobs at level 3.
6800 ****************************************************************************/
6801
6802 static WERROR enumjobs_level3(TALLOC_CTX *mem_ctx,
6803 const print_queue_struct *queue,
6804 uint32_t num_queues, int snum,
6805 struct spoolss_PrinterInfo2 *pinfo2,
6806 union spoolss_JobInfo **info_p,
6807 uint32_t *count)
6808 {
6809 union spoolss_JobInfo *info;
6810 int i;
6811 WERROR result = WERR_OK;
6812
6813 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6814 W_ERROR_HAVE_NO_MEMORY(info);
6815
6816 *count = num_queues;
6817
6818 for (i=0; i<*count; i++) {
6819 const print_queue_struct *next_queue = NULL;
6820
6821 if (i+1 < *count) {
6822 next_queue = &queue[i+1];
6823 }
6824
6825 result = fill_job_info3(info,
6826 &info[i].info3,
6827 &queue[i],
6828 next_queue,
6829 i,
6830 snum,
6831 pinfo2);
6832 if (!W_ERROR_IS_OK(result)) {
6833 goto out;
6834 }
6835 }
6836
6837 out:
6838 if (!W_ERROR_IS_OK(result)) {
6839 TALLOC_FREE(info);
6840 *count = 0;
6841 return result;
6842 }
6843
6844 *info_p = info;
6845
6846 return WERR_OK;
6847 }
6848
6849 /****************************************************************
6850 _spoolss_EnumJobs
6851 ****************************************************************/
6852
6853 WERROR _spoolss_EnumJobs(struct pipes_struct *p,
6854 struct spoolss_EnumJobs *r)
6855 {
6856 WERROR result;
6857 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
6858 int snum;
6859 print_status_struct prt_status;
6860 print_queue_struct *queue = NULL;
6861 uint32_t count;
6862
6863 /* that's an [in out] buffer */
6864
6865 if (!r->in.buffer && (r->in.offered != 0)) {
6866 return WERR_INVALID_PARAM;
6867 }
6868
6869 DEBUG(4,("_spoolss_EnumJobs\n"));
6870
6871 *r->out.needed = 0;
6872 *r->out.count = 0;
6873 *r->out.info = NULL;
6874
6875 /* lookup the printer snum and tdb entry */
6876
6877 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6878 return WERR_BADFID;
6879 }
6880
6881 result = winreg_get_printer(p->mem_ctx,
6882 get_server_info_system(),
6883 p->msg_ctx,
6884 NULL,
6885 lp_const_servicename(snum),
6886 &pinfo2);
6887 if (!W_ERROR_IS_OK(result)) {
6888 return result;
6889 }
6890
6891 count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
6892 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6893 count, prt_status.status, prt_status.message));
6894
6895 if (count == 0) {
6896 SAFE_FREE(queue);
6897 TALLOC_FREE(pinfo2);
6898 return WERR_OK;
6899 }
6900
6901 switch (r->in.level) {
6902 case 1:
6903 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6904 pinfo2, r->out.info, r->out.count);
6905 break;
6906 case 2:
6907 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6908 pinfo2, r->out.info, r->out.count);
6909 break;
6910 case 3:
6911 result = enumjobs_level3(p->mem_ctx, queue, count, snum,
6912 pinfo2, r->out.info, r->out.count);
6913 break;
6914 default:
6915 result = WERR_UNKNOWN_LEVEL;
6916 break;
6917 }
6918
6919 SAFE_FREE(queue);
6920 TALLOC_FREE(pinfo2);
6921
6922 if (!W_ERROR_IS_OK(result)) {
6923 return result;
6924 }
6925
6926 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6927 spoolss_EnumJobs,
6928 *r->out.info, r->in.level,
6929 *r->out.count);
6930 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6931 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6932
6933 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6934 }
6935
6936 /****************************************************************
6937 _spoolss_ScheduleJob
6938 ****************************************************************/
6939
6940 WERROR _spoolss_ScheduleJob(struct pipes_struct *p,
6941 struct spoolss_ScheduleJob *r)
6942 {
6943 return WERR_OK;
6944 }
6945
6946 /****************************************************************
6947 ****************************************************************/
6948
6949 static WERROR spoolss_setjob_1(TALLOC_CTX *mem_ctx,
6950 struct messaging_context *msg_ctx,
6951 const char *printer_name,
6952 uint32_t job_id,
6953 struct spoolss_SetJobInfo1 *r)
6954 {
6955 char *old_doc_name;
6956
6957 if (!print_job_get_name(mem_ctx, printer_name, job_id, &old_doc_name)) {
6958 return WERR_BADFID;
6959 }
6960
6961 if (strequal(old_doc_name, r->document_name)) {
6962 return WERR_OK;
6963 }
6964
6965 if (!print_job_set_name(server_event_context(), msg_ctx,
6966 printer_name, job_id, r->document_name)) {
6967 return WERR_BADFID;
6968 }
6969
6970 return WERR_OK;
6971 }
6972
6973 /****************************************************************
6974 _spoolss_SetJob
6975 ****************************************************************/
6976
6977 WERROR _spoolss_SetJob(struct pipes_struct *p,
6978 struct spoolss_SetJob *r)
6979 {
6980 const struct auth_serversupplied_info *server_info = get_server_info_system();
6981 int snum;
6982 WERROR errcode = WERR_BADFUNC;
6983
6984 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6985 return WERR_BADFID;
6986 }
6987
6988 if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6989 return WERR_INVALID_PRINTER_NAME;
6990 }
6991
6992 switch (r->in.command) {
6993 case SPOOLSS_JOB_CONTROL_CANCEL:
6994 case SPOOLSS_JOB_CONTROL_DELETE:
6995 errcode = print_job_delete(server_info, p->msg_ctx,
6996 snum, r->in.job_id);
6997 if (W_ERROR_EQUAL(errcode, WERR_PRINTER_HAS_JOBS_QUEUED)) {
6998 errcode = WERR_OK;
6999 }
7000 break;
7001 case SPOOLSS_JOB_CONTROL_PAUSE:
7002 if (print_job_pause(server_info, p->msg_ctx,
7003 snum, r->in.job_id, &errcode)) {
7004 errcode = WERR_OK;
7005 }
7006 break;
7007 case SPOOLSS_JOB_CONTROL_RESTART:
7008 case SPOOLSS_JOB_CONTROL_RESUME:
7009 if (print_job_resume(server_info, p->msg_ctx,
7010 snum, r->in.job_id, &errcode)) {
7011 errcode = WERR_OK;
7012 }
7013 break;
7014 case 0:
7015 errcode = WERR_OK;
7016 break;
7017 default:
7018 return WERR_UNKNOWN_LEVEL;
7019 }
7020
7021 if (!W_ERROR_IS_OK(errcode)) {
7022 return errcode;
7023 }
7024
7025 if (r->in.ctr == NULL) {
7026 return errcode;
7027 }
7028
7029 switch (r->in.ctr->level) {
7030 case 1:
7031 errcode = spoolss_setjob_1(p->mem_ctx, p->msg_ctx,
7032 lp_const_servicename(snum),
7033 r->in.job_id,
7034 r->in.ctr->info.info1);
7035 break;
7036 case 2:
7037 case 3:
7038 case 4:
7039 default:
7040 return WERR_UNKNOWN_LEVEL;
7041 }
7042
7043 return errcode;
7044 }
7045
7046 /****************************************************************************
7047 Enumerates all printer drivers by level and architecture.
7048 ****************************************************************************/
7049
7050 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
7051 const struct auth_serversupplied_info *server_info,
7052 struct messaging_context *msg_ctx,
7053 const char *servername,
7054 const char *architecture,
7055 uint32_t level,
7056 union spoolss_DriverInfo **info_p,
7057 uint32_t *count_p)
7058 {
7059 int i;
7060 uint32_t version;
7061 struct spoolss_DriverInfo8 *driver;
7062 union spoolss_DriverInfo *info = NULL;
7063 uint32_t count = 0;
7064 WERROR result = WERR_OK;
7065 uint32_t num_drivers;
7066 const char **drivers;
7067
7068 *count_p = 0;
7069 *info_p = NULL;
7070
7071 for (version=0; version<DRIVER_MAX_VERSION; version++) {
7072 result = winreg_get_driver_list(mem_ctx, server_info, msg_ctx,
7073 architecture, version,
7074 &num_drivers, &drivers);
7075 if (!W_ERROR_IS_OK(result)) {
7076 goto out;
7077 }
7078 DEBUG(4, ("we have:[%d] drivers in environment"
7079 " [%s] and version [%d]\n",
7080 num_drivers, architecture, version));
7081
7082 if (num_drivers != 0) {
7083 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
7084 union spoolss_DriverInfo,
7085 count + num_drivers);
7086 if (!info) {
7087 DEBUG(0,("enumprinterdrivers_level_by_architecture: "
7088 "failed to enlarge driver info buffer!\n"));
7089 result = WERR_NOMEM;
7090 goto out;
7091 }
7092 }
7093
7094 for (i = 0; i < num_drivers; i++) {
7095 DEBUG(5, ("\tdriver: [%s]\n", drivers[i]));
7096
7097 result = winreg_get_driver(mem_ctx, server_info,
7098 msg_ctx,
7099 architecture, drivers[i],
7100 version, &driver);
7101 if (!W_ERROR_IS_OK(result)) {
7102 goto out;
7103 }
7104
7105 switch (level) {
7106 case 1:
7107 result = fill_printer_driver_info1(info, &info[count+i].info1,
7108 driver, servername);
7109 break;
7110 case 2:
7111 result = fill_printer_driver_info2(info, &info[count+i].info2,
7112 driver, servername);
7113 break;
7114 case 3:
7115 result = fill_printer_driver_info3(info, &info[count+i].info3,
7116 driver, servername);
7117 break;
7118 case 4:
7119 result = fill_printer_driver_info4(info, &info[count+i].info4,
7120 driver, servername);
7121 break;
7122 case 5:
7123 result = fill_printer_driver_info5(info, &info[count+i].info5,
7124 driver, servername);
7125 break;
7126 case 6:
7127 result = fill_printer_driver_info6(info, &info[count+i].info6,
7128 driver, servername);
7129 break;
7130 case 8:
7131 result = fill_printer_driver_info8(info, &info[count+i].info8,
7132 driver, servername);
7133 break;
7134 default:
7135 result = WERR_UNKNOWN_LEVEL;
7136 break;
7137 }
7138
7139 TALLOC_FREE(driver);
7140
7141 if (!W_ERROR_IS_OK(result)) {
7142 goto out;
7143 }
7144 }
7145
7146 count += num_drivers;
7147 TALLOC_FREE(drivers);
7148 }
7149
7150 out:
7151 TALLOC_FREE(drivers);
7152
7153 if (!W_ERROR_IS_OK(result)) {
7154 TALLOC_FREE(info);
7155 return result;
7156 }
7157
7158 *info_p = info;
7159 *count_p = count;
7160
7161 return WERR_OK;
7162 }
7163
7164 /****************************************************************************
7165 Enumerates all printer drivers by level.
7166 ****************************************************************************/
7167
7168 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
7169 const struct auth_serversupplied_info *server_info,
7170 struct messaging_context *msg_ctx,
7171 const char *servername,
7172 const char *architecture,
7173 uint32_t level,
7174 union spoolss_DriverInfo **info_p,
7175 uint32_t *count_p)
7176 {
7177 uint32_t a,i;
7178 WERROR result = WERR_OK;
7179
7180 if (strequal(architecture, SPOOLSS_ARCHITECTURE_ALL)) {
7181
7182 for (a=0; archi_table[a].long_archi != NULL; a++) {
7183
7184 union spoolss_DriverInfo *info = NULL;
7185 uint32_t count = 0;
7186
7187 result = enumprinterdrivers_level_by_architecture(mem_ctx,
7188 server_info,
7189 msg_ctx,
7190 servername,
7191 archi_table[a].long_archi,
7192 level,
7193 &info,
7194 &count);
7195 if (!W_ERROR_IS_OK(result)) {
7196 continue;
7197 }
7198
7199 for (i=0; i < count; i++) {
7200 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
7201 info[i], info_p, count_p);
7202 }
7203 }
7204
7205 return result;
7206 }
7207
7208 return enumprinterdrivers_level_by_architecture(mem_ctx,
7209 server_info,
7210 msg_ctx,
7211 servername,
7212 architecture,
7213 level,
7214 info_p,
7215 count_p);
7216 }
7217
7218 /****************************************************************
7219 _spoolss_EnumPrinterDrivers
7220 ****************************************************************/
7221
7222 WERROR _spoolss_EnumPrinterDrivers(struct pipes_struct *p,
7223 struct spoolss_EnumPrinterDrivers *r)
7224 {
7225 const char *cservername;
7226 WERROR result;
7227
7228 /* that's an [in out] buffer */
7229
7230 if (!r->in.buffer && (r->in.offered != 0)) {
7231 return WERR_INVALID_PARAM;
7232 }
7233
7234 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
7235
7236 *r->out.needed = 0;
7237 *r->out.count = 0;
7238 *r->out.info = NULL;
7239
7240 cservername = canon_servername(r->in.server);
7241
7242 if (!is_myname_or_ipaddr(cservername)) {
7243 return WERR_UNKNOWN_PRINTER_DRIVER;
7244 }
7245
7246 result = enumprinterdrivers_level(p->mem_ctx,
7247 get_server_info_system(),
7248 p->msg_ctx,
7249 cservername,
7250 r->in.environment,
7251 r->in.level,
7252 r->out.info,
7253 r->out.count);
7254 if (!W_ERROR_IS_OK(result)) {
7255 return result;
7256 }
7257
7258 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7259 spoolss_EnumPrinterDrivers,
7260 *r->out.info, r->in.level,
7261 *r->out.count);
7262 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7263 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7264
7265 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7266 }
7267
7268 /****************************************************************
7269 _spoolss_EnumForms
7270 ****************************************************************/
7271
7272 WERROR _spoolss_EnumForms(struct pipes_struct *p,
7273 struct spoolss_EnumForms *r)
7274 {
7275 WERROR result;
7276
7277 *r->out.count = 0;
7278 *r->out.needed = 0;
7279 *r->out.info = NULL;
7280
7281 /* that's an [in out] buffer */
7282
7283 if (!r->in.buffer && (r->in.offered != 0) ) {
7284 return WERR_INVALID_PARAM;
7285 }
7286
7287 DEBUG(4,("_spoolss_EnumForms\n"));
7288 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7289 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7290
7291 switch (r->in.level) {
7292 case 1:
7293 result = winreg_printer_enumforms1(p->mem_ctx,
7294 get_server_info_system(),
7295 p->msg_ctx,
7296 r->out.count,
7297 r->out.info);
7298 break;
7299 default:
7300 result = WERR_UNKNOWN_LEVEL;
7301 break;
7302 }
7303
7304 if (!W_ERROR_IS_OK(result)) {
7305 return result;
7306 }
7307
7308 if (*r->out.count == 0) {
7309 return WERR_NO_MORE_ITEMS;
7310 }
7311
7312 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7313 spoolss_EnumForms,
7314 *r->out.info, r->in.level,
7315 *r->out.count);
7316 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7317 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7318
7319 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7320 }
7321
7322 /****************************************************************
7323 _spoolss_GetForm
7324 ****************************************************************/
7325
7326 WERROR _spoolss_GetForm(struct pipes_struct *p,
7327 struct spoolss_GetForm *r)
7328 {
7329 WERROR result;
7330
7331 /* that's an [in out] buffer */
7332
7333 if (!r->in.buffer && (r->in.offered != 0)) {
7334 return WERR_INVALID_PARAM;
7335 }
7336
7337 DEBUG(4,("_spoolss_GetForm\n"));
7338 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7339 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7340
7341 switch (r->in.level) {
7342 case 1:
7343 result = winreg_printer_getform1(p->mem_ctx,
7344 get_server_info_system(),
7345 p->msg_ctx,
7346 r->in.form_name,
7347 &r->out.info->info1);
7348 break;
7349 default:
7350 result = WERR_UNKNOWN_LEVEL;
7351 break;
7352 }
7353
7354 if (!W_ERROR_IS_OK(result)) {
7355 TALLOC_FREE(r->out.info);
7356 return result;
7357 }
7358
7359 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo,
7360 r->out.info, r->in.level);
7361 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7362
7363 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7364 }
7365
7366 /****************************************************************************
7367 ****************************************************************************/
7368
7369 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7370 struct spoolss_PortInfo1 *r,
7371 const char *name)
7372 {
7373 r->port_name = talloc_strdup(mem_ctx, name);
7374 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7375
7376 return WERR_OK;
7377 }
7378
7379 /****************************************************************************
7380 TODO: This probably needs distinguish between TCP/IP and Local ports
7381 somehow.
7382 ****************************************************************************/
7383
7384 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7385 struct spoolss_PortInfo2 *r,
7386 const char *name)
7387 {
7388 r->port_name = talloc_strdup(mem_ctx, name);
7389 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7390
7391 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7392 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7393
7394 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7395 W_ERROR_HAVE_NO_MEMORY(r->description);
7396
7397 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7398 r->reserved = 0;
7399
7400 return WERR_OK;
7401 }
7402
7403
7404 /****************************************************************************
7405 wrapper around the enumer ports command
7406 ****************************************************************************/
7407
7408 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7409 {
7410 char *cmd = lp_enumports_cmd();
7411 char **qlines = NULL;
7412 char *command = NULL;
7413 int numlines;
7414 int ret;
7415 int fd;
7416
7417 *count = 0;
7418 *lines = NULL;
7419
7420 /* if no hook then just fill in the default port */
7421
7422 if ( !*cmd ) {
7423 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7424 return WERR_NOMEM;
7425 }
7426 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7427 TALLOC_FREE(qlines);
7428 return WERR_NOMEM;
7429 }
7430 qlines[1] = NULL;
7431 numlines = 1;
7432 }
7433 else {
7434 /* we have a valid enumport command */
7435
7436 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7437 if (!command) {
7438 return WERR_NOMEM;
7439 }
7440
7441 DEBUG(10,("Running [%s]\n", command));
7442 ret = smbrun(command, &fd);
7443 DEBUG(10,("Returned [%d]\n", ret));
7444 TALLOC_FREE(command);
7445 if (ret != 0) {
7446 if (fd != -1) {
7447 close(fd);
7448 }
7449 return WERR_ACCESS_DENIED;
7450 }
7451
7452 numlines = 0;
7453 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7454 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7455 close(fd);
7456 }
7457
7458 *count = numlines;
7459 *lines = qlines;
7460
7461 return WERR_OK;
7462 }
7463
7464 /****************************************************************************
7465 enumports level 1.
7466 ****************************************************************************/
7467
7468 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7469 union spoolss_PortInfo **info_p,
7470 uint32_t *count)
7471 {
7472 union spoolss_PortInfo *info = NULL;
7473 int i=0;
7474 WERROR result = WERR_OK;
7475 char **qlines = NULL;
7476 int numlines = 0;
7477
7478 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7479 if (!W_ERROR_IS_OK(result)) {
7480 goto out;
7481 }
7482
7483 if (numlines) {
7484 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7485 if (!info) {
7486 DEBUG(10,("Returning WERR_NOMEM\n"));
7487 result = WERR_NOMEM;
7488 goto out;
7489 }
7490
7491 for (i=0; i<numlines; i++) {
7492 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7493 result = fill_port_1(info, &info[i].info1, qlines[i]);
7494 if (!W_ERROR_IS_OK(result)) {
7495 goto out;
7496 }
7497 }
7498 }
7499 TALLOC_FREE(qlines);
7500
7501 out:
7502 if (!W_ERROR_IS_OK(result)) {
7503 TALLOC_FREE(info);
7504 TALLOC_FREE(qlines);
7505 *count = 0;
7506 *info_p = NULL;
7507 return result;
7508 }
7509
7510 *info_p = info;
7511 *count = numlines;
7512
7513 return WERR_OK;
7514 }
7515
7516 /****************************************************************************
7517 enumports level 2.
7518 ****************************************************************************/
7519
7520 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7521 union spoolss_PortInfo **info_p,
7522 uint32_t *count)
7523 {
7524 union spoolss_PortInfo *info = NULL;
7525 int i=0;
7526 WERROR result = WERR_OK;
7527 char **qlines = NULL;
7528 int numlines = 0;
7529
7530 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7531 if (!W_ERROR_IS_OK(result)) {
7532 goto out;
7533 }
7534
7535 if (numlines) {
7536 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7537 if (!info) {
7538 DEBUG(10,("Returning WERR_NOMEM\n"));
7539 result = WERR_NOMEM;
7540 goto out;
7541 }
7542
7543 for (i=0; i<numlines; i++) {
7544 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7545 result = fill_port_2(info, &info[i].info2, qlines[i]);
7546 if (!W_ERROR_IS_OK(result)) {
7547 goto out;
7548 }
7549 }
7550 }
7551 TALLOC_FREE(qlines);
7552
7553 out:
7554 if (!W_ERROR_IS_OK(result)) {
7555 TALLOC_FREE(info);
7556 TALLOC_FREE(qlines);
7557 *count = 0;
7558 *info_p = NULL;
7559 return result;
7560 }
7561
7562 *info_p = info;
7563 *count = numlines;
7564
7565 return WERR_OK;
7566 }
7567
7568 /****************************************************************
7569 _spoolss_EnumPorts
7570 ****************************************************************/
7571
7572 WERROR _spoolss_EnumPorts(struct pipes_struct *p,
7573 struct spoolss_EnumPorts *r)
7574 {
7575 WERROR result;
7576
7577 /* that's an [in out] buffer */
7578
7579 if (!r->in.buffer && (r->in.offered != 0)) {
7580 return WERR_INVALID_PARAM;
7581 }
7582
7583 DEBUG(4,("_spoolss_EnumPorts\n"));
7584
7585 *r->out.count = 0;
7586 *r->out.needed = 0;
7587 *r->out.info = NULL;
7588
7589 switch (r->in.level) {
7590 case 1:
7591 result = enumports_level_1(p->mem_ctx, r->out.info,
7592 r->out.count);
7593 break;
7594 case 2:
7595 result = enumports_level_2(p->mem_ctx, r->out.info,
7596 r->out.count);
7597 break;
7598 default:
7599 return WERR_UNKNOWN_LEVEL;
7600 }
7601
7602 if (!W_ERROR_IS_OK(result)) {
7603 return result;
7604 }
7605
7606 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7607 spoolss_EnumPorts,
7608 *r->out.info, r->in.level,
7609 *r->out.count);
7610 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7611 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7612
7613 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7614 }
7615
7616 /****************************************************************************
7617 ****************************************************************************/
7618
7619 static WERROR spoolss_addprinterex_level_2(struct pipes_struct *p,
7620 const char *server,
7621 struct spoolss_SetPrinterInfoCtr *info_ctr,
7622 struct spoolss_DeviceMode *devmode,
7623 struct security_descriptor *secdesc,
7624 struct spoolss_UserLevelCtr *user_ctr,
7625 struct policy_handle *handle)
7626 {
7627 struct spoolss_SetPrinterInfo2 *info2 = info_ctr->info.info2;
7628 uint32_t info2_mask = SPOOLSS_PRINTER_INFO_ALL;
7629 int snum;
7630 WERROR err = WERR_OK;
7631
7632 /* samba does not have a concept of local, non-shared printers yet, so
7633 * make sure we always setup sharename - gd */
7634 if ((info2->sharename == NULL || info2->sharename[0] == '\0') &&
7635 (info2->printername != NULL && info2->printername[0] != '\0')) {
7636 DEBUG(5, ("spoolss_addprinterex_level_2: "
7637 "no sharename has been set, setting printername %s as sharename\n",
7638 info2->printername));
7639 info2->sharename = info2->printername;
7640 }
7641
7642 /* check to see if the printer already exists */
7643 if ((snum = print_queue_snum(info2->sharename)) != -1) {
7644 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7645 info2->sharename));
7646 return WERR_PRINTER_ALREADY_EXISTS;
7647 }
7648
7649 if (!lp_force_printername(GLOBAL_SECTION_SNUM)) {
7650 if ((snum = print_queue_snum(info2->printername)) != -1) {
7651 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7652 info2->printername));
7653 return WERR_PRINTER_ALREADY_EXISTS;
7654 }
7655 }
7656
7657 /* validate printer info struct */
7658 if (!info2->printername || strlen(info2->printername) == 0) {
7659 return WERR_INVALID_PRINTER_NAME;
7660 }
7661 if (!info2->portname || strlen(info2->portname) == 0) {
7662 return WERR_UNKNOWN_PORT;
7663 }
7664 if (!info2->drivername || strlen(info2->drivername) == 0) {
7665 return WERR_UNKNOWN_PRINTER_DRIVER;
7666 }
7667 if (!info2->printprocessor || strlen(info2->printprocessor) == 0) {
7668 return WERR_UNKNOWN_PRINTPROCESSOR;
7669 }
7670
7671 /* FIXME!!! smbd should check to see if the driver is installed before
7672 trying to add a printer like this --jerry */
7673
7674 if (*lp_addprinter_cmd() ) {
7675 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7676 info2, p->client_id->addr,
7677 p->msg_ctx) ) {
7678 return WERR_ACCESS_DENIED;
7679 }
7680 } else {
7681 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7682 "smb.conf parameter \"addprinter command\" is defined. This"
7683 "parameter must exist for this call to succeed\n",
7684 info2->sharename ));
7685 }
7686
7687 if ((snum = print_queue_snum(info2->sharename)) == -1) {
7688 return WERR_ACCESS_DENIED;
7689 }
7690
7691 /* you must be a printer admin to add a new printer */
7692 if (!print_access_check(get_server_info_system(),
7693 p->msg_ctx,
7694 snum,
7695 PRINTER_ACCESS_ADMINISTER)) {
7696 return WERR_ACCESS_DENIED;
7697 }
7698
7699 /*
7700 * Do sanity check on the requested changes for Samba.
7701 */
7702
7703 if (!check_printer_ok(p->mem_ctx, info2, snum)) {
7704 return WERR_INVALID_PARAM;
7705 }
7706
7707 if (devmode == NULL) {
7708 info2_mask = ~SPOOLSS_PRINTER_INFO_DEVMODE;
7709 }
7710
7711 update_dsspooler(p->mem_ctx,
7712 get_server_info_system(),
7713 p->msg_ctx,
7714 0,
7715 info2,
7716 NULL);
7717
7718 err = winreg_update_printer(p->mem_ctx,
7719 get_server_info_system(),
7720 p->msg_ctx,
7721 info2->sharename,
7722 info2_mask,
7723 info2,
7724 devmode,
7725 secdesc);
7726 if (!W_ERROR_IS_OK(err)) {
7727 return err;
7728 }
7729
7730 if (!open_printer_hnd(p, handle, info2->printername, PRINTER_ACCESS_ADMINISTER)) {
7731 /* Handle open failed - remove addition. */
7732 ZERO_STRUCTP(handle);
7733 return WERR_ACCESS_DENIED;
7734 }
7735
7736 return WERR_OK;
7737 }
7738
7739 /****************************************************************
7740 _spoolss_AddPrinterEx
7741 ****************************************************************/
7742
7743 WERROR _spoolss_AddPrinterEx(struct pipes_struct *p,
7744 struct spoolss_AddPrinterEx *r)
7745 {
7746 switch (r->in.info_ctr->level) {
7747 case 1:
7748 /* we don't handle yet */
7749 /* but I know what to do ... */
7750 return WERR_UNKNOWN_LEVEL;
7751 case 2:
7752 return spoolss_addprinterex_level_2(p, r->in.server,
7753 r->in.info_ctr,
7754 r->in.devmode_ctr->devmode,
7755 r->in.secdesc_ctr->sd,
7756 r->in.userlevel_ctr,
7757 r->out.handle);
7758 default:
7759 return WERR_UNKNOWN_LEVEL;
7760 }
7761 }
7762
7763 /****************************************************************
7764 _spoolss_AddPrinter
7765 ****************************************************************/
7766
7767 WERROR _spoolss_AddPrinter(struct pipes_struct *p,
7768 struct spoolss_AddPrinter *r)
7769 {
7770 struct spoolss_AddPrinterEx a;
7771 struct spoolss_UserLevelCtr userlevel_ctr;
7772
7773 ZERO_STRUCT(userlevel_ctr);
7774
7775 userlevel_ctr.level = 1;
7776
7777 a.in.server = r->in.server;
7778 a.in.info_ctr = r->in.info_ctr;
7779 a.in.devmode_ctr = r->in.devmode_ctr;
7780 a.in.secdesc_ctr = r->in.secdesc_ctr;
7781 a.in.userlevel_ctr = &userlevel_ctr;
7782 a.out.handle = r->out.handle;
7783
7784 return _spoolss_AddPrinterEx(p, &a);
7785 }
7786
7787 /****************************************************************
7788 _spoolss_AddPrinterDriverEx
7789 ****************************************************************/
7790
7791 WERROR _spoolss_AddPrinterDriverEx(struct pipes_struct *p,
7792 struct spoolss_AddPrinterDriverEx *r)
7793 {
7794 WERROR err = WERR_OK;
7795 const char *driver_name = NULL;
7796 uint32_t version;
7797 const char *fn;
7798
7799 switch (p->opnum) {
7800 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7801 fn = "_spoolss_AddPrinterDriver";
7802 break;
7803 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7804 fn = "_spoolss_AddPrinterDriverEx";
7805 break;
7806 default:
7807 return WERR_INVALID_PARAM;
7808 }
7809
7810 /*
7811 * we only support the semantics of AddPrinterDriver()
7812 * i.e. only copy files that are newer than existing ones
7813 */
7814
7815 if (r->in.flags == 0) {
7816 return WERR_INVALID_PARAM;
7817 }
7818
7819 if (r->in.flags != APD_COPY_NEW_FILES) {
7820 return WERR_ACCESS_DENIED;
7821 }
7822
7823 /* FIXME */
7824 if (r->in.info_ctr->level != 3 && r->in.info_ctr->level != 6) {
7825 /* Clever hack from Martin Zielinski <mz@seh.de>
7826 * to allow downgrade from level 8 (Vista).
7827 */
7828 DEBUG(0,("%s: level %d not yet implemented\n", fn,
7829 r->in.info_ctr->level));
7830 return WERR_UNKNOWN_LEVEL;
7831 }
7832
7833 DEBUG(5,("Cleaning driver's information\n"));
7834 err = clean_up_driver_struct(p->mem_ctx, p, r->in.info_ctr);
7835 if (!W_ERROR_IS_OK(err))
7836 goto done;
7837
7838 DEBUG(5,("Moving driver to final destination\n"));
7839 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, r->in.info_ctr,
7840 &err)) ) {
7841 goto done;
7842 }
7843
7844 err = winreg_add_driver(p->mem_ctx,
7845 get_server_info_system(),
7846 p->msg_ctx,
7847 r->in.info_ctr,
7848 &driver_name,
7849 &version);
7850 if (!W_ERROR_IS_OK(err)) {
7851 goto done;
7852 }
7853
7854 /*
7855 * I think this is where he DrvUpgradePrinter() hook would be
7856 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7857 * server. Right now, we just need to send ourselves a message
7858 * to update each printer bound to this driver. --jerry
7859 */
7860
7861 if (!srv_spoolss_drv_upgrade_printer(driver_name, p->msg_ctx)) {
7862 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7863 fn, driver_name));
7864 }
7865
7866 done:
7867 return err;
7868 }
7869
7870 /****************************************************************
7871 _spoolss_AddPrinterDriver
7872 ****************************************************************/
7873
7874 WERROR _spoolss_AddPrinterDriver(struct pipes_struct *p,
7875 struct spoolss_AddPrinterDriver *r)
7876 {
7877 struct spoolss_AddPrinterDriverEx a;
7878
7879 switch (r->in.info_ctr->level) {
7880 case 2:
7881 case 3:
7882 case 4:
7883 case 5:
7884 break;
7885 default:
7886 return WERR_UNKNOWN_LEVEL;
7887 }
7888
7889 a.in.servername = r->in.servername;
7890 a.in.info_ctr = r->in.info_ctr;
7891 a.in.flags = APD_COPY_NEW_FILES;
7892
7893 return _spoolss_AddPrinterDriverEx(p, &a);
7894 }
7895
7896 /****************************************************************************
7897 ****************************************************************************/
7898
7899 struct _spoolss_paths {
7900 int type;
7901 const char *share;
7902 const char *dir;
7903 };
7904
7905 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7906
7907 static const struct _spoolss_paths spoolss_paths[]= {
7908 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
7909 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
7910 };
7911
7912 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7913 const char *servername,
7914 const char *environment,
7915 int component,
7916 char **path)
7917 {
7918 const char *pservername = NULL;
7919 const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7920 const char *short_archi;
7921
7922 *path = NULL;
7923
7924 /* environment may be empty */
7925 if (environment && strlen(environment)) {
7926 long_archi = environment;
7927 }
7928
7929 /* servername may be empty */
7930 if (servername && strlen(servername)) {
7931 pservername = canon_servername(servername);
7932
7933 if (!is_myname_or_ipaddr(pservername)) {
7934 return WERR_INVALID_PARAM;
7935 }
7936 }
7937
7938 if (!(short_archi = get_short_archi(long_archi))) {
7939 return WERR_INVALID_ENVIRONMENT;
7940 }
7941
7942 switch (component) {
7943 case SPOOLSS_PRTPROCS_PATH:
7944 case SPOOLSS_DRIVER_PATH:
7945 if (pservername) {
7946 *path = talloc_asprintf(mem_ctx,
7947 "\\\\%s\\%s\\%s",
7948 pservername,
7949 spoolss_paths[component].share,
7950 short_archi);
7951 } else {
7952 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7953 SPOOLSS_DEFAULT_SERVER_PATH,
7954 spoolss_paths[component].dir,
7955 short_archi);
7956 }
7957 break;
7958 default:
7959 return WERR_INVALID_PARAM;
7960 }
7961
7962 if (!*path) {
7963 return WERR_NOMEM;
7964 }
7965
7966 return WERR_OK;
7967 }
7968
7969 /****************************************************************************
7970 ****************************************************************************/
7971
7972 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7973 const char *servername,
7974 const char *environment,
7975 struct spoolss_DriverDirectoryInfo1 *r)
7976 {
7977 WERROR werr;
7978 char *path = NULL;
7979
7980 werr = compose_spoolss_server_path(mem_ctx,
7981 servername,
7982 environment,
7983 SPOOLSS_DRIVER_PATH,
7984 &path);
7985 if (!W_ERROR_IS_OK(werr)) {
7986 return werr;
7987 }
7988
7989 DEBUG(4,("printer driver directory: [%s]\n", path));
7990
7991 r->directory_name = path;
7992
7993 return WERR_OK;
7994 }
7995
7996 /****************************************************************
7997 _spoolss_GetPrinterDriverDirectory
7998 ****************************************************************/
7999
8000 WERROR _spoolss_GetPrinterDriverDirectory(struct pipes_struct *p,
8001 struct spoolss_GetPrinterDriverDirectory *r)
8002 {
8003 WERROR werror;
8004
8005 /* that's an [in out] buffer */
8006
8007 if (!r->in.buffer && (r->in.offered != 0)) {
8008 return WERR_INVALID_PARAM;
8009 }
8010
8011 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
8012 r->in.level));
8013
8014 *r->out.needed = 0;
8015
8016 /* r->in.level is ignored */
8017
8018 werror = getprinterdriverdir_level_1(p->mem_ctx,
8019 r->in.server,
8020 r->in.environment,
8021 &r->out.info->info1);
8022 if (!W_ERROR_IS_OK(werror)) {
8023 TALLOC_FREE(r->out.info);
8024 return werror;
8025 }
8026
8027 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo,
8028 r->out.info, r->in.level);
8029 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8030
8031 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8032 }
8033
8034 /****************************************************************
8035 _spoolss_EnumPrinterData
8036 ****************************************************************/
8037
8038 WERROR _spoolss_EnumPrinterData(struct pipes_struct *p,
8039 struct spoolss_EnumPrinterData *r)
8040 {
8041 WERROR result;
8042 struct spoolss_EnumPrinterDataEx r2;
8043 uint32_t count;
8044 struct spoolss_PrinterEnumValues *info, *val = NULL;
8045 uint32_t needed;
8046
8047 r2.in.handle = r->in.handle;
8048 r2.in.key_name = "PrinterDriverData";
8049 r2.in.offered = 0;
8050 r2.out.count = &count;
8051 r2.out.info = &info;
8052 r2.out.needed = &needed;
8053
8054 result = _spoolss_EnumPrinterDataEx(p, &r2);
8055 if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
8056 r2.in.offered = needed;
8057 result = _spoolss_EnumPrinterDataEx(p, &r2);
8058 }
8059 if (!W_ERROR_IS_OK(result)) {
8060 return result;
8061 }
8062
8063 /*
8064 * The NT machine wants to know the biggest size of value and data
8065 *
8066 * cf: MSDN EnumPrinterData remark section
8067 */
8068
8069 if (!r->in.value_offered && !r->in.data_offered) {
8070 uint32_t biggest_valuesize = 0;
8071 uint32_t biggest_datasize = 0;
8072 int i, name_length;
8073
8074 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8075
8076 for (i=0; i<count; i++) {
8077
8078 name_length = strlen(info[i].value_name);
8079 if (strlen(info[i].value_name) > biggest_valuesize) {
8080 biggest_valuesize = name_length;
8081 }
8082
8083 if (info[i].data_length > biggest_datasize) {
8084 biggest_datasize = info[i].data_length;
8085 }
8086
8087 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8088 biggest_datasize));
8089 }
8090
8091 /* the value is an UNICODE string but real_value_size is the length
8092 in bytes including the trailing 0 */
8093
8094 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8095 *r->out.data_needed = biggest_datasize;
8096
8097 DEBUG(6,("final values: [%d], [%d]\n",
8098 *r->out.value_needed, *r->out.data_needed));
8099
8100 return WERR_OK;
8101 }
8102
8103 if (r->in.enum_index < count) {
8104 val = &info[r->in.enum_index];
8105 }
8106
8107 if (val == NULL) {
8108 /* out_value should default to "" or else NT4 has
8109 problems unmarshalling the response */
8110
8111 if (r->in.value_offered) {
8112 *r->out.value_needed = 1;
8113 r->out.value_name = talloc_strdup(r, "");
8114 if (!r->out.value_name) {
8115 return WERR_NOMEM;
8116 }
8117 } else {
8118 r->out.value_name = NULL;
8119 *r->out.value_needed = 0;
8120 }
8121
8122 /* the data is counted in bytes */
8123
8124 *r->out.data_needed = r->in.data_offered;
8125
8126 result = WERR_NO_MORE_ITEMS;
8127 } else {
8128 /*
8129 * the value is:
8130 * - counted in bytes in the request
8131 * - counted in UNICODE chars in the max reply
8132 * - counted in bytes in the real size
8133 *
8134 * take a pause *before* coding not *during* coding
8135 */
8136
8137 /* name */
8138 if (r->in.value_offered) {
8139 r->out.value_name = talloc_strdup(r, val->value_name);
8140 if (!r->out.value_name) {
8141 return WERR_NOMEM;
8142 }
8143 *r->out.value_needed = val->value_name_len;
8144 } else {
8145 r->out.value_name = NULL;
8146 *r->out.value_needed = 0;
8147 }
8148
8149 /* type */
8150
8151 *r->out.type = val->type;
8152
8153 /* data - counted in bytes */
8154
8155 /*
8156 * See the section "Dynamically Typed Query Parameters"
8157 * in MS-RPRN.
8158 */
8159
8160 if (r->out.data && val->data && val->data->data &&
8161 val->data_length && r->in.data_offered) {
8162 memcpy(r->out.data, val->data->data,
8163 MIN(val->data_length,r->in.data_offered));
8164 }
8165
8166 *r->out.data_needed = val->data_length;
8167
8168 result = WERR_OK;
8169 }
8170
8171 return result;
8172 }
8173
8174 /****************************************************************
8175 _spoolss_SetPrinterData
8176 ****************************************************************/
8177
8178 WERROR _spoolss_SetPrinterData(struct pipes_struct *p,
8179 struct spoolss_SetPrinterData *r)
8180 {
8181 struct spoolss_SetPrinterDataEx r2;
8182
8183 r2.in.handle = r->in.handle;
8184 r2.in.key_name = "PrinterDriverData";
8185 r2.in.value_name = r->in.value_name;
8186 r2.in.type = r->in.type;
8187 r2.in.data = r->in.data;
8188 r2.in.offered = r->in.offered;
8189
8190 return _spoolss_SetPrinterDataEx(p, &r2);
8191 }
8192
8193 /****************************************************************
8194 _spoolss_ResetPrinter
8195 ****************************************************************/
8196
8197 WERROR _spoolss_ResetPrinter(struct pipes_struct *p,
8198 struct spoolss_ResetPrinter *r)
8199 {
8200 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8201 int snum;
8202
8203 DEBUG(5,("_spoolss_ResetPrinter\n"));
8204
8205 /*
8206 * All we do is to check to see if the handle and queue is valid.
8207 * This call really doesn't mean anything to us because we only
8208 * support RAW printing. --jerry
8209 */
8210
8211 if (!Printer) {
8212 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8213 OUR_HANDLE(r->in.handle)));
8214 return WERR_BADFID;
8215 }
8216
8217 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8218 return WERR_BADFID;
8219
8220
8221 /* blindly return success */
8222 return WERR_OK;
8223 }
8224
8225 /****************************************************************
8226 _spoolss_DeletePrinterData
8227 ****************************************************************/
8228
8229 WERROR _spoolss_DeletePrinterData(struct pipes_struct *p,
8230 struct spoolss_DeletePrinterData *r)
8231 {
8232 struct spoolss_DeletePrinterDataEx r2;
8233
8234 r2.in.handle = r->in.handle;
8235 r2.in.key_name = "PrinterDriverData";
8236 r2.in.value_name = r->in.value_name;
8237
8238 return _spoolss_DeletePrinterDataEx(p, &r2);
8239 }
8240
8241 /****************************************************************
8242 _spoolss_AddForm
8243 ****************************************************************/
8244
8245 WERROR _spoolss_AddForm(struct pipes_struct *p,
8246 struct spoolss_AddForm *r)
8247 {
8248 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8249 int snum = -1;
8250 WERROR status = WERR_OK;
8251 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8252
8253 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8254
8255 DEBUG(5,("_spoolss_AddForm\n"));
8256
8257 if (!Printer) {
8258 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8259 OUR_HANDLE(r->in.handle)));
8260 return WERR_BADFID;
8261 }
8262
8263 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8264 and not a printer admin, then fail */
8265
8266 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8267 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8268 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8269 p->server_info->info3->base.domain.string,
8270 NULL,
8271 p->server_info->ptok,
8272 lp_printer_admin(snum))) {
8273 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8274 return WERR_ACCESS_DENIED;
8275 }
8276
8277 switch (form->flags) {
8278 case SPOOLSS_FORM_USER:
8279 case SPOOLSS_FORM_BUILTIN:
8280 case SPOOLSS_FORM_PRINTER:
8281 break;
8282 default:
8283 return WERR_INVALID_PARAM;
8284 }
8285
8286 status = winreg_printer_addform1(p->mem_ctx,
8287 get_server_info_system(),
8288 p->msg_ctx,
8289 form);
8290 if (!W_ERROR_IS_OK(status)) {
8291 return status;
8292 }
8293
8294 /*
8295 * ChangeID must always be set if this is a printer
8296 */
8297 if (Printer->printer_type == SPLHND_PRINTER) {
8298 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8299 return WERR_BADFID;
8300 }
8301
8302 status = winreg_printer_update_changeid(p->mem_ctx,
8303 get_server_info_system(),
8304 p->msg_ctx,
8305 lp_const_servicename(snum));
8306 if (!W_ERROR_IS_OK(status)) {
8307 return status;
8308 }
8309 }
8310
8311 return status;
8312 }
8313
8314 /****************************************************************
8315 _spoolss_DeleteForm
8316 ****************************************************************/
8317
8318 WERROR _spoolss_DeleteForm(struct pipes_struct *p,
8319 struct spoolss_DeleteForm *r)
8320 {
8321 const char *form_name = r->in.form_name;
8322 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8323 int snum = -1;
8324 WERROR status = WERR_OK;
8325 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8326
8327 DEBUG(5,("_spoolss_DeleteForm\n"));
8328
8329 if (!Printer) {
8330 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8331 OUR_HANDLE(r->in.handle)));
8332 return WERR_BADFID;
8333 }
8334
8335 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8336 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8337 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8338 p->server_info->info3->base.domain.string,
8339 NULL,
8340 p->server_info->ptok,
8341 lp_printer_admin(snum))) {
8342 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8343 return WERR_ACCESS_DENIED;
8344 }
8345
8346 status = winreg_printer_deleteform1(p->mem_ctx,
8347 get_server_info_system(),
8348 p->msg_ctx,
8349 form_name);
8350 if (!W_ERROR_IS_OK(status)) {
8351 return status;
8352 }
8353
8354 /*
8355 * ChangeID must always be set if this is a printer
8356 */
8357 if (Printer->printer_type == SPLHND_PRINTER) {
8358 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8359 return WERR_BADFID;
8360 }
8361
8362 status = winreg_printer_update_changeid(p->mem_ctx,
8363 get_server_info_system(),
8364 p->msg_ctx,
8365 lp_const_servicename(snum));
8366 if (!W_ERROR_IS_OK(status)) {
8367 return status;
8368 }
8369 }
8370
8371 return status;
8372 }
8373
8374 /****************************************************************
8375 _spoolss_SetForm
8376 ****************************************************************/
8377
8378 WERROR _spoolss_SetForm(struct pipes_struct *p,
8379 struct spoolss_SetForm *r)
8380 {
8381 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8382 const char *form_name = r->in.form_name;
8383 int snum = -1;
8384 WERROR status = WERR_OK;
8385 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8386
8387 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8388
8389 DEBUG(5,("_spoolss_SetForm\n"));
8390
8391 if (!Printer) {
8392 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8393 OUR_HANDLE(r->in.handle)));
8394 return WERR_BADFID;
8395 }
8396
8397 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8398 and not a printer admin, then fail */
8399
8400 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8401 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8402 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8403 p->server_info->info3->base.domain.string,
8404 NULL,
8405 p->server_info->ptok,
8406 lp_printer_admin(snum))) {
8407 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8408 return WERR_ACCESS_DENIED;
8409 }
8410
8411 status = winreg_printer_setform1(p->mem_ctx,
8412 get_server_info_system(),
8413 p->msg_ctx,
8414 form_name,
8415 form);
8416 if (!W_ERROR_IS_OK(status)) {
8417 return status;
8418 }
8419
8420 /*
8421 * ChangeID must always be set if this is a printer
8422 */
8423 if (Printer->printer_type == SPLHND_PRINTER) {
8424 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8425 return WERR_BADFID;
8426 }
8427
8428 status = winreg_printer_update_changeid(p->mem_ctx,
8429 get_server_info_system(),
8430 p->msg_ctx,
8431 lp_const_servicename(snum));
8432 if (!W_ERROR_IS_OK(status)) {
8433 return status;
8434 }
8435 }
8436
8437 return status;
8438 }
8439
8440 /****************************************************************************
8441 fill_print_processor1
8442 ****************************************************************************/
8443
8444 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8445 struct spoolss_PrintProcessorInfo1 *r,
8446 const char *print_processor_name)
8447 {
8448 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8449 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8450
8451 return WERR_OK;
8452 }
8453
8454 /****************************************************************************
8455 enumprintprocessors level 1.
8456 ****************************************************************************/
8457
8458 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8459 union spoolss_PrintProcessorInfo **info_p,
8460 uint32_t *count)
8461 {
8462 union spoolss_PrintProcessorInfo *info;
8463 WERROR result;
8464
8465 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8466 W_ERROR_HAVE_NO_MEMORY(info);
8467
8468 *count = 1;
8469
8470 result = fill_print_processor1(info, &info[0].info1, "winprint");
8471 if (!W_ERROR_IS_OK(result)) {
8472 goto out;
8473 }
8474
8475 out:
8476 if (!W_ERROR_IS_OK(result)) {
8477 TALLOC_FREE(info);
8478 *count = 0;
8479 return result;
8480 }
8481
8482 *info_p = info;
8483
8484 return WERR_OK;
8485 }
8486
8487 /****************************************************************
8488 _spoolss_EnumPrintProcessors
8489 ****************************************************************/
8490
8491 WERROR _spoolss_EnumPrintProcessors(struct pipes_struct *p,
8492 struct spoolss_EnumPrintProcessors *r)
8493 {
8494 WERROR result;
8495
8496 /* that's an [in out] buffer */
8497
8498 if (!r->in.buffer && (r->in.offered != 0)) {
8499 return WERR_INVALID_PARAM;
8500 }
8501
8502 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8503
8504 /*
8505 * Enumerate the print processors ...
8506 *
8507 * Just reply with "winprint", to keep NT happy
8508 * and I can use my nice printer checker.
8509 */
8510
8511 *r->out.count = 0;
8512 *r->out.needed = 0;
8513 *r->out.info = NULL;
8514
8515 switch (r->in.level) {
8516 case 1:
8517 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8518 r->out.count);
8519 break;
8520 default:
8521 return WERR_UNKNOWN_LEVEL;
8522 }
8523
8524 if (!W_ERROR_IS_OK(result)) {
8525 return result;
8526 }
8527
8528 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8529 spoolss_EnumPrintProcessors,
8530 *r->out.info, r->in.level,
8531 *r->out.count);
8532 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8533 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8534
8535 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8536 }
8537
8538 /****************************************************************************
8539 fill_printprocdatatype1
8540 ****************************************************************************/
8541
8542 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8543 struct spoolss_PrintProcDataTypesInfo1 *r,
8544 const char *name_array)
8545 {
8546 r->name_array = talloc_strdup(mem_ctx, name_array);
8547 W_ERROR_HAVE_NO_MEMORY(r->name_array);
8548
8549 return WERR_OK;
8550 }
8551
8552 /****************************************************************************
8553 enumprintprocdatatypes level 1.
8554 ****************************************************************************/
8555
8556 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8557 union spoolss_PrintProcDataTypesInfo **info_p,
8558 uint32_t *count)
8559 {
8560 WERROR result;
8561 union spoolss_PrintProcDataTypesInfo *info;
8562
8563 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8564 W_ERROR_HAVE_NO_MEMORY(info);
8565
8566 *count = 1;
8567
8568 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8569 if (!W_ERROR_IS_OK(result)) {
8570 goto out;
8571 }
8572
8573 out:
8574 if (!W_ERROR_IS_OK(result)) {
8575 TALLOC_FREE(info);
8576 *count = 0;
8577 return result;
8578 }
8579
8580 *info_p = info;
8581
8582 return WERR_OK;
8583 }
8584
8585 /****************************************************************
8586 _spoolss_EnumPrintProcDataTypes
8587 ****************************************************************/
8588
8589 WERROR _spoolss_EnumPrintProcDataTypes(struct pipes_struct *p,
8590 struct spoolss_EnumPrintProcDataTypes *r)
8591 {
8592 WERROR result;
8593
8594 /* that's an [in out] buffer */
8595
8596 if (!r->in.buffer && (r->in.offered != 0)) {
8597 return WERR_INVALID_PARAM;
8598 }
8599
8600 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8601
8602 *r->out.count = 0;
8603 *r->out.needed = 0;
8604 *r->out.info = NULL;
8605
8606 switch (r->in.level) {
8607 case 1:
8608 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8609 r->out.count);
8610 break;
8611 default:
8612 return WERR_UNKNOWN_LEVEL;
8613 }
8614
8615 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8616 spoolss_EnumPrintProcDataTypes,
8617 *r->out.info, r->in.level,
8618 *r->out.count);
8619 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8620 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8621
8622 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8623 }
8624
8625 /****************************************************************************
8626 fill_monitor_1
8627 ****************************************************************************/
8628
8629 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8630 struct spoolss_MonitorInfo1 *r,
8631 const char *monitor_name)
8632 {
8633 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8634 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8635
8636 return WERR_OK;
8637 }
8638
8639 /****************************************************************************
8640 fill_monitor_2
8641 ****************************************************************************/
8642
8643 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8644 struct spoolss_MonitorInfo2 *r,
8645 const char *monitor_name,
8646 const char *environment,
8647 const char *dll_name)
8648 {
8649 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8650 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8651 r->environment = talloc_strdup(mem_ctx, environment);
8652 W_ERROR_HAVE_NO_MEMORY(r->environment);
8653 r->dll_name = talloc_strdup(mem_ctx, dll_name);
8654 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8655
8656 return WERR_OK;
8657 }
8658
8659 /****************************************************************************
8660 enumprintmonitors level 1.
8661 ****************************************************************************/
8662
8663 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8664 union spoolss_MonitorInfo **info_p,
8665 uint32_t *count)
8666 {
8667 union spoolss_MonitorInfo *info;
8668 WERROR result = WERR_OK;
8669
8670 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8671 W_ERROR_HAVE_NO_MEMORY(info);
8672
8673 *count = 2;
8674
8675 result = fill_monitor_1(info, &info[0].info1,
8676 SPL_LOCAL_PORT);
8677 if (!W_ERROR_IS_OK(result)) {
8678 goto out;
8679 }
8680
8681 result = fill_monitor_1(info, &info[1].info1,
8682 SPL_TCPIP_PORT);
8683 if (!W_ERROR_IS_OK(result)) {
8684 goto out;
8685 }
8686
8687 out:
8688 if (!W_ERROR_IS_OK(result)) {
8689 TALLOC_FREE(info);
8690 *count = 0;
8691 return result;
8692 }
8693
8694 *info_p = info;
8695
8696 return WERR_OK;
8697 }
8698
8699 /****************************************************************************
8700 enumprintmonitors level 2.
8701 ****************************************************************************/
8702
8703 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8704 union spoolss_MonitorInfo **info_p,
8705 uint32_t *count)
8706 {
8707 union spoolss_MonitorInfo *info;
8708 WERROR result = WERR_OK;
8709
8710 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8711 W_ERROR_HAVE_NO_MEMORY(info);
8712
8713 *count = 2;
8714
8715 result = fill_monitor_2(info, &info[0].info2,
8716 SPL_LOCAL_PORT,
8717 "Windows NT X86", /* FIXME */
8718 "localmon.dll");
8719 if (!W_ERROR_IS_OK(result)) {
8720 goto out;
8721 }
8722
8723 result = fill_monitor_2(info, &info[1].info2,
8724 SPL_TCPIP_PORT,
8725 "Windows NT X86", /* FIXME */
8726 "tcpmon.dll");
8727 if (!W_ERROR_IS_OK(result)) {
8728 goto out;
8729 }
8730
8731 out:
8732 if (!W_ERROR_IS_OK(result)) {
8733 TALLOC_FREE(info);
8734 *count = 0;
8735 return result;
8736 }
8737
8738 *info_p = info;
8739
8740 return WERR_OK;
8741 }
8742
8743 /****************************************************************
8744 _spoolss_EnumMonitors
8745 ****************************************************************/
8746
8747 WERROR _spoolss_EnumMonitors(struct pipes_struct *p,
8748 struct spoolss_EnumMonitors *r)
8749 {
8750 WERROR result;
8751
8752 /* that's an [in out] buffer */
8753
8754 if (!r->in.buffer && (r->in.offered != 0)) {
8755 return WERR_INVALID_PARAM;
8756 }
8757
8758 DEBUG(5,("_spoolss_EnumMonitors\n"));
8759
8760 /*
8761 * Enumerate the print monitors ...
8762 *
8763 * Just reply with "Local Port", to keep NT happy
8764 * and I can use my nice printer checker.
8765 */
8766
8767 *r->out.count = 0;
8768 *r->out.needed = 0;
8769 *r->out.info = NULL;
8770
8771 switch (r->in.level) {
8772 case 1:
8773 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8774 r->out.count);
8775 break;
8776 case 2:
8777 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8778 r->out.count);
8779 break;
8780 default:
8781 return WERR_UNKNOWN_LEVEL;
8782 }
8783
8784 if (!W_ERROR_IS_OK(result)) {
8785 return result;
8786 }
8787
8788 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8789 spoolss_EnumMonitors,
8790 *r->out.info, r->in.level,
8791 *r->out.count);
8792 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8793 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8794
8795 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8796 }
8797
8798 /****************************************************************************
8799 ****************************************************************************/
8800
8801 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8802 const print_queue_struct *queue,
8803 int count, int snum,
8804 struct spoolss_PrinterInfo2 *pinfo2,
8805 uint32_t jobid,
8806 struct spoolss_JobInfo1 *r)
8807 {
8808 int i = 0;
8809 bool found = false;
8810
8811 for (i=0; i<count; i++) {
8812 if (queue[i].job == (int)jobid) {
8813 found = true;
8814 break;
8815 }
8816 }
8817
8818 if (found == false) {
8819 /* NT treats not found as bad param... yet another bad choice */
8820 return WERR_INVALID_PARAM;
8821 }
8822
8823 return fill_job_info1(mem_ctx,
8824 r,
8825 &queue[i],
8826 i,
8827 snum,
8828 pinfo2);
8829 }
8830
8831 /****************************************************************************
8832 ****************************************************************************/
8833
8834 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8835 const print_queue_struct *queue,
8836 int count, int snum,
8837 struct spoolss_PrinterInfo2 *pinfo2,
8838 uint32_t jobid,
8839 struct spoolss_JobInfo2 *r)
8840 {
8841 int i = 0;
8842 bool found = false;
8843 struct spoolss_DeviceMode *devmode;
8844 WERROR result;
8845
8846 for (i=0; i<count; i++) {
8847 if (queue[i].job == (int)jobid) {
8848 found = true;
8849 break;
8850 }
8851 }
8852
8853 if (found == false) {
8854 /* NT treats not found as bad param... yet another bad
8855 choice */
8856 return WERR_INVALID_PARAM;
8857 }
8858
8859 /*
8860 * if the print job does not have a DEVMODE associated with it,
8861 * just use the one for the printer. A NULL devicemode is not
8862 * a failure condition
8863 */
8864
8865 devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8866 if (!devmode) {
8867 result = spoolss_create_default_devmode(mem_ctx,
8868 pinfo2->printername,
8869 &devmode);
8870 if (!W_ERROR_IS_OK(result)) {
8871 DEBUG(3, ("Can't proceed w/o a devmode!"));
8872 return result;
8873 }
8874 }
8875
8876 return fill_job_info2(mem_ctx,
8877 r,
8878 &queue[i],
8879 i,
8880 snum,
8881 pinfo2,
8882 devmode);
8883 }
8884
8885 /****************************************************************
8886 _spoolss_GetJob
8887 ****************************************************************/
8888
8889 WERROR _spoolss_GetJob(struct pipes_struct *p,
8890 struct spoolss_GetJob *r)
8891 {
8892 WERROR result = WERR_OK;
8893 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
8894 int snum;
8895 int count;
8896 print_queue_struct *queue = NULL;
8897 print_status_struct prt_status;
8898
8899 /* that's an [in out] buffer */
8900
8901 if (!r->in.buffer && (r->in.offered != 0)) {
8902 return WERR_INVALID_PARAM;
8903 }
8904
8905 DEBUG(5,("_spoolss_GetJob\n"));
8906
8907 *r->out.needed = 0;
8908
8909 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8910 return WERR_BADFID;
8911 }
8912
8913 result = winreg_get_printer(p->mem_ctx,
8914 get_server_info_system(),
8915 p->msg_ctx,
8916 NULL,
8917 lp_const_servicename(snum),
8918 &pinfo2);
8919 if (!W_ERROR_IS_OK(result)) {
8920 return result;
8921 }
8922
8923 count = print_queue_status(p->msg_ctx, snum, &queue, &prt_status);
8924
8925 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8926 count, prt_status.status, prt_status.message));
8927
8928 switch (r->in.level) {
8929 case 1:
8930 result = getjob_level_1(p->mem_ctx,
8931 queue, count, snum, pinfo2,
8932 r->in.job_id, &r->out.info->info1);
8933 break;
8934 case 2:
8935 result = getjob_level_2(p->mem_ctx,
8936 queue, count, snum, pinfo2,
8937 r->in.job_id, &r->out.info->info2);
8938 break;
8939 default:
8940 result = WERR_UNKNOWN_LEVEL;
8941 break;
8942 }
8943
8944 SAFE_FREE(queue);
8945 TALLOC_FREE(pinfo2);
8946
8947 if (!W_ERROR_IS_OK(result)) {
8948 TALLOC_FREE(r->out.info);
8949 return result;
8950 }
8951
8952 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, r->out.info,
8953 r->in.level);
8954 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8955
8956 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8957 }
8958
8959 /****************************************************************
8960 _spoolss_GetPrinterDataEx
8961 ****************************************************************/
8962
8963 WERROR _spoolss_GetPrinterDataEx(struct pipes_struct *p,
8964 struct spoolss_GetPrinterDataEx *r)
8965 {
8966
8967 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
8968 const char *printer;
8969 int snum = 0;
8970 WERROR result = WERR_OK;
8971 DATA_BLOB blob;
8972 enum winreg_Type val_type;
8973 uint8_t *val_data;
8974 uint32_t val_size;
8975
8976
8977 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
8978
8979 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
8980 r->in.key_name, r->in.value_name));
8981
8982 /* in case of problem, return some default values */
8983
8984 *r->out.needed = 0;
8985 *r->out.type = REG_NONE;
8986
8987 if (!Printer) {
8988 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
8989 OUR_HANDLE(r->in.handle)));
8990 result = WERR_BADFID;
8991 goto done;
8992 }
8993
8994 /* Is the handle to a printer or to the server? */
8995
8996 if (Printer->printer_type == SPLHND_SERVER) {
8997
8998 union spoolss_PrinterData data;
8999
9000 result = getprinterdata_printer_server(p->mem_ctx,
9001 r->in.value_name,
9002 r->out.type,
9003 &data);
9004 if (!W_ERROR_IS_OK(result)) {
9005 return result;
9006 }
9007
9008 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
9009 *r->out.type, &data);
9010 if (!W_ERROR_IS_OK(result)) {
9011 return result;
9012 }
9013
9014 *r->out.needed = blob.length;
9015
9016 if (r->in.offered >= *r->out.needed) {
9017 memcpy(r->out.data, blob.data, blob.length);
9018 }
9019
9020 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9021 }
9022
9023 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9024 return WERR_BADFID;
9025 }
9026 printer = lp_const_servicename(snum);
9027
9028 /* check to see if the keyname is valid */
9029 if (!strlen(r->in.key_name)) {
9030 return WERR_INVALID_PARAM;
9031 }
9032
9033 /* XP sends this and wants the ChangeID value from PRINTER_INFO_0 */
9034 if (strequal(r->in.key_name, SPOOL_PRINTERDATA_KEY) &&
9035 strequal(r->in.value_name, "ChangeId")) {
9036 *r->out.type = REG_DWORD;
9037 *r->out.needed = 4;
9038 if (r->in.offered >= *r->out.needed) {
9039 uint32_t changeid = 0;
9040
9041 result = winreg_printer_get_changeid(p->mem_ctx,
9042 get_server_info_system(),
9043 p->msg_ctx,
9044 printer,
9045 &changeid);
9046 if (!W_ERROR_IS_OK(result)) {
9047 return result;
9048 }
9049
9050 SIVAL(r->out.data, 0, changeid);
9051 result = WERR_OK;
9052 }
9053 goto done;
9054 }
9055
9056 result = winreg_get_printer_dataex(p->mem_ctx,
9057 get_server_info_system(),
9058 p->msg_ctx,
9059 printer,
9060 r->in.key_name,
9061 r->in.value_name,
9062 &val_type,
9063 &val_data,
9064 &val_size);
9065 if (!W_ERROR_IS_OK(result)) {
9066 return result;
9067 }
9068
9069 *r->out.needed = val_size;
9070 *r->out.type = val_type;
9071
9072 if (r->in.offered >= *r->out.needed) {
9073 memcpy(r->out.data, val_data, val_size);
9074 }
9075
9076 done:
9077 *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
9078 r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
9079
9080 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9081 }
9082
9083 /****************************************************************
9084 _spoolss_SetPrinterDataEx
9085 ****************************************************************/
9086
9087 WERROR _spoolss_SetPrinterDataEx(struct pipes_struct *p,
9088 struct spoolss_SetPrinterDataEx *r)
9089 {
9090 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
9091 int snum = 0;
9092 WERROR result = WERR_OK;
9093 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9094 char *oid_string;
9095
9096 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9097
9098 /* From MSDN documentation of SetPrinterDataEx: pass request to
9099 SetPrinterData if key is "PrinterDriverData" */
9100
9101 if (!Printer) {
9102 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9103 OUR_HANDLE(r->in.handle)));
9104 return WERR_BADFID;
9105 }
9106
9107 if (Printer->printer_type == SPLHND_SERVER) {
9108 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9109 "Not implemented for server handles yet\n"));
9110 return WERR_INVALID_PARAM;
9111 }
9112
9113 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9114 return WERR_BADFID;
9115 }
9116
9117 /*
9118 * Access check : NT returns "access denied" if you make a
9119 * SetPrinterData call without the necessary privildge.
9120 * we were originally returning OK if nothing changed
9121 * which made Win2k issue **a lot** of SetPrinterData
9122 * when connecting to a printer --jerry
9123 */
9124
9125 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9126 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9127 "change denied by handle access permissions\n"));
9128 return WERR_ACCESS_DENIED;
9129 }
9130
9131 result = winreg_get_printer(Printer,
9132 get_server_info_system(),
9133 p->msg_ctx,
9134 Printer->servername,
9135 lp_servicename(snum),
9136 &pinfo2);
9137 if (!W_ERROR_IS_OK(result)) {
9138 return result;
9139 }
9140
9141 /* check for OID in valuename */
9142
9143 oid_string = strchr(r->in.value_name, ',');
9144 if (oid_string) {
9145 *oid_string = '\0';
9146 oid_string++;
9147 }
9148
9149 /* save the registry data */
9150
9151 result = winreg_set_printer_dataex(p->mem_ctx,
9152 get_server_info_system(),
9153 p->msg_ctx,
9154 pinfo2->sharename,
9155 r->in.key_name,
9156 r->in.value_name,
9157 r->in.type,
9158 r->in.data,
9159 r->in.offered);
9160
9161 if (W_ERROR_IS_OK(result)) {
9162 /* save the OID if one was specified */
9163 if (oid_string) {
9164 char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
9165 r->in.key_name, SPOOL_OID_KEY);
9166 if (!str) {
9167 result = WERR_NOMEM;
9168 goto done;
9169 }
9170
9171 /*
9172 * I'm not checking the status here on purpose. Don't know
9173 * if this is right, but I'm returning the status from the
9174 * previous set_printer_dataex() call. I have no idea if
9175 * this is right. --jerry
9176 */
9177 winreg_set_printer_dataex(p->mem_ctx,
9178 get_server_info_system(),
9179 p->msg_ctx,
9180 pinfo2->sharename,
9181 str,
9182 r->in.value_name,
9183 REG_SZ,
9184 (uint8_t *) oid_string,
9185 strlen(oid_string) + 1);
9186 }
9187
9188 result = winreg_printer_update_changeid(p->mem_ctx,
9189 get_server_info_system(),
9190 p->msg_ctx,
9191 lp_const_servicename(snum));
9192
9193 }
9194
9195 done:
9196 talloc_free(pinfo2);
9197 return result;
9198 }
9199
9200 /****************************************************************
9201 _spoolss_DeletePrinterDataEx
9202 ****************************************************************/
9203
9204 WERROR _spoolss_DeletePrinterDataEx(struct pipes_struct *p,
9205 struct spoolss_DeletePrinterDataEx *r)
9206 {
9207 const char *printer;
9208 int snum=0;
9209 WERROR status = WERR_OK;
9210 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9211
9212 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9213
9214 if (!Printer) {
9215 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9216 "Invalid handle (%s:%u:%u).\n",
9217 OUR_HANDLE(r->in.handle)));
9218 return WERR_BADFID;
9219 }
9220
9221 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9222 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9223 "printer properties change denied by handle\n"));
9224 return WERR_ACCESS_DENIED;
9225 }
9226
9227 if (!r->in.value_name || !r->in.key_name) {
9228 return WERR_NOMEM;
9229 }
9230
9231 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9232 return WERR_BADFID;
9233 }
9234 printer = lp_const_servicename(snum);
9235
9236 status = winreg_delete_printer_dataex(p->mem_ctx,
9237 get_server_info_system(),
9238 p->msg_ctx,
9239 printer,
9240 r->in.key_name,
9241 r->in.value_name);
9242 if (W_ERROR_IS_OK(status)) {
9243 status = winreg_printer_update_changeid(p->mem_ctx,
9244 get_server_info_system(),
9245 p->msg_ctx,
9246 printer);
9247 }
9248
9249 return status;
9250 }
9251
9252 /****************************************************************
9253 _spoolss_EnumPrinterKey
9254 ****************************************************************/
9255
9256 WERROR _spoolss_EnumPrinterKey(struct pipes_struct *p,
9257 struct spoolss_EnumPrinterKey *r)
9258 {
9259 uint32_t num_keys;
9260 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9261 int snum = 0;
9262 WERROR result = WERR_BADFILE;
9263 const char **array = NULL;
9264 DATA_BLOB blob;
9265
9266 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9267
9268 if (!Printer) {
9269 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9270 OUR_HANDLE(r->in.handle)));
9271 return WERR_BADFID;
9272 }
9273
9274 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9275 return WERR_BADFID;
9276 }
9277
9278 result = winreg_enum_printer_key(p->mem_ctx,
9279 get_server_info_system(),
9280 p->msg_ctx,
9281 lp_const_servicename(snum),
9282 r->in.key_name,
9283 &num_keys,
9284 &array);
9285 if (!W_ERROR_IS_OK(result)) {
9286 goto done;
9287 }
9288
9289 if (!push_reg_multi_sz(p->mem_ctx, &blob, array)) {
9290 result = WERR_NOMEM;
9291 goto done;
9292 }
9293
9294 *r->out._ndr_size = r->in.offered / 2;
9295 *r->out.needed = blob.length;
9296
9297 if (r->in.offered < *r->out.needed) {
9298 result = WERR_MORE_DATA;
9299 } else {
9300 result = WERR_OK;
9301 r->out.key_buffer->string_array = array;
9302 }
9303
9304 done:
9305 if (!W_ERROR_IS_OK(result)) {
9306 TALLOC_FREE(array);
9307 if (!W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
9308 *r->out.needed = 0;
9309 }
9310 }
9311
9312 return result;
9313 }
9314
9315 /****************************************************************
9316 _spoolss_DeletePrinterKey
9317 ****************************************************************/
9318
9319 WERROR _spoolss_DeletePrinterKey(struct pipes_struct *p,
9320 struct spoolss_DeletePrinterKey *r)
9321 {
9322 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9323 int snum=0;
9324 WERROR status;
9325 const char *printer;
9326
9327 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9328
9329 if (!Printer) {
9330 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9331 OUR_HANDLE(r->in.handle)));
9332 return WERR_BADFID;
9333 }
9334
9335 /* if keyname == NULL, return error */
9336 if ( !r->in.key_name )
9337 return WERR_INVALID_PARAM;
9338
9339 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9340 return WERR_BADFID;
9341 }
9342
9343 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9344 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9345 "printer properties change denied by handle\n"));
9346 return WERR_ACCESS_DENIED;
9347 }
9348
9349 printer = lp_const_servicename(snum);
9350
9351 /* delete the key and all subkeys */
9352 status = winreg_delete_printer_key(p->mem_ctx,
9353 get_server_info_system(),
9354 p->msg_ctx,
9355 printer,
9356 r->in.key_name);
9357 if (W_ERROR_IS_OK(status)) {
9358 status = winreg_printer_update_changeid(p->mem_ctx,
9359 get_server_info_system(),
9360 p->msg_ctx,
9361 printer);
9362 }
9363
9364 return status;
9365 }
9366
9367 /****************************************************************
9368 _spoolss_EnumPrinterDataEx
9369 ****************************************************************/
9370
9371 WERROR _spoolss_EnumPrinterDataEx(struct pipes_struct *p,
9372 struct spoolss_EnumPrinterDataEx *r)
9373 {
9374 uint32_t count = 0;
9375 struct spoolss_PrinterEnumValues *info = NULL;
9376 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9377 int snum;
9378 WERROR result;
9379
9380 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9381
9382 *r->out.count = 0;
9383 *r->out.needed = 0;
9384 *r->out.info = NULL;
9385
9386 if (!Printer) {
9387 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9388 OUR_HANDLE(r->in.handle)));
9389 return WERR_BADFID;
9390 }
9391
9392 /*
9393 * first check for a keyname of NULL or "". Win2k seems to send
9394 * this a lot and we should send back WERR_INVALID_PARAM
9395 * no need to spend time looking up the printer in this case.
9396 * --jerry
9397 */
9398
9399 if (!strlen(r->in.key_name)) {
9400 result = WERR_INVALID_PARAM;
9401 goto done;
9402 }
9403
9404 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9405 return WERR_BADFID;
9406 }
9407
9408 /* now look for a match on the key name */
9409 result = winreg_enum_printer_dataex(p->mem_ctx,
9410 get_server_info_system(),
9411 p->msg_ctx,
9412 lp_const_servicename(snum),
9413 r->in.key_name,
9414 &count,
9415 &info);
9416 if (!W_ERROR_IS_OK(result)) {
9417 goto done;
9418 }
9419
9420 #if 0 /* FIXME - gd */
9421 /* housekeeping information in the reply */
9422
9423 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9424 * the hand marshalled container size is a multiple
9425 * of 4 bytes for RPC alignment.
9426 */
9427
9428 if (needed % 4) {
9429 needed += 4-(needed % 4);
9430 }
9431 #endif
9432 *r->out.count = count;
9433 *r->out.info = info;
9434
9435 done:
9436 if (!W_ERROR_IS_OK(result)) {
9437 return result;
9438 }
9439
9440 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9441 spoolss_EnumPrinterDataEx,
9442 *r->out.info,
9443 *r->out.count);
9444 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9445 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9446
9447 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9448 }
9449
9450 /****************************************************************************
9451 ****************************************************************************/
9452
9453 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9454 const char *servername,
9455 const char *environment,
9456 struct spoolss_PrintProcessorDirectoryInfo1 *r)
9457 {
9458 WERROR werr;
9459 char *path = NULL;
9460
9461 werr = compose_spoolss_server_path(mem_ctx,
9462 servername,
9463 environment,
9464 SPOOLSS_PRTPROCS_PATH,
9465 &path);
9466 if (!W_ERROR_IS_OK(werr)) {
9467 return werr;
9468 }
9469
9470 DEBUG(4,("print processor directory: [%s]\n", path));
9471
9472 r->directory_name = path;
9473
9474 return WERR_OK;
9475 }
9476
9477 /****************************************************************
9478 _spoolss_GetPrintProcessorDirectory
9479 ****************************************************************/
9480
9481 WERROR _spoolss_GetPrintProcessorDirectory(struct pipes_struct *p,
9482 struct spoolss_GetPrintProcessorDirectory *r)
9483 {
9484 WERROR result;
9485
9486 /* that's an [in out] buffer */
9487
9488 if (!r->in.buffer && (r->in.offered != 0)) {
9489 return WERR_INVALID_PARAM;
9490 }
9491
9492 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9493 r->in.level));
9494
9495 *r->out.needed = 0;
9496
9497 /* r->in.level is ignored */
9498
9499 /* We always should reply with a local print processor directory so that
9500 * users are not forced to have a [prnproc$] share on the Samba spoolss
9501 * server - Guenther */
9502
9503 result = getprintprocessordirectory_level_1(p->mem_ctx,
9504 NULL, /* r->in.server */
9505 r->in.environment,
9506 &r->out.info->info1);
9507 if (!W_ERROR_IS_OK(result)) {
9508 TALLOC_FREE(r->out.info);
9509 return result;
9510 }
9511
9512 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo,
9513 r->out.info, r->in.level);
9514 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9515
9516 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9517 }
9518
9519 /*******************************************************************
9520 ********************************************************************/
9521
9522 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9523 const char *dllname)
9524 {
9525 enum ndr_err_code ndr_err;
9526 struct spoolss_MonitorUi ui;
9527
9528 ui.dll_name = dllname;
9529
9530 ndr_err = ndr_push_struct_blob(buf, mem_ctx, &ui,
9531 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9532 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9533 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9534 }
9535 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9536 }
9537
9538 /*******************************************************************
9539 Streams the monitor UI DLL name in UNICODE
9540 *******************************************************************/
9541
9542 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9543 NT_USER_TOKEN *token, DATA_BLOB *in,
9544 DATA_BLOB *out, uint32_t *needed)
9545 {
9546 const char *dllname = "tcpmonui.dll";
9547
9548 *needed = (strlen(dllname)+1) * 2;
9549
9550 if (out->length < *needed) {
9551 return WERR_INSUFFICIENT_BUFFER;
9552 }
9553
9554 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9555 return WERR_NOMEM;
9556 }
9557
9558 return WERR_OK;
9559 }
9560
9561 /*******************************************************************
9562 ********************************************************************/
9563
9564 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9565 struct spoolss_PortData1 *port1,
9566 const DATA_BLOB *buf)
9567 {
9568 enum ndr_err_code ndr_err;
9569 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port1,
9570 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9571 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9572 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9573 }
9574 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9575 }
9576
9577 /*******************************************************************
9578 ********************************************************************/
9579
9580 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9581 struct spoolss_PortData2 *port2,
9582 const DATA_BLOB *buf)
9583 {
9584 enum ndr_err_code ndr_err;
9585 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, port2,
9586 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9587 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9588 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9589 }
9590 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9591 }
9592
9593 /*******************************************************************
9594 Create a new TCP/IP port
9595 *******************************************************************/
9596
9597 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9598 NT_USER_TOKEN *token, DATA_BLOB *in,
9599 DATA_BLOB *out, uint32_t *needed)
9600 {
9601 struct spoolss_PortData1 port1;
9602 struct spoolss_PortData2 port2;
9603 char *device_uri = NULL;
9604 uint32_t version;
9605
9606 const char *portname;
9607 const char *hostaddress;
9608 const char *queue;
9609 uint32_t port_number;
9610 uint32_t protocol;
9611
9612 /* peek for spoolss_PortData version */
9613
9614 if (!in || (in->length < (128 + 4))) {
9615 return WERR_GENERAL_FAILURE;
9616 }
9617
9618 version = IVAL(in->data, 128);
9619
9620 switch (version) {
9621 case 1:
9622 ZERO_STRUCT(port1);
9623
9624 if (!pull_port_data_1(mem_ctx, &port1, in)) {
9625 return WERR_NOMEM;
9626 }
9627
9628 portname = port1.portname;
9629 hostaddress = port1.hostaddress;
9630 queue = port1.queue;
9631 protocol = port1.protocol;
9632 port_number = port1.port_number;
9633
9634 break;
9635 case 2:
9636 ZERO_STRUCT(port2);
9637
9638 if (!pull_port_data_2(mem_ctx, &port2, in)) {
9639 return WERR_NOMEM;
9640 }
9641
9642 portname = port2.portname;
9643 hostaddress = port2.hostaddress;
9644 queue = port2.queue;
9645 protocol = port2.protocol;
9646 port_number = port2.port_number;
9647
9648 break;
9649 default:
9650 DEBUG(1,("xcvtcp_addport: "
9651 "unknown version of port_data: %d\n", version));
9652 return WERR_UNKNOWN_PORT;
9653 }
9654
9655 /* create the device URI and call the add_port_hook() */
9656
9657 switch (protocol) {
9658 case PROTOCOL_RAWTCP_TYPE:
9659 device_uri = talloc_asprintf(mem_ctx,
9660 "socket://%s:%d/", hostaddress,
9661 port_number);
9662 break;
9663
9664 case PROTOCOL_LPR_TYPE:
9665 device_uri = talloc_asprintf(mem_ctx,
9666 "lpr://%s/%s", hostaddress, queue );
9667 break;
9668
9669 default:
9670 return WERR_UNKNOWN_PORT;
9671 }
9672
9673 if (!device_uri) {
9674 return WERR_NOMEM;
9675 }
9676
9677 return add_port_hook(mem_ctx, token, portname, device_uri);
9678 }
9679
9680 /*******************************************************************
9681 *******************************************************************/
9682
9683 struct xcv_api_table xcvtcp_cmds[] = {
9684 { "MonitorUI", xcvtcp_monitorui },
9685 { "AddPort", xcvtcp_addport},
9686 { NULL, NULL }
9687 };
9688
9689 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9690 NT_USER_TOKEN *token, const char *command,
9691 DATA_BLOB *inbuf,
9692 DATA_BLOB *outbuf,
9693 uint32_t *needed )
9694 {
9695 int i;
9696
9697 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9698
9699 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9700 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9701 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9702 }
9703
9704 return WERR_BADFUNC;
9705 }
9706
9707 /*******************************************************************
9708 *******************************************************************/
9709 #if 0 /* don't support management using the "Local Port" monitor */
9710
9711 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9712 NT_USER_TOKEN *token, DATA_BLOB *in,
9713 DATA_BLOB *out, uint32_t *needed)
9714 {
9715 const char *dllname = "localui.dll";
9716
9717 *needed = (strlen(dllname)+1) * 2;
9718
9719 if (out->length < *needed) {
9720 return WERR_INSUFFICIENT_BUFFER;
9721 }
9722
9723 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9724 return WERR_NOMEM;
9725 }
9726
9727 return WERR_OK;
9728 }
9729
9730 /*******************************************************************
9731 *******************************************************************/
9732
9733 struct xcv_api_table xcvlocal_cmds[] = {
9734 { "MonitorUI", xcvlocal_monitorui },
9735 { NULL, NULL }
9736 };
9737 #else
9738 struct xcv_api_table xcvlocal_cmds[] = {
9739 { NULL, NULL }
9740 };
9741 #endif
9742
9743
9744
9745 /*******************************************************************
9746 *******************************************************************/
9747
9748 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9749 NT_USER_TOKEN *token, const char *command,
9750 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9751 uint32_t *needed)
9752 {
9753 int i;
9754
9755 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9756
9757 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9758 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9759 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9760 }
9761 return WERR_BADFUNC;
9762 }
9763
9764 /****************************************************************
9765 _spoolss_XcvData
9766 ****************************************************************/
9767
9768 WERROR _spoolss_XcvData(struct pipes_struct *p,
9769 struct spoolss_XcvData *r)
9770 {
9771 struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
9772 DATA_BLOB out_data = data_blob_null;
9773 WERROR werror;
9774
9775 if (!Printer) {
9776 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9777 OUR_HANDLE(r->in.handle)));
9778 return WERR_BADFID;
9779 }
9780
9781 /* Has to be a handle to the TCP/IP port monitor */
9782
9783 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9784 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9785 return WERR_BADFID;
9786 }
9787
9788 /* requires administrative access to the server */
9789
9790 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9791 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9792 return WERR_ACCESS_DENIED;
9793 }
9794
9795 /* Allocate the outgoing buffer */
9796
9797 if (r->in.out_data_size) {
9798 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9799 if (out_data.data == NULL) {
9800 return WERR_NOMEM;
9801 }
9802 }
9803
9804 switch ( Printer->printer_type ) {
9805 case SPLHND_PORTMON_TCP:
9806 werror = process_xcvtcp_command(p->mem_ctx,
9807 p->server_info->ptok,
9808 r->in.function_name,
9809 &r->in.in_data, &out_data,
9810 r->out.needed);
9811 break;
9812 case SPLHND_PORTMON_LOCAL:
9813 werror = process_xcvlocal_command(p->mem_ctx,
9814 p->server_info->ptok,
9815 r->in.function_name,
9816 &r->in.in_data, &out_data,
9817 r->out.needed);
9818 break;
9819 default:
9820 werror = WERR_INVALID_PRINT_MONITOR;
9821 }
9822
9823 if (!W_ERROR_IS_OK(werror)) {
9824 return werror;
9825 }
9826
9827 *r->out.status_code = 0;
9828
9829 if (r->out.out_data && out_data.data && r->in.out_data_size && out_data.length) {
9830 memcpy(r->out.out_data, out_data.data,
9831 MIN(r->in.out_data_size, out_data.length));
9832 }
9833
9834 return WERR_OK;
9835 }
9836
9837 /****************************************************************
9838 _spoolss_AddPrintProcessor
9839 ****************************************************************/
9840
9841 WERROR _spoolss_AddPrintProcessor(struct pipes_struct *p,
9842 struct spoolss_AddPrintProcessor *r)
9843 {
9844 /* for now, just indicate success and ignore the add. We'll
9845 automatically set the winprint processor for printer
9846 entries later. Used to debug the LexMark Optra S 1855 PCL
9847 driver --jerry */
9848
9849 return WERR_OK;
9850 }
9851
9852 /****************************************************************
9853 _spoolss_AddPort
9854 ****************************************************************/
9855
9856 WERROR _spoolss_AddPort(struct pipes_struct *p,
9857 struct spoolss_AddPort *r)
9858 {
9859 /* do what w2k3 does */
9860
9861 return WERR_NOT_SUPPORTED;
9862 }
9863
9864 /****************************************************************
9865 _spoolss_GetPrinterDriver
9866 ****************************************************************/
9867
9868 WERROR _spoolss_GetPrinterDriver(struct pipes_struct *p,
9869 struct spoolss_GetPrinterDriver *r)
9870 {
9871 p->rng_fault_state = true;
9872 return WERR_NOT_SUPPORTED;
9873 }
9874
9875 /****************************************************************
9876 _spoolss_ReadPrinter
9877 ****************************************************************/
9878
9879 WERROR _spoolss_ReadPrinter(struct pipes_struct *p,
9880 struct spoolss_ReadPrinter *r)
9881 {
9882 p->rng_fault_state = true;
9883 return WERR_NOT_SUPPORTED;
9884 }
9885
9886 /****************************************************************
9887 _spoolss_WaitForPrinterChange
9888 ****************************************************************/
9889
9890 WERROR _spoolss_WaitForPrinterChange(struct pipes_struct *p,
9891 struct spoolss_WaitForPrinterChange *r)
9892 {
9893 p->rng_fault_state = true;
9894 return WERR_NOT_SUPPORTED;
9895 }
9896
9897 /****************************************************************
9898 _spoolss_ConfigurePort
9899 ****************************************************************/
9900
9901 WERROR _spoolss_ConfigurePort(struct pipes_struct *p,
9902 struct spoolss_ConfigurePort *r)
9903 {
9904 p->rng_fault_state = true;
9905 return WERR_NOT_SUPPORTED;
9906 }
9907
9908 /****************************************************************
9909 _spoolss_DeletePort
9910 ****************************************************************/
9911
9912 WERROR _spoolss_DeletePort(struct pipes_struct *p,
9913 struct spoolss_DeletePort *r)
9914 {
9915 p->rng_fault_state = true;
9916 return WERR_NOT_SUPPORTED;
9917 }
9918
9919 /****************************************************************
9920 _spoolss_CreatePrinterIC
9921 ****************************************************************/
9922
9923 WERROR _spoolss_CreatePrinterIC(struct pipes_struct *p,
9924 struct spoolss_CreatePrinterIC *r)
9925 {
9926 p->rng_fault_state = true;
9927 return WERR_NOT_SUPPORTED;
9928 }
9929
9930 /****************************************************************
9931 _spoolss_PlayGDIScriptOnPrinterIC
9932 ****************************************************************/
9933
9934 WERROR _spoolss_PlayGDIScriptOnPrinterIC(struct pipes_struct *p,
9935 struct spoolss_PlayGDIScriptOnPrinterIC *r)
9936 {
9937 p->rng_fault_state = true;
9938 return WERR_NOT_SUPPORTED;
9939 }
9940
9941 /****************************************************************
9942 _spoolss_DeletePrinterIC
9943 ****************************************************************/
9944
9945 WERROR _spoolss_DeletePrinterIC(struct pipes_struct *p,
9946 struct spoolss_DeletePrinterIC *r)
9947 {
9948 p->rng_fault_state = true;
9949 return WERR_NOT_SUPPORTED;
9950 }
9951
9952 /****************************************************************
9953 _spoolss_AddPrinterConnection
9954 ****************************************************************/
9955
9956 WERROR _spoolss_AddPrinterConnection(struct pipes_struct *p,
9957 struct spoolss_AddPrinterConnection *r)
9958 {
9959 p->rng_fault_state = true;
9960 return WERR_NOT_SUPPORTED;
9961 }
9962
9963 /****************************************************************
9964 _spoolss_DeletePrinterConnection
9965 ****************************************************************/
9966
9967 WERROR _spoolss_DeletePrinterConnection(struct pipes_struct *p,
9968 struct spoolss_DeletePrinterConnection *r)
9969 {
9970 p->rng_fault_state = true;
9971 return WERR_NOT_SUPPORTED;
9972 }
9973
9974 /****************************************************************
9975 _spoolss_PrinterMessageBox
9976 ****************************************************************/
9977
9978 WERROR _spoolss_PrinterMessageBox(struct pipes_struct *p,
9979 struct spoolss_PrinterMessageBox *r)
9980 {
9981 p->rng_fault_state = true;
9982 return WERR_NOT_SUPPORTED;
9983 }
9984
9985 /****************************************************************
9986 _spoolss_AddMonitor
9987 ****************************************************************/
9988
9989 WERROR _spoolss_AddMonitor(struct pipes_struct *p,
9990 struct spoolss_AddMonitor *r)
9991 {
9992 p->rng_fault_state = true;
9993 return WERR_NOT_SUPPORTED;
9994 }
9995
9996 /****************************************************************
9997 _spoolss_DeleteMonitor
9998 ****************************************************************/
9999
10000 WERROR _spoolss_DeleteMonitor(struct pipes_struct *p,
10001 struct spoolss_DeleteMonitor *r)
10002 {
10003 p->rng_fault_state = true;
10004 return WERR_NOT_SUPPORTED;
10005 }
10006
10007 /****************************************************************
10008 _spoolss_DeletePrintProcessor
10009 ****************************************************************/
10010
10011 WERROR _spoolss_DeletePrintProcessor(struct pipes_struct *p,
10012 struct spoolss_DeletePrintProcessor *r)
10013 {
10014 p->rng_fault_state = true;
10015 return WERR_NOT_SUPPORTED;
10016 }
10017
10018 /****************************************************************
10019 _spoolss_AddPrintProvidor
10020 ****************************************************************/
10021
10022 WERROR _spoolss_AddPrintProvidor(struct pipes_struct *p,
10023 struct spoolss_AddPrintProvidor *r)
10024 {
10025 p->rng_fault_state = true;
10026 return WERR_NOT_SUPPORTED;
10027 }
10028
10029 /****************************************************************
10030 _spoolss_DeletePrintProvidor
10031 ****************************************************************/
10032
10033 WERROR _spoolss_DeletePrintProvidor(struct pipes_struct *p,
10034 struct spoolss_DeletePrintProvidor *r)
10035 {
10036 p->rng_fault_state = true;
10037 return WERR_NOT_SUPPORTED;
10038 }
10039
10040 /****************************************************************
10041 _spoolss_FindFirstPrinterChangeNotification
10042 ****************************************************************/
10043
10044 WERROR _spoolss_FindFirstPrinterChangeNotification(struct pipes_struct *p,
10045 struct spoolss_FindFirstPrinterChangeNotification *r)
10046 {
10047 p->rng_fault_state = true;
10048 return WERR_NOT_SUPPORTED;
10049 }
10050
10051 /****************************************************************
10052 _spoolss_FindNextPrinterChangeNotification
10053 ****************************************************************/
10054
10055 WERROR _spoolss_FindNextPrinterChangeNotification(struct pipes_struct *p,
10056 struct spoolss_FindNextPrinterChangeNotification *r)
10057 {
10058 p->rng_fault_state = true;
10059 return WERR_NOT_SUPPORTED;
10060 }
10061
10062 /****************************************************************
10063 _spoolss_RouterFindFirstPrinterChangeNotificationOld
10064 ****************************************************************/
10065
10066 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(struct pipes_struct *p,
10067 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10068 {
10069 p->rng_fault_state = true;
10070 return WERR_NOT_SUPPORTED;
10071 }
10072
10073 /****************************************************************
10074 _spoolss_ReplyOpenPrinter
10075 ****************************************************************/
10076
10077 WERROR _spoolss_ReplyOpenPrinter(struct pipes_struct *p,
10078 struct spoolss_ReplyOpenPrinter *r)
10079 {
10080 p->rng_fault_state = true;
10081 return WERR_NOT_SUPPORTED;
10082 }
10083
10084 /****************************************************************
10085 _spoolss_RouterReplyPrinter
10086 ****************************************************************/
10087
10088 WERROR _spoolss_RouterReplyPrinter(struct pipes_struct *p,
10089 struct spoolss_RouterReplyPrinter *r)
10090 {
10091 p->rng_fault_state = true;
10092 return WERR_NOT_SUPPORTED;
10093 }
10094
10095 /****************************************************************
10096 _spoolss_ReplyClosePrinter
10097 ****************************************************************/
10098
10099 WERROR _spoolss_ReplyClosePrinter(struct pipes_struct *p,
10100 struct spoolss_ReplyClosePrinter *r)
10101 {
10102 p->rng_fault_state = true;
10103 return WERR_NOT_SUPPORTED;
10104 }
10105
10106 /****************************************************************
10107 _spoolss_AddPortEx
10108 ****************************************************************/
10109
10110 WERROR _spoolss_AddPortEx(struct pipes_struct *p,
10111 struct spoolss_AddPortEx *r)
10112 {
10113 p->rng_fault_state = true;
10114 return WERR_NOT_SUPPORTED;
10115 }
10116
10117 /****************************************************************
10118 _spoolss_RouterFindFirstPrinterChangeNotification
10119 ****************************************************************/
10120
10121 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(struct pipes_struct *p,
10122 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10123 {
10124 p->rng_fault_state = true;
10125 return WERR_NOT_SUPPORTED;
10126 }
10127
10128 /****************************************************************
10129 _spoolss_SpoolerInit
10130 ****************************************************************/
10131
10132 WERROR _spoolss_SpoolerInit(struct pipes_struct *p,
10133 struct spoolss_SpoolerInit *r)
10134 {
10135 p->rng_fault_state = true;
10136 return WERR_NOT_SUPPORTED;
10137 }
10138
10139 /****************************************************************
10140 _spoolss_ResetPrinterEx
10141 ****************************************************************/
10142
10143 WERROR _spoolss_ResetPrinterEx(struct pipes_struct *p,
10144 struct spoolss_ResetPrinterEx *r)
10145 {
10146 p->rng_fault_state = true;
10147 return WERR_NOT_SUPPORTED;
10148 }
10149
10150 /****************************************************************
10151 _spoolss_RouterReplyPrinterEx
10152 ****************************************************************/
10153
10154 WERROR _spoolss_RouterReplyPrinterEx(struct pipes_struct *p,
10155 struct spoolss_RouterReplyPrinterEx *r)
10156 {
10157 p->rng_fault_state = true;
10158 return WERR_NOT_SUPPORTED;
10159 }
10160
10161 /****************************************************************
10162 _spoolss_44
10163 ****************************************************************/
10164
10165 WERROR _spoolss_44(struct pipes_struct *p,
10166 struct spoolss_44 *r)
10167 {
10168 p->rng_fault_state = true;
10169 return WERR_NOT_SUPPORTED;
10170 }
10171
10172 /****************************************************************
10173 _spoolss_47
10174 ****************************************************************/
10175
10176 WERROR _spoolss_47(struct pipes_struct *p,
10177 struct spoolss_47 *r)
10178 {
10179 p->rng_fault_state = true;
10180 return WERR_NOT_SUPPORTED;
10181 }
10182
10183 /****************************************************************
10184 _spoolss_4a
10185 ****************************************************************/
10186
10187 WERROR _spoolss_4a(struct pipes_struct *p,
10188 struct spoolss_4a *r)
10189 {
10190 p->rng_fault_state = true;
10191 return WERR_NOT_SUPPORTED;
10192 }
10193
10194 /****************************************************************
10195 _spoolss_4b
10196 ****************************************************************/
10197
10198 WERROR _spoolss_4b(struct pipes_struct *p,
10199 struct spoolss_4b *r)
10200 {
10201 p->rng_fault_state = true;
10202 return WERR_NOT_SUPPORTED;
10203 }
10204
10205 /****************************************************************
10206 _spoolss_4c
10207 ****************************************************************/
10208
10209 WERROR _spoolss_4c(struct pipes_struct *p,
10210 struct spoolss_4c *r)
10211 {
10212 p->rng_fault_state = true;
10213 return WERR_NOT_SUPPORTED;
10214 }
10215
10216 /****************************************************************
10217 _spoolss_53
10218 ****************************************************************/
10219
10220 WERROR _spoolss_53(struct pipes_struct *p,
10221 struct spoolss_53 *r)
10222 {
10223 p->rng_fault_state = true;
10224 return WERR_NOT_SUPPORTED;
10225 }
10226
10227 /****************************************************************
10228 _spoolss_55
10229 ****************************************************************/
10230
10231 WERROR _spoolss_55(struct pipes_struct *p,
10232 struct spoolss_55 *r)
10233 {
10234 p->rng_fault_state = true;
10235 return WERR_NOT_SUPPORTED;
10236 }
10237
10238 /****************************************************************
10239 _spoolss_56
10240 ****************************************************************/
10241
10242 WERROR _spoolss_56(struct pipes_struct *p,
10243 struct spoolss_56 *r)
10244 {
10245 p->rng_fault_state = true;
10246 return WERR_NOT_SUPPORTED;
10247 }
10248
10249 /****************************************************************
10250 _spoolss_57
10251 ****************************************************************/
10252
10253 WERROR _spoolss_57(struct pipes_struct *p,
10254 struct spoolss_57 *r)
10255 {
10256 p->rng_fault_state = true;
10257 return WERR_NOT_SUPPORTED;
10258 }
10259
10260 /****************************************************************
10261 _spoolss_5a
10262 ****************************************************************/
10263
10264 WERROR _spoolss_5a(struct pipes_struct *p,
10265 struct spoolss_5a *r)
10266 {
10267 p->rng_fault_state = true;
10268 return WERR_NOT_SUPPORTED;
10269 }
10270
10271 /****************************************************************
10272 _spoolss_5b
10273 ****************************************************************/
10274
10275 WERROR _spoolss_5b(struct pipes_struct *p,
10276 struct spoolss_5b *r)
10277 {
10278 p->rng_fault_state = true;
10279 return WERR_NOT_SUPPORTED;
10280 }
10281
10282 /****************************************************************
10283 _spoolss_5c
10284 ****************************************************************/
10285
10286 WERROR _spoolss_5c(struct pipes_struct *p,
10287 struct spoolss_5c *r)
10288 {
10289 p->rng_fault_state = true;
10290 return WERR_NOT_SUPPORTED;
10291 }
10292
10293 /****************************************************************
10294 _spoolss_5d
10295 ****************************************************************/
10296
10297 WERROR _spoolss_5d(struct pipes_struct *p,
10298 struct spoolss_5d *r)
10299 {
10300 p->rng_fault_state = true;
10301 return WERR_NOT_SUPPORTED;
10302 }
10303
10304 /****************************************************************
10305 _spoolss_5e
10306 ****************************************************************/
10307
10308 WERROR _spoolss_5e(struct pipes_struct *p,
10309 struct spoolss_5e *r)
10310 {
10311 p->rng_fault_state = true;
10312 return WERR_NOT_SUPPORTED;
10313 }
10314
10315 /****************************************************************
10316 _spoolss_5f
10317 ****************************************************************/
10318
10319 WERROR _spoolss_5f(struct pipes_struct *p,
10320 struct spoolss_5f *r)
10321 {
10322 p->rng_fault_state = true;
10323 return WERR_NOT_SUPPORTED;
10324 }
10325
10326 /****************************************************************
10327 _spoolss_60
10328 ****************************************************************/
10329
10330 WERROR _spoolss_60(struct pipes_struct *p,
10331 struct spoolss_60 *r)
10332 {
10333 p->rng_fault_state = true;
10334 return WERR_NOT_SUPPORTED;
10335 }
10336
10337 /****************************************************************
10338 _spoolss_61
10339 ****************************************************************/
10340
10341 WERROR _spoolss_61(struct pipes_struct *p,
10342 struct spoolss_61 *r)
10343 {
10344 p->rng_fault_state = true;
10345 return WERR_NOT_SUPPORTED;
10346 }
10347
10348 /****************************************************************
10349 _spoolss_62
10350 ****************************************************************/
10351
10352 WERROR _spoolss_62(struct pipes_struct *p,
10353 struct spoolss_62 *r)
10354 {
10355 p->rng_fault_state = true;
10356 return WERR_NOT_SUPPORTED;
10357 }
10358
10359 /****************************************************************
10360 _spoolss_63
10361 ****************************************************************/
10362
10363 WERROR _spoolss_63(struct pipes_struct *p,
10364 struct spoolss_63 *r)
10365 {
10366 p->rng_fault_state = true;
10367 return WERR_NOT_SUPPORTED;
10368 }
10369
10370 /****************************************************************
10371 _spoolss_64
10372 ****************************************************************/
10373
10374 WERROR _spoolss_64(struct pipes_struct *p,
10375 struct spoolss_64 *r)
10376 {
10377 p->rng_fault_state = true;
10378 return WERR_NOT_SUPPORTED;
10379 }
10380
10381 /****************************************************************
10382 _spoolss_65
10383 ****************************************************************/
10384
10385 WERROR _spoolss_65(struct pipes_struct *p,
10386 struct spoolss_65 *r)
10387 {
10388 p->rng_fault_state = true;
10389 return WERR_NOT_SUPPORTED;
10390 }
10391
10392 /****************************************************************
10393 _spoolss_GetCorePrinterDrivers
10394 ****************************************************************/
10395
10396 WERROR _spoolss_GetCorePrinterDrivers(struct pipes_struct *p,
10397 struct spoolss_GetCorePrinterDrivers *r)
10398 {
10399 p->rng_fault_state = true;
10400 return WERR_NOT_SUPPORTED;
10401 }
10402
10403 /****************************************************************
10404 _spoolss_67
10405 ****************************************************************/
10406
10407 WERROR _spoolss_67(struct pipes_struct *p,
10408 struct spoolss_67 *r)
10409 {
10410 p->rng_fault_state = true;
10411 return WERR_NOT_SUPPORTED;
10412 }
10413
10414 /****************************************************************
10415 _spoolss_GetPrinterDriverPackagePath
10416 ****************************************************************/
10417
10418 WERROR _spoolss_GetPrinterDriverPackagePath(struct pipes_struct *p,
10419 struct spoolss_GetPrinterDriverPackagePath *r)
10420 {
10421 p->rng_fault_state = true;
10422 return WERR_NOT_SUPPORTED;
10423 }
10424
10425 /****************************************************************
10426 _spoolss_69
10427 ****************************************************************/
10428
10429 WERROR _spoolss_69(struct pipes_struct *p,
10430 struct spoolss_69 *r)
10431 {
10432 p->rng_fault_state = true;
10433 return WERR_NOT_SUPPORTED;
10434 }
10435
10436 /****************************************************************
10437 _spoolss_6a
10438 ****************************************************************/
10439
10440 WERROR _spoolss_6a(struct pipes_struct *p,
10441 struct spoolss_6a *r)
10442 {
10443 p->rng_fault_state = true;
10444 return WERR_NOT_SUPPORTED;
10445 }
10446
10447 /****************************************************************
10448 _spoolss_6b
10449 ****************************************************************/
10450
10451 WERROR _spoolss_6b(struct pipes_struct *p,
10452 struct spoolss_6b *r)
10453 {
10454 p->rng_fault_state = true;
10455 return WERR_NOT_SUPPORTED;
10456 }
10457
10458 /****************************************************************
10459 _spoolss_6c
10460 ****************************************************************/
10461
10462 WERROR _spoolss_6c(struct pipes_struct *p,
10463 struct spoolss_6c *r)
10464 {
10465 p->rng_fault_state = true;
10466 return WERR_NOT_SUPPORTED;
10467 }
10468
10469 /****************************************************************
10470 _spoolss_6d
10471 ****************************************************************/
10472
10473 WERROR _spoolss_6d(struct pipes_struct *p,
10474 struct spoolss_6d *r)
10475 {
10476 p->rng_fault_state = true;
10477 return WERR_NOT_SUPPORTED;
10478 }
Samba GIT mirror