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