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