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