?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WHATSNEW: Update changes since 3.3.0pre1.
[Samba.git] / source / rpc_server / srv_spoolss_nt.c
blob635898a9d5769e12b8b07987767f561b00d4a5dd
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( rpc_pipe_np_smb_conn(notify_cli_pipe) );
180 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
181
182 messaging_deregister(smbd_messaging_context(),
183 MSG_PRINTER_NOTIFY2, NULL);
184
185 /* Tell the connections db we're no longer interested in
186 * printer notify messages. */
187
188 register_message_flags( False, FLAG_MSG_PRINT_NOTIFY );
189 }
190
191 smb_connections--;
192 }
193
194 /****************************************************************************
195 Functions to free a printer entry datastruct.
196 ****************************************************************************/
197
198 static void free_printer_entry(void *ptr)
199 {
200 Printer_entry *Printer = (Printer_entry *)ptr;
201
202 if (Printer->notify.client_connected==True) {
203 int snum = -1;
204
205 if ( Printer->printer_type == SPLHND_SERVER) {
206 snum = -1;
207 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
208 } else if (Printer->printer_type == SPLHND_PRINTER) {
209 snum = print_queue_snum(Printer->sharename);
210 if (snum != -1)
211 srv_spoolss_replycloseprinter(snum,
212 &Printer->notify.client_hnd);
213 }
214 }
215
216 Printer->notify.flags=0;
217 Printer->notify.options=0;
218 Printer->notify.localmachine[0]='\0';
219 Printer->notify.printerlocal=0;
220 free_spool_notify_option(&Printer->notify.option);
221 Printer->notify.option=NULL;
222 Printer->notify.client_connected=False;
223
224 free_nt_devicemode( &Printer->nt_devmode );
225 free_a_printer( &Printer->printer_info, 2 );
226
227 talloc_destroy( Printer->ctx );
228
229 /* Remove from the internal list. */
230 DLIST_REMOVE(printers_list, Printer);
231
232 SAFE_FREE(Printer);
233 }
234
235 /****************************************************************************
236 Functions to duplicate a SPOOL_NOTIFY_OPTION struct stored in Printer_entry.
237 ****************************************************************************/
238
239 static SPOOL_NOTIFY_OPTION *dup_spool_notify_option(SPOOL_NOTIFY_OPTION *sp)
240 {
241 SPOOL_NOTIFY_OPTION *new_sp = NULL;
242
243 if (!sp)
244 return NULL;
245
246 new_sp = SMB_MALLOC_P(SPOOL_NOTIFY_OPTION);
247 if (!new_sp)
248 return NULL;
249
250 *new_sp = *sp;
251
252 if (sp->ctr.count) {
253 new_sp->ctr.type = (SPOOL_NOTIFY_OPTION_TYPE *)memdup(sp->ctr.type, sizeof(SPOOL_NOTIFY_OPTION_TYPE) * sp->ctr.count);
254
255 if (!new_sp->ctr.type) {
256 SAFE_FREE(new_sp);
257 return NULL;
258 }
259 }
260
261 return new_sp;
262 }
263
264 /****************************************************************************
265 find printer index by handle
266 ****************************************************************************/
267
268 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p, POLICY_HND *hnd)
269 {
270 Printer_entry *find_printer = NULL;
271
272 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
273 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
274 return NULL;
275 }
276
277 return find_printer;
278 }
279
280 /****************************************************************************
281 Close printer index by handle.
282 ****************************************************************************/
283
284 static bool close_printer_handle(pipes_struct *p, POLICY_HND *hnd)
285 {
286 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
287
288 if (!Printer) {
289 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(hnd)));
290 return False;
291 }
292
293 close_policy_hnd(p, hnd);
294
295 return True;
296 }
297
298 /****************************************************************************
299 Delete a printer given a handle.
300 ****************************************************************************/
301
302 WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename )
303 {
304 char *cmd = lp_deleteprinter_cmd();
305 char *command = NULL;
306 int ret;
307 SE_PRIV se_printop = SE_PRINT_OPERATOR;
308 bool is_print_op = False;
309
310 /* can't fail if we don't try */
311
312 if ( !*cmd )
313 return WERR_OK;
314
315 command = talloc_asprintf(ctx,
316 "%s \"%s\"",
317 cmd, sharename);
318 if (!command) {
319 return WERR_NOMEM;
320 }
321 if ( token )
322 is_print_op = user_has_privileges( token, &se_printop );
323
324 DEBUG(10,("Running [%s]\n", command));
325
326 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
327
328 if ( is_print_op )
329 become_root();
330
331 if ( (ret = smbrun(command, NULL)) == 0 ) {
332 /* Tell everyone we updated smb.conf. */
333 message_send_all(smbd_messaging_context(),
334 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
335 }
336
337 if ( is_print_op )
338 unbecome_root();
339
340 /********** END SePrintOperatorPrivlege BLOCK **********/
341
342 DEBUGADD(10,("returned [%d]\n", ret));
343
344 TALLOC_FREE(command);
345
346 if (ret != 0)
347 return WERR_BADFID; /* What to return here? */
348
349 /* go ahead and re-read the services immediately */
350 reload_services( False );
351
352 if ( lp_servicenumber( sharename ) < 0 )
353 return WERR_ACCESS_DENIED;
354
355 return WERR_OK;
356 }
357
358 /****************************************************************************
359 Delete a printer given a handle.
360 ****************************************************************************/
361
362 static WERROR delete_printer_handle(pipes_struct *p, POLICY_HND *hnd)
363 {
364 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
365
366 if (!Printer) {
367 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(hnd)));
368 return WERR_BADFID;
369 }
370
371 /*
372 * It turns out that Windows allows delete printer on a handle
373 * opened by an admin user, then used on a pipe handle created
374 * by an anonymous user..... but they're working on security.... riiight !
375 * JRA.
376 */
377
378 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
379 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
380 return WERR_ACCESS_DENIED;
381 }
382
383 /* this does not need a become root since the access check has been
384 done on the handle already */
385
386 if (del_a_printer( Printer->sharename ) != 0) {
387 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
388 return WERR_BADFID;
389 }
390
391 return delete_printer_hook(p->mem_ctx, p->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),
1664 NULL, NULL,
1665 p->pipe_user.nt_user_token,
1666 lp_printer_admin(snum))) {
1667 close_printer_handle(p, handle);
1668 return WERR_ACCESS_DENIED;
1669 }
1670
1671 printer_default->access_required = SERVER_ACCESS_ADMINISTER;
1672 }
1673 else
1674 {
1675 printer_default->access_required = SERVER_ACCESS_ENUMERATE;
1676 }
1677
1678 DEBUG(4,("Setting print server access = %s\n", (printer_default->access_required == SERVER_ACCESS_ADMINISTER)
1679 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1680
1681 /* We fall through to return WERR_OK */
1682 break;
1683
1684 case SPLHND_PRINTER:
1685 /* NT doesn't let us connect to a printer if the connecting user
1686 doesn't have print permission. */
1687
1688 if (!get_printer_snum(p, handle, &snum, NULL)) {
1689 close_printer_handle(p, handle);
1690 return WERR_BADFID;
1691 }
1692
1693 se_map_standard(&printer_default->access_required, &printer_std_mapping);
1694
1695 /* map an empty access mask to the minimum access mask */
1696 if (printer_default->access_required == 0x0)
1697 printer_default->access_required = PRINTER_ACCESS_USE;
1698
1699 /*
1700 * If we are not serving the printer driver for this printer,
1701 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1702 * will keep NT clients happy --jerry
1703 */
1704
1705 if (lp_use_client_driver(snum)
1706 && (printer_default->access_required & PRINTER_ACCESS_ADMINISTER))
1707 {
1708 printer_default->access_required = PRINTER_ACCESS_USE;
1709 }
1710
1711 /* check smb.conf parameters and the the sec_desc */
1712
1713 if ( !check_access(smbd_server_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1714 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1715 return WERR_ACCESS_DENIED;
1716 }
1717
1718 if (!user_ok_token(uidtoname(p->pipe_user.ut.uid), NULL,
1719 p->pipe_user.nt_user_token, snum) ||
1720 !print_access_check(p->server_info, snum,
1721 printer_default->access_required)) {
1722 DEBUG(3, ("access DENIED for printer open\n"));
1723 close_printer_handle(p, handle);
1724 return WERR_ACCESS_DENIED;
1725 }
1726
1727 if ((printer_default->access_required & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1728 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1729 close_printer_handle(p, handle);
1730 return WERR_ACCESS_DENIED;
1731 }
1732
1733 if (printer_default->access_required & PRINTER_ACCESS_ADMINISTER)
1734 printer_default->access_required = PRINTER_ACCESS_ADMINISTER;
1735 else
1736 printer_default->access_required = PRINTER_ACCESS_USE;
1737
1738 DEBUG(4,("Setting printer access = %s\n", (printer_default->access_required == PRINTER_ACCESS_ADMINISTER)
1739 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1740
1741 break;
1742
1743 default:
1744 /* sanity check to prevent programmer error */
1745 return WERR_BADFID;
1746 }
1747
1748 Printer->access_granted = printer_default->access_required;
1749
1750 /*
1751 * If the client sent a devmode in the OpenPrinter() call, then
1752 * save it here in case we get a job submission on this handle
1753 */
1754
1755 if ( (Printer->printer_type != SPLHND_SERVER)
1756 && q_u->printer_default.devmode_cont.devmode_ptr )
1757 {
1758 convert_devicemode( Printer->sharename, q_u->printer_default.devmode_cont.devmode,
1759 &Printer->nt_devmode );
1760 }
1761
1762 #if 0 /* JERRY -- I'm doubtful this is really effective */
1763 /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1764 optimization in Windows 2000 clients --jerry */
1765
1766 if ( (printer_default->access_required == PRINTER_ACCESS_ADMINISTER)
1767 && (RA_WIN2K == get_remote_arch()) )
1768 {
1769 DEBUG(10,("_spoolss_open_printer_ex: Enabling LAN/WAN hack for Win2k clients.\n"));
1770 sys_usleep( 500000 );
1771 }
1772 #endif
1773
1774 return WERR_OK;
1775 }
1776
1777 /****************************************************************************
1778 ****************************************************************************/
1779
1780 static bool convert_printer_info(const SPOOL_PRINTER_INFO_LEVEL *uni,
1781 NT_PRINTER_INFO_LEVEL *printer, uint32 level)
1782 {
1783 bool ret;
1784
1785 switch (level) {
1786 case 2:
1787 /* allocate memory if needed. Messy because
1788 convert_printer_info is used to update an existing
1789 printer or build a new one */
1790
1791 if ( !printer->info_2 ) {
1792 printer->info_2 = TALLOC_ZERO_P( printer, NT_PRINTER_INFO_LEVEL_2 );
1793 if ( !printer->info_2 ) {
1794 DEBUG(0,("convert_printer_info: talloc() failed!\n"));
1795 return False;
1796 }
1797 }
1798
1799 ret = uni_2_asc_printer_info_2(uni->info_2, printer->info_2);
1800 printer->info_2->setuptime = time(NULL);
1801
1802 return ret;
1803 }
1804
1805 return False;
1806 }
1807
1808 static bool convert_printer_driver_info(const SPOOL_PRINTER_DRIVER_INFO_LEVEL *uni,
1809 NT_PRINTER_DRIVER_INFO_LEVEL *printer, uint32 level)
1810 {
1811 bool result = True;
1812
1813 switch (level) {
1814 case 3:
1815 printer->info_3=NULL;
1816 if (!uni_2_asc_printer_driver_3(uni->info_3, &printer->info_3))
1817 result = False;
1818 break;
1819 case 6:
1820 printer->info_6=NULL;
1821 if (!uni_2_asc_printer_driver_6(uni->info_6, &printer->info_6))
1822 result = False;
1823 break;
1824 default:
1825 break;
1826 }
1827
1828 return result;
1829 }
1830
1831 bool convert_devicemode(const char *printername, const DEVICEMODE *devmode,
1832 NT_DEVICEMODE **pp_nt_devmode)
1833 {
1834 NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1835
1836 /*
1837 * Ensure nt_devmode is a valid pointer
1838 * as we will be overwriting it.
1839 */
1840
1841 if (nt_devmode == NULL) {
1842 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1843 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1844 return False;
1845 }
1846
1847 rpcstr_pull(nt_devmode->devicename,devmode->devicename.buffer, 31, -1, 0);
1848 rpcstr_pull(nt_devmode->formname,devmode->formname.buffer, 31, -1, 0);
1849
1850 nt_devmode->specversion=devmode->specversion;
1851 nt_devmode->driverversion=devmode->driverversion;
1852 nt_devmode->size=devmode->size;
1853 nt_devmode->fields=devmode->fields;
1854 nt_devmode->orientation=devmode->orientation;
1855 nt_devmode->papersize=devmode->papersize;
1856 nt_devmode->paperlength=devmode->paperlength;
1857 nt_devmode->paperwidth=devmode->paperwidth;
1858 nt_devmode->scale=devmode->scale;
1859 nt_devmode->copies=devmode->copies;
1860 nt_devmode->defaultsource=devmode->defaultsource;
1861 nt_devmode->printquality=devmode->printquality;
1862 nt_devmode->color=devmode->color;
1863 nt_devmode->duplex=devmode->duplex;
1864 nt_devmode->yresolution=devmode->yresolution;
1865 nt_devmode->ttoption=devmode->ttoption;
1866 nt_devmode->collate=devmode->collate;
1867
1868 nt_devmode->logpixels=devmode->logpixels;
1869 nt_devmode->bitsperpel=devmode->bitsperpel;
1870 nt_devmode->pelswidth=devmode->pelswidth;
1871 nt_devmode->pelsheight=devmode->pelsheight;
1872 nt_devmode->displayflags=devmode->displayflags;
1873 nt_devmode->displayfrequency=devmode->displayfrequency;
1874 nt_devmode->icmmethod=devmode->icmmethod;
1875 nt_devmode->icmintent=devmode->icmintent;
1876 nt_devmode->mediatype=devmode->mediatype;
1877 nt_devmode->dithertype=devmode->dithertype;
1878 nt_devmode->reserved1=devmode->reserved1;
1879 nt_devmode->reserved2=devmode->reserved2;
1880 nt_devmode->panningwidth=devmode->panningwidth;
1881 nt_devmode->panningheight=devmode->panningheight;
1882
1883 /*
1884 * Only change private and driverextra if the incoming devmode
1885 * has a new one. JRA.
1886 */
1887
1888 if ((devmode->driverextra != 0) && (devmode->dev_private != NULL)) {
1889 SAFE_FREE(nt_devmode->nt_dev_private);
1890 nt_devmode->driverextra=devmode->driverextra;
1891 if((nt_devmode->nt_dev_private=SMB_MALLOC_ARRAY(uint8, nt_devmode->driverextra)) == NULL)
1892 return False;
1893 memcpy(nt_devmode->nt_dev_private, devmode->dev_private, nt_devmode->driverextra);
1894 }
1895
1896 *pp_nt_devmode = nt_devmode;
1897
1898 return True;
1899 }
1900
1901 /********************************************************************
1902 * _spoolss_enddocprinter_internal.
1903 ********************************************************************/
1904
1905 static WERROR _spoolss_enddocprinter_internal(pipes_struct *p, POLICY_HND *handle)
1906 {
1907 Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
1908 int snum;
1909
1910 if (!Printer) {
1911 DEBUG(2,("_spoolss_enddocprinter_internal: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
1912 return WERR_BADFID;
1913 }
1914
1915 if (!get_printer_snum(p, handle, &snum, NULL))
1916 return WERR_BADFID;
1917
1918 Printer->document_started=False;
1919 print_job_end(snum, Printer->jobid,NORMAL_CLOSE);
1920 /* error codes unhandled so far ... */
1921
1922 return WERR_OK;
1923 }
1924
1925 /********************************************************************
1926 * api_spoolss_closeprinter
1927 ********************************************************************/
1928
1929 WERROR _spoolss_closeprinter(pipes_struct *p, SPOOL_Q_CLOSEPRINTER *q_u, SPOOL_R_CLOSEPRINTER *r_u)
1930 {
1931 POLICY_HND *handle = &q_u->handle;
1932
1933 Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
1934
1935 if (Printer && Printer->document_started)
1936 _spoolss_enddocprinter_internal(p, handle); /* print job was not closed */
1937
1938 if (!close_printer_handle(p, handle))
1939 return WERR_BADFID;
1940
1941 /* clear the returned printer handle. Observed behavior
1942 from Win2k server. Don't think this really matters.
1943 Previous code just copied the value of the closed
1944 handle. --jerry */
1945
1946 memset(&r_u->handle, '\0', sizeof(r_u->handle));
1947
1948 return WERR_OK;
1949 }
1950
1951 /********************************************************************
1952 * api_spoolss_deleteprinter
1953
1954 ********************************************************************/
1955
1956 WERROR _spoolss_deleteprinter(pipes_struct *p, SPOOL_Q_DELETEPRINTER *q_u, SPOOL_R_DELETEPRINTER *r_u)
1957 {
1958 POLICY_HND *handle = &q_u->handle;
1959 Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
1960 WERROR result;
1961
1962 if (Printer && Printer->document_started)
1963 _spoolss_enddocprinter_internal(p, handle); /* print job was not closed */
1964
1965 memcpy(&r_u->handle, &q_u->handle, sizeof(r_u->handle));
1966
1967 result = delete_printer_handle(p, handle);
1968
1969 update_c_setprinter(False);
1970
1971 return result;
1972 }
1973
1974 /*******************************************************************
1975 * static function to lookup the version id corresponding to an
1976 * long architecture string
1977 ******************************************************************/
1978
1979 static int get_version_id (char * arch)
1980 {
1981 int i;
1982 struct table_node archi_table[]= {
1983
1984 {"Windows 4.0", "WIN40", 0 },
1985 {"Windows NT x86", "W32X86", 2 },
1986 {"Windows NT R4000", "W32MIPS", 2 },
1987 {"Windows NT Alpha_AXP", "W32ALPHA", 2 },
1988 {"Windows NT PowerPC", "W32PPC", 2 },
1989 {"Windows IA64", "IA64", 3 },
1990 {"Windows x64", "x64", 3 },
1991 {NULL, "", -1 }
1992 };
1993
1994 for (i=0; archi_table[i].long_archi != NULL; i++)
1995 {
1996 if (strcmp(arch, archi_table[i].long_archi) == 0)
1997 return (archi_table[i].version);
1998 }
1999
2000 return -1;
2001 }
2002
2003 /********************************************************************
2004 * _spoolss_deleteprinterdriver
2005 ********************************************************************/
2006
2007 WERROR _spoolss_deleteprinterdriver(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIVER *q_u, SPOOL_R_DELETEPRINTERDRIVER *r_u)
2008 {
2009 fstring driver;
2010 fstring arch;
2011 NT_PRINTER_DRIVER_INFO_LEVEL info;
2012 NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
2013 int version;
2014 WERROR status;
2015 WERROR status_win2k = WERR_ACCESS_DENIED;
2016 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2017
2018 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2019 and not a printer admin, then fail */
2020
2021 if ( (p->pipe_user.ut.uid != 0)
2022 && !user_has_privileges(p->pipe_user.nt_user_token, &se_printop )
2023 && !token_contains_name_in_list(
2024 uidtoname(p->pipe_user.ut.uid), NULL,
2025 NULL, p->pipe_user.nt_user_token,
2026 lp_printer_admin(-1)) )
2027 {
2028 return WERR_ACCESS_DENIED;
2029 }
2030
2031 unistr2_to_ascii(driver, &q_u->driver, sizeof(driver));
2032 unistr2_to_ascii(arch, &q_u->arch, sizeof(arch));
2033
2034 /* check that we have a valid driver name first */
2035
2036 if ((version=get_version_id(arch)) == -1)
2037 return WERR_INVALID_ENVIRONMENT;
2038
2039 ZERO_STRUCT(info);
2040 ZERO_STRUCT(info_win2k);
2041
2042 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version)))
2043 {
2044 /* try for Win2k driver if "Windows NT x86" */
2045
2046 if ( version == 2 ) {
2047 version = 3;
2048 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version))) {
2049 status = WERR_UNKNOWN_PRINTER_DRIVER;
2050 goto done;
2051 }
2052 }
2053 /* otherwise it was a failure */
2054 else {
2055 status = WERR_UNKNOWN_PRINTER_DRIVER;
2056 goto done;
2057 }
2058
2059 }
2060
2061 if (printer_driver_in_use(info.info_3)) {
2062 status = WERR_PRINTER_DRIVER_IN_USE;
2063 goto done;
2064 }
2065
2066 if ( version == 2 )
2067 {
2068 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3, driver, arch, 3)))
2069 {
2070 /* if we get to here, we now have 2 driver info structures to remove */
2071 /* remove the Win2k driver first*/
2072
2073 status_win2k = delete_printer_driver(info_win2k.info_3, &p->pipe_user, 3, False );
2074 free_a_printer_driver( info_win2k, 3 );
2075
2076 /* this should not have failed---if it did, report to client */
2077 if ( !W_ERROR_IS_OK(status_win2k) )
2078 {
2079 status = status_win2k;
2080 goto done;
2081 }
2082 }
2083 }
2084
2085 status = delete_printer_driver(info.info_3, &p->pipe_user, version, False);
2086
2087 /* if at least one of the deletes succeeded return OK */
2088
2089 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2090 status = WERR_OK;
2091
2092 done:
2093 free_a_printer_driver( info, 3 );
2094
2095 return status;
2096 }
2097
2098 /********************************************************************
2099 * spoolss_deleteprinterdriverex
2100 ********************************************************************/
2101
2102 WERROR _spoolss_deleteprinterdriverex(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIVEREX *q_u, SPOOL_R_DELETEPRINTERDRIVEREX *r_u)
2103 {
2104 fstring driver;
2105 fstring arch;
2106 NT_PRINTER_DRIVER_INFO_LEVEL info;
2107 NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
2108 int version;
2109 uint32 flags = q_u->delete_flags;
2110 bool delete_files;
2111 WERROR status;
2112 WERROR status_win2k = WERR_ACCESS_DENIED;
2113 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2114
2115 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2116 and not a printer admin, then fail */
2117
2118 if ( (p->pipe_user.ut.uid != 0)
2119 && !user_has_privileges(p->pipe_user.nt_user_token, &se_printop )
2120 && !token_contains_name_in_list(
2121 uidtoname(p->pipe_user.ut.uid), NULL, NULL,
2122 p->pipe_user.nt_user_token, lp_printer_admin(-1)) )
2123 {
2124 return WERR_ACCESS_DENIED;
2125 }
2126
2127 unistr2_to_ascii(driver, &q_u->driver, sizeof(driver));
2128 unistr2_to_ascii(arch, &q_u->arch, sizeof(arch));
2129
2130 /* check that we have a valid driver name first */
2131 if ((version=get_version_id(arch)) == -1) {
2132 /* this is what NT returns */
2133 return WERR_INVALID_ENVIRONMENT;
2134 }
2135
2136 if ( flags & DPD_DELETE_SPECIFIC_VERSION )
2137 version = q_u->version;
2138
2139 ZERO_STRUCT(info);
2140 ZERO_STRUCT(info_win2k);
2141
2142 status = get_a_printer_driver(&info, 3, driver, arch, version);
2143
2144 if ( !W_ERROR_IS_OK(status) )
2145 {
2146 /*
2147 * if the client asked for a specific version,
2148 * or this is something other than Windows NT x86,
2149 * then we've failed
2150 */
2151
2152 if ( (flags&DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2153 goto done;
2154
2155 /* try for Win2k driver if "Windows NT x86" */
2156
2157 version = 3;
2158 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version))) {
2159 status = WERR_UNKNOWN_PRINTER_DRIVER;
2160 goto done;
2161 }
2162 }
2163
2164 if ( printer_driver_in_use(info.info_3) ) {
2165 status = WERR_PRINTER_DRIVER_IN_USE;
2166 goto done;
2167 }
2168
2169 /*
2170 * we have a couple of cases to consider.
2171 * (1) Are any files in use? If so and DPD_DELTE_ALL_FILE is set,
2172 * then the delete should fail if **any** files overlap with
2173 * other drivers
2174 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2175 * non-overlapping files
2176 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2177 * is set, the do not delete any files
2178 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2179 */
2180
2181 delete_files = flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2182
2183 /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2184
2185 if ( delete_files && printer_driver_files_in_use(info.info_3) & (flags&DPD_DELETE_ALL_FILES) ) {
2186 /* no idea of the correct error here */
2187 status = WERR_ACCESS_DENIED;
2188 goto done;
2189 }
2190
2191
2192 /* also check for W32X86/3 if necessary; maybe we already have? */
2193
2194 if ( (version == 2) && ((flags&DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
2195 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3, driver, arch, 3)))
2196 {
2197
2198 if ( delete_files && printer_driver_files_in_use(info_win2k.info_3) & (flags&DPD_DELETE_ALL_FILES) ) {
2199 /* no idea of the correct error here */
2200 free_a_printer_driver( info_win2k, 3 );
2201 status = WERR_ACCESS_DENIED;
2202 goto done;
2203 }
2204
2205 /* if we get to here, we now have 2 driver info structures to remove */
2206 /* remove the Win2k driver first*/
2207
2208 status_win2k = delete_printer_driver(info_win2k.info_3, &p->pipe_user, 3, delete_files);
2209 free_a_printer_driver( info_win2k, 3 );
2210
2211 /* this should not have failed---if it did, report to client */
2212
2213 if ( !W_ERROR_IS_OK(status_win2k) )
2214 goto done;
2215 }
2216 }
2217
2218 status = delete_printer_driver(info.info_3, &p->pipe_user, version, delete_files);
2219
2220 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2221 status = WERR_OK;
2222 done:
2223 free_a_printer_driver( info, 3 );
2224
2225 return status;
2226 }
2227
2228
2229 /****************************************************************************
2230 Internal routine for retreiving printerdata
2231 ***************************************************************************/
2232
2233 static WERROR get_printer_dataex( TALLOC_CTX *ctx, NT_PRINTER_INFO_LEVEL *printer,
2234 const char *key, const char *value, uint32 *type, uint8 **data,
2235 uint32 *needed, uint32 in_size )
2236 {
2237 REGISTRY_VALUE *val;
2238 uint32 size;
2239 int data_len;
2240
2241 if ( !(val = get_printer_data( printer->info_2, key, value)) )
2242 return WERR_BADFILE;
2243
2244 *type = regval_type( val );
2245
2246 DEBUG(5,("get_printer_dataex: allocating %d\n", in_size));
2247
2248 size = regval_size( val );
2249
2250 /* copy the min(in_size, len) */
2251
2252 if ( in_size ) {
2253 data_len = (size > in_size) ? in_size : size*sizeof(uint8);
2254
2255 /* special case for 0 length values */
2256 if ( data_len ) {
2257 if ( (*data = (uint8 *)TALLOC_MEMDUP(ctx, regval_data_p(val), data_len)) == NULL )
2258 return WERR_NOMEM;
2259 }
2260 else {
2261 if ( (*data = (uint8 *)TALLOC_ZERO(ctx, in_size)) == NULL )
2262 return WERR_NOMEM;
2263 }
2264 }
2265 else
2266 *data = NULL;
2267
2268 *needed = size;
2269
2270 DEBUG(5,("get_printer_dataex: copy done\n"));
2271
2272 return WERR_OK;
2273 }
2274
2275 /****************************************************************************
2276 Internal routine for removing printerdata
2277 ***************************************************************************/
2278
2279 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2280 {
2281 return delete_printer_data( printer->info_2, key, value );
2282 }
2283
2284 /****************************************************************************
2285 Internal routine for storing printerdata
2286 ***************************************************************************/
2287
2288 WERROR set_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value,
2289 uint32 type, uint8 *data, int real_len )
2290 {
2291 /* the registry objects enforce uniqueness based on value name */
2292
2293 return add_printer_data( printer->info_2, key, value, type, data, real_len );
2294 }
2295
2296 /********************************************************************
2297 GetPrinterData on a printer server Handle.
2298 ********************************************************************/
2299
2300 static WERROR getprinterdata_printer_server(TALLOC_CTX *ctx, fstring value, uint32 *type, uint8 **data, uint32 *needed, uint32 in_size)
2301 {
2302 int i;
2303
2304 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2305
2306 if (!StrCaseCmp(value, "W3SvcInstalled")) {
2307 *type = REG_DWORD;
2308 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2309 return WERR_NOMEM;
2310 SIVAL(*data, 0, 0x00);
2311 *needed = 0x4;
2312 return WERR_OK;
2313 }
2314
2315 if (!StrCaseCmp(value, "BeepEnabled")) {
2316 *type = REG_DWORD;
2317 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2318 return WERR_NOMEM;
2319 SIVAL(*data, 0, 0x00);
2320 *needed = 0x4;
2321 return WERR_OK;
2322 }
2323
2324 if (!StrCaseCmp(value, "EventLog")) {
2325 *type = REG_DWORD;
2326 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2327 return WERR_NOMEM;
2328 /* formally was 0x1b */
2329 SIVAL(*data, 0, 0x0);
2330 *needed = 0x4;
2331 return WERR_OK;
2332 }
2333
2334 if (!StrCaseCmp(value, "NetPopup")) {
2335 *type = REG_DWORD;
2336 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2337 return WERR_NOMEM;
2338 SIVAL(*data, 0, 0x00);
2339 *needed = 0x4;
2340 return WERR_OK;
2341 }
2342
2343 if (!StrCaseCmp(value, "MajorVersion")) {
2344 *type = REG_DWORD;
2345 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2346 return WERR_NOMEM;
2347
2348 /* Windows NT 4.0 seems to not allow uploading of drivers
2349 to a server that reports 0x3 as the MajorVersion.
2350 need to investigate more how Win2k gets around this .
2351 -- jerry */
2352
2353 if ( RA_WINNT == get_remote_arch() )
2354 SIVAL(*data, 0, 2);
2355 else
2356 SIVAL(*data, 0, 3);
2357
2358 *needed = 0x4;
2359 return WERR_OK;
2360 }
2361
2362 if (!StrCaseCmp(value, "MinorVersion")) {
2363 *type = REG_DWORD;
2364 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2365 return WERR_NOMEM;
2366 SIVAL(*data, 0, 0);
2367 *needed = 0x4;
2368 return WERR_OK;
2369 }
2370
2371 /* REG_BINARY
2372 * uint32 size = 0x114
2373 * uint32 major = 5
2374 * uint32 minor = [0|1]
2375 * uint32 build = [2195|2600]
2376 * extra unicode string = e.g. "Service Pack 3"
2377 */
2378 if (!StrCaseCmp(value, "OSVersion")) {
2379 *type = REG_BINARY;
2380 *needed = 0x114;
2381
2382 if ( !(*data = TALLOC_ZERO_ARRAY(ctx, uint8, (*needed > in_size) ? *needed:in_size )) )
2383 return WERR_NOMEM;
2384
2385 SIVAL(*data, 0, *needed); /* size */
2386 SIVAL(*data, 4, 5); /* Windows 2000 == 5.0 */
2387 SIVAL(*data, 8, 0);
2388 SIVAL(*data, 12, 2195); /* build */
2389
2390 /* leave extra string empty */
2391
2392 return WERR_OK;
2393 }
2394
2395
2396 if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2397 const char *string="C:\\PRINTERS";
2398 *type = REG_SZ;
2399 *needed = 2*(strlen(string)+1);
2400 if((*data = (uint8 *)TALLOC(ctx, (*needed > in_size) ? *needed:in_size )) == NULL)
2401 return WERR_NOMEM;
2402 memset(*data, 0, (*needed > in_size) ? *needed:in_size);
2403
2404 /* it's done by hand ready to go on the wire */
2405 for (i=0; i<strlen(string); i++) {
2406 (*data)[2*i]=string[i];
2407 (*data)[2*i+1]='\0';
2408 }
2409 return WERR_OK;
2410 }
2411
2412 if (!StrCaseCmp(value, "Architecture")) {
2413 const char *string="Windows NT x86";
2414 *type = REG_SZ;
2415 *needed = 2*(strlen(string)+1);
2416 if((*data = (uint8 *)TALLOC(ctx, (*needed > in_size) ? *needed:in_size )) == NULL)
2417 return WERR_NOMEM;
2418 memset(*data, 0, (*needed > in_size) ? *needed:in_size);
2419 for (i=0; i<strlen(string); i++) {
2420 (*data)[2*i]=string[i];
2421 (*data)[2*i+1]='\0';
2422 }
2423 return WERR_OK;
2424 }
2425
2426 if (!StrCaseCmp(value, "DsPresent")) {
2427 *type = REG_DWORD;
2428 if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
2429 return WERR_NOMEM;
2430
2431 /* only show the publish check box if we are a
2432 memeber of a AD domain */
2433
2434 if ( lp_security() == SEC_ADS )
2435 SIVAL(*data, 0, 0x01);
2436 else
2437 SIVAL(*data, 0, 0x00);
2438
2439 *needed = 0x4;
2440 return WERR_OK;
2441 }
2442
2443 if (!StrCaseCmp(value, "DNSMachineName")) {
2444 const char *hostname = get_mydnsfullname();
2445
2446 if (!hostname)
2447 return WERR_BADFILE;
2448 *type = REG_SZ;
2449 *needed = 2*(strlen(hostname)+1);
2450 if((*data = (uint8 *)TALLOC(ctx, (*needed > in_size) ? *needed:in_size )) == NULL)
2451 return WERR_NOMEM;
2452 memset(*data, 0, (*needed > in_size) ? *needed:in_size);
2453 for (i=0; i<strlen(hostname); i++) {
2454 (*data)[2*i]=hostname[i];
2455 (*data)[2*i+1]='\0';
2456 }
2457 return WERR_OK;
2458 }
2459
2460
2461 return WERR_BADFILE;
2462 }
2463
2464 /********************************************************************
2465 * spoolss_getprinterdata
2466 ********************************************************************/
2467
2468 WERROR _spoolss_getprinterdata(pipes_struct *p, SPOOL_Q_GETPRINTERDATA *q_u, SPOOL_R_GETPRINTERDATA *r_u)
2469 {
2470 POLICY_HND *handle = &q_u->handle;
2471 UNISTR2 *valuename = &q_u->valuename;
2472 uint32 in_size = q_u->size;
2473 uint32 *type = &r_u->type;
2474 uint32 *out_size = &r_u->size;
2475 uint8 **data = &r_u->data;
2476 uint32 *needed = &r_u->needed;
2477 WERROR status;
2478 fstring value;
2479 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
2480 NT_PRINTER_INFO_LEVEL *printer = NULL;
2481 int snum = 0;
2482
2483 /*
2484 * Reminder: when it's a string, the length is in BYTES
2485 * even if UNICODE is negociated.
2486 *
2487 * JFM, 4/19/1999
2488 */
2489
2490 *out_size = in_size;
2491
2492 /* in case of problem, return some default values */
2493
2494 *needed = 0;
2495 *type = 0;
2496
2497 DEBUG(4,("_spoolss_getprinterdata\n"));
2498
2499 if ( !Printer ) {
2500 DEBUG(2,("_spoolss_getprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
2501 status = WERR_BADFID;
2502 goto done;
2503 }
2504
2505 unistr2_to_ascii(value, valuename, sizeof(value));
2506
2507 if ( Printer->printer_type == SPLHND_SERVER )
2508 status = getprinterdata_printer_server( p->mem_ctx, value, type, data, needed, *out_size );
2509 else
2510 {
2511 if ( !get_printer_snum(p,handle, &snum, NULL) ) {
2512 status = WERR_BADFID;
2513 goto done;
2514 }
2515
2516 status = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
2517 if ( !W_ERROR_IS_OK(status) )
2518 goto done;
2519
2520 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
2521
2522 if ( strequal(value, "ChangeId") ) {
2523 *type = REG_DWORD;
2524 *needed = sizeof(uint32);
2525 if ( (*data = (uint8*)TALLOC(p->mem_ctx, sizeof(uint32))) == NULL) {
2526 status = WERR_NOMEM;
2527 goto done;
2528 }
2529 SIVAL( *data, 0, printer->info_2->changeid );
2530 status = WERR_OK;
2531 }
2532 else
2533 status = get_printer_dataex( p->mem_ctx, printer, SPOOL_PRINTERDATA_KEY, value, type, data, needed, *out_size );
2534 }
2535
2536 if (*needed > *out_size)
2537 status = WERR_MORE_DATA;
2538
2539 done:
2540 if ( !W_ERROR_IS_OK(status) )
2541 {
2542 DEBUG(5, ("error %d: allocating %d\n", W_ERROR_V(status),*out_size));
2543
2544 /* reply this param doesn't exist */
2545
2546 if ( *out_size ) {
2547 if((*data=(uint8 *)TALLOC_ZERO_ARRAY(p->mem_ctx, uint8, *out_size)) == NULL) {
2548 if ( printer )
2549 free_a_printer( &printer, 2 );
2550 return WERR_NOMEM;
2551 }
2552 } else {
2553 *data = NULL;
2554 }
2555 }
2556
2557 /* cleanup & exit */
2558
2559 if ( printer )
2560 free_a_printer( &printer, 2 );
2561
2562 return status;
2563 }
2564
2565 /*********************************************************
2566 Connect to the client machine.
2567 **********************************************************/
2568
2569 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2570 struct sockaddr_storage *client_ss, const char *remote_machine)
2571 {
2572 NTSTATUS ret;
2573 struct cli_state *the_cli;
2574 struct sockaddr_storage rm_addr;
2575
2576 if ( is_zero_addr(client_ss) ) {
2577 if ( !resolve_name( remote_machine, &rm_addr, 0x20) ) {
2578 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2579 return False;
2580 }
2581
2582 if (ismyaddr(&rm_addr)) {
2583 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
2584 return False;
2585 }
2586 } else {
2587 char addr[INET6_ADDRSTRLEN];
2588 rm_addr = *client_ss;
2589 print_sockaddr(addr, sizeof(addr), &rm_addr);
2590 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2591 addr));
2592 }
2593
2594 /* setup the connection */
2595
2596 ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2597 &rm_addr, 0, "IPC$", "IPC",
2598 "", /* username */
2599 "", /* domain */
2600 "", /* password */
2601 0, lp_client_signing(), NULL );
2602
2603 if ( !NT_STATUS_IS_OK( ret ) ) {
2604 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2605 remote_machine ));
2606 return False;
2607 }
2608
2609 if ( the_cli->protocol != PROTOCOL_NT1 ) {
2610 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2611 cli_shutdown(the_cli);
2612 return False;
2613 }
2614
2615 /*
2616 * Ok - we have an anonymous connection to the IPC$ share.
2617 * Now start the NT Domain stuff :-).
2618 */
2619
2620 ret = cli_rpc_pipe_open_noauth(the_cli, &syntax_spoolss, pp_pipe);
2621 if (!NT_STATUS_IS_OK(ret)) {
2622 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2623 remote_machine, nt_errstr(ret)));
2624 cli_shutdown(the_cli);
2625 return False;
2626 }
2627
2628 return True;
2629 }
2630
2631 /***************************************************************************
2632 Connect to the client.
2633 ****************************************************************************/
2634
2635 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2636 uint32 localprinter, uint32 type,
2637 POLICY_HND *handle, struct sockaddr_storage *client_ss)
2638 {
2639 WERROR result;
2640
2641 /*
2642 * If it's the first connection, contact the client
2643 * and connect to the IPC$ share anonymously
2644 */
2645 if (smb_connections==0) {
2646 fstring unix_printer;
2647
2648 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2649
2650 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2651 return False;
2652
2653 messaging_register(smbd_messaging_context(), NULL,
2654 MSG_PRINTER_NOTIFY2,
2655 receive_notify2_message_list);
2656 /* Tell the connections db we're now interested in printer
2657 * notify messages. */
2658 register_message_flags( True, FLAG_MSG_PRINT_NOTIFY );
2659 }
2660
2661 /*
2662 * Tell the specific printing tdb we want messages for this printer
2663 * by registering our PID.
2664 */
2665
2666 if (!print_notify_register_pid(snum))
2667 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2668
2669 smb_connections++;
2670
2671 result = rpccli_spoolss_reply_open_printer(notify_cli_pipe,
2672 talloc_tos(),
2673 printer,
2674 localprinter,
2675 type,
2676 handle);
2677
2678 if (!W_ERROR_IS_OK(result))
2679 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2680 dos_errstr(result)));
2681
2682 return (W_ERROR_IS_OK(result));
2683 }
2684
2685 /********************************************************************
2686 * _spoolss_rffpcnex
2687 * ReplyFindFirstPrinterChangeNotifyEx
2688 *
2689 * before replying OK: status=0 a rpc call is made to the workstation
2690 * asking ReplyOpenPrinter
2691 *
2692 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2693 * called from api_spoolss_rffpcnex
2694 ********************************************************************/
2695
2696 WERROR _spoolss_rffpcnex(pipes_struct *p, SPOOL_Q_RFFPCNEX *q_u, SPOOL_R_RFFPCNEX *r_u)
2697 {
2698 POLICY_HND *handle = &q_u->handle;
2699 uint32 flags = q_u->flags;
2700 uint32 options = q_u->options;
2701 UNISTR2 *localmachine = &q_u->localmachine;
2702 uint32 printerlocal = q_u->printerlocal;
2703 int snum = -1;
2704 SPOOL_NOTIFY_OPTION *option = q_u->option;
2705 struct sockaddr_storage client_ss;
2706
2707 /* store the notify value in the printer struct */
2708
2709 Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
2710
2711 if (!Printer) {
2712 DEBUG(2,("_spoolss_rffpcnex: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
2713 return WERR_BADFID;
2714 }
2715
2716 Printer->notify.flags=flags;
2717 Printer->notify.options=options;
2718 Printer->notify.printerlocal=printerlocal;
2719
2720 if (Printer->notify.option)
2721 free_spool_notify_option(&Printer->notify.option);
2722
2723 Printer->notify.option=dup_spool_notify_option(option);
2724
2725 unistr2_to_ascii(Printer->notify.localmachine, localmachine,
2726 sizeof(Printer->notify.localmachine));
2727
2728 /* Connect to the client machine and send a ReplyOpenPrinter */
2729
2730 if ( Printer->printer_type == SPLHND_SERVER)
2731 snum = -1;
2732 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2733 !get_printer_snum(p, handle, &snum, NULL) )
2734 return WERR_BADFID;
2735
2736 if (!interpret_string_addr(&client_ss, p->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 rpcbuf_move(q_u->buffer, &r_u->buffer);
4733 buffer = r_u->buffer;
4734
4735 DEBUG(4,("_spoolss_enumprinters\n"));
4736
4737 *needed=0;
4738 *returned=0;
4739
4740 /*
4741 * Level 1:
4742 * flags==PRINTER_ENUM_NAME
4743 * if name=="" then enumerates all printers
4744 * if name!="" then enumerate the printer
4745 * flags==PRINTER_ENUM_REMOTE
4746 * name is NULL, enumerate printers
4747 * Level 2: name!="" enumerates printers, name can't be NULL
4748 * Level 3: doesn't exist
4749 * Level 4: does a local registry lookup
4750 * Level 5: same as Level 2
4751 */
4752
4753 unistr2_to_ascii(name, servername, sizeof(name));
4754 strupper_m(name);
4755
4756 switch (level) {
4757 case 1:
4758 return enumprinters_level1(flags, name, buffer, offered, needed, returned);
4759 case 2:
4760 return enumprinters_level2(flags, name, buffer, offered, needed, returned);
4761 case 5:
4762 return enumprinters_level5(flags, name, buffer, offered, needed, returned);
4763 case 3:
4764 case 4:
4765 break;
4766 }
4767 return WERR_UNKNOWN_LEVEL;
4768 }
4769
4770 /****************************************************************************
4771 ****************************************************************************/
4772
4773 static WERROR getprinter_level_0(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4774 {
4775 PRINTER_INFO_0 *printer=NULL;
4776 WERROR result = WERR_OK;
4777
4778 if((printer=SMB_MALLOC_P(PRINTER_INFO_0)) == NULL)
4779 return WERR_NOMEM;
4780
4781 construct_printer_info_0(print_hnd, printer, snum);
4782
4783 /* check the required size. */
4784 *needed += spoolss_size_printer_info_0(printer);
4785
4786 if (*needed > offered) {
4787 result = WERR_INSUFFICIENT_BUFFER;
4788 goto out;
4789 }
4790
4791 if (!rpcbuf_alloc_size(buffer, *needed)) {
4792 result = WERR_NOMEM;
4793 goto out;
4794 }
4795
4796 /* fill the buffer with the structures */
4797 smb_io_printer_info_0("", buffer, printer, 0);
4798
4799 out:
4800 /* clear memory */
4801
4802 SAFE_FREE(printer);
4803
4804 return result;
4805 }
4806
4807 /****************************************************************************
4808 ****************************************************************************/
4809
4810 static WERROR getprinter_level_1(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4811 {
4812 PRINTER_INFO_1 *printer=NULL;
4813 WERROR result = WERR_OK;
4814
4815 if((printer=SMB_MALLOC_P(PRINTER_INFO_1)) == NULL)
4816 return WERR_NOMEM;
4817
4818 construct_printer_info_1(print_hnd, PRINTER_ENUM_ICON8, printer, snum);
4819
4820 /* check the required size. */
4821 *needed += spoolss_size_printer_info_1(printer);
4822
4823 if (*needed > offered) {
4824 result = WERR_INSUFFICIENT_BUFFER;
4825 goto out;
4826 }
4827
4828 if (!rpcbuf_alloc_size(buffer, *needed)) {
4829 result = WERR_NOMEM;
4830 goto out;
4831 }
4832
4833 /* fill the buffer with the structures */
4834 smb_io_printer_info_1("", buffer, printer, 0);
4835
4836 out:
4837 /* clear memory */
4838 SAFE_FREE(printer);
4839
4840 return result;
4841 }
4842
4843 /****************************************************************************
4844 ****************************************************************************/
4845
4846 static WERROR getprinter_level_2(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4847 {
4848 PRINTER_INFO_2 *printer=NULL;
4849 WERROR result = WERR_OK;
4850
4851 if((printer=SMB_MALLOC_P(PRINTER_INFO_2))==NULL)
4852 return WERR_NOMEM;
4853
4854 construct_printer_info_2(print_hnd, printer, snum);
4855
4856 /* check the required size. */
4857 *needed += spoolss_size_printer_info_2(printer);
4858
4859 if (*needed > offered) {
4860 result = WERR_INSUFFICIENT_BUFFER;
4861 goto out;
4862 }
4863
4864 if (!rpcbuf_alloc_size(buffer, *needed)) {
4865 result = WERR_NOMEM;
4866 goto out;
4867 }
4868
4869 /* fill the buffer with the structures */
4870 if (!smb_io_printer_info_2("", buffer, printer, 0))
4871 result = WERR_NOMEM;
4872
4873 out:
4874 /* clear memory */
4875 free_printer_info_2(printer);
4876
4877 return result;
4878 }
4879
4880 /****************************************************************************
4881 ****************************************************************************/
4882
4883 static WERROR getprinter_level_3(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4884 {
4885 PRINTER_INFO_3 *printer=NULL;
4886 WERROR result = WERR_OK;
4887
4888 if (!construct_printer_info_3(print_hnd, &printer, snum))
4889 return WERR_NOMEM;
4890
4891 /* check the required size. */
4892 *needed += spoolss_size_printer_info_3(printer);
4893
4894 if (*needed > offered) {
4895 result = WERR_INSUFFICIENT_BUFFER;
4896 goto out;
4897 }
4898
4899 if (!rpcbuf_alloc_size(buffer, *needed)) {
4900 result = WERR_NOMEM;
4901 goto out;
4902 }
4903
4904 /* fill the buffer with the structures */
4905 smb_io_printer_info_3("", buffer, printer, 0);
4906
4907 out:
4908 /* clear memory */
4909 free_printer_info_3(printer);
4910
4911 return result;
4912 }
4913
4914 /****************************************************************************
4915 ****************************************************************************/
4916
4917 static WERROR getprinter_level_4(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4918 {
4919 PRINTER_INFO_4 *printer=NULL;
4920 WERROR result = WERR_OK;
4921
4922 if((printer=SMB_MALLOC_P(PRINTER_INFO_4))==NULL)
4923 return WERR_NOMEM;
4924
4925 if (!construct_printer_info_4(print_hnd, printer, snum)) {
4926 SAFE_FREE(printer);
4927 return WERR_NOMEM;
4928 }
4929
4930 /* check the required size. */
4931 *needed += spoolss_size_printer_info_4(printer);
4932
4933 if (*needed > offered) {
4934 result = WERR_INSUFFICIENT_BUFFER;
4935 goto out;
4936 }
4937
4938 if (!rpcbuf_alloc_size(buffer, *needed)) {
4939 result = WERR_NOMEM;
4940 goto out;
4941 }
4942
4943 /* fill the buffer with the structures */
4944 smb_io_printer_info_4("", buffer, printer, 0);
4945
4946 out:
4947 /* clear memory */
4948 free_printer_info_4(printer);
4949
4950 return result;
4951 }
4952
4953 /****************************************************************************
4954 ****************************************************************************/
4955
4956 static WERROR getprinter_level_5(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
4957 {
4958 PRINTER_INFO_5 *printer=NULL;
4959 WERROR result = WERR_OK;
4960
4961 if((printer=SMB_MALLOC_P(PRINTER_INFO_5))==NULL)
4962 return WERR_NOMEM;
4963
4964 if (!construct_printer_info_5(print_hnd, printer, snum)) {
4965 free_printer_info_5(printer);
4966 return WERR_NOMEM;
4967 }
4968
4969 /* check the required size. */
4970 *needed += spoolss_size_printer_info_5(printer);
4971
4972 if (*needed > offered) {
4973 result = WERR_INSUFFICIENT_BUFFER;
4974 goto out;
4975 }
4976
4977 if (!rpcbuf_alloc_size(buffer, *needed)) {
4978 result = WERR_NOMEM;
4979 goto out;
4980 }
4981
4982 /* fill the buffer with the structures */
4983 smb_io_printer_info_5("", buffer, printer, 0);
4984
4985 out:
4986 /* clear memory */
4987 free_printer_info_5(printer);
4988
4989 return result;
4990 }
4991
4992 static WERROR getprinter_level_6(Printer_entry *print_hnd,
4993 int snum,
4994 RPC_BUFFER *buffer, uint32 offered,
4995 uint32 *needed)
4996 {
4997 PRINTER_INFO_6 *printer;
4998 WERROR result = WERR_OK;
4999
5000 if ((printer = SMB_MALLOC_P(PRINTER_INFO_6)) == NULL) {
5001 return WERR_NOMEM;
5002 }
5003
5004 if (!construct_printer_info_6(print_hnd, printer, snum)) {
5005 free_printer_info_6(printer);
5006 return WERR_NOMEM;
5007 }
5008
5009 /* check the required size. */
5010 *needed += spoolss_size_printer_info_6(printer);
5011
5012 if (*needed > offered) {
5013 result = WERR_INSUFFICIENT_BUFFER;
5014 goto out;
5015 }
5016
5017 if (!rpcbuf_alloc_size(buffer, *needed)) {
5018 result = WERR_NOMEM;
5019 goto out;
5020 }
5021
5022 /* fill the buffer with the structures */
5023 smb_io_printer_info_6("", buffer, printer, 0);
5024
5025 out:
5026 /* clear memory */
5027 free_printer_info_6(printer);
5028
5029 return result;
5030 }
5031
5032 static WERROR getprinter_level_7(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5033 {
5034 PRINTER_INFO_7 *printer=NULL;
5035 WERROR result = WERR_OK;
5036
5037 if((printer=SMB_MALLOC_P(PRINTER_INFO_7))==NULL)
5038 return WERR_NOMEM;
5039
5040 if (!construct_printer_info_7(print_hnd, printer, snum)) {
5041 result = WERR_NOMEM;
5042 goto out;
5043 }
5044
5045 /* check the required size. */
5046 *needed += spoolss_size_printer_info_7(printer);
5047
5048 if (*needed > offered) {
5049 result = WERR_INSUFFICIENT_BUFFER;
5050 goto out;
5051 }
5052
5053 if (!rpcbuf_alloc_size(buffer, *needed)) {
5054 result = WERR_NOMEM;
5055 goto out;
5056
5057 }
5058
5059 /* fill the buffer with the structures */
5060 smb_io_printer_info_7("", buffer, printer, 0);
5061
5062 out:
5063 /* clear memory */
5064 free_printer_info_7(printer);
5065
5066 return result;
5067 }
5068
5069 /****************************************************************************
5070 ****************************************************************************/
5071
5072 WERROR _spoolss_getprinter(pipes_struct *p, SPOOL_Q_GETPRINTER *q_u, SPOOL_R_GETPRINTER *r_u)
5073 {
5074 POLICY_HND *handle = &q_u->handle;
5075 uint32 level = q_u->level;
5076 RPC_BUFFER *buffer = NULL;
5077 uint32 offered = q_u->offered;
5078 uint32 *needed = &r_u->needed;
5079 Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
5080
5081 int snum;
5082
5083 /* that's an [in out] buffer */
5084
5085 if (!q_u->buffer && (offered!=0)) {
5086 return WERR_INVALID_PARAM;
5087 }
5088
5089 rpcbuf_move(q_u->buffer, &r_u->buffer);
5090 buffer = r_u->buffer;
5091
5092 *needed=0;
5093
5094 if (!get_printer_snum(p, handle, &snum, NULL))
5095 return WERR_BADFID;
5096
5097 switch (level) {
5098 case 0:
5099 return getprinter_level_0(Printer, snum, buffer, offered, needed);
5100 case 1:
5101 return getprinter_level_1(Printer, snum, buffer, offered, needed);
5102 case 2:
5103 return getprinter_level_2(Printer, snum, buffer, offered, needed);
5104 case 3:
5105 return getprinter_level_3(Printer, snum, buffer, offered, needed);
5106 case 4:
5107 return getprinter_level_4(Printer, snum, buffer, offered, needed);
5108 case 5:
5109 return getprinter_level_5(Printer, snum, buffer, offered, needed);
5110 case 6:
5111 return getprinter_level_6(Printer, snum, buffer, offered, needed);
5112 case 7:
5113 return getprinter_level_7(Printer, snum, buffer, offered, needed);
5114 }
5115 return WERR_UNKNOWN_LEVEL;
5116 }
5117
5118 /********************************************************************
5119 * fill a DRIVER_INFO_1 struct
5120 ********************************************************************/
5121
5122 static void fill_printer_driver_info_1(DRIVER_INFO_1 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, const char *servername, fstring architecture)
5123 {
5124 init_unistr( &info->name, driver.info_3->name);
5125 }
5126
5127 /********************************************************************
5128 * construct_printer_driver_info_1
5129 ********************************************************************/
5130
5131 static WERROR construct_printer_driver_info_1(DRIVER_INFO_1 *info, int snum, const char *servername, fstring architecture, uint32 version)
5132 {
5133 NT_PRINTER_INFO_LEVEL *printer = NULL;
5134 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5135
5136 ZERO_STRUCT(driver);
5137
5138 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5139 return WERR_INVALID_PRINTER_NAME;
5140
5141 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5142 free_a_printer(&printer, 2);
5143 return WERR_UNKNOWN_PRINTER_DRIVER;
5144 }
5145
5146 fill_printer_driver_info_1(info, driver, servername, architecture);
5147
5148 free_a_printer(&printer,2);
5149
5150 return WERR_OK;
5151 }
5152
5153 /********************************************************************
5154 * construct_printer_driver_info_2
5155 * fill a printer_info_2 struct
5156 ********************************************************************/
5157
5158 static void fill_printer_driver_info_2(DRIVER_INFO_2 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, const char *servername)
5159 {
5160 TALLOC_CTX *ctx = talloc_tos();
5161 char *temp = NULL;
5162 const char *cservername = canon_servername(servername);
5163
5164 info->version=driver.info_3->cversion;
5165
5166 init_unistr( &info->name, driver.info_3->name );
5167 init_unistr( &info->architecture, driver.info_3->environment );
5168
5169 if (strlen(driver.info_3->driverpath)) {
5170 temp = talloc_asprintf(ctx,
5171 "\\\\%s%s",
5172 cservername,
5173 driver.info_3->driverpath);
5174 init_unistr( &info->driverpath, temp );
5175 } else {
5176 init_unistr( &info->driverpath, "" );
5177 }
5178
5179 TALLOC_FREE(temp);
5180 if (strlen(driver.info_3->datafile)) {
5181 temp = talloc_asprintf(ctx,
5182 "\\\\%s%s",
5183 cservername,
5184 driver.info_3->datafile);
5185 init_unistr( &info->datafile, temp );
5186 } else
5187 init_unistr( &info->datafile, "" );
5188
5189 TALLOC_FREE(temp);
5190 if (strlen(driver.info_3->configfile)) {
5191 temp = talloc_asprintf(ctx,
5192 "\\\\%s%s",
5193 cservername,
5194 driver.info_3->configfile);
5195 init_unistr( &info->configfile, temp );
5196 } else
5197 init_unistr( &info->configfile, "" );
5198 }
5199
5200 /********************************************************************
5201 * construct_printer_driver_info_2
5202 * fill a printer_info_2 struct
5203 ********************************************************************/
5204
5205 static WERROR construct_printer_driver_info_2(DRIVER_INFO_2 *info, int snum, const char *servername, fstring architecture, uint32 version)
5206 {
5207 NT_PRINTER_INFO_LEVEL *printer = NULL;
5208 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5209
5210 ZERO_STRUCT(printer);
5211 ZERO_STRUCT(driver);
5212
5213 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5214 return WERR_INVALID_PRINTER_NAME;
5215
5216 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5217 free_a_printer(&printer, 2);
5218 return WERR_UNKNOWN_PRINTER_DRIVER;
5219 }
5220
5221 fill_printer_driver_info_2(info, driver, servername);
5222
5223 free_a_printer(&printer,2);
5224
5225 return WERR_OK;
5226 }
5227
5228 /********************************************************************
5229 * copy a strings array and convert to UNICODE
5230 *
5231 * convert an array of ascii string to a UNICODE string
5232 ********************************************************************/
5233
5234 static uint32 init_unistr_array(uint16 **uni_array, fstring *char_array, const char *servername)
5235 {
5236 int i=0;
5237 int j=0;
5238 const char *v;
5239 char *line = NULL;
5240 TALLOC_CTX *ctx = talloc_tos();
5241
5242 DEBUG(6,("init_unistr_array\n"));
5243 *uni_array=NULL;
5244
5245 while (true) {
5246 if ( !char_array ) {
5247 v = "";
5248 } else {
5249 v = char_array[i];
5250 if (!v)
5251 v = ""; /* hack to handle null lists */
5252 }
5253
5254 /* hack to allow this to be used in places other than when generating
5255 the list of dependent files */
5256
5257 TALLOC_FREE(line);
5258 if ( servername ) {
5259 line = talloc_asprintf(ctx,
5260 "\\\\%s%s",
5261 canon_servername(servername),
5262 v);
5263 } else {
5264 line = talloc_strdup(ctx, v);
5265 }
5266
5267 if (!line) {
5268 SAFE_FREE(*uni_array);
5269 return 0;
5270 }
5271 DEBUGADD(6,("%d:%s:%lu\n", i, line, (unsigned long)strlen(line)));
5272
5273 /* add one extra unit16 for the second terminating NULL */
5274
5275 if ( (*uni_array=SMB_REALLOC_ARRAY(*uni_array, uint16, j+1+strlen(line)+2)) == NULL ) {
5276 DEBUG(2,("init_unistr_array: Realloc error\n" ));
5277 return 0;
5278 }
5279
5280 if ( !strlen(v) )
5281 break;
5282
5283 j += (rpcstr_push((*uni_array+j), line, sizeof(uint16)*strlen(line)+2, STR_TERMINATE) / sizeof(uint16));
5284 i++;
5285 }
5286
5287 if (*uni_array) {
5288 /* special case for ""; we need to add both NULL's here */
5289 if (!j)
5290 (*uni_array)[j++]=0x0000;
5291 (*uni_array)[j]=0x0000;
5292 }
5293
5294 DEBUGADD(6,("last one:done\n"));
5295
5296 /* return size of array in uint16's */
5297
5298 return j+1;
5299 }
5300
5301 /********************************************************************
5302 * construct_printer_info_3
5303 * fill a printer_info_3 struct
5304 ********************************************************************/
5305
5306 static void fill_printer_driver_info_3(DRIVER_INFO_3 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, const char *servername)
5307 {
5308 char *temp = NULL;
5309 TALLOC_CTX *ctx = talloc_tos();
5310 const char *cservername = canon_servername(servername);
5311
5312 ZERO_STRUCTP(info);
5313
5314 info->version=driver.info_3->cversion;
5315
5316 init_unistr( &info->name, driver.info_3->name );
5317 init_unistr( &info->architecture, driver.info_3->environment );
5318
5319 if (strlen(driver.info_3->driverpath)) {
5320 temp = talloc_asprintf(ctx,
5321 "\\\\%s%s",
5322 cservername,
5323 driver.info_3->driverpath);
5324 init_unistr( &info->driverpath, temp );
5325 } else
5326 init_unistr( &info->driverpath, "" );
5327
5328 TALLOC_FREE(temp);
5329 if (strlen(driver.info_3->datafile)) {
5330 temp = talloc_asprintf(ctx,
5331 "\\\\%s%s",
5332 cservername,
5333 driver.info_3->datafile);
5334 init_unistr( &info->datafile, temp );
5335 } else
5336 init_unistr( &info->datafile, "" );
5337
5338 TALLOC_FREE(temp);
5339 if (strlen(driver.info_3->configfile)) {
5340 temp = talloc_asprintf(ctx,
5341 "\\\\%s%s",
5342 cservername,
5343 driver.info_3->configfile);
5344 init_unistr( &info->configfile, temp );
5345 } else
5346 init_unistr( &info->configfile, "" );
5347
5348 TALLOC_FREE(temp);
5349 if (strlen(driver.info_3->helpfile)) {
5350 temp = talloc_asprintf(ctx,
5351 "\\\\%s%s",
5352 cservername,
5353 driver.info_3->helpfile);
5354 init_unistr( &info->helpfile, temp );
5355 } else
5356 init_unistr( &info->helpfile, "" );
5357
5358 TALLOC_FREE(temp);
5359 init_unistr( &info->monitorname, driver.info_3->monitorname );
5360 init_unistr( &info->defaultdatatype, driver.info_3->defaultdatatype );
5361
5362 info->dependentfiles=NULL;
5363 init_unistr_array(&info->dependentfiles, driver.info_3->dependentfiles, cservername);
5364 }
5365
5366 /********************************************************************
5367 * construct_printer_info_3
5368 * fill a printer_info_3 struct
5369 ********************************************************************/
5370
5371 static WERROR construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum, const char *servername, fstring architecture, uint32 version)
5372 {
5373 NT_PRINTER_INFO_LEVEL *printer = NULL;
5374 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5375 WERROR status;
5376 ZERO_STRUCT(driver);
5377
5378 status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5379 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", dos_errstr(status)));
5380 if (!W_ERROR_IS_OK(status))
5381 return WERR_INVALID_PRINTER_NAME;
5382
5383 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5384 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", dos_errstr(status)));
5385
5386 #if 0 /* JERRY */
5387
5388 /*
5389 * I put this code in during testing. Helpful when commenting out the
5390 * support for DRIVER_INFO_6 in regards to win2k. Not needed in general
5391 * as win2k always queries the driver using an infor level of 6.
5392 * I've left it in (but ifdef'd out) because I'll probably
5393 * use it in experimentation again in the future. --jerry 22/01/2002
5394 */
5395
5396 if (!W_ERROR_IS_OK(status)) {
5397 /*
5398 * Is this a W2k client ?
5399 */
5400 if (version == 3) {
5401 /* Yes - try again with a WinNT driver. */
5402 version = 2;
5403 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5404 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", dos_errstr(status)));
5405 }
5406 #endif
5407
5408 if (!W_ERROR_IS_OK(status)) {
5409 free_a_printer(&printer,2);
5410 return WERR_UNKNOWN_PRINTER_DRIVER;
5411 }
5412
5413 #if 0 /* JERRY */
5414 }
5415 #endif
5416
5417
5418 fill_printer_driver_info_3(info, driver, servername);
5419
5420 free_a_printer(&printer,2);
5421
5422 return WERR_OK;
5423 }
5424
5425 /********************************************************************
5426 * construct_printer_info_6
5427 * fill a printer_info_6 struct - we know that driver is really level 3. This sucks. JRA.
5428 ********************************************************************/
5429
5430 static void fill_printer_driver_info_6(DRIVER_INFO_6 *info, NT_PRINTER_DRIVER_INFO_LEVEL driver, const char *servername)
5431 {
5432 char *temp = NULL;
5433 fstring nullstr;
5434 TALLOC_CTX *ctx = talloc_tos();
5435 const char *cservername = canon_servername(servername);
5436
5437 ZERO_STRUCTP(info);
5438 memset(&nullstr, '\0', sizeof(fstring));
5439
5440 info->version=driver.info_3->cversion;
5441
5442 init_unistr( &info->name, driver.info_3->name );
5443 init_unistr( &info->architecture, driver.info_3->environment );
5444
5445 if (strlen(driver.info_3->driverpath)) {
5446 temp = talloc_asprintf(ctx,
5447 "\\\\%s%s",
5448 cservername,
5449 driver.info_3->driverpath);
5450 init_unistr( &info->driverpath, temp );
5451 } else
5452 init_unistr( &info->driverpath, "" );
5453
5454 TALLOC_FREE(temp);
5455 if (strlen(driver.info_3->datafile)) {
5456 temp = talloc_asprintf(ctx,
5457 "\\\\%s%s",
5458 cservername,
5459 driver.info_3->datafile);
5460 init_unistr( &info->datafile, temp );
5461 } else
5462 init_unistr( &info->datafile, "" );
5463
5464 TALLOC_FREE(temp);
5465 if (strlen(driver.info_3->configfile)) {
5466 temp = talloc_asprintf(ctx,
5467 "\\\\%s%s",
5468 cservername,
5469 driver.info_3->configfile);
5470 init_unistr( &info->configfile, temp );
5471 } else
5472 init_unistr( &info->configfile, "" );
5473
5474 TALLOC_FREE(temp);
5475 if (strlen(driver.info_3->helpfile)) {
5476 temp = talloc_asprintf(ctx,
5477 "\\\\%s%s",
5478 cservername,
5479 driver.info_3->helpfile);
5480 init_unistr( &info->helpfile, temp );
5481 } else
5482 init_unistr( &info->helpfile, "" );
5483
5484 TALLOC_FREE(temp);
5485 init_unistr( &info->monitorname, driver.info_3->monitorname );
5486 init_unistr( &info->defaultdatatype, driver.info_3->defaultdatatype );
5487
5488 info->dependentfiles = NULL;
5489 init_unistr_array( &info->dependentfiles, driver.info_3->dependentfiles, servername );
5490
5491 info->previousdrivernames=NULL;
5492 init_unistr_array(&info->previousdrivernames, &nullstr, servername);
5493
5494 info->driver_date=0;
5495
5496 info->padding=0;
5497 info->driver_version_low=0;
5498 info->driver_version_high=0;
5499
5500 init_unistr( &info->mfgname, "");
5501 init_unistr( &info->oem_url, "");
5502 init_unistr( &info->hardware_id, "");
5503 init_unistr( &info->provider, "");
5504 }
5505
5506 /********************************************************************
5507 * construct_printer_info_6
5508 * fill a printer_info_6 struct
5509 ********************************************************************/
5510
5511 static WERROR construct_printer_driver_info_6(DRIVER_INFO_6 *info, int snum,
5512 const char *servername, fstring architecture, uint32 version)
5513 {
5514 NT_PRINTER_INFO_LEVEL *printer = NULL;
5515 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5516 WERROR status;
5517
5518 ZERO_STRUCT(driver);
5519
5520 status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5521
5522 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", dos_errstr(status)));
5523
5524 if (!W_ERROR_IS_OK(status))
5525 return WERR_INVALID_PRINTER_NAME;
5526
5527 status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5528
5529 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", dos_errstr(status)));
5530
5531 if (!W_ERROR_IS_OK(status))
5532 {
5533 /*
5534 * Is this a W2k client ?
5535 */
5536
5537 if (version < 3) {
5538 free_a_printer(&printer,2);
5539 return WERR_UNKNOWN_PRINTER_DRIVER;
5540 }
5541
5542 /* Yes - try again with a WinNT driver. */
5543 version = 2;
5544 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5545 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", dos_errstr(status)));
5546 if (!W_ERROR_IS_OK(status)) {
5547 free_a_printer(&printer,2);
5548 return WERR_UNKNOWN_PRINTER_DRIVER;
5549 }
5550 }
5551
5552 fill_printer_driver_info_6(info, driver, servername);
5553
5554 free_a_printer(&printer,2);
5555 free_a_printer_driver(driver, 3);
5556
5557 return WERR_OK;
5558 }
5559
5560 /****************************************************************************
5561 ****************************************************************************/
5562
5563 static void free_printer_driver_info_3(DRIVER_INFO_3 *info)
5564 {
5565 SAFE_FREE(info->dependentfiles);
5566 }
5567
5568 /****************************************************************************
5569 ****************************************************************************/
5570
5571 static void free_printer_driver_info_6(DRIVER_INFO_6 *info)
5572 {
5573 SAFE_FREE(info->dependentfiles);
5574 }
5575
5576 /****************************************************************************
5577 ****************************************************************************/
5578
5579 static WERROR getprinterdriver2_level1(const char *servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5580 {
5581 DRIVER_INFO_1 *info=NULL;
5582 WERROR result;
5583
5584 if((info=SMB_MALLOC_P(DRIVER_INFO_1)) == NULL)
5585 return WERR_NOMEM;
5586
5587 result = construct_printer_driver_info_1(info, snum, servername, architecture, version);
5588 if (!W_ERROR_IS_OK(result))
5589 goto out;
5590
5591 /* check the required size. */
5592 *needed += spoolss_size_printer_driver_info_1(info);
5593
5594 if (*needed > offered) {
5595 result = WERR_INSUFFICIENT_BUFFER;
5596 goto out;
5597 }
5598
5599 if (!rpcbuf_alloc_size(buffer, *needed)) {
5600 result = WERR_NOMEM;
5601 goto out;
5602 }
5603
5604 /* fill the buffer with the structures */
5605 smb_io_printer_driver_info_1("", buffer, info, 0);
5606
5607 out:
5608 /* clear memory */
5609 SAFE_FREE(info);
5610
5611 return result;
5612 }
5613
5614 /****************************************************************************
5615 ****************************************************************************/
5616
5617 static WERROR getprinterdriver2_level2(const char *servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5618 {
5619 DRIVER_INFO_2 *info=NULL;
5620 WERROR result;
5621
5622 if((info=SMB_MALLOC_P(DRIVER_INFO_2)) == NULL)
5623 return WERR_NOMEM;
5624
5625 result = construct_printer_driver_info_2(info, snum, servername, architecture, version);
5626 if (!W_ERROR_IS_OK(result))
5627 goto out;
5628
5629 /* check the required size. */
5630 *needed += spoolss_size_printer_driver_info_2(info);
5631
5632 if (*needed > offered) {
5633 result = WERR_INSUFFICIENT_BUFFER;
5634 goto out;
5635 }
5636
5637 if (!rpcbuf_alloc_size(buffer, *needed)) {
5638 result = WERR_NOMEM;
5639 goto out;
5640 }
5641
5642 /* fill the buffer with the structures */
5643 smb_io_printer_driver_info_2("", buffer, info, 0);
5644
5645 out:
5646 /* clear memory */
5647 SAFE_FREE(info);
5648
5649 return result;
5650 }
5651
5652 /****************************************************************************
5653 ****************************************************************************/
5654
5655 static WERROR getprinterdriver2_level3(const char *servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5656 {
5657 DRIVER_INFO_3 info;
5658 WERROR result;
5659
5660 ZERO_STRUCT(info);
5661
5662 result = construct_printer_driver_info_3(&info, snum, servername, architecture, version);
5663 if (!W_ERROR_IS_OK(result))
5664 goto out;
5665
5666 /* check the required size. */
5667 *needed += spoolss_size_printer_driver_info_3(&info);
5668
5669 if (*needed > offered) {
5670 result = WERR_INSUFFICIENT_BUFFER;
5671 goto out;
5672 }
5673
5674 if (!rpcbuf_alloc_size(buffer, *needed)) {
5675 result = WERR_NOMEM;
5676 goto out;
5677 }
5678
5679 /* fill the buffer with the structures */
5680 smb_io_printer_driver_info_3("", buffer, &info, 0);
5681
5682 out:
5683 free_printer_driver_info_3(&info);
5684
5685 return result;
5686 }
5687
5688 /****************************************************************************
5689 ****************************************************************************/
5690
5691 static WERROR getprinterdriver2_level6(const char *servername, fstring architecture, uint32 version, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
5692 {
5693 DRIVER_INFO_6 info;
5694 WERROR result;
5695
5696 ZERO_STRUCT(info);
5697
5698 result = construct_printer_driver_info_6(&info, snum, servername, architecture, version);
5699 if (!W_ERROR_IS_OK(result))
5700 goto out;
5701
5702 /* check the required size. */
5703 *needed += spoolss_size_printer_driver_info_6(&info);
5704
5705 if (*needed > offered) {
5706 result = WERR_INSUFFICIENT_BUFFER;
5707 goto out;
5708 }
5709
5710 if (!rpcbuf_alloc_size(buffer, *needed)) {
5711 result = WERR_NOMEM;
5712 goto out;
5713 }
5714
5715 /* fill the buffer with the structures */
5716 smb_io_printer_driver_info_6("", buffer, &info, 0);
5717
5718 out:
5719 free_printer_driver_info_6(&info);
5720
5721 return result;
5722 }
5723
5724 /****************************************************************************
5725 ****************************************************************************/
5726
5727 WERROR _spoolss_getprinterdriver2(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVER2 *q_u, SPOOL_R_GETPRINTERDRIVER2 *r_u)
5728 {
5729 POLICY_HND *handle = &q_u->handle;
5730 UNISTR2 *uni_arch = &q_u->architecture;
5731 uint32 level = q_u->level;
5732 uint32 clientmajorversion = q_u->clientmajorversion;
5733 RPC_BUFFER *buffer = NULL;
5734 uint32 offered = q_u->offered;
5735 uint32 *needed = &r_u->needed;
5736 uint32 *servermajorversion = &r_u->servermajorversion;
5737 uint32 *serverminorversion = &r_u->serverminorversion;
5738 Printer_entry *printer;
5739
5740 fstring servername;
5741 fstring architecture;
5742 int snum;
5743
5744 /* that's an [in out] buffer */
5745
5746 if (!q_u->buffer && (offered!=0)) {
5747 return WERR_INVALID_PARAM;
5748 }
5749
5750 rpcbuf_move(q_u->buffer, &r_u->buffer);
5751 buffer = r_u->buffer;
5752
5753 DEBUG(4,("_spoolss_getprinterdriver2\n"));
5754
5755 if ( !(printer = find_printer_index_by_hnd( p, handle )) ) {
5756 DEBUG(0,("_spoolss_getprinterdriver2: invalid printer handle!\n"));
5757 return WERR_INVALID_PRINTER_NAME;
5758 }
5759
5760 *needed = 0;
5761 *servermajorversion = 0;
5762 *serverminorversion = 0;
5763
5764 fstrcpy(servername, get_server_name( printer ));
5765 unistr2_to_ascii(architecture, uni_arch, sizeof(architecture));
5766
5767 if (!get_printer_snum(p, handle, &snum, NULL))
5768 return WERR_BADFID;
5769
5770 switch (level) {
5771 case 1:
5772 return getprinterdriver2_level1(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5773 case 2:
5774 return getprinterdriver2_level2(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5775 case 3:
5776 return getprinterdriver2_level3(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5777 case 6:
5778 return getprinterdriver2_level6(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
5779 #if 0 /* JERRY */
5780 case 101:
5781 /* apparently this call is the equivalent of
5782 EnumPrinterDataEx() for the DsDriver key */
5783 break;
5784 #endif
5785 }
5786
5787 return WERR_UNKNOWN_LEVEL;
5788 }
5789
5790 /****************************************************************************
5791 ****************************************************************************/
5792
5793 WERROR _spoolss_startpageprinter(pipes_struct *p, SPOOL_Q_STARTPAGEPRINTER *q_u, SPOOL_R_STARTPAGEPRINTER *r_u)
5794 {
5795 POLICY_HND *handle = &q_u->handle;
5796
5797 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5798
5799 if (!Printer) {
5800 DEBUG(3,("Error in startpageprinter printer handle\n"));
5801 return WERR_BADFID;
5802 }
5803
5804 Printer->page_started=True;
5805 return WERR_OK;
5806 }
5807
5808 /****************************************************************************
5809 ****************************************************************************/
5810
5811 WERROR _spoolss_endpageprinter(pipes_struct *p, SPOOL_Q_ENDPAGEPRINTER *q_u, SPOOL_R_ENDPAGEPRINTER *r_u)
5812 {
5813 POLICY_HND *handle = &q_u->handle;
5814 int snum;
5815
5816 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5817
5818 if (!Printer) {
5819 DEBUG(2,("_spoolss_endpageprinter: Invalid handle (%s:%u:%u).\n",OUR_HANDLE(handle)));
5820 return WERR_BADFID;
5821 }
5822
5823 if (!get_printer_snum(p, handle, &snum, NULL))
5824 return WERR_BADFID;
5825
5826 Printer->page_started=False;
5827 print_job_endpage(snum, Printer->jobid);
5828
5829 return WERR_OK;
5830 }
5831
5832 /********************************************************************
5833 * api_spoolss_getprinter
5834 * called from the spoolss dispatcher
5835 *
5836 ********************************************************************/
5837
5838 WERROR _spoolss_startdocprinter(pipes_struct *p, SPOOL_Q_STARTDOCPRINTER *q_u, SPOOL_R_STARTDOCPRINTER *r_u)
5839 {
5840 POLICY_HND *handle = &q_u->handle;
5841 DOC_INFO *docinfo = &q_u->doc_info_container.docinfo;
5842 uint32 *jobid = &r_u->jobid;
5843 TALLOC_CTX *ctx = p->mem_ctx;
5844 DOC_INFO_1 *info_1 = &docinfo->doc_info_1;
5845 int snum;
5846 char *jobname = NULL;
5847 fstring datatype;
5848 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5849
5850 if (!Printer) {
5851 DEBUG(2,("_spoolss_startdocprinter: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
5852 return WERR_BADFID;
5853 }
5854
5855 /*
5856 * a nice thing with NT is it doesn't listen to what you tell it.
5857 * when asked to send _only_ RAW datas, it tries to send datas
5858 * in EMF format.
5859 *
5860 * So I add checks like in NT Server ...
5861 */
5862
5863 if (info_1->p_datatype != 0) {
5864 unistr2_to_ascii(datatype, &info_1->datatype, sizeof(datatype));
5865 if (strcmp(datatype, "RAW") != 0) {
5866 (*jobid)=0;
5867 return WERR_INVALID_DATATYPE;
5868 }
5869 }
5870
5871 /* get the share number of the printer */
5872 if (!get_printer_snum(p, handle, &snum, NULL)) {
5873 return WERR_BADFID;
5874 }
5875
5876 jobname = unistr2_to_ascii_talloc(ctx, &info_1->docname);
5877
5878 Printer->jobid = print_job_start(p->server_info, snum, jobname,
5879 Printer->nt_devmode);
5880
5881 /* An error occured in print_job_start() so return an appropriate
5882 NT error code. */
5883
5884 if (Printer->jobid == -1) {
5885 return map_werror_from_unix(errno);
5886 }
5887
5888 Printer->document_started=True;
5889 (*jobid) = Printer->jobid;
5890
5891 return WERR_OK;
5892 }
5893
5894 /********************************************************************
5895 * api_spoolss_getprinter
5896 * called from the spoolss dispatcher
5897 *
5898 ********************************************************************/
5899
5900 WERROR _spoolss_enddocprinter(pipes_struct *p, SPOOL_Q_ENDDOCPRINTER *q_u, SPOOL_R_ENDDOCPRINTER *r_u)
5901 {
5902 POLICY_HND *handle = &q_u->handle;
5903
5904 return _spoolss_enddocprinter_internal(p, handle);
5905 }
5906
5907 /****************************************************************************
5908 ****************************************************************************/
5909
5910 WERROR _spoolss_writeprinter(pipes_struct *p, SPOOL_Q_WRITEPRINTER *q_u, SPOOL_R_WRITEPRINTER *r_u)
5911 {
5912 POLICY_HND *handle = &q_u->handle;
5913 uint32 buffer_size = q_u->buffer_size;
5914 uint8 *buffer = q_u->buffer;
5915 uint32 *buffer_written = &q_u->buffer_size2;
5916 int snum;
5917 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5918
5919 if (!Printer) {
5920 DEBUG(2,("_spoolss_writeprinter: Invalid handle (%s:%u:%u)\n",OUR_HANDLE(handle)));
5921 r_u->buffer_written = q_u->buffer_size2;
5922 return WERR_BADFID;
5923 }
5924
5925 if (!get_printer_snum(p, handle, &snum, NULL))
5926 return WERR_BADFID;
5927
5928 (*buffer_written) = (uint32)print_job_write(snum, Printer->jobid, (const char *)buffer,
5929 (SMB_OFF_T)-1, (size_t)buffer_size);
5930 if (*buffer_written == (uint32)-1) {
5931 r_u->buffer_written = 0;
5932 if (errno == ENOSPC)
5933 return WERR_NO_SPOOL_SPACE;
5934 else
5935 return WERR_ACCESS_DENIED;
5936 }
5937
5938 r_u->buffer_written = q_u->buffer_size2;
5939
5940 return WERR_OK;
5941 }
5942
5943 /********************************************************************
5944 * api_spoolss_getprinter
5945 * called from the spoolss dispatcher
5946 *
5947 ********************************************************************/
5948
5949 static WERROR control_printer(POLICY_HND *handle, uint32 command,
5950 pipes_struct *p)
5951 {
5952 int snum;
5953 WERROR errcode = WERR_BADFUNC;
5954 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5955
5956 if (!Printer) {
5957 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
5958 return WERR_BADFID;
5959 }
5960
5961 if (!get_printer_snum(p, handle, &snum, NULL))
5962 return WERR_BADFID;
5963
5964 switch (command) {
5965 case PRINTER_CONTROL_PAUSE:
5966 if (print_queue_pause(p->server_info, snum, &errcode)) {
5967 errcode = WERR_OK;
5968 }
5969 break;
5970 case PRINTER_CONTROL_RESUME:
5971 case PRINTER_CONTROL_UNPAUSE:
5972 if (print_queue_resume(p->server_info, snum, &errcode)) {
5973 errcode = WERR_OK;
5974 }
5975 break;
5976 case PRINTER_CONTROL_PURGE:
5977 if (print_queue_purge(p->server_info, snum, &errcode)) {
5978 errcode = WERR_OK;
5979 }
5980 break;
5981 default:
5982 return WERR_UNKNOWN_LEVEL;
5983 }
5984
5985 return errcode;
5986 }
5987
5988 /********************************************************************
5989 * api_spoolss_abortprinter
5990 * From MSDN: "Deletes printer's spool file if printer is configured
5991 * for spooling"
5992 ********************************************************************/
5993
5994 WERROR _spoolss_abortprinter(pipes_struct *p, SPOOL_Q_ABORTPRINTER *q_u, SPOOL_R_ABORTPRINTER *r_u)
5995 {
5996 POLICY_HND *handle = &q_u->handle;
5997 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5998 int snum;
5999 WERROR errcode = WERR_OK;
6000
6001 if (!Printer) {
6002 DEBUG(2,("_spoolss_abortprinter: Invalid handle (%s:%u:%u)\n",OUR_HANDLE(handle)));
6003 return WERR_BADFID;
6004 }
6005
6006 if (!get_printer_snum(p, handle, &snum, NULL))
6007 return WERR_BADFID;
6008
6009 print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
6010
6011 return errcode;
6012 }
6013
6014 /********************************************************************
6015 * called by spoolss_api_setprinter
6016 * when updating a printer description
6017 ********************************************************************/
6018
6019 static WERROR update_printer_sec(POLICY_HND *handle, uint32 level,
6020 const SPOOL_PRINTER_INFO_LEVEL *info,
6021 pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
6022 {
6023 SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
6024 WERROR result;
6025 int snum;
6026
6027 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6028
6029 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
6030 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
6031 OUR_HANDLE(handle)));
6032
6033 result = WERR_BADFID;
6034 goto done;
6035 }
6036
6037 if (!secdesc_ctr) {
6038 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
6039 result = WERR_INVALID_PARAM;
6040 goto done;
6041 }
6042
6043 /* Check the user has permissions to change the security
6044 descriptor. By experimentation with two NT machines, the user
6045 requires Full Access to the printer to change security
6046 information. */
6047
6048 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
6049 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
6050 result = WERR_ACCESS_DENIED;
6051 goto done;
6052 }
6053
6054 /* NT seems to like setting the security descriptor even though
6055 nothing may have actually changed. */
6056
6057 if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
6058 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
6059 result = WERR_BADFID;
6060 goto done;
6061 }
6062
6063 if (DEBUGLEVEL >= 10) {
6064 SEC_ACL *the_acl;
6065 int i;
6066
6067 the_acl = old_secdesc_ctr->sd->dacl;
6068 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
6069 PRINTERNAME(snum), the_acl->num_aces));
6070
6071 for (i = 0; i < the_acl->num_aces; i++) {
6072 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6073 &the_acl->aces[i].trustee),
6074 the_acl->aces[i].access_mask));
6075 }
6076
6077 the_acl = secdesc_ctr->sd->dacl;
6078
6079 if (the_acl) {
6080 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
6081 PRINTERNAME(snum), the_acl->num_aces));
6082
6083 for (i = 0; i < the_acl->num_aces; i++) {
6084 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
6085 &the_acl->aces[i].trustee),
6086 the_acl->aces[i].access_mask));
6087 }
6088 } else {
6089 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
6090 }
6091 }
6092
6093 new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
6094 if (!new_secdesc_ctr) {
6095 result = WERR_NOMEM;
6096 goto done;
6097 }
6098
6099 if (sec_desc_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
6100 result = WERR_OK;
6101 goto done;
6102 }
6103
6104 result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
6105
6106 done:
6107
6108 return result;
6109 }
6110
6111 /********************************************************************
6112 Canonicalize printer info from a client
6113
6114 ATTN: It does not matter what we set the servername to hear
6115 since we do the necessary work in get_a_printer() to set it to
6116 the correct value based on what the client sent in the
6117 _spoolss_open_printer_ex().
6118 ********************************************************************/
6119
6120 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
6121 {
6122 fstring printername;
6123 const char *p;
6124
6125 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
6126 "portname=%s drivername=%s comment=%s location=%s\n",
6127 info->servername, info->printername, info->sharename,
6128 info->portname, info->drivername, info->comment, info->location));
6129
6130 /* we force some elements to "correct" values */
6131 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
6132 fstrcpy(info->sharename, lp_servicename(snum));
6133
6134 /* check to see if we allow printername != sharename */
6135
6136 if ( lp_force_printername(snum) ) {
6137 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
6138 global_myname(), info->sharename );
6139 } else {
6140
6141 /* make sure printername is in \\server\printername format */
6142
6143 fstrcpy( printername, info->printername );
6144 p = printername;
6145 if ( printername[0] == '\\' && printername[1] == '\\' ) {
6146 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
6147 p++;
6148 }
6149
6150 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
6151 global_myname(), p );
6152 }
6153
6154 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
6155 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
6156
6157
6158
6159 return True;
6160 }
6161
6162 /****************************************************************************
6163 ****************************************************************************/
6164
6165 WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri )
6166 {
6167 char *cmd = lp_addport_cmd();
6168 char *command = NULL;
6169 int ret;
6170 SE_PRIV se_printop = SE_PRINT_OPERATOR;
6171 bool is_print_op = False;
6172
6173 if ( !*cmd ) {
6174 return WERR_ACCESS_DENIED;
6175 }
6176
6177 command = talloc_asprintf(ctx,
6178 "%s \"%s\" \"%s\"", cmd, portname, uri );
6179 if (!command) {
6180 return WERR_NOMEM;
6181 }
6182
6183 if ( token )
6184 is_print_op = user_has_privileges( token, &se_printop );
6185
6186 DEBUG(10,("Running [%s]\n", command));
6187
6188 /********* BEGIN SePrintOperatorPrivilege **********/
6189
6190 if ( is_print_op )
6191 become_root();
6192
6193 ret = smbrun(command, NULL);
6194
6195 if ( is_print_op )
6196 unbecome_root();
6197
6198 /********* END SePrintOperatorPrivilege **********/
6199
6200 DEBUGADD(10,("returned [%d]\n", ret));
6201
6202 TALLOC_FREE(command);
6203
6204 if ( ret != 0 ) {
6205 return WERR_ACCESS_DENIED;
6206 }
6207
6208 return WERR_OK;
6209 }
6210
6211 /****************************************************************************
6212 ****************************************************************************/
6213
6214 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
6215 {
6216 char *cmd = lp_addprinter_cmd();
6217 char **qlines;
6218 char *command = NULL;
6219 int numlines;
6220 int ret;
6221 int fd;
6222 SE_PRIV se_printop = SE_PRINT_OPERATOR;
6223 bool is_print_op = False;
6224 char *remote_machine = talloc_strdup(ctx, "%m");
6225
6226 if (!remote_machine) {
6227 return false;
6228 }
6229 remote_machine = talloc_sub_basic(ctx,
6230 current_user_info.smb_name,
6231 current_user_info.domain,
6232 remote_machine);
6233 if (!remote_machine) {
6234 return false;
6235 }
6236
6237 command = talloc_asprintf(ctx,
6238 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
6239 cmd, printer->info_2->printername, printer->info_2->sharename,
6240 printer->info_2->portname, printer->info_2->drivername,
6241 printer->info_2->location, printer->info_2->comment, remote_machine);
6242 if (!command) {
6243 return false;
6244 }
6245
6246 if ( token )
6247 is_print_op = user_has_privileges( token, &se_printop );
6248
6249 DEBUG(10,("Running [%s]\n", command));
6250
6251 /********* BEGIN SePrintOperatorPrivilege **********/
6252
6253 if ( is_print_op )
6254 become_root();
6255
6256 if ( (ret = smbrun(command, &fd)) == 0 ) {
6257 /* Tell everyone we updated smb.conf. */
6258 message_send_all(smbd_messaging_context(),
6259 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6260 }
6261
6262 if ( is_print_op )
6263 unbecome_root();
6264
6265 /********* END SePrintOperatorPrivilege **********/
6266
6267 DEBUGADD(10,("returned [%d]\n", ret));
6268
6269 TALLOC_FREE(command);
6270 TALLOC_FREE(remote_machine);
6271
6272 if ( ret != 0 ) {
6273 if (fd != -1)
6274 close(fd);
6275 return False;
6276 }
6277
6278 /* reload our services immediately */
6279 reload_services( False );
6280
6281 numlines = 0;
6282 /* Get lines and convert them back to dos-codepage */
6283 qlines = fd_lines_load(fd, &numlines, 0);
6284 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6285 close(fd);
6286
6287 /* Set the portname to what the script says the portname should be. */
6288 /* but don't require anything to be return from the script exit a good error code */
6289
6290 if (numlines) {
6291 /* Set the portname to what the script says the portname should be. */
6292 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
6293 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6294 }
6295
6296 file_lines_free(qlines);
6297 return True;
6298 }
6299
6300
6301 /********************************************************************
6302 * Called by spoolss_api_setprinter
6303 * when updating a printer description.
6304 ********************************************************************/
6305
6306 static WERROR update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
6307 const SPOOL_PRINTER_INFO_LEVEL *info,
6308 DEVICEMODE *devmode)
6309 {
6310 int snum;
6311 NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
6312 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6313 WERROR result;
6314 UNISTR2 buffer;
6315 fstring asc_buffer;
6316
6317 DEBUG(8,("update_printer\n"));
6318
6319 result = WERR_OK;
6320
6321 if (!Printer) {
6322 result = WERR_BADFID;
6323 goto done;
6324 }
6325
6326 if (!get_printer_snum(p, handle, &snum, NULL)) {
6327 result = WERR_BADFID;
6328 goto done;
6329 }
6330
6331 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
6332 (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
6333 result = WERR_BADFID;
6334 goto done;
6335 }
6336
6337 DEBUGADD(8,("Converting info_2 struct\n"));
6338
6339 /*
6340 * convert_printer_info converts the incoming
6341 * info from the client and overwrites the info
6342 * just read from the tdb in the pointer 'printer'.
6343 */
6344
6345 if (!convert_printer_info(info, printer, level)) {
6346 result = WERR_NOMEM;
6347 goto done;
6348 }
6349
6350 if (devmode) {
6351 /* we have a valid devmode
6352 convert it and link it*/
6353
6354 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
6355 if (!convert_devicemode(printer->info_2->printername, devmode,
6356 &printer->info_2->devmode)) {
6357 result = WERR_NOMEM;
6358 goto done;
6359 }
6360 }
6361
6362 /* Do sanity check on the requested changes for Samba */
6363
6364 if (!check_printer_ok(printer->info_2, snum)) {
6365 result = WERR_INVALID_PARAM;
6366 goto done;
6367 }
6368
6369 /* FIXME!!! If the driver has changed we really should verify that
6370 it is installed before doing much else --jerry */
6371
6372 /* Check calling user has permission to update printer description */
6373
6374 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6375 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6376 result = WERR_ACCESS_DENIED;
6377 goto done;
6378 }
6379
6380 /* Call addprinter hook */
6381 /* Check changes to see if this is really needed */
6382
6383 if ( *lp_addprinter_cmd()
6384 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
6385 || !strequal(printer->info_2->comment, old_printer->info_2->comment)
6386 || !strequal(printer->info_2->portname, old_printer->info_2->portname)
6387 || !strequal(printer->info_2->location, old_printer->info_2->location)) )
6388 {
6389 /* add_printer_hook() will call reload_services() */
6390
6391 if ( !add_printer_hook(p->mem_ctx, p->pipe_user.nt_user_token, printer) ) {
6392 result = WERR_ACCESS_DENIED;
6393 goto done;
6394 }
6395 }
6396
6397 /*
6398 * When a *new* driver is bound to a printer, the drivername is used to
6399 * lookup previously saved driver initialization info, which is then
6400 * bound to the printer, simulating what happens in the Windows arch.
6401 */
6402 if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
6403 {
6404 if (!set_driver_init(printer, 2))
6405 {
6406 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
6407 printer->info_2->drivername));
6408 }
6409
6410 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
6411 printer->info_2->drivername));
6412
6413 notify_printer_driver(snum, printer->info_2->drivername);
6414 }
6415
6416 /*
6417 * flag which changes actually occured. This is a small subset of
6418 * all the possible changes. We also have to update things in the
6419 * DsSpooler key.
6420 */
6421
6422 if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
6423 init_unistr2( &buffer, printer->info_2->comment, UNI_STR_TERMINATE);
6424 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
6425 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6426
6427 notify_printer_comment(snum, printer->info_2->comment);
6428 }
6429
6430 if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
6431 init_unistr2( &buffer, printer->info_2->sharename, UNI_STR_TERMINATE);
6432 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
6433 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6434
6435 notify_printer_sharename(snum, printer->info_2->sharename);
6436 }
6437
6438 if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
6439 char *pname;
6440
6441 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
6442 pname++;
6443 else
6444 pname = printer->info_2->printername;
6445
6446
6447 init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
6448 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
6449 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6450
6451 notify_printer_printername( snum, pname );
6452 }
6453
6454 if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
6455 init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
6456 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
6457 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6458
6459 notify_printer_port(snum, printer->info_2->portname);
6460 }
6461
6462 if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
6463 init_unistr2( &buffer, printer->info_2->location, UNI_STR_TERMINATE);
6464 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
6465 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6466
6467 notify_printer_location(snum, printer->info_2->location);
6468 }
6469
6470 /* here we need to update some more DsSpooler keys */
6471 /* uNCName, serverName, shortServerName */
6472
6473 init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
6474 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
6475 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6476 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
6477 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6478
6479 slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
6480 global_myname(), printer->info_2->sharename );
6481 init_unistr2( &buffer, asc_buffer, UNI_STR_TERMINATE);
6482 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
6483 REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
6484
6485 /* Update printer info */
6486 result = mod_a_printer(printer, 2);
6487
6488 done:
6489 free_a_printer(&printer, 2);
6490 free_a_printer(&old_printer, 2);
6491
6492
6493 return result;
6494 }
6495
6496 /****************************************************************************
6497 ****************************************************************************/
6498 static WERROR publish_or_unpublish_printer(pipes_struct *p, POLICY_HND *handle,
6499 const SPOOL_PRINTER_INFO_LEVEL *info)
6500 {
6501 #ifdef HAVE_ADS
6502 SPOOL_PRINTER_INFO_LEVEL_7 *info7 = info->info_7;
6503 int snum;
6504 Printer_entry *Printer;
6505
6506 if ( lp_security() != SEC_ADS ) {
6507 return WERR_UNKNOWN_LEVEL;
6508 }
6509
6510 Printer = find_printer_index_by_hnd(p, handle);
6511
6512 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6513
6514 if (!Printer)
6515 return WERR_BADFID;
6516
6517 if (!get_printer_snum(p, handle, &snum, NULL))
6518 return WERR_BADFID;
6519
6520 nt_printer_publish(Printer, snum, info7->action);
6521
6522 return WERR_OK;
6523 #else
6524 return WERR_UNKNOWN_LEVEL;
6525 #endif
6526 }
6527 /****************************************************************************
6528 ****************************************************************************/
6529
6530 WERROR _spoolss_setprinter(pipes_struct *p, SPOOL_Q_SETPRINTER *q_u, SPOOL_R_SETPRINTER *r_u)
6531 {
6532 POLICY_HND *handle = &q_u->handle;
6533 uint32 level = q_u->level;
6534 SPOOL_PRINTER_INFO_LEVEL *info = &q_u->info;
6535 DEVMODE_CTR devmode_ctr = q_u->devmode_ctr;
6536 SEC_DESC_BUF *secdesc_ctr = q_u->secdesc_ctr;
6537 uint32 command = q_u->command;
6538 WERROR result;
6539
6540 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6541
6542 if (!Printer) {
6543 DEBUG(2,("_spoolss_setprinter: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
6544 return WERR_BADFID;
6545 }
6546
6547 /* check the level */
6548 switch (level) {
6549 case 0:
6550 return control_printer(handle, command, p);
6551 case 2:
6552 result = update_printer(p, handle, level, info, devmode_ctr.devmode);
6553 if (!W_ERROR_IS_OK(result))
6554 return result;
6555 if (secdesc_ctr)
6556 result = update_printer_sec(handle, level, info, p, secdesc_ctr);
6557 return result;
6558 case 3:
6559 return update_printer_sec(handle, level, info, p,
6560 secdesc_ctr);
6561 case 7:
6562 return publish_or_unpublish_printer(p, handle, info);
6563 default:
6564 return WERR_UNKNOWN_LEVEL;
6565 }
6566 }
6567
6568 /****************************************************************************
6569 ****************************************************************************/
6570
6571 WERROR _spoolss_fcpn(pipes_struct *p, SPOOL_Q_FCPN *q_u, SPOOL_R_FCPN *r_u)
6572 {
6573 POLICY_HND *handle = &q_u->handle;
6574 Printer_entry *Printer= find_printer_index_by_hnd(p, handle);
6575
6576 if (!Printer) {
6577 DEBUG(2,("_spoolss_fcpn: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
6578 return WERR_BADFID;
6579 }
6580
6581 if (Printer->notify.client_connected==True) {
6582 int snum = -1;
6583
6584 if ( Printer->printer_type == SPLHND_SERVER)
6585 snum = -1;
6586 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6587 !get_printer_snum(p, handle, &snum, NULL) )
6588 return WERR_BADFID;
6589
6590 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6591 }
6592
6593 Printer->notify.flags=0;
6594 Printer->notify.options=0;
6595 Printer->notify.localmachine[0]='\0';
6596 Printer->notify.printerlocal=0;
6597 if (Printer->notify.option)
6598 free_spool_notify_option(&Printer->notify.option);
6599 Printer->notify.client_connected=False;
6600
6601 return WERR_OK;
6602 }
6603
6604 /****************************************************************************
6605 ****************************************************************************/
6606
6607 WERROR _spoolss_addjob(pipes_struct *p, SPOOL_Q_ADDJOB *q_u, SPOOL_R_ADDJOB *r_u)
6608 {
6609 /* that's an [in out] buffer */
6610
6611 if (!q_u->buffer && (q_u->offered!=0)) {
6612 return WERR_INVALID_PARAM;
6613 }
6614
6615 rpcbuf_move(q_u->buffer, &r_u->buffer);
6616
6617 r_u->needed = 0;
6618 return WERR_INVALID_PARAM; /* this is what a NT server
6619 returns for AddJob. AddJob
6620 must fail on non-local
6621 printers */
6622 }
6623
6624 /****************************************************************************
6625 ****************************************************************************/
6626
6627 static void fill_job_info_1(JOB_INFO_1 *job_info, const print_queue_struct *queue,
6628 int position, int snum,
6629 const NT_PRINTER_INFO_LEVEL *ntprinter)
6630 {
6631 struct tm *t;
6632
6633 t=gmtime(&queue->time);
6634
6635 job_info->jobid=queue->job;
6636 init_unistr(&job_info->printername, lp_servicename(snum));
6637 init_unistr(&job_info->machinename, ntprinter->info_2->servername);
6638 init_unistr(&job_info->username, queue->fs_user);
6639 init_unistr(&job_info->document, queue->fs_file);
6640 init_unistr(&job_info->datatype, "RAW");
6641 init_unistr(&job_info->text_status, "");
6642 job_info->status=nt_printj_status(queue->status);
6643 job_info->priority=queue->priority;
6644 job_info->position=position;
6645 job_info->totalpages=queue->page_count;
6646 job_info->pagesprinted=0;
6647
6648 make_systemtime(&job_info->submitted, t);
6649 }
6650
6651 /****************************************************************************
6652 ****************************************************************************/
6653
6654 static bool fill_job_info_2(JOB_INFO_2 *job_info, const print_queue_struct *queue,
6655 int position, int snum,
6656 const NT_PRINTER_INFO_LEVEL *ntprinter,
6657 DEVICEMODE *devmode)
6658 {
6659 struct tm *t;
6660
6661 t=gmtime(&queue->time);
6662
6663 job_info->jobid=queue->job;
6664
6665 init_unistr(&job_info->printername, ntprinter->info_2->printername);
6666
6667 init_unistr(&job_info->machinename, ntprinter->info_2->servername);
6668 init_unistr(&job_info->username, queue->fs_user);
6669 init_unistr(&job_info->document, queue->fs_file);
6670 init_unistr(&job_info->notifyname, queue->fs_user);
6671 init_unistr(&job_info->datatype, "RAW");
6672 init_unistr(&job_info->printprocessor, "winprint");
6673 init_unistr(&job_info->parameters, "");
6674 init_unistr(&job_info->drivername, ntprinter->info_2->drivername);
6675 init_unistr(&job_info->text_status, "");
6676
6677 /* and here the security descriptor */
6678
6679 job_info->status=nt_printj_status(queue->status);
6680 job_info->priority=queue->priority;
6681 job_info->position=position;
6682 job_info->starttime=0;
6683 job_info->untiltime=0;
6684 job_info->totalpages=queue->page_count;
6685 job_info->size=queue->size;
6686 make_systemtime(&(job_info->submitted), t);
6687 job_info->timeelapsed=0;
6688 job_info->pagesprinted=0;
6689
6690 job_info->devmode = devmode;
6691
6692 return (True);
6693 }
6694
6695 /****************************************************************************
6696 Enumjobs at level 1.
6697 ****************************************************************************/
6698
6699 static WERROR enumjobs_level1(const print_queue_struct *queue, int snum,
6700 const NT_PRINTER_INFO_LEVEL *ntprinter,
6701 RPC_BUFFER *buffer, uint32 offered,
6702 uint32 *needed, uint32 *returned)
6703 {
6704 JOB_INFO_1 *info;
6705 int i;
6706 WERROR result = WERR_OK;
6707
6708 info=SMB_MALLOC_ARRAY(JOB_INFO_1,*returned);
6709 if (info==NULL) {
6710 *returned=0;
6711 return WERR_NOMEM;
6712 }
6713
6714 for (i=0; i<*returned; i++)
6715 fill_job_info_1( &info[i], &queue[i], i, snum, ntprinter );
6716
6717 /* check the required size. */
6718 for (i=0; i<*returned; i++)
6719 (*needed) += spoolss_size_job_info_1(&info[i]);
6720
6721 if (*needed > offered) {
6722 result = WERR_INSUFFICIENT_BUFFER;
6723 goto out;
6724 }
6725
6726 if (!rpcbuf_alloc_size(buffer, *needed)) {
6727 result = WERR_NOMEM;
6728 goto out;
6729 }
6730
6731 /* fill the buffer with the structures */
6732 for (i=0; i<*returned; i++)
6733 smb_io_job_info_1("", buffer, &info[i], 0);
6734
6735 out:
6736 /* clear memory */
6737 SAFE_FREE(info);
6738
6739 if ( !W_ERROR_IS_OK(result) )
6740 *returned = 0;
6741
6742 return result;
6743 }
6744
6745 /****************************************************************************
6746 Enumjobs at level 2.
6747 ****************************************************************************/
6748
6749 static WERROR enumjobs_level2(const print_queue_struct *queue, int snum,
6750 const NT_PRINTER_INFO_LEVEL *ntprinter,
6751 RPC_BUFFER *buffer, uint32 offered,
6752 uint32 *needed, uint32 *returned)
6753 {
6754 JOB_INFO_2 *info = NULL;
6755 int i;
6756 WERROR result = WERR_OK;
6757 DEVICEMODE *devmode = NULL;
6758
6759 if ( !(info = SMB_MALLOC_ARRAY(JOB_INFO_2,*returned)) ) {
6760 *returned=0;
6761 return WERR_NOMEM;
6762 }
6763
6764 /* this should not be a failure condition if the devmode is NULL */
6765
6766 devmode = construct_dev_mode(lp_const_servicename(snum));
6767
6768 for (i=0; i<*returned; i++)
6769 fill_job_info_2(&(info[i]), &queue[i], i, snum, ntprinter, devmode);
6770
6771 /* check the required size. */
6772 for (i=0; i<*returned; i++)
6773 (*needed) += spoolss_size_job_info_2(&info[i]);
6774
6775 if (*needed > offered) {
6776 result = WERR_INSUFFICIENT_BUFFER;
6777 goto out;
6778 }
6779
6780 if (!rpcbuf_alloc_size(buffer, *needed)) {
6781 result = WERR_NOMEM;
6782 goto out;
6783 }
6784
6785 /* fill the buffer with the structures */
6786 for (i=0; i<*returned; i++)
6787 smb_io_job_info_2("", buffer, &info[i], 0);
6788
6789 out:
6790 free_devmode(devmode);
6791 SAFE_FREE(info);
6792
6793 if ( !W_ERROR_IS_OK(result) )
6794 *returned = 0;
6795
6796 return result;
6797
6798 }
6799
6800 /****************************************************************************
6801 Enumjobs.
6802 ****************************************************************************/
6803
6804 WERROR _spoolss_enumjobs( pipes_struct *p, SPOOL_Q_ENUMJOBS *q_u, SPOOL_R_ENUMJOBS *r_u)
6805 {
6806 POLICY_HND *handle = &q_u->handle;
6807 uint32 level = q_u->level;
6808 RPC_BUFFER *buffer = NULL;
6809 uint32 offered = q_u->offered;
6810 uint32 *needed = &r_u->needed;
6811 uint32 *returned = &r_u->returned;
6812 WERROR wret;
6813 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6814 int snum;
6815 print_status_struct prt_status;
6816 print_queue_struct *queue=NULL;
6817
6818 /* that's an [in out] buffer */
6819
6820 if (!q_u->buffer && (offered!=0)) {
6821 return WERR_INVALID_PARAM;
6822 }
6823
6824 rpcbuf_move(q_u->buffer, &r_u->buffer);
6825 buffer = r_u->buffer;
6826
6827 DEBUG(4,("_spoolss_enumjobs\n"));
6828
6829 *needed=0;
6830 *returned=0;
6831
6832 /* lookup the printer snum and tdb entry */
6833
6834 if (!get_printer_snum(p, handle, &snum, NULL))
6835 return WERR_BADFID;
6836
6837 wret = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6838 if ( !W_ERROR_IS_OK(wret) )
6839 return wret;
6840
6841 *returned = print_queue_status(snum, &queue, &prt_status);
6842 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n", *returned, prt_status.status, prt_status.message));
6843
6844 if (*returned == 0) {
6845 SAFE_FREE(queue);
6846 free_a_printer(&ntprinter, 2);
6847 return WERR_OK;
6848 }
6849
6850 switch (level) {
6851 case 1:
6852 wret = enumjobs_level1(queue, snum, ntprinter, buffer, offered, needed, returned);
6853 break;
6854 case 2:
6855 wret = enumjobs_level2(queue, snum, ntprinter, buffer, offered, needed, returned);
6856 break;
6857 default:
6858 *returned=0;
6859 wret = WERR_UNKNOWN_LEVEL;
6860 break;
6861 }
6862
6863 SAFE_FREE(queue);
6864 free_a_printer( &ntprinter, 2 );
6865 return wret;
6866 }
6867
6868 /****************************************************************************
6869 ****************************************************************************/
6870
6871 WERROR _spoolss_schedulejob( pipes_struct *p, SPOOL_Q_SCHEDULEJOB *q_u, SPOOL_R_SCHEDULEJOB *r_u)
6872 {
6873 return WERR_OK;
6874 }
6875
6876 /****************************************************************************
6877 ****************************************************************************/
6878
6879 WERROR _spoolss_setjob(pipes_struct *p, SPOOL_Q_SETJOB *q_u, SPOOL_R_SETJOB *r_u)
6880 {
6881 POLICY_HND *handle = &q_u->handle;
6882 uint32 jobid = q_u->jobid;
6883 uint32 command = q_u->command;
6884
6885 int snum;
6886 WERROR errcode = WERR_BADFUNC;
6887
6888 if (!get_printer_snum(p, handle, &snum, NULL)) {
6889 return WERR_BADFID;
6890 }
6891
6892 if (!print_job_exists(lp_const_servicename(snum), jobid)) {
6893 return WERR_INVALID_PRINTER_NAME;
6894 }
6895
6896 switch (command) {
6897 case JOB_CONTROL_CANCEL:
6898 case JOB_CONTROL_DELETE:
6899 if (print_job_delete(p->server_info, snum, jobid, &errcode)) {
6900 errcode = WERR_OK;
6901 }
6902 break;
6903 case JOB_CONTROL_PAUSE:
6904 if (print_job_pause(p->server_info, snum, jobid, &errcode)) {
6905 errcode = WERR_OK;
6906 }
6907 break;
6908 case JOB_CONTROL_RESTART:
6909 case JOB_CONTROL_RESUME:
6910 if (print_job_resume(p->server_info, snum, jobid, &errcode)) {
6911 errcode = WERR_OK;
6912 }
6913 break;
6914 default:
6915 return WERR_UNKNOWN_LEVEL;
6916 }
6917
6918 return errcode;
6919 }
6920
6921 /****************************************************************************
6922 Enumerates all printer drivers at level 1.
6923 ****************************************************************************/
6924
6925 static WERROR enumprinterdrivers_level1(const char *servername, fstring architecture, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
6926 {
6927 int i;
6928 int ndrivers;
6929 uint32 version;
6930 fstring *list = NULL;
6931 NT_PRINTER_DRIVER_INFO_LEVEL driver;
6932 DRIVER_INFO_1 *driver_info_1=NULL;
6933 WERROR result = WERR_OK;
6934
6935 *returned=0;
6936
6937 for (version=0; version<DRIVER_MAX_VERSION; version++) {
6938 list=NULL;
6939 ndrivers=get_ntdrivers(&list, architecture, version);
6940 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
6941
6942 if(ndrivers == -1) {
6943 SAFE_FREE(driver_info_1);
6944 return WERR_NOMEM;
6945 }
6946
6947 if(ndrivers != 0) {
6948 if((driver_info_1=SMB_REALLOC_ARRAY(driver_info_1, DRIVER_INFO_1, *returned+ndrivers )) == NULL) {
6949 DEBUG(0,("enumprinterdrivers_level1: failed to enlarge driver info buffer!\n"));
6950 SAFE_FREE(list);
6951 return WERR_NOMEM;
6952 }
6953 }
6954
6955 for (i=0; i<ndrivers; i++) {
6956 WERROR status;
6957 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6958 ZERO_STRUCT(driver);
6959 status = get_a_printer_driver(&driver, 3, list[i],
6960 architecture, version);
6961 if (!W_ERROR_IS_OK(status)) {
6962 SAFE_FREE(list);
6963 SAFE_FREE(driver_info_1);
6964 return status;
6965 }
6966 fill_printer_driver_info_1(&driver_info_1[*returned+i], driver, servername, architecture );
6967 free_a_printer_driver(driver, 3);
6968 }
6969
6970 *returned+=ndrivers;
6971 SAFE_FREE(list);
6972 }
6973
6974 /* check the required size. */
6975 for (i=0; i<*returned; i++) {
6976 DEBUGADD(6,("adding driver [%d]'s size\n",i));
6977 *needed += spoolss_size_printer_driver_info_1(&driver_info_1[i]);
6978 }
6979
6980 if (*needed > offered) {
6981 result = WERR_INSUFFICIENT_BUFFER;
6982 goto out;
6983 }
6984
6985 if (!rpcbuf_alloc_size(buffer, *needed)) {
6986 result = WERR_NOMEM;
6987 goto out;
6988 }
6989
6990 /* fill the buffer with the driver structures */
6991 for (i=0; i<*returned; i++) {
6992 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
6993 smb_io_printer_driver_info_1("", buffer, &driver_info_1[i], 0);
6994 }
6995
6996 out:
6997 SAFE_FREE(driver_info_1);
6998
6999 if ( !W_ERROR_IS_OK(result) )
7000 *returned = 0;
7001
7002 return result;
7003 }
7004
7005 /****************************************************************************
7006 Enumerates all printer drivers at level 2.
7007 ****************************************************************************/
7008
7009 static WERROR enumprinterdrivers_level2(const char *servername, fstring architecture, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
7010 {
7011 int i;
7012 int ndrivers;
7013 uint32 version;
7014 fstring *list = NULL;
7015 NT_PRINTER_DRIVER_INFO_LEVEL driver;
7016 DRIVER_INFO_2 *driver_info_2=NULL;
7017 WERROR result = WERR_OK;
7018
7019 *returned=0;
7020
7021 for (version=0; version<DRIVER_MAX_VERSION; version++) {
7022 list=NULL;
7023 ndrivers=get_ntdrivers(&list, architecture, version);
7024 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
7025
7026 if(ndrivers == -1) {
7027 SAFE_FREE(driver_info_2);
7028 return WERR_NOMEM;
7029 }
7030
7031 if(ndrivers != 0) {
7032 if((driver_info_2=SMB_REALLOC_ARRAY(driver_info_2, DRIVER_INFO_2, *returned+ndrivers )) == NULL) {
7033 DEBUG(0,("enumprinterdrivers_level2: failed to enlarge driver info buffer!\n"));
7034 SAFE_FREE(list);
7035 return WERR_NOMEM;
7036 }
7037 }
7038
7039 for (i=0; i<ndrivers; i++) {
7040 WERROR status;
7041
7042 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
7043 ZERO_STRUCT(driver);
7044 status = get_a_printer_driver(&driver, 3, list[i],
7045 architecture, version);
7046 if (!W_ERROR_IS_OK(status)) {
7047 SAFE_FREE(list);
7048 SAFE_FREE(driver_info_2);
7049 return status;
7050 }
7051 fill_printer_driver_info_2(&driver_info_2[*returned+i], driver, servername);
7052 free_a_printer_driver(driver, 3);
7053 }
7054
7055 *returned+=ndrivers;
7056 SAFE_FREE(list);
7057 }
7058
7059 /* check the required size. */
7060 for (i=0; i<*returned; i++) {
7061 DEBUGADD(6,("adding driver [%d]'s size\n",i));
7062 *needed += spoolss_size_printer_driver_info_2(&(driver_info_2[i]));
7063 }
7064
7065 if (*needed > offered) {
7066 result = WERR_INSUFFICIENT_BUFFER;
7067 goto out;
7068 }
7069
7070 if (!rpcbuf_alloc_size(buffer, *needed)) {
7071 result = WERR_NOMEM;
7072 goto out;
7073 }
7074
7075 /* fill the buffer with the form structures */
7076 for (i=0; i<*returned; i++) {
7077 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
7078 smb_io_printer_driver_info_2("", buffer, &(driver_info_2[i]), 0);
7079 }
7080
7081 out:
7082 SAFE_FREE(driver_info_2);
7083
7084 if ( !W_ERROR_IS_OK(result) )
7085 *returned = 0;
7086
7087 return result;
7088 }
7089
7090 /****************************************************************************
7091 Enumerates all printer drivers at level 3.
7092 ****************************************************************************/
7093
7094 static WERROR enumprinterdrivers_level3(const char *servername, fstring architecture, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
7095 {
7096 int i;
7097 int ndrivers;
7098 uint32 version;
7099 fstring *list = NULL;
7100 DRIVER_INFO_3 *driver_info_3=NULL;
7101 NT_PRINTER_DRIVER_INFO_LEVEL driver;
7102 WERROR result = WERR_OK;
7103
7104 *returned=0;
7105
7106 for (version=0; version<DRIVER_MAX_VERSION; version++) {
7107 list=NULL;
7108 ndrivers=get_ntdrivers(&list, architecture, version);
7109 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
7110
7111 if(ndrivers == -1) {
7112 SAFE_FREE(driver_info_3);
7113 return WERR_NOMEM;
7114 }
7115
7116 if(ndrivers != 0) {
7117 if((driver_info_3=SMB_REALLOC_ARRAY(driver_info_3, DRIVER_INFO_3, *returned+ndrivers )) == NULL) {
7118 DEBUG(0,("enumprinterdrivers_level3: failed to enlarge driver info buffer!\n"));
7119 SAFE_FREE(list);
7120 return WERR_NOMEM;
7121 }
7122 }
7123
7124 for (i=0; i<ndrivers; i++) {
7125 WERROR status;
7126
7127 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
7128 ZERO_STRUCT(driver);
7129 status = get_a_printer_driver(&driver, 3, list[i],
7130 architecture, version);
7131 if (!W_ERROR_IS_OK(status)) {
7132 SAFE_FREE(list);
7133 SAFE_FREE(driver_info_3);
7134 return status;
7135 }
7136 fill_printer_driver_info_3(&driver_info_3[*returned+i], driver, servername);
7137 free_a_printer_driver(driver, 3);
7138 }
7139
7140 *returned+=ndrivers;
7141 SAFE_FREE(list);
7142 }
7143
7144 /* check the required size. */
7145 for (i=0; i<*returned; i++) {
7146 DEBUGADD(6,("adding driver [%d]'s size\n",i));
7147 *needed += spoolss_size_printer_driver_info_3(&driver_info_3[i]);
7148 }
7149
7150 if (*needed > offered) {
7151 result = WERR_INSUFFICIENT_BUFFER;
7152 goto out;
7153 }
7154
7155 if (!rpcbuf_alloc_size(buffer, *needed)) {
7156 result = WERR_NOMEM;
7157 goto out;
7158 }
7159
7160 /* fill the buffer with the driver structures */
7161 for (i=0; i<*returned; i++) {
7162 DEBUGADD(6,("adding driver [%d] to buffer\n",i));
7163 smb_io_printer_driver_info_3("", buffer, &driver_info_3[i], 0);
7164 }
7165
7166 out:
7167 for (i=0; i<*returned; i++) {
7168 SAFE_FREE(driver_info_3[i].dependentfiles);
7169 }
7170
7171 SAFE_FREE(driver_info_3);
7172
7173 if ( !W_ERROR_IS_OK(result) )
7174 *returned = 0;
7175
7176 return result;
7177 }
7178
7179 /****************************************************************************
7180 Enumerates all printer drivers.
7181 ****************************************************************************/
7182
7183 WERROR _spoolss_enumprinterdrivers( pipes_struct *p, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, SPOOL_R_ENUMPRINTERDRIVERS *r_u)
7184 {
7185 uint32 level = q_u->level;
7186 RPC_BUFFER *buffer = NULL;
7187 uint32 offered = q_u->offered;
7188 uint32 *needed = &r_u->needed;
7189 uint32 *returned = &r_u->returned;
7190 const char *cservername;
7191 fstring servername;
7192 fstring architecture;
7193
7194 /* that's an [in out] buffer */
7195
7196 if (!q_u->buffer && (offered!=0)) {
7197 return WERR_INVALID_PARAM;
7198 }
7199
7200 rpcbuf_move(q_u->buffer, &r_u->buffer);
7201 buffer = r_u->buffer;
7202
7203 DEBUG(4,("_spoolss_enumprinterdrivers\n"));
7204
7205 *needed = 0;
7206 *returned = 0;
7207
7208 unistr2_to_ascii(architecture, &q_u->environment, sizeof(architecture));
7209 unistr2_to_ascii(servername, &q_u->name, sizeof(servername));
7210
7211 cservername = canon_servername(servername);
7212
7213 if (!is_myname_or_ipaddr(cservername))
7214 return WERR_UNKNOWN_PRINTER_DRIVER;
7215
7216 switch (level) {
7217 case 1:
7218 return enumprinterdrivers_level1(cservername, architecture, buffer, offered, needed, returned);
7219 case 2:
7220 return enumprinterdrivers_level2(cservername, architecture, buffer, offered, needed, returned);
7221 case 3:
7222 return enumprinterdrivers_level3(cservername, architecture, buffer, offered, needed, returned);
7223 default:
7224 return WERR_UNKNOWN_LEVEL;
7225 }
7226 }
7227
7228 /****************************************************************************
7229 ****************************************************************************/
7230
7231 static void fill_form_1(FORM_1 *form, nt_forms_struct *list)
7232 {
7233 form->flag=list->flag;
7234 init_unistr(&form->name, list->name);
7235 form->width=list->width;
7236 form->length=list->length;
7237 form->left=list->left;
7238 form->top=list->top;
7239 form->right=list->right;
7240 form->bottom=list->bottom;
7241 }
7242
7243 /****************************************************************************
7244 ****************************************************************************/
7245
7246 WERROR _spoolss_enumforms(pipes_struct *p, SPOOL_Q_ENUMFORMS *q_u, SPOOL_R_ENUMFORMS *r_u)
7247 {
7248 uint32 level = q_u->level;
7249 RPC_BUFFER *buffer = NULL;
7250 uint32 offered = q_u->offered;
7251 uint32 *needed = &r_u->needed;
7252 uint32 *numofforms = &r_u->numofforms;
7253 uint32 numbuiltinforms;
7254
7255 nt_forms_struct *list=NULL;
7256 nt_forms_struct *builtinlist=NULL;
7257 FORM_1 *forms_1;
7258 int buffer_size=0;
7259 int i;
7260
7261 /* that's an [in out] buffer */
7262
7263 if (!q_u->buffer && (offered!=0) ) {
7264 return WERR_INVALID_PARAM;
7265 }
7266
7267 rpcbuf_move(q_u->buffer, &r_u->buffer);
7268 buffer = r_u->buffer;
7269
7270 DEBUG(4,("_spoolss_enumforms\n"));
7271 DEBUGADD(5,("Offered buffer size [%d]\n", offered));
7272 DEBUGADD(5,("Info level [%d]\n", level));
7273
7274 numbuiltinforms = get_builtin_ntforms(&builtinlist);
7275 DEBUGADD(5,("Number of builtin forms [%d]\n", numbuiltinforms));
7276 *numofforms = get_ntforms(&list);
7277 DEBUGADD(5,("Number of user forms [%d]\n", *numofforms));
7278 *numofforms += numbuiltinforms;
7279
7280 if (*numofforms == 0) {
7281 SAFE_FREE(builtinlist);
7282 SAFE_FREE(list);
7283 return WERR_NO_MORE_ITEMS;
7284 }
7285
7286 switch (level) {
7287 case 1:
7288 if ((forms_1=SMB_MALLOC_ARRAY(FORM_1, *numofforms)) == NULL) {
7289 SAFE_FREE(builtinlist);
7290 SAFE_FREE(list);
7291 *numofforms=0;
7292 return WERR_NOMEM;
7293 }
7294
7295 /* construct the list of form structures */
7296 for (i=0; i<numbuiltinforms; i++) {
7297 DEBUGADD(6,("Filling form number [%d]\n",i));
7298 fill_form_1(&forms_1[i], &builtinlist[i]);
7299 }
7300
7301 SAFE_FREE(builtinlist);
7302
7303 for (; i<*numofforms; i++) {
7304 DEBUGADD(6,("Filling form number [%d]\n",i));
7305 fill_form_1(&forms_1[i], &list[i-numbuiltinforms]);
7306 }
7307
7308 SAFE_FREE(list);
7309
7310 /* check the required size. */
7311 for (i=0; i<numbuiltinforms; i++) {
7312 DEBUGADD(6,("adding form [%d]'s size\n",i));
7313 buffer_size += spoolss_size_form_1(&forms_1[i]);
7314 }
7315 for (; i<*numofforms; i++) {
7316 DEBUGADD(6,("adding form [%d]'s size\n",i));
7317 buffer_size += spoolss_size_form_1(&forms_1[i]);
7318 }
7319
7320 *needed=buffer_size;
7321
7322 if (*needed > offered) {
7323 SAFE_FREE(forms_1);
7324 *numofforms=0;
7325 return WERR_INSUFFICIENT_BUFFER;
7326 }
7327
7328 if (!rpcbuf_alloc_size(buffer, buffer_size)){
7329 SAFE_FREE(forms_1);
7330 *numofforms=0;
7331 return WERR_NOMEM;
7332 }
7333
7334 /* fill the buffer with the form structures */
7335 for (i=0; i<numbuiltinforms; i++) {
7336 DEBUGADD(6,("adding form [%d] to buffer\n",i));
7337 smb_io_form_1("", buffer, &forms_1[i], 0);
7338 }
7339 for (; i<*numofforms; i++) {
7340 DEBUGADD(6,("adding form [%d] to buffer\n",i));
7341 smb_io_form_1("", buffer, &forms_1[i], 0);
7342 }
7343
7344 SAFE_FREE(forms_1);
7345
7346 return WERR_OK;
7347
7348 default:
7349 SAFE_FREE(list);
7350 SAFE_FREE(builtinlist);
7351 return WERR_UNKNOWN_LEVEL;
7352 }
7353 }
7354
7355 /****************************************************************************
7356 ****************************************************************************/
7357
7358 WERROR _spoolss_getform(pipes_struct *p, SPOOL_Q_GETFORM *q_u, SPOOL_R_GETFORM *r_u)
7359 {
7360 uint32 level = q_u->level;
7361 UNISTR2 *uni_formname = &q_u->formname;
7362 RPC_BUFFER *buffer = NULL;
7363 uint32 offered = q_u->offered;
7364 uint32 *needed = &r_u->needed;
7365
7366 nt_forms_struct *list=NULL;
7367 nt_forms_struct builtin_form;
7368 bool foundBuiltin;
7369 FORM_1 form_1;
7370 fstring form_name;
7371 int buffer_size=0;
7372 int numofforms=0, i=0;
7373
7374 /* that's an [in out] buffer */
7375
7376 if (!q_u->buffer && (offered!=0)) {
7377 return WERR_INVALID_PARAM;
7378 }
7379
7380 rpcbuf_move(q_u->buffer, &r_u->buffer);
7381 buffer = r_u->buffer;
7382
7383 unistr2_to_ascii(form_name, uni_formname, sizeof(form_name));
7384
7385 DEBUG(4,("_spoolss_getform\n"));
7386 DEBUGADD(5,("Offered buffer size [%d]\n", offered));
7387 DEBUGADD(5,("Info level [%d]\n", level));
7388
7389 foundBuiltin = get_a_builtin_ntform(uni_formname,&builtin_form);
7390 if (!foundBuiltin) {
7391 numofforms = get_ntforms(&list);
7392 DEBUGADD(5,("Number of forms [%d]\n", numofforms));
7393
7394 if (numofforms == 0)
7395 return WERR_BADFID;
7396 }
7397
7398 switch (level) {
7399 case 1:
7400 if (foundBuiltin) {
7401 fill_form_1(&form_1, &builtin_form);
7402 } else {
7403
7404 /* Check if the requested name is in the list of form structures */
7405 for (i=0; i<numofforms; i++) {
7406
7407 DEBUG(4,("_spoolss_getform: checking form %s (want %s)\n", list[i].name, form_name));
7408
7409 if (strequal(form_name, list[i].name)) {
7410 DEBUGADD(6,("Found form %s number [%d]\n", form_name, i));
7411 fill_form_1(&form_1, &list[i]);
7412 break;
7413 }
7414 }
7415
7416 SAFE_FREE(list);
7417 if (i == numofforms) {
7418 return WERR_BADFID;
7419 }
7420 }
7421 /* check the required size. */
7422
7423 *needed=spoolss_size_form_1(&form_1);
7424
7425 if (*needed > offered)
7426 return WERR_INSUFFICIENT_BUFFER;
7427
7428 if (!rpcbuf_alloc_size(buffer, buffer_size))
7429 return WERR_NOMEM;
7430
7431 /* fill the buffer with the form structures */
7432 DEBUGADD(6,("adding form %s [%d] to buffer\n", form_name, i));
7433 smb_io_form_1("", buffer, &form_1, 0);
7434
7435 return WERR_OK;
7436
7437 default:
7438 SAFE_FREE(list);
7439 return WERR_UNKNOWN_LEVEL;
7440 }
7441 }
7442
7443 /****************************************************************************
7444 ****************************************************************************/
7445
7446 static void fill_port_1(PORT_INFO_1 *port, const char *name)
7447 {
7448 init_unistr(&port->port_name, name);
7449 }
7450
7451 /****************************************************************************
7452 TODO: This probably needs distinguish between TCP/IP and Local ports
7453 somehow.
7454 ****************************************************************************/
7455
7456 static void fill_port_2(PORT_INFO_2 *port, const char *name)
7457 {
7458 init_unistr(&port->port_name, name);
7459 init_unistr(&port->monitor_name, "Local Monitor");
7460 init_unistr(&port->description, SPL_LOCAL_PORT );
7461 port->port_type=PORT_TYPE_WRITE;
7462 port->reserved=0x0;
7463 }
7464
7465
7466 /****************************************************************************
7467 wrapper around the enumer ports command
7468 ****************************************************************************/
7469
7470 WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines )
7471 {
7472 char *cmd = lp_enumports_cmd();
7473 char **qlines = NULL;
7474 char *command = NULL;
7475 int numlines;
7476 int ret;
7477 int fd;
7478
7479 *count = 0;
7480 *lines = NULL;
7481
7482 /* if no hook then just fill in the default port */
7483
7484 if ( !*cmd ) {
7485 if (!(qlines = SMB_MALLOC_ARRAY( char*, 2 ))) {
7486 return WERR_NOMEM;
7487 }
7488 if (!(qlines[0] = SMB_STRDUP( SAMBA_PRINTER_PORT_NAME ))) {
7489 SAFE_FREE(qlines);
7490 return WERR_NOMEM;
7491 }
7492 qlines[1] = NULL;
7493 numlines = 1;
7494 }
7495 else {
7496 /* we have a valid enumport command */
7497
7498 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7499 if (!command) {
7500 return WERR_NOMEM;
7501 }
7502
7503 DEBUG(10,("Running [%s]\n", command));
7504 ret = smbrun(command, &fd);
7505 DEBUG(10,("Returned [%d]\n", ret));
7506 TALLOC_FREE(command);
7507 if (ret != 0) {
7508 if (fd != -1) {
7509 close(fd);
7510 }
7511 return WERR_ACCESS_DENIED;
7512 }
7513
7514 numlines = 0;
7515 qlines = fd_lines_load(fd, &numlines, 0);
7516 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7517 close(fd);
7518 }
7519
7520 *count = numlines;
7521 *lines = qlines;
7522
7523 return WERR_OK;
7524 }
7525
7526 /****************************************************************************
7527 enumports level 1.
7528 ****************************************************************************/
7529
7530 static WERROR enumports_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
7531 {
7532 PORT_INFO_1 *ports=NULL;
7533 int i=0;
7534 WERROR result = WERR_OK;
7535 char **qlines = NULL;
7536 int numlines = 0;
7537
7538 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7539 if (!W_ERROR_IS_OK(result)) {
7540 file_lines_free(qlines);
7541 return result;
7542 }
7543
7544 if(numlines) {
7545 if((ports=SMB_MALLOC_ARRAY( PORT_INFO_1, numlines )) == NULL) {
7546 DEBUG(10,("Returning WERR_NOMEM [%s]\n",
7547 dos_errstr(WERR_NOMEM)));
7548 file_lines_free(qlines);
7549 return WERR_NOMEM;
7550 }
7551
7552 for (i=0; i<numlines; i++) {
7553 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7554 fill_port_1(&ports[i], qlines[i]);
7555 }
7556 }
7557 file_lines_free(qlines);
7558
7559 *returned = numlines;
7560
7561 /* check the required size. */
7562 for (i=0; i<*returned; i++) {
7563 DEBUGADD(6,("adding port [%d]'s size\n", i));
7564 *needed += spoolss_size_port_info_1(&ports[i]);
7565 }
7566
7567 if (*needed > offered) {
7568 result = WERR_INSUFFICIENT_BUFFER;
7569 goto out;
7570 }
7571
7572 if (!rpcbuf_alloc_size(buffer, *needed)) {
7573 result = WERR_NOMEM;
7574 goto out;
7575 }
7576
7577 /* fill the buffer with the ports structures */
7578 for (i=0; i<*returned; i++) {
7579 DEBUGADD(6,("adding port [%d] to buffer\n", i));
7580 smb_io_port_1("", buffer, &ports[i], 0);
7581 }
7582
7583 out:
7584 SAFE_FREE(ports);
7585
7586 if ( !W_ERROR_IS_OK(result) )
7587 *returned = 0;
7588
7589 return result;
7590 }
7591
7592 /****************************************************************************
7593 enumports level 2.
7594 ****************************************************************************/
7595
7596 static WERROR enumports_level_2(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
7597 {
7598 PORT_INFO_2 *ports=NULL;
7599 int i=0;
7600 WERROR result = WERR_OK;
7601 char **qlines = NULL;
7602 int numlines = 0;
7603
7604 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7605 if ( !W_ERROR_IS_OK(result)) {
7606 file_lines_free(qlines);
7607 return result;
7608 }
7609
7610 if(numlines) {
7611 if((ports=SMB_MALLOC_ARRAY( PORT_INFO_2, numlines)) == NULL) {
7612 file_lines_free(qlines);
7613 return WERR_NOMEM;
7614 }
7615
7616 for (i=0; i<numlines; i++) {
7617 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7618 fill_port_2(&(ports[i]), qlines[i]);
7619 }
7620 }
7621
7622 file_lines_free(qlines);
7623
7624 *returned = numlines;
7625
7626 /* check the required size. */
7627 for (i=0; i<*returned; i++) {
7628 DEBUGADD(6,("adding port [%d]'s size\n", i));
7629 *needed += spoolss_size_port_info_2(&ports[i]);
7630 }
7631
7632 if (*needed > offered) {
7633 result = WERR_INSUFFICIENT_BUFFER;
7634 goto out;
7635 }
7636
7637 if (!rpcbuf_alloc_size(buffer, *needed)) {
7638 result = WERR_NOMEM;
7639 goto out;
7640 }
7641
7642 /* fill the buffer with the ports structures */
7643 for (i=0; i<*returned; i++) {
7644 DEBUGADD(6,("adding port [%d] to buffer\n", i));
7645 smb_io_port_2("", buffer, &ports[i], 0);
7646 }
7647
7648 out:
7649 SAFE_FREE(ports);
7650
7651 if ( !W_ERROR_IS_OK(result) )
7652 *returned = 0;
7653
7654 return result;
7655 }
7656
7657 /****************************************************************************
7658 enumports.
7659 ****************************************************************************/
7660
7661 WERROR _spoolss_enumports( pipes_struct *p, SPOOL_Q_ENUMPORTS *q_u, SPOOL_R_ENUMPORTS *r_u)
7662 {
7663 uint32 level = q_u->level;
7664 RPC_BUFFER *buffer = NULL;
7665 uint32 offered = q_u->offered;
7666 uint32 *needed = &r_u->needed;
7667 uint32 *returned = &r_u->returned;
7668
7669 /* that's an [in out] buffer */
7670
7671 if (!q_u->buffer && (offered!=0)) {
7672 return WERR_INVALID_PARAM;
7673 }
7674
7675 rpcbuf_move(q_u->buffer, &r_u->buffer);
7676 buffer = r_u->buffer;
7677
7678 DEBUG(4,("_spoolss_enumports\n"));
7679
7680 *returned=0;
7681 *needed=0;
7682
7683 switch (level) {
7684 case 1:
7685 return enumports_level_1(buffer, offered, needed, returned);
7686 case 2:
7687 return enumports_level_2(buffer, offered, needed, returned);
7688 default:
7689 return WERR_UNKNOWN_LEVEL;
7690 }
7691 }
7692
7693 /****************************************************************************
7694 ****************************************************************************/
7695
7696 static WERROR spoolss_addprinterex_level_2( pipes_struct *p, const UNISTR2 *uni_srv_name,
7697 const SPOOL_PRINTER_INFO_LEVEL *info,
7698 DEVICEMODE *devmode, SEC_DESC_BUF *sec_desc_buf,
7699 uint32 user_switch, const SPOOL_USER_CTR *user,
7700 POLICY_HND *handle)
7701 {
7702 NT_PRINTER_INFO_LEVEL *printer = NULL;
7703 fstring name;
7704 int snum;
7705 WERROR err = WERR_OK;
7706
7707 if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7708 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7709 return WERR_NOMEM;
7710 }
7711
7712 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7713 if (!convert_printer_info(info, printer, 2)) {
7714 free_a_printer(&printer, 2);
7715 return WERR_NOMEM;
7716 }
7717
7718 /* check to see if the printer already exists */
7719
7720 if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7721 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7722 printer->info_2->sharename));
7723 free_a_printer(&printer, 2);
7724 return WERR_PRINTER_ALREADY_EXISTS;
7725 }
7726
7727 /* FIXME!!! smbd should check to see if the driver is installed before
7728 trying to add a printer like this --jerry */
7729
7730 if (*lp_addprinter_cmd() ) {
7731 if ( !add_printer_hook(p->mem_ctx, p->pipe_user.nt_user_token, printer) ) {
7732 free_a_printer(&printer,2);
7733 return WERR_ACCESS_DENIED;
7734 }
7735 } else {
7736 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7737 "smb.conf parameter \"addprinter command\" is defined. This"
7738 "parameter must exist for this call to succeed\n",
7739 printer->info_2->sharename ));
7740 }
7741
7742 /* use our primary netbios name since get_a_printer() will convert
7743 it to what the client expects on a case by case basis */
7744
7745 slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7746 printer->info_2->sharename);
7747
7748
7749 if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7750 free_a_printer(&printer,2);
7751 return WERR_ACCESS_DENIED;
7752 }
7753
7754 /* you must be a printer admin to add a new printer */
7755 if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
7756 free_a_printer(&printer,2);
7757 return WERR_ACCESS_DENIED;
7758 }
7759
7760 /*
7761 * Do sanity check on the requested changes for Samba.
7762 */
7763
7764 if (!check_printer_ok(printer->info_2, snum)) {
7765 free_a_printer(&printer,2);
7766 return WERR_INVALID_PARAM;
7767 }
7768
7769 /*
7770 * When a printer is created, the drivername bound to the printer is used
7771 * to lookup previously saved driver initialization info, which is then
7772 * bound to the new printer, simulating what happens in the Windows arch.
7773 */
7774
7775 if (!devmode)
7776 {
7777 set_driver_init(printer, 2);
7778 }
7779 else
7780 {
7781 /* A valid devmode was included, convert and link it
7782 */
7783 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7784
7785 if (!convert_devicemode(printer->info_2->printername, devmode,
7786 &printer->info_2->devmode))
7787 return WERR_NOMEM;
7788 }
7789
7790 /* write the ASCII on disk */
7791 err = mod_a_printer(printer, 2);
7792 if (!W_ERROR_IS_OK(err)) {
7793 free_a_printer(&printer,2);
7794 return err;
7795 }
7796
7797 if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7798 /* Handle open failed - remove addition. */
7799 del_a_printer(printer->info_2->sharename);
7800 free_a_printer(&printer,2);
7801 return WERR_ACCESS_DENIED;
7802 }
7803
7804 update_c_setprinter(False);
7805 free_a_printer(&printer,2);
7806
7807 return WERR_OK;
7808 }
7809
7810 /****************************************************************************
7811 ****************************************************************************/
7812
7813 WERROR _spoolss_addprinterex( pipes_struct *p, SPOOL_Q_ADDPRINTEREX *q_u, SPOOL_R_ADDPRINTEREX *r_u)
7814 {
7815 UNISTR2 *uni_srv_name = q_u->server_name;
7816 uint32 level = q_u->level;
7817 SPOOL_PRINTER_INFO_LEVEL *info = &q_u->info;
7818 DEVICEMODE *devmode = q_u->devmode_ctr.devmode;
7819 SEC_DESC_BUF *sdb = q_u->secdesc_ctr;
7820 uint32 user_switch = q_u->user_switch;
7821 SPOOL_USER_CTR *user = &q_u->user_ctr;
7822 POLICY_HND *handle = &r_u->handle;
7823
7824 switch (level) {
7825 case 1:
7826 /* we don't handle yet */
7827 /* but I know what to do ... */
7828 return WERR_UNKNOWN_LEVEL;
7829 case 2:
7830 return spoolss_addprinterex_level_2(p, uni_srv_name, info,
7831 devmode, sdb,
7832 user_switch, user, handle);
7833 default:
7834 return WERR_UNKNOWN_LEVEL;
7835 }
7836 }
7837
7838 /****************************************************************************
7839 ****************************************************************************/
7840
7841 WERROR _spoolss_addprinterdriver(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVER *q_u, SPOOL_R_ADDPRINTERDRIVER *r_u)
7842 {
7843 uint32 level = q_u->level;
7844 SPOOL_PRINTER_DRIVER_INFO_LEVEL *info = &q_u->info;
7845 WERROR err = WERR_OK;
7846 NT_PRINTER_DRIVER_INFO_LEVEL driver;
7847 fstring driver_name;
7848 uint32 version;
7849
7850 ZERO_STRUCT(driver);
7851
7852 if (!convert_printer_driver_info(info, &driver, level)) {
7853 err = WERR_NOMEM;
7854 goto done;
7855 }
7856
7857 DEBUG(5,("Cleaning driver's information\n"));
7858 err = clean_up_driver_struct(driver, level, &p->pipe_user);
7859 if (!W_ERROR_IS_OK(err))
7860 goto done;
7861
7862 DEBUG(5,("Moving driver to final destination\n"));
7863 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(driver, level, &p->pipe_user, &err)) ) {
7864 goto done;
7865 }
7866
7867 if (add_a_printer_driver(driver, level)!=0) {
7868 err = WERR_ACCESS_DENIED;
7869 goto done;
7870 }
7871
7872 switch(level) {
7873 case 3:
7874 fstrcpy(driver_name,
7875 driver.info_3->name ? driver.info_3->name : "");
7876 break;
7877 case 6:
7878 fstrcpy(driver_name,
7879 driver.info_6->name ? driver.info_6->name : "");
7880 break;
7881 }
7882
7883 /*
7884 * I think this is where he DrvUpgradePrinter() hook would be
7885 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7886 * server. Right now, we just need to send ourselves a message
7887 * to update each printer bound to this driver. --jerry
7888 */
7889
7890 if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7891 DEBUG(0,("_spoolss_addprinterdriver: Failed to send message about upgrading driver [%s]!\n",
7892 driver_name));
7893 }
7894
7895 /*
7896 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7897 * decide if the driver init data should be deleted. The rules are:
7898 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7899 * 2) delete init data only if there is no 2k/Xp driver
7900 * 3) always delete init data
7901 * The generalized rule is always use init data from the highest order driver.
7902 * It is necessary to follow the driver install by an initialization step to
7903 * finish off this process.
7904 */
7905 if (level == 3)
7906 version = driver.info_3->cversion;
7907 else if (level == 6)
7908 version = driver.info_6->version;
7909 else
7910 version = -1;
7911 switch (version) {
7912 /*
7913 * 9x printer driver - never delete init data
7914 */
7915 case 0:
7916 DEBUG(10,("_spoolss_addprinterdriver: init data not deleted for 9x driver [%s]\n",
7917 driver_name));
7918 break;
7919
7920 /*
7921 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7922 * there is no 2k/Xp driver init data for this driver name.
7923 */
7924 case 2:
7925 {
7926 NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7927
7928 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7929 /*
7930 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7931 */
7932 if (!del_driver_init(driver_name))
7933 DEBUG(6,("_spoolss_addprinterdriver: del_driver_init(%s) Nt failed!\n", driver_name));
7934 } else {
7935 /*
7936 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7937 */
7938 free_a_printer_driver(driver1,3);
7939 DEBUG(10,("_spoolss_addprinterdriver: init data not deleted for Nt driver [%s]\n",
7940 driver_name));
7941 }
7942 }
7943 break;
7944
7945 /*
7946 * 2k or Xp printer driver - always delete init data
7947 */
7948 case 3:
7949 if (!del_driver_init(driver_name))
7950 DEBUG(6,("_spoolss_addprinterdriver: del_driver_init(%s) 2k/Xp failed!\n", driver_name));
7951 break;
7952
7953 default:
7954 DEBUG(0,("_spoolss_addprinterdriver: invalid level=%d\n", level));
7955 break;
7956 }
7957
7958
7959 done:
7960 free_a_printer_driver(driver, level);
7961 return err;
7962 }
7963
7964 /********************************************************************
7965 * spoolss_addprinterdriverex
7966 ********************************************************************/
7967
7968 WERROR _spoolss_addprinterdriverex(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVEREX *q_u, SPOOL_R_ADDPRINTERDRIVEREX *r_u)
7969 {
7970 SPOOL_Q_ADDPRINTERDRIVER q_u_local;
7971 SPOOL_R_ADDPRINTERDRIVER r_u_local;
7972
7973 /*
7974 * we only support the semantics of AddPrinterDriver()
7975 * i.e. only copy files that are newer than existing ones
7976 */
7977
7978 if ( q_u->copy_flags != APD_COPY_NEW_FILES )
7979 return WERR_ACCESS_DENIED;
7980
7981 ZERO_STRUCT(q_u_local);
7982 ZERO_STRUCT(r_u_local);
7983
7984 /* just pass the information off to _spoolss_addprinterdriver() */
7985 q_u_local.server_name_ptr = q_u->server_name_ptr;
7986 copy_unistr2(&q_u_local.server_name, &q_u->server_name);
7987 q_u_local.level = q_u->level;
7988 memcpy( &q_u_local.info, &q_u->info, sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL) );
7989
7990 return _spoolss_addprinterdriver( p, &q_u_local, &r_u_local );
7991 }
7992
7993 /****************************************************************************
7994 ****************************************************************************/
7995
7996 static void fill_driverdir_1(DRIVER_DIRECTORY_1 *info, char *name)
7997 {
7998 init_unistr(&info->name, name);
7999 }
8000
8001 /****************************************************************************
8002 ****************************************************************************/
8003
8004 static WERROR getprinterdriverdir_level_1(UNISTR2 *name, UNISTR2 *uni_environment, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
8005 {
8006 char *path = NULL;
8007 char *long_archi = NULL;
8008 char *servername = NULL;
8009 const char *pservername = NULL;
8010 const char *short_archi;
8011 DRIVER_DIRECTORY_1 *info=NULL;
8012 WERROR result = WERR_OK;
8013 TALLOC_CTX *ctx = talloc_tos();
8014
8015 servername = unistr2_to_ascii_talloc(ctx, name);
8016 if (!servername) {
8017 return WERR_NOMEM;
8018 }
8019 long_archi = unistr2_to_ascii_talloc(ctx, uni_environment);
8020 if (!long_archi) {
8021 return WERR_NOMEM;
8022 }
8023
8024 pservername = canon_servername(servername);
8025
8026 if ( !is_myname_or_ipaddr(pservername))
8027 return WERR_INVALID_PARAM;
8028
8029 if (!(short_archi = get_short_archi(long_archi)))
8030 return WERR_INVALID_ENVIRONMENT;
8031
8032 if((info=SMB_MALLOC_P(DRIVER_DIRECTORY_1)) == NULL)
8033 return WERR_NOMEM;
8034
8035 path = talloc_asprintf(ctx,
8036 "\\\\%s\\print$\\%s", pservername, short_archi);
8037 if (!path) {
8038 result = WERR_NOMEM;
8039 goto out;
8040 }
8041
8042 DEBUG(4,("printer driver directory: [%s]\n", path));
8043
8044 fill_driverdir_1(info, path);
8045
8046 *needed += spoolss_size_driverdir_info_1(info);
8047
8048 if (*needed > offered) {
8049 result = WERR_INSUFFICIENT_BUFFER;
8050 goto out;
8051 }
8052
8053 if (!rpcbuf_alloc_size(buffer, *needed)) {
8054 result = WERR_NOMEM;
8055 goto out;
8056 }
8057
8058 smb_io_driverdir_1("", buffer, info, 0);
8059
8060 out:
8061 SAFE_FREE(info);
8062
8063 return result;
8064 }
8065
8066 /****************************************************************************
8067 ****************************************************************************/
8068
8069 WERROR _spoolss_getprinterdriverdirectory(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, SPOOL_R_GETPRINTERDRIVERDIR *r_u)
8070 {
8071 UNISTR2 *name = &q_u->name;
8072 UNISTR2 *uni_environment = &q_u->environment;
8073 uint32 level = q_u->level;
8074 RPC_BUFFER *buffer = NULL;
8075 uint32 offered = q_u->offered;
8076 uint32 *needed = &r_u->needed;
8077
8078 /* that's an [in out] buffer */
8079
8080 if (!q_u->buffer && (offered!=0)) {
8081 return WERR_INVALID_PARAM;
8082 }
8083
8084 rpcbuf_move(q_u->buffer, &r_u->buffer);
8085 buffer = r_u->buffer;
8086
8087 DEBUG(4,("_spoolss_getprinterdriverdirectory\n"));
8088
8089 *needed=0;
8090
8091 switch(level) {
8092 case 1:
8093 return getprinterdriverdir_level_1(name, uni_environment, buffer, offered, needed);
8094 default:
8095 return WERR_UNKNOWN_LEVEL;
8096 }
8097 }
8098
8099 /****************************************************************************
8100 ****************************************************************************/
8101
8102 WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, SPOOL_R_ENUMPRINTERDATA *r_u)
8103 {
8104 POLICY_HND *handle = &q_u->handle;
8105 uint32 idx = q_u->index;
8106 uint32 in_value_len = q_u->valuesize;
8107 uint32 in_data_len = q_u->datasize;
8108 uint32 *out_max_value_len = &r_u->valuesize;
8109 uint16 **out_value = &r_u->value;
8110 uint32 *out_value_len = &r_u->realvaluesize;
8111 uint32 *out_type = &r_u->type;
8112 uint32 *out_max_data_len = &r_u->datasize;
8113 uint8 **data_out = &r_u->data;
8114 uint32 *out_data_len = &r_u->realdatasize;
8115
8116 NT_PRINTER_INFO_LEVEL *printer = NULL;
8117
8118 uint32 biggest_valuesize;
8119 uint32 biggest_datasize;
8120 uint32 data_len;
8121 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
8122 int snum;
8123 WERROR result;
8124 REGISTRY_VALUE *val = NULL;
8125 NT_PRINTER_DATA *p_data;
8126 int i, key_index, num_values;
8127 int name_length;
8128
8129 *out_type = 0;
8130
8131 *out_max_data_len = 0;
8132 *data_out = NULL;
8133 *out_data_len = 0;
8134
8135 DEBUG(5,("spoolss_enumprinterdata\n"));
8136
8137 if (!Printer) {
8138 DEBUG(2,("_spoolss_enumprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8139 return WERR_BADFID;
8140 }
8141
8142 if (!get_printer_snum(p,handle, &snum, NULL))
8143 return WERR_BADFID;
8144
8145 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8146 if (!W_ERROR_IS_OK(result))
8147 return result;
8148
8149 p_data = printer->info_2->data;
8150 key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
8151
8152 result = WERR_OK;
8153
8154 /*
8155 * The NT machine wants to know the biggest size of value and data
8156 *
8157 * cf: MSDN EnumPrinterData remark section
8158 */
8159
8160 if ( !in_value_len && !in_data_len && (key_index != -1) )
8161 {
8162 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8163
8164 biggest_valuesize = 0;
8165 biggest_datasize = 0;
8166
8167 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
8168
8169 for ( i=0; i<num_values; i++ )
8170 {
8171 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
8172
8173 name_length = strlen(val->valuename);
8174 if ( strlen(val->valuename) > biggest_valuesize )
8175 biggest_valuesize = name_length;
8176
8177 if ( val->size > biggest_datasize )
8178 biggest_datasize = val->size;
8179
8180 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8181 biggest_datasize));
8182 }
8183
8184 /* the value is an UNICODE string but real_value_size is the length
8185 in bytes including the trailing 0 */
8186
8187 *out_value_len = 2 * (1+biggest_valuesize);
8188 *out_data_len = biggest_datasize;
8189
8190 DEBUG(6,("final values: [%d], [%d]\n", *out_value_len, *out_data_len));
8191
8192 goto done;
8193 }
8194
8195 /*
8196 * the value len is wrong in NT sp3
8197 * that's the number of bytes not the number of unicode chars
8198 */
8199
8200 if ( key_index != -1 )
8201 val = regval_ctr_specific_value( p_data->keys[key_index].values, idx );
8202
8203 if ( !val )
8204 {
8205
8206 /* out_value should default to "" or else NT4 has
8207 problems unmarshalling the response */
8208
8209 *out_max_value_len=(in_value_len/sizeof(uint16));
8210
8211 if (in_value_len) {
8212 if((*out_value=(uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL)
8213 {
8214 result = WERR_NOMEM;
8215 goto done;
8216 }
8217 *out_value_len = (uint32)rpcstr_push((char *)*out_value, "", in_value_len, 0);
8218 } else {
8219 *out_value=NULL;
8220 *out_value_len = 0;
8221 }
8222
8223 /* the data is counted in bytes */
8224
8225 *out_max_data_len = in_data_len;
8226 *out_data_len = in_data_len;
8227
8228 /* only allocate when given a non-zero data_len */
8229
8230 if ( in_data_len && ((*data_out=(uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL) )
8231 {
8232 result = WERR_NOMEM;
8233 goto done;
8234 }
8235
8236 result = WERR_NO_MORE_ITEMS;
8237 }
8238 else
8239 {
8240 /*
8241 * the value is:
8242 * - counted in bytes in the request
8243 * - counted in UNICODE chars in the max reply
8244 * - counted in bytes in the real size
8245 *
8246 * take a pause *before* coding not *during* coding
8247 */
8248
8249 /* name */
8250 *out_max_value_len=(in_value_len/sizeof(uint16));
8251 if (in_value_len) {
8252 if ( (*out_value = (uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL )
8253 {
8254 result = WERR_NOMEM;
8255 goto done;
8256 }
8257
8258 *out_value_len = (uint32)rpcstr_push((char *)*out_value, regval_name(val), (size_t)in_value_len, 0);
8259 } else {
8260 *out_value = NULL;
8261 *out_value_len = 0;
8262 }
8263
8264 /* type */
8265
8266 *out_type = regval_type( val );
8267
8268 /* data - counted in bytes */
8269
8270 *out_max_data_len = in_data_len;
8271 if ( in_data_len && (*data_out = (uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL)
8272 {
8273 result = WERR_NOMEM;
8274 goto done;
8275 }
8276 data_len = regval_size(val);
8277 if ( *data_out && data_len )
8278 memcpy( *data_out, regval_data_p(val), data_len );
8279 *out_data_len = data_len;
8280 }
8281
8282 done:
8283 free_a_printer(&printer, 2);
8284 return result;
8285 }
8286
8287 /****************************************************************************
8288 ****************************************************************************/
8289
8290 WERROR _spoolss_setprinterdata( pipes_struct *p, SPOOL_Q_SETPRINTERDATA *q_u, SPOOL_R_SETPRINTERDATA *r_u)
8291 {
8292 POLICY_HND *handle = &q_u->handle;
8293 UNISTR2 *value = &q_u->value;
8294 uint32 type = q_u->type;
8295 uint8 *data = q_u->data;
8296 uint32 real_len = q_u->real_len;
8297
8298 NT_PRINTER_INFO_LEVEL *printer = NULL;
8299 int snum=0;
8300 WERROR status = WERR_OK;
8301 Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
8302 fstring valuename;
8303
8304 DEBUG(5,("spoolss_setprinterdata\n"));
8305
8306 if (!Printer) {
8307 DEBUG(2,("_spoolss_setprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8308 return WERR_BADFID;
8309 }
8310
8311 if ( Printer->printer_type == SPLHND_SERVER ) {
8312 DEBUG(10,("_spoolss_setprinterdata: Not implemented for server handles yet\n"));
8313 return WERR_INVALID_PARAM;
8314 }
8315
8316 if (!get_printer_snum(p,handle, &snum, NULL))
8317 return WERR_BADFID;
8318
8319 /*
8320 * Access check : NT returns "access denied" if you make a
8321 * SetPrinterData call without the necessary privildge.
8322 * we were originally returning OK if nothing changed
8323 * which made Win2k issue **a lot** of SetPrinterData
8324 * when connecting to a printer --jerry
8325 */
8326
8327 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER)
8328 {
8329 DEBUG(3, ("_spoolss_setprinterdata: change denied by handle access permissions\n"));
8330 status = WERR_ACCESS_DENIED;
8331 goto done;
8332 }
8333
8334 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8335 if (!W_ERROR_IS_OK(status))
8336 return status;
8337
8338 unistr2_to_ascii(valuename, value, sizeof(valuename));
8339
8340 /*
8341 * When client side code sets a magic printer data key, detect it and save
8342 * the current printer data and the magic key's data (its the DEVMODE) for
8343 * future printer/driver initializations.
8344 */
8345 if ( (type == REG_BINARY) && strequal( valuename, PHANTOM_DEVMODE_KEY))
8346 {
8347 /* Set devmode and printer initialization info */
8348 status = save_driver_init( printer, 2, data, real_len );
8349
8350 srv_spoolss_reset_printerdata( printer->info_2->drivername );
8351 }
8352 else
8353 {
8354 status = set_printer_dataex( printer, SPOOL_PRINTERDATA_KEY, valuename,
8355 type, data, real_len );
8356 if ( W_ERROR_IS_OK(status) )
8357 status = mod_a_printer(printer, 2);
8358 }
8359
8360 done:
8361 free_a_printer(&printer, 2);
8362
8363 return status;
8364 }
8365
8366 /****************************************************************************
8367 ****************************************************************************/
8368
8369 WERROR _spoolss_resetprinter(pipes_struct *p, SPOOL_Q_RESETPRINTER *q_u, SPOOL_R_RESETPRINTER *r_u)
8370 {
8371 POLICY_HND *handle = &q_u->handle;
8372 Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
8373 int snum;
8374
8375 DEBUG(5,("_spoolss_resetprinter\n"));
8376
8377 /*
8378 * All we do is to check to see if the handle and queue is valid.
8379 * This call really doesn't mean anything to us because we only
8380 * support RAW printing. --jerry
8381 */
8382
8383 if (!Printer) {
8384 DEBUG(2,("_spoolss_resetprinter: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8385 return WERR_BADFID;
8386 }
8387
8388 if (!get_printer_snum(p,handle, &snum, NULL))
8389 return WERR_BADFID;
8390
8391
8392 /* blindly return success */
8393 return WERR_OK;
8394 }
8395
8396
8397 /****************************************************************************
8398 ****************************************************************************/
8399
8400 WERROR _spoolss_deleteprinterdata(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATA *q_u, SPOOL_R_DELETEPRINTERDATA *r_u)
8401 {
8402 POLICY_HND *handle = &q_u->handle;
8403 UNISTR2 *value = &q_u->valuename;
8404
8405 NT_PRINTER_INFO_LEVEL *printer = NULL;
8406 int snum=0;
8407 WERROR status = WERR_OK;
8408 Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
8409 char *valuename = NULL;
8410 TALLOC_CTX *ctx = p->mem_ctx;
8411
8412 DEBUG(5,("spoolss_deleteprinterdata\n"));
8413
8414 if (!Printer) {
8415 DEBUG(2,("_spoolss_deleteprinterdata: 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 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8423 DEBUG(3, ("_spoolss_deleteprinterdata: printer properties change denied by handle\n"));
8424 return WERR_ACCESS_DENIED;
8425 }
8426
8427 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8428 if (!W_ERROR_IS_OK(status))
8429 return status;
8430
8431 valuename = unistr2_to_ascii_talloc(ctx, value);
8432 if (!valuename) {
8433 free_a_printer(&printer, 2);
8434 return WERR_NOMEM;
8435 }
8436
8437 status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY, valuename );
8438
8439 if ( W_ERROR_IS_OK(status) )
8440 mod_a_printer( printer, 2 );
8441
8442 free_a_printer(&printer, 2);
8443 TALLOC_FREE(valuename);
8444
8445 return status;
8446 }
8447
8448 /****************************************************************************
8449 ****************************************************************************/
8450
8451 WERROR _spoolss_addform( pipes_struct *p, SPOOL_Q_ADDFORM *q_u, SPOOL_R_ADDFORM *r_u)
8452 {
8453 POLICY_HND *handle = &q_u->handle;
8454 FORM *form = &q_u->form;
8455 nt_forms_struct tmpForm;
8456 int snum;
8457 WERROR status = WERR_OK;
8458 NT_PRINTER_INFO_LEVEL *printer = NULL;
8459
8460 int count=0;
8461 nt_forms_struct *list=NULL;
8462 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
8463
8464 DEBUG(5,("spoolss_addform\n"));
8465
8466 if (!Printer) {
8467 DEBUG(2,("_spoolss_addform: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8468 return WERR_BADFID;
8469 }
8470
8471
8472 /* forms can be added on printer of on the print server handle */
8473
8474 if ( Printer->printer_type == SPLHND_PRINTER )
8475 {
8476 if (!get_printer_snum(p,handle, &snum, NULL))
8477 return WERR_BADFID;
8478
8479 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8480 if (!W_ERROR_IS_OK(status))
8481 goto done;
8482 }
8483
8484 if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
8485 DEBUG(2,("_spoolss_addform: denied by handle permissions.\n"));
8486 status = WERR_ACCESS_DENIED;
8487 goto done;
8488 }
8489
8490 /* can't add if builtin */
8491
8492 if (get_a_builtin_ntform(&form->name,&tmpForm)) {
8493 status = WERR_ALREADY_EXISTS;
8494 goto done;
8495 }
8496
8497 count = get_ntforms(&list);
8498
8499 if(!add_a_form(&list, form, &count)) {
8500 status = WERR_NOMEM;
8501 goto done;
8502 }
8503
8504 write_ntforms(&list, count);
8505
8506 /*
8507 * ChangeID must always be set if this is a printer
8508 */
8509
8510 if ( Printer->printer_type == SPLHND_PRINTER )
8511 status = mod_a_printer(printer, 2);
8512
8513 done:
8514 if ( printer )
8515 free_a_printer(&printer, 2);
8516 SAFE_FREE(list);
8517
8518 return status;
8519 }
8520
8521 /****************************************************************************
8522 ****************************************************************************/
8523
8524 WERROR _spoolss_deleteform( pipes_struct *p, SPOOL_Q_DELETEFORM *q_u, SPOOL_R_DELETEFORM *r_u)
8525 {
8526 POLICY_HND *handle = &q_u->handle;
8527 UNISTR2 *form_name = &q_u->name;
8528 nt_forms_struct tmpForm;
8529 int count=0;
8530 nt_forms_struct *list=NULL;
8531 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
8532 int snum;
8533 WERROR status = WERR_OK;
8534 NT_PRINTER_INFO_LEVEL *printer = NULL;
8535
8536 DEBUG(5,("spoolss_deleteform\n"));
8537
8538 if (!Printer) {
8539 DEBUG(2,("_spoolss_deleteform: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8540 return WERR_BADFID;
8541 }
8542
8543 /* forms can be deleted on printer of on the print server handle */
8544
8545 if ( Printer->printer_type == SPLHND_PRINTER )
8546 {
8547 if (!get_printer_snum(p,handle, &snum, NULL))
8548 return WERR_BADFID;
8549
8550 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8551 if (!W_ERROR_IS_OK(status))
8552 goto done;
8553 }
8554
8555 if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
8556 DEBUG(2,("_spoolss_deleteform: denied by handle permissions.\n"));
8557 status = WERR_ACCESS_DENIED;
8558 goto done;
8559 }
8560
8561 /* can't delete if builtin */
8562
8563 if (get_a_builtin_ntform(form_name,&tmpForm)) {
8564 status = WERR_INVALID_PARAM;
8565 goto done;
8566 }
8567
8568 count = get_ntforms(&list);
8569
8570 if ( !delete_a_form(&list, form_name, &count, &status ))
8571 goto done;
8572
8573 /*
8574 * ChangeID must always be set if this is a printer
8575 */
8576
8577 if ( Printer->printer_type == SPLHND_PRINTER )
8578 status = mod_a_printer(printer, 2);
8579
8580 done:
8581 if ( printer )
8582 free_a_printer(&printer, 2);
8583 SAFE_FREE(list);
8584
8585 return status;
8586 }
8587
8588 /****************************************************************************
8589 ****************************************************************************/
8590
8591 WERROR _spoolss_setform(pipes_struct *p, SPOOL_Q_SETFORM *q_u, SPOOL_R_SETFORM *r_u)
8592 {
8593 POLICY_HND *handle = &q_u->handle;
8594 FORM *form = &q_u->form;
8595 nt_forms_struct tmpForm;
8596 int snum;
8597 WERROR status = WERR_OK;
8598 NT_PRINTER_INFO_LEVEL *printer = NULL;
8599
8600 int count=0;
8601 nt_forms_struct *list=NULL;
8602 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
8603
8604 DEBUG(5,("spoolss_setform\n"));
8605
8606 if (!Printer) {
8607 DEBUG(2,("_spoolss_setform: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
8608 return WERR_BADFID;
8609 }
8610
8611 /* forms can be modified on printer of on the print server handle */
8612
8613 if ( Printer->printer_type == SPLHND_PRINTER )
8614 {
8615 if (!get_printer_snum(p,handle, &snum, NULL))
8616 return WERR_BADFID;
8617
8618 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8619 if (!W_ERROR_IS_OK(status))
8620 goto done;
8621 }
8622
8623 if ( !(Printer->access_granted & (PRINTER_ACCESS_ADMINISTER|SERVER_ACCESS_ADMINISTER)) ) {
8624 DEBUG(2,("_spoolss_setform: denied by handle permissions\n"));
8625 status = WERR_ACCESS_DENIED;
8626 goto done;
8627 }
8628
8629 /* can't set if builtin */
8630 if (get_a_builtin_ntform(&form->name,&tmpForm)) {
8631 status = WERR_INVALID_PARAM;
8632 goto done;
8633 }
8634
8635 count = get_ntforms(&list);
8636 update_a_form(&list, form, count);
8637 write_ntforms(&list, count);
8638
8639 /*
8640 * ChangeID must always be set if this is a printer
8641 */
8642
8643 if ( Printer->printer_type == SPLHND_PRINTER )
8644 status = mod_a_printer(printer, 2);
8645
8646
8647 done:
8648 if ( printer )
8649 free_a_printer(&printer, 2);
8650 SAFE_FREE(list);
8651
8652 return status;
8653 }
8654
8655 /****************************************************************************
8656 enumprintprocessors level 1.
8657 ****************************************************************************/
8658
8659 static WERROR enumprintprocessors_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8660 {
8661 PRINTPROCESSOR_1 *info_1=NULL;
8662 WERROR result = WERR_OK;
8663
8664 if((info_1 = SMB_MALLOC_P(PRINTPROCESSOR_1)) == NULL)
8665 return WERR_NOMEM;
8666
8667 (*returned) = 0x1;
8668
8669 init_unistr(&info_1->name, "winprint");
8670
8671 *needed += spoolss_size_printprocessor_info_1(info_1);
8672
8673 if (*needed > offered) {
8674 result = WERR_INSUFFICIENT_BUFFER;
8675 goto out;
8676 }
8677
8678 if (!rpcbuf_alloc_size(buffer, *needed)) {
8679 result = WERR_NOMEM;
8680 goto out;
8681 }
8682
8683 smb_io_printprocessor_info_1("", buffer, info_1, 0);
8684
8685 out:
8686 SAFE_FREE(info_1);
8687
8688 if ( !W_ERROR_IS_OK(result) )
8689 *returned = 0;
8690
8691 return result;
8692 }
8693
8694 /****************************************************************************
8695 ****************************************************************************/
8696
8697 WERROR _spoolss_enumprintprocessors(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, SPOOL_R_ENUMPRINTPROCESSORS *r_u)
8698 {
8699 uint32 level = q_u->level;
8700 RPC_BUFFER *buffer = NULL;
8701 uint32 offered = q_u->offered;
8702 uint32 *needed = &r_u->needed;
8703 uint32 *returned = &r_u->returned;
8704
8705 /* that's an [in out] buffer */
8706
8707 if (!q_u->buffer && (offered!=0)) {
8708 return WERR_INVALID_PARAM;
8709 }
8710
8711 rpcbuf_move(q_u->buffer, &r_u->buffer);
8712 buffer = r_u->buffer;
8713
8714 DEBUG(5,("spoolss_enumprintprocessors\n"));
8715
8716 /*
8717 * Enumerate the print processors ...
8718 *
8719 * Just reply with "winprint", to keep NT happy
8720 * and I can use my nice printer checker.
8721 */
8722
8723 *returned=0;
8724 *needed=0;
8725
8726 switch (level) {
8727 case 1:
8728 return enumprintprocessors_level_1(buffer, offered, needed, returned);
8729 default:
8730 return WERR_UNKNOWN_LEVEL;
8731 }
8732 }
8733
8734 /****************************************************************************
8735 enumprintprocdatatypes level 1.
8736 ****************************************************************************/
8737
8738 static WERROR enumprintprocdatatypes_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8739 {
8740 PRINTPROCDATATYPE_1 *info_1=NULL;
8741 WERROR result = WERR_OK;
8742
8743 if((info_1 = SMB_MALLOC_P(PRINTPROCDATATYPE_1)) == NULL)
8744 return WERR_NOMEM;
8745
8746 (*returned) = 0x1;
8747
8748 init_unistr(&info_1->name, "RAW");
8749
8750 *needed += spoolss_size_printprocdatatype_info_1(info_1);
8751
8752 if (*needed > offered) {
8753 result = WERR_INSUFFICIENT_BUFFER;
8754 goto out;
8755 }
8756
8757 if (!rpcbuf_alloc_size(buffer, *needed)) {
8758 result = WERR_NOMEM;
8759 goto out;
8760 }
8761
8762 smb_io_printprocdatatype_info_1("", buffer, info_1, 0);
8763
8764 out:
8765 SAFE_FREE(info_1);
8766
8767 if ( !W_ERROR_IS_OK(result) )
8768 *returned = 0;
8769
8770 return result;
8771 }
8772
8773 /****************************************************************************
8774 ****************************************************************************/
8775
8776 WERROR _spoolss_enumprintprocdatatypes(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u)
8777 {
8778 uint32 level = q_u->level;
8779 RPC_BUFFER *buffer = NULL;
8780 uint32 offered = q_u->offered;
8781 uint32 *needed = &r_u->needed;
8782 uint32 *returned = &r_u->returned;
8783
8784 /* that's an [in out] buffer */
8785
8786 if (!q_u->buffer && (offered!=0)) {
8787 return WERR_INVALID_PARAM;
8788 }
8789
8790 rpcbuf_move(q_u->buffer, &r_u->buffer);
8791 buffer = r_u->buffer;
8792
8793 DEBUG(5,("_spoolss_enumprintprocdatatypes\n"));
8794
8795 *returned=0;
8796 *needed=0;
8797
8798 switch (level) {
8799 case 1:
8800 return enumprintprocdatatypes_level_1(buffer, offered, needed, returned);
8801 default:
8802 return WERR_UNKNOWN_LEVEL;
8803 }
8804 }
8805
8806 /****************************************************************************
8807 enumprintmonitors level 1.
8808 ****************************************************************************/
8809
8810 static WERROR enumprintmonitors_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8811 {
8812 PRINTMONITOR_1 *info_1;
8813 WERROR result = WERR_OK;
8814 int i;
8815
8816 if((info_1 = SMB_MALLOC_ARRAY(PRINTMONITOR_1, 2)) == NULL)
8817 return WERR_NOMEM;
8818
8819 *returned = 2;
8820
8821 init_unistr(&(info_1[0].name), SPL_LOCAL_PORT );
8822 init_unistr(&(info_1[1].name), SPL_TCPIP_PORT );
8823
8824 for ( i=0; i<*returned; i++ ) {
8825 *needed += spoolss_size_printmonitor_info_1(&info_1[i]);
8826 }
8827
8828 if (*needed > offered) {
8829 result = WERR_INSUFFICIENT_BUFFER;
8830 goto out;
8831 }
8832
8833 if (!rpcbuf_alloc_size(buffer, *needed)) {
8834 result = WERR_NOMEM;
8835 goto out;
8836 }
8837
8838 for ( i=0; i<*returned; i++ ) {
8839 smb_io_printmonitor_info_1("", buffer, &info_1[i], 0);
8840 }
8841
8842 out:
8843 SAFE_FREE(info_1);
8844
8845 if ( !W_ERROR_IS_OK(result) )
8846 *returned = 0;
8847
8848 return result;
8849 }
8850
8851 /****************************************************************************
8852 enumprintmonitors level 2.
8853 ****************************************************************************/
8854
8855 static WERROR enumprintmonitors_level_2(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
8856 {
8857 PRINTMONITOR_2 *info_2;
8858 WERROR result = WERR_OK;
8859 int i;
8860
8861 if((info_2 = SMB_MALLOC_ARRAY(PRINTMONITOR_2, 2)) == NULL)
8862 return WERR_NOMEM;
8863
8864 *returned = 2;
8865
8866 init_unistr( &(info_2[0].name), SPL_LOCAL_PORT );
8867 init_unistr( &(info_2[0].environment), "Windows NT X86" );
8868 init_unistr( &(info_2[0].dll_name), "localmon.dll" );
8869
8870 init_unistr( &(info_2[1].name), SPL_TCPIP_PORT );
8871 init_unistr( &(info_2[1].environment), "Windows NT X86" );
8872 init_unistr( &(info_2[1].dll_name), "tcpmon.dll" );
8873
8874 for ( i=0; i<*returned; i++ ) {
8875 *needed += spoolss_size_printmonitor_info_2(&info_2[i]);
8876 }
8877
8878 if (*needed > offered) {
8879 result = WERR_INSUFFICIENT_BUFFER;
8880 goto out;
8881 }
8882
8883 if (!rpcbuf_alloc_size(buffer, *needed)) {
8884 result = WERR_NOMEM;
8885 goto out;
8886 }
8887
8888 for ( i=0; i<*returned; i++ ) {
8889 smb_io_printmonitor_info_2("", buffer, &info_2[i], 0);
8890 }
8891
8892 out:
8893 SAFE_FREE(info_2);
8894
8895 if ( !W_ERROR_IS_OK(result) )
8896 *returned = 0;
8897
8898 return result;
8899 }
8900
8901 /****************************************************************************
8902 ****************************************************************************/
8903
8904 WERROR _spoolss_enumprintmonitors(pipes_struct *p, SPOOL_Q_ENUMPRINTMONITORS *q_u, SPOOL_R_ENUMPRINTMONITORS *r_u)
8905 {
8906 uint32 level = q_u->level;
8907 RPC_BUFFER *buffer = NULL;
8908 uint32 offered = q_u->offered;
8909 uint32 *needed = &r_u->needed;
8910 uint32 *returned = &r_u->returned;
8911
8912 /* that's an [in out] buffer */
8913
8914 if (!q_u->buffer && (offered!=0)) {
8915 return WERR_INVALID_PARAM;
8916 }
8917
8918 rpcbuf_move(q_u->buffer, &r_u->buffer);
8919 buffer = r_u->buffer;
8920
8921 DEBUG(5,("spoolss_enumprintmonitors\n"));
8922
8923 /*
8924 * Enumerate the print monitors ...
8925 *
8926 * Just reply with "Local Port", to keep NT happy
8927 * and I can use my nice printer checker.
8928 */
8929
8930 *returned=0;
8931 *needed=0;
8932
8933 switch (level) {
8934 case 1:
8935 return enumprintmonitors_level_1(buffer, offered, needed, returned);
8936 case 2:
8937 return enumprintmonitors_level_2(buffer, offered, needed, returned);
8938 default:
8939 return WERR_UNKNOWN_LEVEL;
8940 }
8941 }
8942
8943 /****************************************************************************
8944 ****************************************************************************/
8945
8946 static WERROR getjob_level_1(print_queue_struct **queue, int count, int snum,
8947 NT_PRINTER_INFO_LEVEL *ntprinter,
8948 uint32 jobid, RPC_BUFFER *buffer, uint32 offered,
8949 uint32 *needed)
8950 {
8951 int i=0;
8952 bool found=False;
8953 JOB_INFO_1 *info_1=NULL;
8954 WERROR result = WERR_OK;
8955
8956 info_1=SMB_MALLOC_P(JOB_INFO_1);
8957
8958 if (info_1 == NULL) {
8959 return WERR_NOMEM;
8960 }
8961
8962 for (i=0; i<count && found==False; i++) {
8963 if ((*queue)[i].job==(int)jobid)
8964 found=True;
8965 }
8966
8967 if (found==False) {
8968 SAFE_FREE(info_1);
8969 /* NT treats not found as bad param... yet another bad choice */
8970 return WERR_INVALID_PARAM;
8971 }
8972
8973 fill_job_info_1( info_1, &((*queue)[i-1]), i, snum, ntprinter );
8974
8975 *needed += spoolss_size_job_info_1(info_1);
8976
8977 if (*needed > offered) {
8978 result = WERR_INSUFFICIENT_BUFFER;
8979 goto out;
8980 }
8981
8982 if (!rpcbuf_alloc_size(buffer, *needed)) {
8983 result = WERR_NOMEM;
8984 goto out;
8985 }
8986
8987 smb_io_job_info_1("", buffer, info_1, 0);
8988
8989 out:
8990 SAFE_FREE(info_1);
8991
8992 return result;
8993 }
8994
8995 /****************************************************************************
8996 ****************************************************************************/
8997
8998 static WERROR getjob_level_2(print_queue_struct **queue, int count, int snum,
8999 NT_PRINTER_INFO_LEVEL *ntprinter,
9000 uint32 jobid, RPC_BUFFER *buffer, uint32 offered,
9001 uint32 *needed)
9002 {
9003 int i = 0;
9004 bool found = False;
9005 JOB_INFO_2 *info_2;
9006 WERROR result;
9007 DEVICEMODE *devmode = NULL;
9008 NT_DEVICEMODE *nt_devmode = NULL;
9009
9010 if ( !(info_2=SMB_MALLOC_P(JOB_INFO_2)) )
9011 return WERR_NOMEM;
9012
9013 ZERO_STRUCTP(info_2);
9014
9015 for ( i=0; i<count && found==False; i++ )
9016 {
9017 if ((*queue)[i].job == (int)jobid)
9018 found = True;
9019 }
9020
9021 if ( !found ) {
9022 /* NT treats not found as bad param... yet another bad
9023 choice */
9024 result = WERR_INVALID_PARAM;
9025 goto done;
9026 }
9027
9028 /*
9029 * if the print job does not have a DEVMODE associated with it,
9030 * just use the one for the printer. A NULL devicemode is not
9031 * a failure condition
9032 */
9033
9034 if ( !(nt_devmode=print_job_devmode( lp_const_servicename(snum), jobid )) )
9035 devmode = construct_dev_mode(lp_const_servicename(snum));
9036 else {
9037 if ((devmode = SMB_MALLOC_P(DEVICEMODE)) != NULL) {
9038 ZERO_STRUCTP( devmode );
9039 convert_nt_devicemode( devmode, nt_devmode );
9040 }
9041 }
9042
9043 fill_job_info_2(info_2, &((*queue)[i-1]), i, snum, ntprinter, devmode);
9044
9045 *needed += spoolss_size_job_info_2(info_2);
9046
9047 if (*needed > offered) {
9048 result = WERR_INSUFFICIENT_BUFFER;
9049 goto done;
9050 }
9051
9052 if (!rpcbuf_alloc_size(buffer, *needed)) {
9053 result = WERR_NOMEM;
9054 goto done;
9055 }
9056
9057 smb_io_job_info_2("", buffer, info_2, 0);
9058
9059 result = WERR_OK;
9060
9061 done:
9062 /* Cleanup allocated memory */
9063
9064 free_job_info_2(info_2); /* Also frees devmode */
9065 SAFE_FREE(info_2);
9066
9067 return result;
9068 }
9069
9070 /****************************************************************************
9071 ****************************************************************************/
9072
9073 WERROR _spoolss_getjob( pipes_struct *p, SPOOL_Q_GETJOB *q_u, SPOOL_R_GETJOB *r_u)
9074 {
9075 POLICY_HND *handle = &q_u->handle;
9076 uint32 jobid = q_u->jobid;
9077 uint32 level = q_u->level;
9078 RPC_BUFFER *buffer = NULL;
9079 uint32 offered = q_u->offered;
9080 uint32 *needed = &r_u->needed;
9081 WERROR wstatus = WERR_OK;
9082 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
9083 int snum;
9084 int count;
9085 print_queue_struct *queue = NULL;
9086 print_status_struct prt_status;
9087
9088 /* that's an [in out] buffer */
9089
9090 if (!q_u->buffer && (offered!=0)) {
9091 return WERR_INVALID_PARAM;
9092 }
9093
9094 rpcbuf_move(q_u->buffer, &r_u->buffer);
9095 buffer = r_u->buffer;
9096
9097 DEBUG(5,("spoolss_getjob\n"));
9098
9099 *needed = 0;
9100
9101 if (!get_printer_snum(p, handle, &snum, NULL))
9102 return WERR_BADFID;
9103
9104 wstatus = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
9105 if ( !W_ERROR_IS_OK(wstatus) )
9106 return wstatus;
9107
9108 count = print_queue_status(snum, &queue, &prt_status);
9109
9110 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
9111 count, prt_status.status, prt_status.message));
9112
9113 switch ( level ) {
9114 case 1:
9115 wstatus = getjob_level_1(&queue, count, snum, ntprinter, jobid,
9116 buffer, offered, needed);
9117 break;
9118 case 2:
9119 wstatus = getjob_level_2(&queue, count, snum, ntprinter, jobid,
9120 buffer, offered, needed);
9121 break;
9122 default:
9123 wstatus = WERR_UNKNOWN_LEVEL;
9124 break;
9125 }
9126
9127 SAFE_FREE(queue);
9128 free_a_printer( &ntprinter, 2 );
9129
9130 return wstatus;
9131 }
9132
9133 /********************************************************************
9134 spoolss_getprinterdataex
9135
9136 From MSDN documentation of GetPrinterDataEx: pass request
9137 to GetPrinterData if key is "PrinterDriverData".
9138 ********************************************************************/
9139
9140 WERROR _spoolss_getprinterdataex(pipes_struct *p, SPOOL_Q_GETPRINTERDATAEX *q_u, SPOOL_R_GETPRINTERDATAEX *r_u)
9141 {
9142 POLICY_HND *handle = &q_u->handle;
9143 uint32 in_size = q_u->size;
9144 uint32 *type = &r_u->type;
9145 uint32 *out_size = &r_u->size;
9146 uint8 **data = &r_u->data;
9147 uint32 *needed = &r_u->needed;
9148 fstring keyname, valuename;
9149
9150 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
9151
9152 NT_PRINTER_INFO_LEVEL *printer = NULL;
9153 int snum = 0;
9154 WERROR status = WERR_OK;
9155
9156 DEBUG(4,("_spoolss_getprinterdataex\n"));
9157
9158 unistr2_to_ascii(keyname, &q_u->keyname, sizeof(keyname));
9159 unistr2_to_ascii(valuename, &q_u->valuename, sizeof(valuename));
9160
9161 DEBUG(10, ("_spoolss_getprinterdataex: key => [%s], value => [%s]\n",
9162 keyname, valuename));
9163
9164 /* in case of problem, return some default values */
9165
9166 *needed = 0;
9167 *type = 0;
9168 *out_size = in_size;
9169
9170 if (!Printer) {
9171 DEBUG(2,("_spoolss_getprinterdataex: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9172 status = WERR_BADFID;
9173 goto done;
9174 }
9175
9176 /* Is the handle to a printer or to the server? */
9177
9178 if (Printer->printer_type == SPLHND_SERVER) {
9179 DEBUG(10,("_spoolss_getprinterdataex: Not implemented for server handles yet\n"));
9180 status = WERR_INVALID_PARAM;
9181 goto done;
9182 }
9183
9184 if ( !get_printer_snum(p,handle, &snum, NULL) )
9185 return WERR_BADFID;
9186
9187 status = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9188 if ( !W_ERROR_IS_OK(status) )
9189 goto done;
9190
9191 /* check to see if the keyname is valid */
9192 if ( !strlen(keyname) ) {
9193 status = WERR_INVALID_PARAM;
9194 goto done;
9195 }
9196
9197 if ( lookup_printerkey( printer->info_2->data, keyname ) == -1 ) {
9198 DEBUG(4,("_spoolss_getprinterdataex: Invalid keyname [%s]\n", keyname ));
9199 free_a_printer( &printer, 2 );
9200 status = WERR_BADFILE;
9201 goto done;
9202 }
9203
9204 /* When given a new keyname, we should just create it */
9205
9206 status = get_printer_dataex( p->mem_ctx, printer, keyname, valuename, type, data, needed, in_size );
9207
9208 if (*needed > *out_size)
9209 status = WERR_MORE_DATA;
9210
9211 done:
9212 if ( !W_ERROR_IS_OK(status) )
9213 {
9214 DEBUG(5, ("error: allocating %d\n", *out_size));
9215
9216 /* reply this param doesn't exist */
9217
9218 if ( *out_size )
9219 {
9220 if( (*data=(uint8 *)TALLOC_ZERO(p->mem_ctx, *out_size*sizeof(uint8))) == NULL ) {
9221 status = WERR_NOMEM;
9222 goto done;
9223 }
9224 } else {
9225 *data = NULL;
9226 }
9227 }
9228
9229 if ( printer )
9230 free_a_printer( &printer, 2 );
9231
9232 return status;
9233 }
9234
9235 /********************************************************************
9236 * spoolss_setprinterdataex
9237 ********************************************************************/
9238
9239 WERROR _spoolss_setprinterdataex(pipes_struct *p, SPOOL_Q_SETPRINTERDATAEX *q_u, SPOOL_R_SETPRINTERDATAEX *r_u)
9240 {
9241 POLICY_HND *handle = &q_u->handle;
9242 uint32 type = q_u->type;
9243 uint8 *data = q_u->data;
9244 uint32 real_len = q_u->real_len;
9245
9246 NT_PRINTER_INFO_LEVEL *printer = NULL;
9247 int snum = 0;
9248 WERROR status = WERR_OK;
9249 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
9250 fstring valuename;
9251 fstring keyname;
9252 char *oid_string;
9253
9254 DEBUG(4,("_spoolss_setprinterdataex\n"));
9255
9256 /* From MSDN documentation of SetPrinterDataEx: pass request to
9257 SetPrinterData if key is "PrinterDriverData" */
9258
9259 if (!Printer) {
9260 DEBUG(2,("_spoolss_setprinterdataex: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9261 return WERR_BADFID;
9262 }
9263
9264 if ( Printer->printer_type == SPLHND_SERVER ) {
9265 DEBUG(10,("_spoolss_setprinterdataex: Not implemented for server handles yet\n"));
9266 return WERR_INVALID_PARAM;
9267 }
9268
9269 if ( !get_printer_snum(p,handle, &snum, NULL) )
9270 return WERR_BADFID;
9271
9272 /*
9273 * Access check : NT returns "access denied" if you make a
9274 * SetPrinterData call without the necessary privildge.
9275 * we were originally returning OK if nothing changed
9276 * which made Win2k issue **a lot** of SetPrinterData
9277 * when connecting to a printer --jerry
9278 */
9279
9280 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER)
9281 {
9282 DEBUG(3, ("_spoolss_setprinterdataex: change denied by handle access permissions\n"));
9283 return WERR_ACCESS_DENIED;
9284 }
9285
9286 status = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9287 if (!W_ERROR_IS_OK(status))
9288 return status;
9289
9290 unistr2_to_ascii( valuename, &q_u->value, sizeof(valuename));
9291 unistr2_to_ascii( keyname, &q_u->key, sizeof(keyname));
9292
9293 /* check for OID in valuename */
9294
9295 if ( (oid_string = strchr( valuename, ',' )) != NULL )
9296 {
9297 *oid_string = '\0';
9298 oid_string++;
9299 }
9300
9301 /* save the registry data */
9302
9303 status = set_printer_dataex( printer, keyname, valuename, type, data, real_len );
9304
9305 if ( W_ERROR_IS_OK(status) )
9306 {
9307 /* save the OID if one was specified */
9308 if ( oid_string ) {
9309 fstrcat( keyname, "\\" );
9310 fstrcat( keyname, SPOOL_OID_KEY );
9311
9312 /*
9313 * I'm not checking the status here on purpose. Don't know
9314 * if this is right, but I'm returning the status from the
9315 * previous set_printer_dataex() call. I have no idea if
9316 * this is right. --jerry
9317 */
9318
9319 set_printer_dataex( printer, keyname, valuename,
9320 REG_SZ, (uint8 *)oid_string,
9321 strlen(oid_string)+1 );
9322 }
9323
9324 status = mod_a_printer(printer, 2);
9325 }
9326
9327 free_a_printer(&printer, 2);
9328
9329 return status;
9330 }
9331
9332
9333 /********************************************************************
9334 * spoolss_deleteprinterdataex
9335 ********************************************************************/
9336
9337 WERROR _spoolss_deleteprinterdataex(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATAEX *q_u, SPOOL_R_DELETEPRINTERDATAEX *r_u)
9338 {
9339 POLICY_HND *handle = &q_u->handle;
9340 UNISTR2 *value = &q_u->valuename;
9341 UNISTR2 *key = &q_u->keyname;
9342
9343 NT_PRINTER_INFO_LEVEL *printer = NULL;
9344 int snum=0;
9345 WERROR status = WERR_OK;
9346 Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
9347 char *valuename = NULL;
9348 char *keyname = NULL;
9349 TALLOC_CTX *ctx = p->mem_ctx;
9350
9351 DEBUG(5,("spoolss_deleteprinterdataex\n"));
9352
9353 if (!Printer) {
9354 DEBUG(2,("_spoolss_deleteprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9355 return WERR_BADFID;
9356 }
9357
9358 if (!get_printer_snum(p, handle, &snum, NULL))
9359 return WERR_BADFID;
9360
9361 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9362 DEBUG(3, ("_spoolss_deleteprinterdataex: printer properties change denied by handle\n"));
9363 return WERR_ACCESS_DENIED;
9364 }
9365
9366 valuename = unistr2_to_ascii_talloc(ctx, value);
9367 keyname = unistr2_to_ascii_talloc(ctx, key);
9368 if (!valuename || !keyname) {
9369 return WERR_NOMEM;
9370 }
9371
9372 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9373 if (!W_ERROR_IS_OK(status))
9374 return status;
9375
9376 status = delete_printer_dataex( printer, keyname, valuename );
9377
9378 if ( W_ERROR_IS_OK(status) )
9379 mod_a_printer( printer, 2 );
9380
9381 free_a_printer(&printer, 2);
9382
9383 return status;
9384 }
9385
9386 /********************************************************************
9387 * spoolss_enumprinterkey
9388 ********************************************************************/
9389
9390
9391 WERROR _spoolss_enumprinterkey(pipes_struct *p, SPOOL_Q_ENUMPRINTERKEY *q_u, SPOOL_R_ENUMPRINTERKEY *r_u)
9392 {
9393 fstring key;
9394 fstring *keynames = NULL;
9395 uint16 *enumkeys = NULL;
9396 int num_keys;
9397 int printerkey_len;
9398 POLICY_HND *handle = &q_u->handle;
9399 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
9400 NT_PRINTER_DATA *data;
9401 NT_PRINTER_INFO_LEVEL *printer = NULL;
9402 int snum = 0;
9403 WERROR status = WERR_BADFILE;
9404
9405
9406 DEBUG(4,("_spoolss_enumprinterkey\n"));
9407
9408 if (!Printer) {
9409 DEBUG(2,("_spoolss_enumprinterkey: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9410 return WERR_BADFID;
9411 }
9412
9413 if ( !get_printer_snum(p,handle, &snum, NULL) )
9414 return WERR_BADFID;
9415
9416 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9417 if (!W_ERROR_IS_OK(status))
9418 return status;
9419
9420 /* get the list of subkey names */
9421
9422 unistr2_to_ascii(key, &q_u->key, sizeof(key));
9423 data = printer->info_2->data;
9424
9425 num_keys = get_printer_subkeys( data, key, &keynames );
9426
9427 if ( num_keys == -1 ) {
9428 status = WERR_BADFILE;
9429 goto done;
9430 }
9431
9432 printerkey_len = init_unistr_array( &enumkeys, keynames, NULL );
9433
9434 r_u->needed = printerkey_len*2;
9435
9436 if ( q_u->size < r_u->needed ) {
9437 status = WERR_MORE_DATA;
9438 goto done;
9439 }
9440
9441 if (!make_spoolss_buffer5(p->mem_ctx, &r_u->keys, printerkey_len, enumkeys)) {
9442 status = WERR_NOMEM;
9443 goto done;
9444 }
9445
9446 status = WERR_OK;
9447
9448 if ( q_u->size < r_u->needed )
9449 status = WERR_MORE_DATA;
9450
9451 done:
9452 free_a_printer( &printer, 2 );
9453 SAFE_FREE( keynames );
9454
9455 return status;
9456 }
9457
9458 /********************************************************************
9459 * spoolss_deleteprinterkey
9460 ********************************************************************/
9461
9462 WERROR _spoolss_deleteprinterkey(pipes_struct *p, SPOOL_Q_DELETEPRINTERKEY *q_u, SPOOL_R_DELETEPRINTERKEY *r_u)
9463 {
9464 POLICY_HND *handle = &q_u->handle;
9465 Printer_entry *Printer = find_printer_index_by_hnd(p, &q_u->handle);
9466 fstring key;
9467 NT_PRINTER_INFO_LEVEL *printer = NULL;
9468 int snum=0;
9469 WERROR status;
9470
9471 DEBUG(5,("spoolss_deleteprinterkey\n"));
9472
9473 if (!Printer) {
9474 DEBUG(2,("_spoolss_deleteprinterkey: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
9475 return WERR_BADFID;
9476 }
9477
9478 /* if keyname == NULL, return error */
9479
9480 if ( !q_u->keyname.buffer )
9481 return WERR_INVALID_PARAM;
9482
9483 if (!get_printer_snum(p, handle, &snum, NULL))
9484 return WERR_BADFID;
9485
9486 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9487 DEBUG(3, ("_spoolss_deleteprinterkey: printer properties change denied by handle\n"));
9488 return WERR_ACCESS_DENIED;
9489 }
9490
9491 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9492 if (!W_ERROR_IS_OK(status))
9493 return status;
9494
9495 /* delete the key and all subneys */
9496
9497 unistr2_to_ascii(key, &q_u->keyname, sizeof(key));
9498
9499 status = delete_all_printer_data( printer->info_2, key );
9500
9501 if ( W_ERROR_IS_OK(status) )
9502 status = mod_a_printer(printer, 2);
9503
9504 free_a_printer( &printer, 2 );
9505
9506 return status;
9507 }
9508
9509
9510 /********************************************************************
9511 * spoolss_enumprinterdataex
9512 ********************************************************************/
9513
9514 WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_u, SPOOL_R_ENUMPRINTERDATAEX *r_u)
9515 {
9516 POLICY_HND *handle = &q_u->handle;
9517 uint32 in_size = q_u->size;
9518 uint32 num_entries,
9519 needed;
9520 NT_PRINTER_INFO_LEVEL *printer = NULL;
9521 PRINTER_ENUM_VALUES *enum_values = NULL;
9522 NT_PRINTER_DATA *p_data;
9523 fstring key;
9524 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
9525 int snum;
9526 WERROR result;
9527 int key_index;
9528 int i;
9529 REGISTRY_VALUE *val;
9530 char *value_name;
9531 uint32 data_len;
9532
9533
9534 DEBUG(4,("_spoolss_enumprinterdataex\n"));
9535
9536 if (!Printer) {
9537 DEBUG(2,("_spoolss_enumprinterdataex: Invalid handle (%s:%u:%u1<).\n", OUR_HANDLE(handle)));
9538 return WERR_BADFID;
9539 }
9540
9541 /*
9542 * first check for a keyname of NULL or "". Win2k seems to send
9543 * this a lot and we should send back WERR_INVALID_PARAM
9544 * no need to spend time looking up the printer in this case.
9545 * --jerry
9546 */
9547
9548 unistr2_to_ascii(key, &q_u->key, sizeof(key));
9549 if ( !strlen(key) ) {
9550 result = WERR_INVALID_PARAM;
9551 goto done;
9552 }
9553
9554 /* get the printer off of disk */
9555
9556 if (!get_printer_snum(p,handle, &snum, NULL))
9557 return WERR_BADFID;
9558
9559 ZERO_STRUCT(printer);
9560 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9561 if (!W_ERROR_IS_OK(result))
9562 return result;
9563
9564 /* now look for a match on the key name */
9565
9566 p_data = printer->info_2->data;
9567
9568 unistr2_to_ascii(key, &q_u->key, sizeof(key));
9569 if ( (key_index = lookup_printerkey( p_data, key)) == -1 )
9570 {
9571 DEBUG(10,("_spoolss_enumprinterdataex: Unknown keyname [%s]\n", key));
9572 result = WERR_INVALID_PARAM;
9573 goto done;
9574 }
9575
9576 result = WERR_OK;
9577 needed = 0;
9578
9579 /* allocate the memory for the array of pointers -- if necessary */
9580
9581 num_entries = regval_ctr_numvals( p_data->keys[key_index].values );
9582 if ( num_entries )
9583 {
9584 if ( (enum_values=TALLOC_ARRAY(p->mem_ctx, PRINTER_ENUM_VALUES, num_entries)) == NULL )
9585 {
9586 DEBUG(0,("_spoolss_enumprinterdataex: talloc() failed to allocate memory for [%lu] bytes!\n",
9587 (unsigned long)num_entries*sizeof(PRINTER_ENUM_VALUES)));
9588 result = WERR_NOMEM;
9589 goto done;
9590 }
9591
9592 memset( enum_values, 0x0, num_entries*sizeof(PRINTER_ENUM_VALUES) );
9593 }
9594
9595 /*
9596 * loop through all params and build the array to pass
9597 * back to the client
9598 */
9599
9600 for ( i=0; i<num_entries; i++ )
9601 {
9602 /* lookup the registry value */
9603
9604 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
9605 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val) ));
9606
9607 /* copy the data */
9608
9609 value_name = regval_name( val );
9610 init_unistr( &enum_values[i].valuename, value_name );
9611 enum_values[i].value_len = (strlen(value_name)+1) * 2;
9612 enum_values[i].type = regval_type( val );
9613
9614 data_len = regval_size( val );
9615 if ( data_len ) {
9616 if ( !(enum_values[i].data = (uint8 *)TALLOC_MEMDUP(p->mem_ctx, regval_data_p(val), data_len)) )
9617 {
9618 DEBUG(0,("TALLOC_MEMDUP failed to allocate memory [data_len=%d] for data!\n",
9619 data_len ));
9620 result = WERR_NOMEM;
9621 goto done;
9622 }
9623 }
9624 enum_values[i].data_len = data_len;
9625
9626 /* keep track of the size of the array in bytes */
9627
9628 needed += spoolss_size_printer_enum_values(&enum_values[i]);
9629 }
9630
9631 /* housekeeping information in the reply */
9632
9633 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9634 * the hand marshalled container size is a multiple
9635 * of 4 bytes for RPC alignment.
9636 */
9637
9638 if (needed % 4) {
9639 needed += 4-(needed % 4);
9640 }
9641
9642 r_u->needed = needed;
9643 r_u->returned = num_entries;
9644
9645 if (needed > in_size) {
9646 result = WERR_MORE_DATA;
9647 goto done;
9648 }
9649
9650 /* copy data into the reply */
9651
9652 /* mz: Vista x64 returns 0x6f7 (The stub received bad data), if the
9653 response buffer size is != the offered buffer size
9654
9655 r_u->ctr.size = r_u->needed;
9656 */
9657 r_u->ctr.size = in_size;
9658
9659 r_u->ctr.size_of_array = r_u->returned;
9660 r_u->ctr.values = enum_values;
9661
9662 done:
9663 if ( printer )
9664 free_a_printer(&printer, 2);
9665
9666 return result;
9667 }
9668
9669 /****************************************************************************
9670 ****************************************************************************/
9671
9672 static void fill_printprocessordirectory_1(PRINTPROCESSOR_DIRECTORY_1 *info, const char *name)
9673 {
9674 init_unistr(&info->name, name);
9675 }
9676
9677 static WERROR getprintprocessordirectory_level_1(UNISTR2 *name,
9678 UNISTR2 *environment,
9679 RPC_BUFFER *buffer,
9680 uint32 offered,
9681 uint32 *needed)
9682 {
9683 char *long_archi = NULL;
9684 PRINTPROCESSOR_DIRECTORY_1 *info=NULL;
9685 WERROR result = WERR_OK;
9686 TALLOC_CTX *ctx = talloc_tos();
9687
9688 long_archi = unistr2_to_ascii_talloc(ctx, environment);
9689 if (!long_archi) {
9690 return WERR_NOMEM;
9691 }
9692
9693 if (!get_short_archi(long_archi))
9694 return WERR_INVALID_ENVIRONMENT;
9695
9696 if((info=SMB_MALLOC_P(PRINTPROCESSOR_DIRECTORY_1)) == NULL)
9697 return WERR_NOMEM;
9698
9699 fill_printprocessordirectory_1(info, "C:\\WINNT\\System32\\spool\\PRTPROCS\\W32X86");
9700
9701 *needed += spoolss_size_printprocessordirectory_info_1(info);
9702
9703 if (*needed > offered) {
9704 result = WERR_INSUFFICIENT_BUFFER;
9705 goto out;
9706 }
9707
9708 if (!rpcbuf_alloc_size(buffer, *needed)) {
9709 result = WERR_INSUFFICIENT_BUFFER;
9710 goto out;
9711 }
9712
9713 smb_io_printprocessordirectory_1("", buffer, info, 0);
9714
9715 out:
9716 SAFE_FREE(info);
9717
9718 return result;
9719 }
9720
9721 WERROR _spoolss_getprintprocessordirectory(pipes_struct *p, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u)
9722 {
9723 uint32 level = q_u->level;
9724 RPC_BUFFER *buffer = NULL;
9725 uint32 offered = q_u->offered;
9726 uint32 *needed = &r_u->needed;
9727 WERROR result;
9728
9729 /* that's an [in out] buffer */
9730
9731 if (!q_u->buffer && (offered!=0)) {
9732 return WERR_INVALID_PARAM;
9733 }
9734
9735 rpcbuf_move(q_u->buffer, &r_u->buffer);
9736 buffer = r_u->buffer;
9737
9738 DEBUG(5,("_spoolss_getprintprocessordirectory\n"));
9739
9740 *needed=0;
9741
9742 switch(level) {
9743 case 1:
9744 result = getprintprocessordirectory_level_1
9745 (&q_u->name, &q_u->environment, buffer, offered, needed);
9746 break;
9747 default:
9748 result = WERR_UNKNOWN_LEVEL;
9749 }
9750
9751 return result;
9752 }
9753
9754 /*******************************************************************
9755 Streams the monitor UI DLL name in UNICODE
9756 *******************************************************************/
9757
9758 static WERROR xcvtcp_monitorui( NT_USER_TOKEN *token, RPC_BUFFER *in,
9759 RPC_BUFFER *out, uint32 *needed )
9760 {
9761 const char *dllname = "tcpmonui.dll";
9762
9763 *needed = (strlen(dllname)+1) * 2;
9764
9765 if ( rpcbuf_get_size(out) < *needed ) {
9766 return WERR_INSUFFICIENT_BUFFER;
9767 }
9768
9769 if ( !make_monitorui_buf( out, dllname ) ) {
9770 return WERR_NOMEM;
9771 }
9772
9773 return WERR_OK;
9774 }
9775
9776 /*******************************************************************
9777 Create a new TCP/IP port
9778 *******************************************************************/
9779
9780 static WERROR xcvtcp_addport( NT_USER_TOKEN *token, RPC_BUFFER *in,
9781 RPC_BUFFER *out, uint32 *needed )
9782 {
9783 NT_PORT_DATA_1 port1;
9784 TALLOC_CTX *ctx = talloc_tos();
9785 char *device_uri = NULL;
9786
9787 ZERO_STRUCT( port1 );
9788
9789 /* convert to our internal port data structure */
9790
9791 if ( !convert_port_data_1( &port1, in ) ) {
9792 return WERR_NOMEM;
9793 }
9794
9795 /* create the device URI and call the add_port_hook() */
9796
9797 switch ( port1.protocol ) {
9798 case PORT_PROTOCOL_DIRECT:
9799 device_uri = talloc_asprintf(ctx,
9800 "socket://%s:%d/", port1.hostaddr, port1.port );
9801 break;
9802
9803 case PORT_PROTOCOL_LPR:
9804 device_uri = talloc_asprintf(ctx,
9805 "lpr://%s/%s", port1.hostaddr, port1.queue );
9806 break;
9807
9808 default:
9809 return WERR_UNKNOWN_PORT;
9810 }
9811
9812 if (!device_uri) {
9813 return WERR_NOMEM;
9814 }
9815
9816 return add_port_hook(ctx, token, port1.name, device_uri );
9817 }
9818
9819 /*******************************************************************
9820 *******************************************************************/
9821
9822 struct xcv_api_table xcvtcp_cmds[] = {
9823 { "MonitorUI", xcvtcp_monitorui },
9824 { "AddPort", xcvtcp_addport},
9825 { NULL, NULL }
9826 };
9827
9828 static WERROR process_xcvtcp_command( NT_USER_TOKEN *token, const char *command,
9829 RPC_BUFFER *inbuf, RPC_BUFFER *outbuf,
9830 uint32 *needed )
9831 {
9832 int i;
9833
9834 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9835
9836 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9837 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9838 return xcvtcp_cmds[i].fn( token, inbuf, outbuf, needed );
9839 }
9840
9841 return WERR_BADFUNC;
9842 }
9843
9844 /*******************************************************************
9845 *******************************************************************/
9846 #if 0 /* don't support management using the "Local Port" monitor */
9847
9848 static WERROR xcvlocal_monitorui( NT_USER_TOKEN *token, RPC_BUFFER *in,
9849 RPC_BUFFER *out, uint32 *needed )
9850 {
9851 const char *dllname = "localui.dll";
9852
9853 *needed = (strlen(dllname)+1) * 2;
9854
9855 if ( rpcbuf_get_size(out) < *needed ) {
9856 return WERR_INSUFFICIENT_BUFFER;
9857 }
9858
9859 if ( !make_monitorui_buf( out, dllname )) {
9860 return WERR_NOMEM;
9861 }
9862
9863 return WERR_OK;
9864 }
9865
9866 /*******************************************************************
9867 *******************************************************************/
9868
9869 struct xcv_api_table xcvlocal_cmds[] = {
9870 { "MonitorUI", xcvlocal_monitorui },
9871 { NULL, NULL }
9872 };
9873 #else
9874 struct xcv_api_table xcvlocal_cmds[] = {
9875 { NULL, NULL }
9876 };
9877 #endif
9878
9879
9880
9881 /*******************************************************************
9882 *******************************************************************/
9883
9884 static WERROR process_xcvlocal_command( NT_USER_TOKEN *token, const char *command,
9885 RPC_BUFFER *inbuf, RPC_BUFFER *outbuf,
9886 uint32 *needed )
9887 {
9888 int i;
9889
9890 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9891
9892 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9893 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9894 return xcvlocal_cmds[i].fn( token, inbuf, outbuf , needed );
9895 }
9896 return WERR_BADFUNC;
9897 }
9898
9899 /*******************************************************************
9900 *******************************************************************/
9901
9902 WERROR _spoolss_xcvdataport(pipes_struct *p, SPOOL_Q_XCVDATAPORT *q_u, SPOOL_R_XCVDATAPORT *r_u)
9903 {
9904 Printer_entry *Printer = find_printer_index_by_hnd(p, &q_u->handle);
9905 fstring command;
9906
9907 if (!Printer) {
9908 DEBUG(2,("_spoolss_xcvdataport: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(&q_u->handle)));
9909 return WERR_BADFID;
9910 }
9911
9912 /* Has to be a handle to the TCP/IP port monitor */
9913
9914 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9915 DEBUG(2,("_spoolss_xcvdataport: Call only valid for Port Monitors\n"));
9916 return WERR_BADFID;
9917 }
9918
9919 /* requires administrative access to the server */
9920
9921 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9922 DEBUG(2,("_spoolss_xcvdataport: denied by handle permissions.\n"));
9923 return WERR_ACCESS_DENIED;
9924 }
9925
9926 /* Get the command name. There's numerous commands supported by the
9927 TCPMON interface. */
9928
9929 rpcstr_pull(command, q_u->dataname.buffer, sizeof(command),
9930 q_u->dataname.uni_str_len*2, 0);
9931
9932 /* Allocate the outgoing buffer */
9933
9934 rpcbuf_init( &r_u->outdata, q_u->offered, p->mem_ctx );
9935
9936 switch ( Printer->printer_type ) {
9937 case SPLHND_PORTMON_TCP:
9938 return process_xcvtcp_command( p->pipe_user.nt_user_token, command,
9939 &q_u->indata, &r_u->outdata, &r_u->needed );
9940 case SPLHND_PORTMON_LOCAL:
9941 return process_xcvlocal_command( p->pipe_user.nt_user_token, command,
9942 &q_u->indata, &r_u->outdata, &r_u->needed );
9943 }
9944
9945 return WERR_INVALID_PRINT_MONITOR;
9946 }
Samba GIT mirror