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