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