?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: Add talloc_dict.[ch]
[Samba/aatanasov.git] / source3 / rpc_server / srv_spoolss_nt.c
blobe535f26a83012822e00ad1cb9ed993904bd7994d
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 * Copyright (C) Guenther Deschner 2009.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 3 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <http://www.gnu.org/licenses/>.
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 /* macros stolen from s4 spoolss server */
32 #define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
33 ((info)?ndr_size_##fn(info, level, ic, 0):0)
34
35 #define SPOOLSS_BUFFER_UNION_ARRAY(mem_ctx,fn,ic,info,level,count) \
36 ((info)?ndr_size_##fn##_info(mem_ctx, ic, level, count, info):0)
37
38 #define SPOOLSS_BUFFER_ARRAY(mem_ctx,fn,ic,info,count) \
39 ((info)?ndr_size_##fn##_info(mem_ctx, ic, count, info):0)
40
41 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
42
43
44 extern userdom_struct current_user_info;
45
46 #undef DBGC_CLASS
47 #define DBGC_CLASS DBGC_RPC_SRV
48
49 #ifndef MAX_OPEN_PRINTER_EXS
50 #define MAX_OPEN_PRINTER_EXS 50
51 #endif
52
53 #define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
54 #define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
55
56 static Printer_entry *printers_list;
57
58 typedef struct _counter_printer_0 {
59 struct _counter_printer_0 *next;
60 struct _counter_printer_0 *prev;
61
62 int snum;
63 uint32_t counter;
64 } counter_printer_0;
65
66 static counter_printer_0 *counter_list;
67
68 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
69 static uint32_t smb_connections = 0;
70
71
72 /* in printing/nt_printing.c */
73
74 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
75
76 /* API table for Xcv Monitor functions */
77
78 struct xcv_api_table {
79 const char *name;
80 WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
81 };
82
83 /********************************************************************
84 * Canonicalize servername.
85 ********************************************************************/
86
87 static const char *canon_servername(const char *servername)
88 {
89 const char *pservername = servername;
90 while (*pservername == '\\') {
91 pservername++;
92 }
93 return pservername;
94 }
95
96 /* translate between internal status numbers and NT status numbers */
97 static int nt_printj_status(int v)
98 {
99 switch (v) {
100 case LPQ_QUEUED:
101 return 0;
102 case LPQ_PAUSED:
103 return JOB_STATUS_PAUSED;
104 case LPQ_SPOOLING:
105 return JOB_STATUS_SPOOLING;
106 case LPQ_PRINTING:
107 return JOB_STATUS_PRINTING;
108 case LPQ_ERROR:
109 return JOB_STATUS_ERROR;
110 case LPQ_DELETING:
111 return JOB_STATUS_DELETING;
112 case LPQ_OFFLINE:
113 return JOB_STATUS_OFFLINE;
114 case LPQ_PAPEROUT:
115 return JOB_STATUS_PAPEROUT;
116 case LPQ_PRINTED:
117 return JOB_STATUS_PRINTED;
118 case LPQ_DELETED:
119 return JOB_STATUS_DELETED;
120 case LPQ_BLOCKED:
121 return JOB_STATUS_BLOCKED_DEVQ;
122 case LPQ_USER_INTERVENTION:
123 return JOB_STATUS_USER_INTERVENTION;
124 }
125 return 0;
126 }
127
128 static int nt_printq_status(int v)
129 {
130 switch (v) {
131 case LPQ_PAUSED:
132 return PRINTER_STATUS_PAUSED;
133 case LPQ_QUEUED:
134 case LPQ_SPOOLING:
135 case LPQ_PRINTING:
136 return 0;
137 }
138 return 0;
139 }
140
141 /***************************************************************************
142 Disconnect from the client
143 ****************************************************************************/
144
145 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
146 {
147 WERROR result;
148 NTSTATUS status;
149
150 /*
151 * Tell the specific printing tdb we no longer want messages for this printer
152 * by deregistering our PID.
153 */
154
155 if (!print_notify_deregister_pid(snum))
156 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
157
158 /* weird if the test succeds !!! */
159 if (smb_connections==0) {
160 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
161 return;
162 }
163
164 status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
165 handle,
166 &result);
167 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
168 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
169 win_errstr(result)));
170
171 /* if it's the last connection, deconnect the IPC$ share */
172 if (smb_connections==1) {
173
174 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
175 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
176
177 messaging_deregister(smbd_messaging_context(),
178 MSG_PRINTER_NOTIFY2, NULL);
179
180 /* Tell the connections db we're no longer interested in
181 * printer notify messages. */
182
183 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
184 }
185
186 smb_connections--;
187 }
188
189 /****************************************************************************
190 Functions to free a printer entry datastruct.
191 ****************************************************************************/
192
193 static int printer_entry_destructor(Printer_entry *Printer)
194 {
195 if (Printer->notify.client_connected == true) {
196 int snum = -1;
197
198 if ( Printer->printer_type == SPLHND_SERVER) {
199 snum = -1;
200 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
201 } else if (Printer->printer_type == SPLHND_PRINTER) {
202 snum = print_queue_snum(Printer->sharename);
203 if (snum != -1)
204 srv_spoolss_replycloseprinter(snum,
205 &Printer->notify.client_hnd);
206 }
207 }
208
209 Printer->notify.flags=0;
210 Printer->notify.options=0;
211 Printer->notify.localmachine[0]='\0';
212 Printer->notify.printerlocal=0;
213 TALLOC_FREE(Printer->notify.option);
214 Printer->notify.client_connected = false;
215
216 free_nt_devicemode( &Printer->nt_devmode );
217 free_a_printer( &Printer->printer_info, 2 );
218
219 /* Remove from the internal list. */
220 DLIST_REMOVE(printers_list, Printer);
221 return 0;
222 }
223
224 /****************************************************************************
225 find printer index by handle
226 ****************************************************************************/
227
228 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
229 struct policy_handle *hnd)
230 {
231 Printer_entry *find_printer = NULL;
232
233 if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
234 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
235 return NULL;
236 }
237
238 return find_printer;
239 }
240
241 /****************************************************************************
242 Close printer index by handle.
243 ****************************************************************************/
244
245 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
246 {
247 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
248
249 if (!Printer) {
250 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
251 OUR_HANDLE(hnd)));
252 return false;
253 }
254
255 close_policy_hnd(p, hnd);
256
257 return true;
258 }
259
260 /****************************************************************************
261 Delete a printer given a handle.
262 ****************************************************************************/
263
264 static WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename)
265 {
266 char *cmd = lp_deleteprinter_cmd();
267 char *command = NULL;
268 int ret;
269 SE_PRIV se_printop = SE_PRINT_OPERATOR;
270 bool is_print_op = false;
271
272 /* can't fail if we don't try */
273
274 if ( !*cmd )
275 return WERR_OK;
276
277 command = talloc_asprintf(ctx,
278 "%s \"%s\"",
279 cmd, sharename);
280 if (!command) {
281 return WERR_NOMEM;
282 }
283 if ( token )
284 is_print_op = user_has_privileges( token, &se_printop );
285
286 DEBUG(10,("Running [%s]\n", command));
287
288 /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
289
290 if ( is_print_op )
291 become_root();
292
293 if ( (ret = smbrun(command, NULL)) == 0 ) {
294 /* Tell everyone we updated smb.conf. */
295 message_send_all(smbd_messaging_context(),
296 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
297 }
298
299 if ( is_print_op )
300 unbecome_root();
301
302 /********** END SePrintOperatorPrivlege BLOCK **********/
303
304 DEBUGADD(10,("returned [%d]\n", ret));
305
306 TALLOC_FREE(command);
307
308 if (ret != 0)
309 return WERR_BADFID; /* What to return here? */
310
311 /* go ahead and re-read the services immediately */
312 become_root();
313 reload_services(false);
314 unbecome_root();
315
316 if ( lp_servicenumber( sharename ) < 0 )
317 return WERR_ACCESS_DENIED;
318
319 return WERR_OK;
320 }
321
322 /****************************************************************************
323 Delete a printer given a handle.
324 ****************************************************************************/
325
326 static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
327 {
328 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
329
330 if (!Printer) {
331 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
332 OUR_HANDLE(hnd)));
333 return WERR_BADFID;
334 }
335
336 /*
337 * It turns out that Windows allows delete printer on a handle
338 * opened by an admin user, then used on a pipe handle created
339 * by an anonymous user..... but they're working on security.... riiight !
340 * JRA.
341 */
342
343 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
344 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
345 return WERR_ACCESS_DENIED;
346 }
347
348 /* this does not need a become root since the access check has been
349 done on the handle already */
350
351 if (del_a_printer( Printer->sharename ) != 0) {
352 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
353 return WERR_BADFID;
354 }
355
356 return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
357 Printer->sharename );
358 }
359
360 /****************************************************************************
361 Return the snum of a printer corresponding to an handle.
362 ****************************************************************************/
363
364 static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
365 int *number, struct share_params **params)
366 {
367 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
368
369 if (!Printer) {
370 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
371 OUR_HANDLE(hnd)));
372 return false;
373 }
374
375 switch (Printer->printer_type) {
376 case SPLHND_PRINTER:
377 DEBUG(4,("short name:%s\n", Printer->sharename));
378 *number = print_queue_snum(Printer->sharename);
379 return (*number != -1);
380 case SPLHND_SERVER:
381 return false;
382 default:
383 return false;
384 }
385 }
386
387 /****************************************************************************
388 Set printer handle type.
389 Check if it's \\server or \\server\printer
390 ****************************************************************************/
391
392 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
393 {
394 DEBUG(3,("Setting printer type=%s\n", handlename));
395
396 if ( strlen(handlename) < 3 ) {
397 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
398 return false;
399 }
400
401 /* it's a print server */
402 if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
403 DEBUGADD(4,("Printer is a print server\n"));
404 Printer->printer_type = SPLHND_SERVER;
405 }
406 /* it's a printer (set_printer_hnd_name() will handle port monitors */
407 else {
408 DEBUGADD(4,("Printer is a printer\n"));
409 Printer->printer_type = SPLHND_PRINTER;
410 }
411
412 return true;
413 }
414
415 /****************************************************************************
416 Set printer handle name.. Accept names like \\server, \\server\printer,
417 \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port" See
418 the MSDN docs regarding OpenPrinter() for details on the XcvData() and
419 XcvDataPort() interface.
420 ****************************************************************************/
421
422 static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
423 {
424 int snum;
425 int n_services=lp_numservices();
426 char *aprinter, *printername;
427 const char *servername;
428 fstring sname;
429 bool found = false;
430 NT_PRINTER_INFO_LEVEL *printer = NULL;
431 WERROR result;
432
433 DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
434 (unsigned long)strlen(handlename)));
435
436 aprinter = CONST_DISCARD(char *, handlename);
437 if ( *handlename == '\\' ) {
438 servername = canon_servername(handlename);
439 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
440 *aprinter = '\0';
441 aprinter++;
442 }
443 } else {
444 servername = global_myname();
445 }
446
447 /* save the servername to fill in replies on this handle */
448
449 if ( !is_myname_or_ipaddr( servername ) )
450 return false;
451
452 fstrcpy( Printer->servername, servername );
453
454 if ( Printer->printer_type == SPLHND_SERVER )
455 return true;
456
457 if ( Printer->printer_type != SPLHND_PRINTER )
458 return false;
459
460 DEBUGADD(5, ("searching for [%s]\n", aprinter ));
461
462 /* check for the Port Monitor Interface */
463
464 if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
465 Printer->printer_type = SPLHND_PORTMON_TCP;
466 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
467 found = true;
468 }
469 else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
470 Printer->printer_type = SPLHND_PORTMON_LOCAL;
471 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
472 found = true;
473 }
474
475 /* Search all sharenames first as this is easier than pulling
476 the printer_info_2 off of disk. Don't use find_service() since
477 that calls out to map_username() */
478
479 /* do another loop to look for printernames */
480
481 for (snum=0; !found && snum<n_services; snum++) {
482
483 /* no point going on if this is not a printer */
484
485 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
486 continue;
487
488 fstrcpy(sname, lp_servicename(snum));
489 if ( strequal( aprinter, sname ) ) {
490 found = true;
491 break;
492 }
493
494 /* no point looking up the printer object if
495 we aren't allowing printername != sharename */
496
497 if ( lp_force_printername(snum) )
498 continue;
499
500 fstrcpy(sname, lp_servicename(snum));
501
502 printer = NULL;
503
504 /* This call doesn't fill in the location or comment from
505 * a CUPS server for efficiency with large numbers of printers.
506 * JRA.
507 */
508
509 result = get_a_printer_search( 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, win_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 free_a_printer( &printer, 2);
528 found = true;
529 break;
530 }
531
532 DEBUGADD(10, ("printername: %s\n", printername));
533
534 free_a_printer( &printer, 2);
535 }
536
537 free_a_printer( &printer, 2);
538
539 if ( !found ) {
540 DEBUGADD(4,("Printer not found\n"));
541 return false;
542 }
543
544 DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
545
546 fstrcpy(Printer->sharename, sname);
547
548 return true;
549 }
550
551 /****************************************************************************
552 Find first available printer slot. creates a printer handle for you.
553 ****************************************************************************/
554
555 static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
556 const char *name, uint32_t access_granted)
557 {
558 Printer_entry *new_printer;
559
560 DEBUG(10,("open_printer_hnd: name [%s]\n", name));
561
562 new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
563 if (new_printer == NULL) {
564 return false;
565 }
566 talloc_set_destructor(new_printer, printer_entry_destructor);
567
568 if (!create_policy_hnd(p, hnd, new_printer)) {
569 TALLOC_FREE(new_printer);
570 return false;
571 }
572
573 /* Add to the internal list. */
574 DLIST_ADD(printers_list, new_printer);
575
576 new_printer->notify.option=NULL;
577
578 if (!set_printer_hnd_printertype(new_printer, name)) {
579 close_printer_handle(p, hnd);
580 return false;
581 }
582
583 if (!set_printer_hnd_name(new_printer, name)) {
584 close_printer_handle(p, hnd);
585 return false;
586 }
587
588 new_printer->access_granted = access_granted;
589
590 DEBUG(5, ("%d printer handles active\n",
591 (int)num_pipe_handles(p->pipe_handles)));
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_t flags, uint16_t notify_type,
602 uint16_t notify_field)
603 {
604 return true;
605 }
606
607 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
608 uint16_t notify_field)
609 {
610 struct spoolss_NotifyOption *option = p->notify.option;
611 uint32_t 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->types[i].type != notify_type)
633 continue;
634
635 /* Check match for field */
636
637 for (j = 0; j < option->types[i].count; j++) {
638 if (option->types[i].fields[j].field == 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 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
651 _data->data.integer[0] = _integer; \
652 _data->data.integer[1] = 0;
653
654
655 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
656 _data->data.string.string = talloc_strdup(mem_ctx, _p); \
657 if (!_data->data.string.string) {\
658 _data->data.string.size = 0; \
659 } \
660 _data->data.string.size = strlen_m_term(_p) * 2;
661
662 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
663 _data->data.devmode.devmode = _devmode;
664
665 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
666 _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
667 if (!_data->data.sd.sd) { \
668 _data->data.sd.sd_size = 0; \
669 } \
670 _data->data.sd.sd_size = _size;
671
672 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
673 struct tm *t,
674 const char **pp,
675 uint32_t *plen)
676 {
677 struct spoolss_Time st;
678 uint32_t len = 16;
679 char *p;
680
681 if (!init_systemtime(&st, t)) {
682 return;
683 }
684
685 p = talloc_array(mem_ctx, char, len);
686 if (!p) {
687 return;
688 }
689
690 /*
691 * Systemtime must be linearized as a set of UINT16's.
692 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
693 */
694
695 SSVAL(p, 0, st.year);
696 SSVAL(p, 2, st.month);
697 SSVAL(p, 4, st.day_of_week);
698 SSVAL(p, 6, st.day);
699 SSVAL(p, 8, st.hour);
700 SSVAL(p, 10, st.minute);
701 SSVAL(p, 12, st.second);
702 SSVAL(p, 14, st.millisecond);
703
704 *pp = p;
705 *plen = len;
706 }
707
708 /* Convert a notification message to a struct spoolss_Notify */
709
710 static void notify_one_value(struct spoolss_notify_msg *msg,
711 struct spoolss_Notify *data,
712 TALLOC_CTX *mem_ctx)
713 {
714 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
715 }
716
717 static void notify_string(struct spoolss_notify_msg *msg,
718 struct spoolss_Notify *data,
719 TALLOC_CTX *mem_ctx)
720 {
721 /* The length of the message includes the trailing \0 */
722
723 data->data.string.size = msg->len * 2;
724 data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
725 if (!data->data.string.string) {
726 data->data.string.size = 0;
727 return;
728 }
729 }
730
731 static void notify_system_time(struct spoolss_notify_msg *msg,
732 struct spoolss_Notify *data,
733 TALLOC_CTX *mem_ctx)
734 {
735 data->data.string.string = NULL;
736 data->data.string.size = 0;
737
738 if (msg->len != sizeof(time_t)) {
739 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
740 msg->len));
741 return;
742 }
743
744 init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
745 &data->data.string.string,
746 &data->data.string.size);
747 }
748
749 struct notify2_message_table {
750 const char *name;
751 void (*fn)(struct spoolss_notify_msg *msg,
752 struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
753 };
754
755 static struct notify2_message_table printer_notify_table[] = {
756 /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
757 /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
758 /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
759 /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
760 /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
761 /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
762 /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
763 /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
764 /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
765 /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
766 /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
767 /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
768 /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
769 /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
770 /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
771 /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
772 /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
773 /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
774 /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
775 };
776
777 static struct notify2_message_table job_notify_table[] = {
778 /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
779 /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
780 /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
781 /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
782 /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
783 /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
784 /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
785 /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
786 /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
787 /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
788 /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
789 /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
790 /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
791 /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
792 /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
793 /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
794 /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
795 /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
796 /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
797 /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
798 /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
799 /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
800 /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
801 /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
802 };
803
804
805 /***********************************************************************
806 Allocate talloc context for container object
807 **********************************************************************/
808
809 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
810 {
811 if ( !ctr )
812 return;
813
814 ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
815
816 return;
817 }
818
819 /***********************************************************************
820 release all allocated memory and zero out structure
821 **********************************************************************/
822
823 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
824 {
825 if ( !ctr )
826 return;
827
828 if ( ctr->ctx )
829 talloc_destroy(ctr->ctx);
830
831 ZERO_STRUCTP(ctr);
832
833 return;
834 }
835
836 /***********************************************************************
837 **********************************************************************/
838
839 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
840 {
841 if ( !ctr )
842 return NULL;
843
844 return ctr->ctx;
845 }
846
847 /***********************************************************************
848 **********************************************************************/
849
850 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
851 {
852 if ( !ctr || !ctr->msg_groups )
853 return NULL;
854
855 if ( idx >= ctr->num_groups )
856 return NULL;
857
858 return &ctr->msg_groups[idx];
859
860 }
861
862 /***********************************************************************
863 How many groups of change messages do we have ?
864 **********************************************************************/
865
866 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
867 {
868 if ( !ctr )
869 return 0;
870
871 return ctr->num_groups;
872 }
873
874 /***********************************************************************
875 Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
876 **********************************************************************/
877
878 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
879 {
880 SPOOLSS_NOTIFY_MSG_GROUP *groups = NULL;
881 SPOOLSS_NOTIFY_MSG_GROUP *msg_grp = NULL;
882 SPOOLSS_NOTIFY_MSG *msg_list = NULL;
883 int i, new_slot;
884
885 if ( !ctr || !msg )
886 return 0;
887
888 /* loop over all groups looking for a matching printer name */
889
890 for ( i=0; i<ctr->num_groups; i++ ) {
891 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
892 break;
893 }
894
895 /* add a new group? */
896
897 if ( i == ctr->num_groups ) {
898 ctr->num_groups++;
899
900 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
901 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
902 return 0;
903 }
904 ctr->msg_groups = groups;
905
906 /* clear the new entry and set the printer name */
907
908 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
909 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
910 }
911
912 /* add the change messages; 'i' is the correct index now regardless */
913
914 msg_grp = &ctr->msg_groups[i];
915
916 msg_grp->num_msgs++;
917
918 if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
919 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
920 return 0;
921 }
922 msg_grp->msgs = msg_list;
923
924 new_slot = msg_grp->num_msgs-1;
925 memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
926
927 /* need to allocate own copy of data */
928
929 if ( msg->len != 0 )
930 msg_grp->msgs[new_slot].notify.data = (char *)
931 TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
932
933 return ctr->num_groups;
934 }
935
936 /***********************************************************************
937 Send a change notication message on all handles which have a call
938 back registered
939 **********************************************************************/
940
941 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
942 {
943 Printer_entry *p;
944 TALLOC_CTX *mem_ctx = notify_ctr_getctx( ctr );
945 SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
946 SPOOLSS_NOTIFY_MSG *messages;
947 int sending_msg_count;
948
949 if ( !msg_group ) {
950 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
951 return;
952 }
953
954 messages = msg_group->msgs;
955
956 if ( !messages ) {
957 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
958 return;
959 }
960
961 DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
962
963 /* loop over all printers */
964
965 for (p = printers_list; p; p = p->next) {
966 struct spoolss_Notify *notifies;
967 uint32_t count = 0;
968 uint32_t id;
969 int i;
970
971 /* Is there notification on this handle? */
972
973 if ( !p->notify.client_connected )
974 continue;
975
976 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
977
978 /* For this printer? Print servers always receive
979 notifications. */
980
981 if ( ( p->printer_type == SPLHND_PRINTER ) &&
982 ( !strequal(msg_group->printername, p->sharename) ) )
983 continue;
984
985 DEBUG(10,("Our printer\n"));
986
987 /* allocate the max entries possible */
988
989 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
990 if (!notifies) {
991 return;
992 }
993
994 /* build the array of change notifications */
995
996 sending_msg_count = 0;
997
998 for ( i=0; i<msg_group->num_msgs; i++ ) {
999 SPOOLSS_NOTIFY_MSG *msg = &messages[i];
1000
1001 /* Are we monitoring this event? */
1002
1003 if (!is_monitoring_event(p, msg->type, msg->field))
1004 continue;
1005
1006 sending_msg_count++;
1007
1008
1009 DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1010 msg->type, msg->field, p->sharename));
1011
1012 /*
1013 * if the is a printer notification handle and not a job notification
1014 * type, then set the id to 0. Other wise just use what was specified
1015 * in the message.
1016 *
1017 * When registering change notification on a print server handle
1018 * we always need to send back the id (snum) matching the printer
1019 * for which the change took place. For change notify registered
1020 * on a printer handle, this does not matter and the id should be 0.
1021 *
1022 * --jerry
1023 */
1024
1025 if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1026 id = 0;
1027 else
1028 id = msg->id;
1029
1030
1031 /* Convert unix jobid to smb jobid */
1032
1033 if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1034 id = sysjob_to_jobid(msg->id);
1035
1036 if (id == -1) {
1037 DEBUG(3, ("no such unix jobid %d\n", msg->id));
1038 goto done;
1039 }
1040 }
1041
1042 construct_info_data( &notifies[count], msg->type, msg->field, id );
1043
1044 switch(msg->type) {
1045 case PRINTER_NOTIFY_TYPE:
1046 if ( printer_notify_table[msg->field].fn )
1047 printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1048 break;
1049
1050 case JOB_NOTIFY_TYPE:
1051 if ( job_notify_table[msg->field].fn )
1052 job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1053 break;
1054
1055 default:
1056 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1057 goto done;
1058 }
1059
1060 count++;
1061 }
1062
1063 if ( sending_msg_count ) {
1064 NTSTATUS status;
1065 WERROR werr;
1066 union spoolss_ReplyPrinterInfo info;
1067 struct spoolss_NotifyInfo info0;
1068 uint32_t reply_result;
1069
1070 info0.version = 0x2;
1071 info0.flags = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1072 info0.count = count;
1073 info0.notifies = notifies;
1074
1075 info.info0 = &info0;
1076
1077 status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1078 &p->notify.client_hnd,
1079 p->notify.change, /* color */
1080 p->notify.flags,
1081 &reply_result,
1082 0, /* reply_type, must be 0 */
1083 info,
1084 &werr);
1085 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1086 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1087 notify_cli_pipe->srv_name_slash,
1088 win_errstr(werr)));
1089 }
1090 switch (reply_result) {
1091 case 0:
1092 break;
1093 case PRINTER_NOTIFY_INFO_DISCARDED:
1094 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1095 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1096 break;
1097 default:
1098 break;
1099 }
1100 }
1101 }
1102
1103 done:
1104 DEBUG(8,("send_notify2_changes: Exit...\n"));
1105 return;
1106 }
1107
1108 /***********************************************************************
1109 **********************************************************************/
1110
1111 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1112 {
1113
1114 uint32_t tv_sec, tv_usec;
1115 size_t offset = 0;
1116
1117 /* Unpack message */
1118
1119 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1120 msg->printer);
1121
1122 offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1123 &tv_sec, &tv_usec,
1124 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1125
1126 if (msg->len == 0)
1127 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1128 &msg->notify.value[0], &msg->notify.value[1]);
1129 else
1130 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1131 &msg->len, &msg->notify.data);
1132
1133 DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1134 msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1135
1136 tv->tv_sec = tv_sec;
1137 tv->tv_usec = tv_usec;
1138
1139 if (msg->len == 0)
1140 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1141 msg->notify.value[1]));
1142 else
1143 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1144
1145 return true;
1146 }
1147
1148 /********************************************************************
1149 Receive a notify2 message list
1150 ********************************************************************/
1151
1152 static void receive_notify2_message_list(struct messaging_context *msg,
1153 void *private_data,
1154 uint32_t msg_type,
1155 struct server_id server_id,
1156 DATA_BLOB *data)
1157 {
1158 size_t msg_count, i;
1159 char *buf = (char *)data->data;
1160 char *msg_ptr;
1161 size_t msg_len;
1162 SPOOLSS_NOTIFY_MSG notify;
1163 SPOOLSS_NOTIFY_MSG_CTR messages;
1164 int num_groups;
1165
1166 if (data->length < 4) {
1167 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1168 return;
1169 }
1170
1171 msg_count = IVAL(buf, 0);
1172 msg_ptr = buf + 4;
1173
1174 DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1175
1176 if (msg_count == 0) {
1177 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1178 return;
1179 }
1180
1181 /* initialize the container */
1182
1183 ZERO_STRUCT( messages );
1184 notify_msg_ctr_init( &messages );
1185
1186 /*
1187 * build message groups for each printer identified
1188 * in a change_notify msg. Remember that a PCN message
1189 * includes the handle returned for the srv_spoolss_replyopenprinter()
1190 * call. Therefore messages are grouped according to printer handle.
1191 */
1192
1193 for ( i=0; i<msg_count; i++ ) {
1194 struct timeval msg_tv;
1195
1196 if (msg_ptr + 4 - buf > data->length) {
1197 DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1198 return;
1199 }
1200
1201 msg_len = IVAL(msg_ptr,0);
1202 msg_ptr += 4;
1203
1204 if (msg_ptr + msg_len - buf > data->length) {
1205 DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1206 return;
1207 }
1208
1209 /* unpack messages */
1210
1211 ZERO_STRUCT( notify );
1212 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1213 msg_ptr += msg_len;
1214
1215 /* add to correct list in container */
1216
1217 notify_msg_ctr_addmsg( &messages, &notify );
1218
1219 /* free memory that might have been allocated by notify2_unpack_msg() */
1220
1221 if ( notify.len != 0 )
1222 SAFE_FREE( notify.notify.data );
1223 }
1224
1225 /* process each group of messages */
1226
1227 num_groups = notify_msg_ctr_numgroups( &messages );
1228 for ( i=0; i<num_groups; i++ )
1229 send_notify2_changes( &messages, i );
1230
1231
1232 /* cleanup */
1233
1234 DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1235 (uint32_t)msg_count ));
1236
1237 notify_msg_ctr_destroy( &messages );
1238
1239 return;
1240 }
1241
1242 /********************************************************************
1243 Send a message to ourself about new driver being installed
1244 so we can upgrade the information for each printer bound to this
1245 driver
1246 ********************************************************************/
1247
1248 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1249 {
1250 int len = strlen(drivername);
1251
1252 if (!len)
1253 return false;
1254
1255 DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1256 drivername));
1257
1258 messaging_send_buf(smbd_messaging_context(), procid_self(),
1259 MSG_PRINTER_DRVUPGRADE,
1260 (uint8_t *)drivername, len+1);
1261
1262 return true;
1263 }
1264
1265 /**********************************************************************
1266 callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1267 over all printers, upgrading ones as necessary
1268 **********************************************************************/
1269
1270 void do_drv_upgrade_printer(struct messaging_context *msg,
1271 void *private_data,
1272 uint32_t msg_type,
1273 struct server_id server_id,
1274 DATA_BLOB *data)
1275 {
1276 fstring drivername;
1277 int snum;
1278 int n_services = lp_numservices();
1279 size_t len;
1280
1281 len = MIN(data->length,sizeof(drivername)-1);
1282 strncpy(drivername, (const char *)data->data, len);
1283
1284 DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1285
1286 /* Iterate the printer list */
1287
1288 for (snum=0; snum<n_services; snum++)
1289 {
1290 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1291 {
1292 WERROR result;
1293 NT_PRINTER_INFO_LEVEL *printer = NULL;
1294
1295 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1296 if (!W_ERROR_IS_OK(result))
1297 continue;
1298
1299 if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1300 {
1301 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1302
1303 /* all we care about currently is the change_id */
1304
1305 result = mod_a_printer(printer, 2);
1306 if (!W_ERROR_IS_OK(result)) {
1307 DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1308 win_errstr(result)));
1309 }
1310 }
1311
1312 free_a_printer(&printer, 2);
1313 }
1314 }
1315
1316 /* all done */
1317 }
1318
1319 /********************************************************************
1320 Update the cache for all printq's with a registered client
1321 connection
1322 ********************************************************************/
1323
1324 void update_monitored_printq_cache( void )
1325 {
1326 Printer_entry *printer = printers_list;
1327 int snum;
1328
1329 /* loop through all printers and update the cache where
1330 client_connected == true */
1331 while ( printer )
1332 {
1333 if ( (printer->printer_type == SPLHND_PRINTER)
1334 && printer->notify.client_connected )
1335 {
1336 snum = print_queue_snum(printer->sharename);
1337 print_queue_status( snum, NULL, NULL );
1338 }
1339
1340 printer = printer->next;
1341 }
1342
1343 return;
1344 }
1345 /********************************************************************
1346 Send a message to ourself about new driver being installed
1347 so we can upgrade the information for each printer bound to this
1348 driver
1349 ********************************************************************/
1350
1351 static bool srv_spoolss_reset_printerdata(char* drivername)
1352 {
1353 int len = strlen(drivername);
1354
1355 if (!len)
1356 return false;
1357
1358 DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1359 drivername));
1360
1361 messaging_send_buf(smbd_messaging_context(), procid_self(),
1362 MSG_PRINTERDATA_INIT_RESET,
1363 (uint8_t *)drivername, len+1);
1364
1365 return true;
1366 }
1367
1368 /**********************************************************************
1369 callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1370 over all printers, resetting printer data as neessary
1371 **********************************************************************/
1372
1373 void reset_all_printerdata(struct messaging_context *msg,
1374 void *private_data,
1375 uint32_t msg_type,
1376 struct server_id server_id,
1377 DATA_BLOB *data)
1378 {
1379 fstring drivername;
1380 int snum;
1381 int n_services = lp_numservices();
1382 size_t len;
1383
1384 len = MIN( data->length, sizeof(drivername)-1 );
1385 strncpy( drivername, (const char *)data->data, len );
1386
1387 DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1388
1389 /* Iterate the printer list */
1390
1391 for ( snum=0; snum<n_services; snum++ )
1392 {
1393 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1394 {
1395 WERROR result;
1396 NT_PRINTER_INFO_LEVEL *printer = NULL;
1397
1398 result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1399 if ( !W_ERROR_IS_OK(result) )
1400 continue;
1401
1402 /*
1403 * if the printer is bound to the driver,
1404 * then reset to the new driver initdata
1405 */
1406
1407 if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1408 {
1409 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1410
1411 if ( !set_driver_init(printer, 2) ) {
1412 DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1413 printer->info_2->printername, printer->info_2->drivername));
1414 }
1415
1416 result = mod_a_printer( printer, 2 );
1417 if ( !W_ERROR_IS_OK(result) ) {
1418 DEBUG(3,("reset_all_printerdata: mod_a_printer() failed! (%s)\n",
1419 get_dos_error_msg(result)));
1420 }
1421 }
1422
1423 free_a_printer( &printer, 2 );
1424 }
1425 }
1426
1427 /* all done */
1428
1429 return;
1430 }
1431
1432 /****************************************************************
1433 _spoolss_OpenPrinter
1434 ****************************************************************/
1435
1436 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1437 struct spoolss_OpenPrinter *r)
1438 {
1439 struct spoolss_OpenPrinterEx e;
1440 WERROR werr;
1441
1442 ZERO_STRUCT(e.in.userlevel);
1443
1444 e.in.printername = r->in.printername;
1445 e.in.datatype = r->in.datatype;
1446 e.in.devmode_ctr = r->in.devmode_ctr;
1447 e.in.access_mask = r->in.access_mask;
1448 e.in.level = 0;
1449
1450 e.out.handle = r->out.handle;
1451
1452 werr = _spoolss_OpenPrinterEx(p, &e);
1453
1454 if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1455 /* OpenPrinterEx returns this for a bad
1456 * printer name. We must return WERR_INVALID_PRINTER_NAME
1457 * instead.
1458 */
1459 werr = WERR_INVALID_PRINTER_NAME;
1460 }
1461
1462 return werr;
1463 }
1464
1465 /********************************************************************
1466 ********************************************************************/
1467
1468 bool convert_devicemode(const char *printername,
1469 const struct spoolss_DeviceMode *devmode,
1470 NT_DEVICEMODE **pp_nt_devmode)
1471 {
1472 NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1473
1474 /*
1475 * Ensure nt_devmode is a valid pointer
1476 * as we will be overwriting it.
1477 */
1478
1479 if (nt_devmode == NULL) {
1480 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1481 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1482 return false;
1483 }
1484
1485 rpcstr_push(nt_devmode->devicename, devmode->devicename, 31, 0);
1486 rpcstr_push(nt_devmode->formname, devmode->formname, 31, 0);
1487
1488 nt_devmode->specversion = devmode->specversion;
1489 nt_devmode->driverversion = devmode->driverversion;
1490 nt_devmode->size = devmode->size;
1491 nt_devmode->fields = devmode->fields;
1492 nt_devmode->orientation = devmode->orientation;
1493 nt_devmode->papersize = devmode->papersize;
1494 nt_devmode->paperlength = devmode->paperlength;
1495 nt_devmode->paperwidth = devmode->paperwidth;
1496 nt_devmode->scale = devmode->scale;
1497 nt_devmode->copies = devmode->copies;
1498 nt_devmode->defaultsource = devmode->defaultsource;
1499 nt_devmode->printquality = devmode->printquality;
1500 nt_devmode->color = devmode->color;
1501 nt_devmode->duplex = devmode->duplex;
1502 nt_devmode->yresolution = devmode->yresolution;
1503 nt_devmode->ttoption = devmode->ttoption;
1504 nt_devmode->collate = devmode->collate;
1505
1506 nt_devmode->logpixels = devmode->logpixels;
1507 nt_devmode->bitsperpel = devmode->bitsperpel;
1508 nt_devmode->pelswidth = devmode->pelswidth;
1509 nt_devmode->pelsheight = devmode->pelsheight;
1510 nt_devmode->displayflags = devmode->displayflags;
1511 nt_devmode->displayfrequency = devmode->displayfrequency;
1512 nt_devmode->icmmethod = devmode->icmmethod;
1513 nt_devmode->icmintent = devmode->icmintent;
1514 nt_devmode->mediatype = devmode->mediatype;
1515 nt_devmode->dithertype = devmode->dithertype;
1516 nt_devmode->reserved1 = devmode->reserved1;
1517 nt_devmode->reserved2 = devmode->reserved2;
1518 nt_devmode->panningwidth = devmode->panningwidth;
1519 nt_devmode->panningheight = devmode->panningheight;
1520
1521 /*
1522 * Only change private and driverextra if the incoming devmode
1523 * has a new one. JRA.
1524 */
1525
1526 if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1527 SAFE_FREE(nt_devmode->nt_dev_private);
1528 nt_devmode->driverextra = devmode->__driverextra_length;
1529 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1530 return false;
1531 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1532 }
1533
1534 *pp_nt_devmode = nt_devmode;
1535
1536 return true;
1537 }
1538
1539 /****************************************************************
1540 _spoolss_OpenPrinterEx
1541 ****************************************************************/
1542
1543 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1544 struct spoolss_OpenPrinterEx *r)
1545 {
1546 int snum;
1547 Printer_entry *Printer=NULL;
1548
1549 if (!r->in.printername) {
1550 return WERR_INVALID_PARAM;
1551 }
1552
1553 /* some sanity check because you can open a printer or a print server */
1554 /* aka: \\server\printer or \\server */
1555
1556 DEBUGADD(3,("checking name: %s\n", r->in.printername));
1557
1558 if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1559 ZERO_STRUCTP(r->out.handle);
1560 return WERR_INVALID_PARAM;
1561 }
1562
1563 Printer = find_printer_index_by_hnd(p, r->out.handle);
1564 if ( !Printer ) {
1565 DEBUG(0,("_spoolss_OpenPrinterEx: logic error. Can't find printer "
1566 "handle we created for printer %s\n", r->in.printername));
1567 close_printer_handle(p, r->out.handle);
1568 ZERO_STRUCTP(r->out.handle);
1569 return WERR_INVALID_PARAM;
1570 }
1571
1572 /*
1573 * First case: the user is opening the print server:
1574 *
1575 * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1576 * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1577 *
1578 * Then both Win2k and WinNT clients try an OpenPrinterEx with
1579 * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1580 * or if the user is listed in the smb.conf printer admin parameter.
1581 *
1582 * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1583 * client view printer folder, but does not show the MSAPW.
1584 *
1585 * Note: this test needs code to check access rights here too. Jeremy
1586 * could you look at this?
1587 *
1588 * Second case: the user is opening a printer:
1589 * NT doesn't let us connect to a printer if the connecting user
1590 * doesn't have print permission.
1591 *
1592 * Third case: user is opening a Port Monitor
1593 * access checks same as opening a handle to the print server.
1594 */
1595
1596 switch (Printer->printer_type )
1597 {
1598 case SPLHND_SERVER:
1599 case SPLHND_PORTMON_TCP:
1600 case SPLHND_PORTMON_LOCAL:
1601 /* Printserver handles use global struct... */
1602
1603 snum = -1;
1604
1605 /* Map standard access rights to object specific access rights */
1606
1607 se_map_standard(&r->in.access_mask,
1608 &printserver_std_mapping);
1609
1610 /* Deny any object specific bits that don't apply to print
1611 servers (i.e printer and job specific bits) */
1612
1613 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1614
1615 if (r->in.access_mask &
1616 ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1617 DEBUG(3, ("access DENIED for non-printserver bits\n"));
1618 close_printer_handle(p, r->out.handle);
1619 ZERO_STRUCTP(r->out.handle);
1620 return WERR_ACCESS_DENIED;
1621 }
1622
1623 /* Allow admin access */
1624
1625 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1626 {
1627 SE_PRIV se_printop = SE_PRINT_OPERATOR;
1628
1629 if (!lp_ms_add_printer_wizard()) {
1630 close_printer_handle(p, r->out.handle);
1631 ZERO_STRUCTP(r->out.handle);
1632 return WERR_ACCESS_DENIED;
1633 }
1634
1635 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1636 and not a printer admin, then fail */
1637
1638 if ((p->server_info->utok.uid != sec_initial_uid()) &&
1639 !user_has_privileges(p->server_info->ptok,
1640 &se_printop ) &&
1641 !token_contains_name_in_list(
1642 uidtoname(p->server_info->utok.uid),
1643 NULL, NULL,
1644 p->server_info->ptok,
1645 lp_printer_admin(snum))) {
1646 close_printer_handle(p, r->out.handle);
1647 ZERO_STRUCTP(r->out.handle);
1648 return WERR_ACCESS_DENIED;
1649 }
1650
1651 r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1652 }
1653 else
1654 {
1655 r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1656 }
1657
1658 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1659 ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1660
1661 /* We fall through to return WERR_OK */
1662 break;
1663
1664 case SPLHND_PRINTER:
1665 /* NT doesn't let us connect to a printer if the connecting user
1666 doesn't have print permission. */
1667
1668 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1669 close_printer_handle(p, r->out.handle);
1670 ZERO_STRUCTP(r->out.handle);
1671 return WERR_BADFID;
1672 }
1673
1674 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1675
1676 /* map an empty access mask to the minimum access mask */
1677 if (r->in.access_mask == 0x0)
1678 r->in.access_mask = PRINTER_ACCESS_USE;
1679
1680 /*
1681 * If we are not serving the printer driver for this printer,
1682 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE. This
1683 * will keep NT clients happy --jerry
1684 */
1685
1686 if (lp_use_client_driver(snum)
1687 && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1688 {
1689 r->in.access_mask = PRINTER_ACCESS_USE;
1690 }
1691
1692 /* check smb.conf parameters and the the sec_desc */
1693
1694 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1695 DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1696 ZERO_STRUCTP(r->out.handle);
1697 return WERR_ACCESS_DENIED;
1698 }
1699
1700 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1701 p->server_info->ptok, snum) ||
1702 !print_access_check(p->server_info, snum,
1703 r->in.access_mask)) {
1704 DEBUG(3, ("access DENIED for printer open\n"));
1705 close_printer_handle(p, r->out.handle);
1706 ZERO_STRUCTP(r->out.handle);
1707 return WERR_ACCESS_DENIED;
1708 }
1709
1710 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1711 DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1712 close_printer_handle(p, r->out.handle);
1713 ZERO_STRUCTP(r->out.handle);
1714 return WERR_ACCESS_DENIED;
1715 }
1716
1717 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1718 r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1719 else
1720 r->in.access_mask = PRINTER_ACCESS_USE;
1721
1722 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1723 ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1724
1725 break;
1726
1727 default:
1728 /* sanity check to prevent programmer error */
1729 ZERO_STRUCTP(r->out.handle);
1730 return WERR_BADFID;
1731 }
1732
1733 Printer->access_granted = r->in.access_mask;
1734
1735 /*
1736 * If the client sent a devmode in the OpenPrinter() call, then
1737 * save it here in case we get a job submission on this handle
1738 */
1739
1740 if ((Printer->printer_type != SPLHND_SERVER) &&
1741 r->in.devmode_ctr.devmode) {
1742 convert_devicemode(Printer->sharename,
1743 r->in.devmode_ctr.devmode,
1744 &Printer->nt_devmode);
1745 }
1746
1747 #if 0 /* JERRY -- I'm doubtful this is really effective */
1748 /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1749 optimization in Windows 2000 clients --jerry */
1750
1751 if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1752 && (RA_WIN2K == get_remote_arch()) )
1753 {
1754 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1755 sys_usleep( 500000 );
1756 }
1757 #endif
1758
1759 return WERR_OK;
1760 }
1761
1762 /****************************************************************************
1763 ****************************************************************************/
1764
1765 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1766 NT_PRINTER_INFO_LEVEL_2 *d)
1767 {
1768 DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1769
1770 if (!r || !d) {
1771 return false;
1772 }
1773
1774 d->attributes = r->attributes;
1775 d->priority = r->priority;
1776 d->default_priority = r->defaultpriority;
1777 d->starttime = r->starttime;
1778 d->untiltime = r->untiltime;
1779 d->status = r->status;
1780 d->cjobs = r->cjobs;
1781
1782 fstrcpy(d->servername, r->servername);
1783 fstrcpy(d->printername, r->printername);
1784 fstrcpy(d->sharename, r->sharename);
1785 fstrcpy(d->portname, r->portname);
1786 fstrcpy(d->drivername, r->drivername);
1787 slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1788 fstrcpy(d->location, r->location);
1789 fstrcpy(d->sepfile, r->sepfile);
1790 fstrcpy(d->printprocessor, r->printprocessor);
1791 fstrcpy(d->datatype, r->datatype);
1792 fstrcpy(d->parameters, r->parameters);
1793
1794 return true;
1795 }
1796
1797 /****************************************************************************
1798 ****************************************************************************/
1799
1800 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1801 NT_PRINTER_INFO_LEVEL *printer)
1802 {
1803 bool ret;
1804
1805 switch (info_ctr->level) {
1806 case 2:
1807 /* allocate memory if needed. Messy because
1808 convert_printer_info is used to update an existing
1809 printer or build a new one */
1810
1811 if (!printer->info_2) {
1812 printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1813 if (!printer->info_2) {
1814 DEBUG(0,("convert_printer_info: "
1815 "talloc() failed!\n"));
1816 return false;
1817 }
1818 }
1819
1820 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1821 printer->info_2);
1822 printer->info_2->setuptime = time(NULL);
1823 return ret;
1824 }
1825
1826 return false;
1827 }
1828
1829 /*******************************************************************
1830 ********************************************************************/
1831
1832 static bool string_array_to_fstring_array(const char **sarray, fstring **farray)
1833 {
1834 int i;
1835
1836 if (!sarray) {
1837 *farray = NULL;
1838 return true;
1839 }
1840
1841 *farray = SMB_MALLOC_ARRAY(fstring, 1);
1842 if (!*farray) {
1843 return false;
1844 }
1845
1846 for (i=0; sarray[i] != NULL; i++) {
1847 *farray = SMB_REALLOC_ARRAY(*farray, fstring, i+2);
1848 if (!*farray) {
1849 return false;
1850 }
1851 fstrcpy((*farray)[i], sarray[i]);
1852 }
1853
1854 fstrcpy((*farray)[i], "");
1855
1856 return true;
1857 }
1858
1859 /*******************************************************************
1860 ********************************************************************/
1861
1862 static bool driver_info3_to_nt_driver_info3(struct spoolss_AddDriverInfo3 *r,
1863 NT_PRINTER_DRIVER_INFO_LEVEL_3 **p)
1864 {
1865 NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
1866
1867 DEBUG(7,("driver_info3_to_nt_driver_info3: Converting from UNICODE to ASCII\n"));
1868
1869 if (*p == NULL) {
1870 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
1871 if (*p == NULL) {
1872 return false;
1873 }
1874 ZERO_STRUCTP(*p);
1875 }
1876
1877 d = *p;
1878
1879 d->cversion = r->version;
1880
1881 fstrcpy(d->name, r->driver_name);
1882 fstrcpy(d->environment, r->architecture);
1883 fstrcpy(d->driverpath, r->driver_path);
1884 fstrcpy(d->datafile, r->data_file);
1885 fstrcpy(d->configfile, r->config_file);
1886 fstrcpy(d->helpfile, r->help_file);
1887 fstrcpy(d->monitorname, r->monitor_name);
1888 fstrcpy(d->defaultdatatype, r->default_datatype);
1889
1890 DEBUGADD(8,( "version: %d\n", d->cversion));
1891 DEBUGADD(8,( "name: %s\n", d->name));
1892 DEBUGADD(8,( "environment: %s\n", d->environment));
1893 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
1894 DEBUGADD(8,( "datafile: %s\n", d->datafile));
1895 DEBUGADD(8,( "configfile: %s\n", d->configfile));
1896 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
1897 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
1898 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1899
1900 if (r->dependent_files) {
1901 if (!string_array_to_fstring_array(r->dependent_files->string,
1902 &d->dependentfiles)) {
1903 SAFE_FREE(*p);
1904 return false;
1905 }
1906 }
1907
1908 return true;
1909 }
1910
1911 /*******************************************************************
1912 ********************************************************************/
1913
1914 static bool driver_info6_to_nt_driver_info6(struct spoolss_AddDriverInfo6 *r,
1915 NT_PRINTER_DRIVER_INFO_LEVEL_6 **p)
1916 {
1917 NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
1918
1919 DEBUG(7,("driver_info6_to_nt_driver_info6: Converting from UNICODE to ASCII\n"));
1920
1921 if (*p == NULL) {
1922 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
1923 if (*p == NULL) {
1924 return false;
1925 }
1926 ZERO_STRUCTP(*p);
1927 }
1928
1929 d = *p;
1930
1931 d->version = r->version;
1932
1933 fstrcpy(d->name, r->driver_name);
1934 fstrcpy(d->environment, r->architecture);
1935 fstrcpy(d->driverpath, r->driver_path);
1936 fstrcpy(d->datafile, r->data_file);
1937 fstrcpy(d->configfile, r->config_file);
1938 fstrcpy(d->helpfile, r->help_file);
1939 fstrcpy(d->monitorname, r->monitor_name);
1940 fstrcpy(d->defaultdatatype, r->default_datatype);
1941
1942 DEBUGADD(8,( "version: %d\n", d->version));
1943 DEBUGADD(8,( "name: %s\n", d->name));
1944 DEBUGADD(8,( "environment: %s\n", d->environment));
1945 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
1946 DEBUGADD(8,( "datafile: %s\n", d->datafile));
1947 DEBUGADD(8,( "configfile: %s\n", d->configfile));
1948 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
1949 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
1950 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1951
1952 if (r->dependent_files) {
1953 if (!string_array_to_fstring_array(r->dependent_files->string,
1954 &d->dependentfiles)) {
1955 goto error;
1956 }
1957 }
1958
1959 if (r->previous_names) {
1960 if (!string_array_to_fstring_array(r->previous_names->string,
1961 &d->previousnames)) {
1962 goto error;
1963 }
1964 }
1965
1966 return true;
1967
1968 error:
1969 SAFE_FREE(*p);
1970 return false;
1971 }
1972
1973 /********************************************************************
1974 ********************************************************************/
1975
1976 static bool convert_printer_driver_info(const struct spoolss_AddDriverInfoCtr *r,
1977 NT_PRINTER_DRIVER_INFO_LEVEL *printer,
1978 uint32_t level)
1979 {
1980 switch (level) {
1981 case 3:
1982 printer->info_3 = NULL;
1983 if (!driver_info3_to_nt_driver_info3(r->info.info3, &printer->info_3)) {
1984 return false;
1985 }
1986 break;
1987 case 6:
1988 printer->info_6 = NULL;
1989 if (!driver_info6_to_nt_driver_info6(r->info.info6, &printer->info_6)) {
1990 return false;
1991 }
1992 break;
1993 default:
1994 return false;
1995 }
1996
1997 return true;
1998 }
1999
2000 /****************************************************************
2001 _spoolss_ClosePrinter
2002 ****************************************************************/
2003
2004 WERROR _spoolss_ClosePrinter(pipes_struct *p,
2005 struct spoolss_ClosePrinter *r)
2006 {
2007 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2008
2009 if (Printer && Printer->document_started) {
2010 struct spoolss_EndDocPrinter e;
2011
2012 e.in.handle = r->in.handle;
2013
2014 _spoolss_EndDocPrinter(p, &e);
2015 }
2016
2017 if (!close_printer_handle(p, r->in.handle))
2018 return WERR_BADFID;
2019
2020 /* clear the returned printer handle. Observed behavior
2021 from Win2k server. Don't think this really matters.
2022 Previous code just copied the value of the closed
2023 handle. --jerry */
2024
2025 ZERO_STRUCTP(r->out.handle);
2026
2027 return WERR_OK;
2028 }
2029
2030 /****************************************************************
2031 _spoolss_DeletePrinter
2032 ****************************************************************/
2033
2034 WERROR _spoolss_DeletePrinter(pipes_struct *p,
2035 struct spoolss_DeletePrinter *r)
2036 {
2037 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2038 WERROR result;
2039
2040 if (Printer && Printer->document_started) {
2041 struct spoolss_EndDocPrinter e;
2042
2043 e.in.handle = r->in.handle;
2044
2045 _spoolss_EndDocPrinter(p, &e);
2046 }
2047
2048 result = delete_printer_handle(p, r->in.handle);
2049
2050 update_c_setprinter(false);
2051
2052 return result;
2053 }
2054
2055 /*******************************************************************
2056 * static function to lookup the version id corresponding to an
2057 * long architecture string
2058 ******************************************************************/
2059
2060 static int get_version_id(const char *arch)
2061 {
2062 int i;
2063 struct print_architecture_table_node archi_table[]= {
2064
2065 {"Windows 4.0", "WIN40", 0 },
2066 {"Windows NT x86", "W32X86", 2 },
2067 {"Windows NT R4000", "W32MIPS", 2 },
2068 {"Windows NT Alpha_AXP", "W32ALPHA", 2 },
2069 {"Windows NT PowerPC", "W32PPC", 2 },
2070 {"Windows IA64", "IA64", 3 },
2071 {"Windows x64", "x64", 3 },
2072 {NULL, "", -1 }
2073 };
2074
2075 for (i=0; archi_table[i].long_archi != NULL; i++)
2076 {
2077 if (strcmp(arch, archi_table[i].long_archi) == 0)
2078 return (archi_table[i].version);
2079 }
2080
2081 return -1;
2082 }
2083
2084 /****************************************************************
2085 _spoolss_DeletePrinterDriver
2086 ****************************************************************/
2087
2088 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
2089 struct spoolss_DeletePrinterDriver *r)
2090 {
2091 NT_PRINTER_DRIVER_INFO_LEVEL info;
2092 NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
2093 int version;
2094 WERROR status;
2095 WERROR status_win2k = WERR_ACCESS_DENIED;
2096 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2097
2098 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2099 and not a printer admin, then fail */
2100
2101 if ( (p->server_info->utok.uid != sec_initial_uid())
2102 && !user_has_privileges(p->server_info->ptok, &se_printop )
2103 && !token_contains_name_in_list(
2104 uidtoname(p->server_info->utok.uid), NULL,
2105 NULL, p->server_info->ptok,
2106 lp_printer_admin(-1)) )
2107 {
2108 return WERR_ACCESS_DENIED;
2109 }
2110
2111 /* check that we have a valid driver name first */
2112
2113 if ((version = get_version_id(r->in.architecture)) == -1)
2114 return WERR_INVALID_ENVIRONMENT;
2115
2116 ZERO_STRUCT(info);
2117 ZERO_STRUCT(info_win2k);
2118
2119 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2120 r->in.architecture,
2121 version)))
2122 {
2123 /* try for Win2k driver if "Windows NT x86" */
2124
2125 if ( version == 2 ) {
2126 version = 3;
2127 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3,
2128 r->in.driver,
2129 r->in.architecture,
2130 version))) {
2131 status = WERR_UNKNOWN_PRINTER_DRIVER;
2132 goto done;
2133 }
2134 }
2135 /* otherwise it was a failure */
2136 else {
2137 status = WERR_UNKNOWN_PRINTER_DRIVER;
2138 goto done;
2139 }
2140
2141 }
2142
2143 if (printer_driver_in_use(info.info_3)) {
2144 status = WERR_PRINTER_DRIVER_IN_USE;
2145 goto done;
2146 }
2147
2148 if ( version == 2 )
2149 {
2150 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2151 r->in.driver,
2152 r->in.architecture, 3)))
2153 {
2154 /* if we get to here, we now have 2 driver info structures to remove */
2155 /* remove the Win2k driver first*/
2156
2157 status_win2k = delete_printer_driver(
2158 p, info_win2k.info_3, 3, false);
2159 free_a_printer_driver( info_win2k, 3 );
2160
2161 /* this should not have failed---if it did, report to client */
2162 if ( !W_ERROR_IS_OK(status_win2k) )
2163 {
2164 status = status_win2k;
2165 goto done;
2166 }
2167 }
2168 }
2169
2170 status = delete_printer_driver(p, info.info_3, version, false);
2171
2172 /* if at least one of the deletes succeeded return OK */
2173
2174 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2175 status = WERR_OK;
2176
2177 done:
2178 free_a_printer_driver( info, 3 );
2179
2180 return status;
2181 }
2182
2183 /****************************************************************
2184 _spoolss_DeletePrinterDriverEx
2185 ****************************************************************/
2186
2187 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2188 struct spoolss_DeletePrinterDriverEx *r)
2189 {
2190 NT_PRINTER_DRIVER_INFO_LEVEL info;
2191 NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
2192 int version;
2193 bool delete_files;
2194 WERROR status;
2195 WERROR status_win2k = WERR_ACCESS_DENIED;
2196 SE_PRIV se_printop = SE_PRINT_OPERATOR;
2197
2198 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2199 and not a printer admin, then fail */
2200
2201 if ( (p->server_info->utok.uid != sec_initial_uid())
2202 && !user_has_privileges(p->server_info->ptok, &se_printop )
2203 && !token_contains_name_in_list(
2204 uidtoname(p->server_info->utok.uid), NULL, NULL,
2205 p->server_info->ptok, lp_printer_admin(-1)) )
2206 {
2207 return WERR_ACCESS_DENIED;
2208 }
2209
2210 /* check that we have a valid driver name first */
2211 if ((version = get_version_id(r->in.architecture)) == -1) {
2212 /* this is what NT returns */
2213 return WERR_INVALID_ENVIRONMENT;
2214 }
2215
2216 if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2217 version = r->in.version;
2218
2219 ZERO_STRUCT(info);
2220 ZERO_STRUCT(info_win2k);
2221
2222 status = get_a_printer_driver(&info, 3, r->in.driver,
2223 r->in.architecture, version);
2224
2225 if ( !W_ERROR_IS_OK(status) )
2226 {
2227 /*
2228 * if the client asked for a specific version,
2229 * or this is something other than Windows NT x86,
2230 * then we've failed
2231 */
2232
2233 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2234 goto done;
2235
2236 /* try for Win2k driver if "Windows NT x86" */
2237
2238 version = 3;
2239 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2240 r->in.architecture,
2241 version))) {
2242 status = WERR_UNKNOWN_PRINTER_DRIVER;
2243 goto done;
2244 }
2245 }
2246
2247 if ( printer_driver_in_use(info.info_3) ) {
2248 status = WERR_PRINTER_DRIVER_IN_USE;
2249 goto done;
2250 }
2251
2252 /*
2253 * we have a couple of cases to consider.
2254 * (1) Are any files in use? If so and DPD_DELTE_ALL_FILE is set,
2255 * then the delete should fail if **any** files overlap with
2256 * other drivers
2257 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2258 * non-overlapping files
2259 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2260 * is set, the do not delete any files
2261 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2262 */
2263
2264 delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2265
2266 /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2267
2268 if ( delete_files && printer_driver_files_in_use(info.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2269 /* no idea of the correct error here */
2270 status = WERR_ACCESS_DENIED;
2271 goto done;
2272 }
2273
2274
2275 /* also check for W32X86/3 if necessary; maybe we already have? */
2276
2277 if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
2278 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2279 r->in.driver,
2280 r->in.architecture, 3)))
2281 {
2282
2283 if ( delete_files && printer_driver_files_in_use(info_win2k.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2284 /* no idea of the correct error here */
2285 free_a_printer_driver( info_win2k, 3 );
2286 status = WERR_ACCESS_DENIED;
2287 goto done;
2288 }
2289
2290 /* if we get to here, we now have 2 driver info structures to remove */
2291 /* remove the Win2k driver first*/
2292
2293 status_win2k = delete_printer_driver(
2294 p, info_win2k.info_3, 3, delete_files);
2295 free_a_printer_driver( info_win2k, 3 );
2296
2297 /* this should not have failed---if it did, report to client */
2298
2299 if ( !W_ERROR_IS_OK(status_win2k) )
2300 goto done;
2301 }
2302 }
2303
2304 status = delete_printer_driver(p, info.info_3, version, delete_files);
2305
2306 if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2307 status = WERR_OK;
2308 done:
2309 free_a_printer_driver( info, 3 );
2310
2311 return status;
2312 }
2313
2314
2315 /****************************************************************************
2316 Internal routine for removing printerdata
2317 ***************************************************************************/
2318
2319 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2320 {
2321 return delete_printer_data( printer->info_2, key, value );
2322 }
2323
2324 /****************************************************************************
2325 Internal routine for storing printerdata
2326 ***************************************************************************/
2327
2328 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2329 const char *key, const char *value,
2330 uint32_t type, uint8_t *data, int real_len)
2331 {
2332 /* the registry objects enforce uniqueness based on value name */
2333
2334 return add_printer_data( printer->info_2, key, value, type, data, real_len );
2335 }
2336
2337 /********************************************************************
2338 GetPrinterData on a printer server Handle.
2339 ********************************************************************/
2340
2341 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2342 const char *value,
2343 enum winreg_Type *type,
2344 union spoolss_PrinterData *data)
2345 {
2346 DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2347
2348 if (!StrCaseCmp(value, "W3SvcInstalled")) {
2349 *type = REG_DWORD;
2350 data->value = 0x00;
2351 return WERR_OK;
2352 }
2353
2354 if (!StrCaseCmp(value, "BeepEnabled")) {
2355 *type = REG_DWORD;
2356 data->value = 0x00;
2357 return WERR_OK;
2358 }
2359
2360 if (!StrCaseCmp(value, "EventLog")) {
2361 *type = REG_DWORD;
2362 /* formally was 0x1b */
2363 data->value = 0x00;
2364 return WERR_OK;
2365 }
2366
2367 if (!StrCaseCmp(value, "NetPopup")) {
2368 *type = REG_DWORD;
2369 data->value = 0x00;
2370 return WERR_OK;
2371 }
2372
2373 if (!StrCaseCmp(value, "MajorVersion")) {
2374 *type = REG_DWORD;
2375
2376 /* Windows NT 4.0 seems to not allow uploading of drivers
2377 to a server that reports 0x3 as the MajorVersion.
2378 need to investigate more how Win2k gets around this .
2379 -- jerry */
2380
2381 if (RA_WINNT == get_remote_arch()) {
2382 data->value = 0x02;
2383 } else {
2384 data->value = 0x03;
2385 }
2386
2387 return WERR_OK;
2388 }
2389
2390 if (!StrCaseCmp(value, "MinorVersion")) {
2391 *type = REG_DWORD;
2392 data->value = 0x00;
2393 return WERR_OK;
2394 }
2395
2396 /* REG_BINARY
2397 * uint32_t size = 0x114
2398 * uint32_t major = 5
2399 * uint32_t minor = [0|1]
2400 * uint32_t build = [2195|2600]
2401 * extra unicode string = e.g. "Service Pack 3"
2402 */
2403 if (!StrCaseCmp(value, "OSVersion")) {
2404 DATA_BLOB blob;
2405 enum ndr_err_code ndr_err;
2406 struct spoolss_OSVersion os;
2407
2408 os.major = 5; /* Windows 2000 == 5.0 */
2409 os.minor = 0;
2410 os.build = 2195; /* build */
2411 os.extra_string = ""; /* leave extra string empty */
2412
2413 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2414 (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2415 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2416 return WERR_GENERAL_FAILURE;
2417 }
2418
2419 *type = REG_BINARY;
2420 data->binary = blob;
2421
2422 return WERR_OK;
2423 }
2424
2425
2426 if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2427 *type = REG_SZ;
2428
2429 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2430 W_ERROR_HAVE_NO_MEMORY(data->string);
2431
2432 return WERR_OK;
2433 }
2434
2435 if (!StrCaseCmp(value, "Architecture")) {
2436 *type = REG_SZ;
2437
2438 data->string = talloc_strdup(mem_ctx, "Windows NT x86");
2439 W_ERROR_HAVE_NO_MEMORY(data->string);
2440
2441 return WERR_OK;
2442 }
2443
2444 if (!StrCaseCmp(value, "DsPresent")) {
2445 *type = REG_DWORD;
2446
2447 /* only show the publish check box if we are a
2448 member of a AD domain */
2449
2450 if (lp_security() == SEC_ADS) {
2451 data->value = 0x01;
2452 } else {
2453 data->value = 0x00;
2454 }
2455 return WERR_OK;
2456 }
2457
2458 if (!StrCaseCmp(value, "DNSMachineName")) {
2459 const char *hostname = get_mydnsfullname();
2460
2461 if (!hostname) {
2462 return WERR_BADFILE;
2463 }
2464
2465 *type = REG_SZ;
2466 data->string = talloc_strdup(mem_ctx, hostname);
2467 W_ERROR_HAVE_NO_MEMORY(data->string);
2468
2469 return WERR_OK;
2470 }
2471
2472 return WERR_INVALID_PARAM;
2473 }
2474
2475 /****************************************************************
2476 _spoolss_GetPrinterData
2477 ****************************************************************/
2478
2479 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2480 struct spoolss_GetPrinterData *r)
2481 {
2482 WERROR result;
2483 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2484 NT_PRINTER_INFO_LEVEL *printer = NULL;
2485 int snum = 0;
2486
2487 /*
2488 * Reminder: when it's a string, the length is in BYTES
2489 * even if UNICODE is negociated.
2490 *
2491 * JFM, 4/19/1999
2492 */
2493
2494 /* in case of problem, return some default values */
2495
2496 *r->out.needed = 0;
2497 *r->out.type = 0;
2498
2499 DEBUG(4,("_spoolss_GetPrinterData\n"));
2500
2501 if (!Printer) {
2502 DEBUG(2,("_spoolss_GetPrinterData: Invalid handle (%s:%u:%u).\n",
2503 OUR_HANDLE(r->in.handle)));
2504 result = WERR_BADFID;
2505 goto done;
2506 }
2507
2508 if (Printer->printer_type == SPLHND_SERVER) {
2509 result = getprinterdata_printer_server(p->mem_ctx,
2510 r->in.value_name,
2511 r->out.type,
2512 r->out.data);
2513 } else {
2514 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
2515 result = WERR_BADFID;
2516 goto done;
2517 }
2518
2519 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
2520 if (!W_ERROR_IS_OK(result)) {
2521 goto done;
2522 }
2523
2524 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
2525
2526 if (strequal(r->in.value_name, "ChangeId")) {
2527 *r->out.type = REG_DWORD;
2528 r->out.data->value = printer->info_2->changeid;
2529 result = WERR_OK;
2530 } else {
2531 struct regval_blob *v;
2532 DATA_BLOB blob;
2533
2534 v = get_printer_data(printer->info_2,
2535 SPOOL_PRINTERDATA_KEY,
2536 r->in.value_name);
2537 if (!v) {
2538 result = WERR_BADFILE;
2539 goto done;
2540 }
2541
2542 *r->out.type = v->type;
2543
2544 blob = data_blob_const(v->data_p, v->size);
2545
2546 result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
2547 r->out.data,
2548 *r->out.type);
2549 }
2550 }
2551
2552 done:
2553 /* cleanup & exit */
2554
2555 if (printer) {
2556 free_a_printer(&printer, 2);
2557 }
2558
2559 if (!W_ERROR_IS_OK(result)) {
2560 return result;
2561 }
2562
2563 *r->out.needed = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
2564 *r->out.type = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
2565 r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
2566
2567 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
2568 }
2569
2570 /*********************************************************
2571 Connect to the client machine.
2572 **********************************************************/
2573
2574 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2575 struct sockaddr_storage *client_ss, const char *remote_machine)
2576 {
2577 NTSTATUS ret;
2578 struct cli_state *the_cli;
2579 struct sockaddr_storage rm_addr;
2580
2581 if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2582 if ( !resolve_name( remote_machine, &rm_addr, 0x20, false) ) {
2583 DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2584 return false;
2585 }
2586
2587 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2588 DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
2589 return false;
2590 }
2591 } else {
2592 char addr[INET6_ADDRSTRLEN];
2593 rm_addr = *client_ss;
2594 print_sockaddr(addr, sizeof(addr), &rm_addr);
2595 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2596 addr));
2597 }
2598
2599 /* setup the connection */
2600
2601 ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2602 &rm_addr, 0, "IPC$", "IPC",
2603 "", /* username */
2604 "", /* domain */
2605 "", /* password */
2606 0, lp_client_signing(), NULL );
2607
2608 if ( !NT_STATUS_IS_OK( ret ) ) {
2609 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2610 remote_machine ));
2611 return false;
2612 }
2613
2614 if ( the_cli->protocol != PROTOCOL_NT1 ) {
2615 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2616 cli_shutdown(the_cli);
2617 return false;
2618 }
2619
2620 /*
2621 * Ok - we have an anonymous connection to the IPC$ share.
2622 * Now start the NT Domain stuff :-).
2623 */
2624
2625 ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2626 if (!NT_STATUS_IS_OK(ret)) {
2627 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2628 remote_machine, nt_errstr(ret)));
2629 cli_shutdown(the_cli);
2630 return false;
2631 }
2632
2633 return true;
2634 }
2635
2636 /***************************************************************************
2637 Connect to the client.
2638 ****************************************************************************/
2639
2640 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2641 uint32_t localprinter, uint32_t type,
2642 struct policy_handle *handle,
2643 struct sockaddr_storage *client_ss)
2644 {
2645 WERROR result;
2646 NTSTATUS status;
2647
2648 /*
2649 * If it's the first connection, contact the client
2650 * and connect to the IPC$ share anonymously
2651 */
2652 if (smb_connections==0) {
2653 fstring unix_printer;
2654
2655 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2656
2657 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2658 return false;
2659
2660 messaging_register(smbd_messaging_context(), NULL,
2661 MSG_PRINTER_NOTIFY2,
2662 receive_notify2_message_list);
2663 /* Tell the connections db we're now interested in printer
2664 * notify messages. */
2665 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2666 }
2667
2668 /*
2669 * Tell the specific printing tdb we want messages for this printer
2670 * by registering our PID.
2671 */
2672
2673 if (!print_notify_register_pid(snum))
2674 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2675
2676 smb_connections++;
2677
2678 status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2679 printer,
2680 localprinter,
2681 type,
2682 0,
2683 NULL,
2684 handle,
2685 &result);
2686 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2687 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2688 win_errstr(result)));
2689
2690 return (W_ERROR_IS_OK(result));
2691 }
2692
2693 /****************************************************************
2694 ****************************************************************/
2695
2696 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2697 const struct spoolss_NotifyOption *r)
2698 {
2699 struct spoolss_NotifyOption *option;
2700 uint32_t i,k;
2701
2702 if (!r) {
2703 return NULL;
2704 }
2705
2706 option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2707 if (!option) {
2708 return NULL;
2709 }
2710
2711 *option = *r;
2712
2713 if (!option->count) {
2714 return option;
2715 }
2716
2717 option->types = talloc_zero_array(option,
2718 struct spoolss_NotifyOptionType, option->count);
2719 if (!option->types) {
2720 talloc_free(option);
2721 return NULL;
2722 }
2723
2724 for (i=0; i < option->count; i++) {
2725 option->types[i] = r->types[i];
2726
2727 if (option->types[i].count) {
2728 option->types[i].fields = talloc_zero_array(option,
2729 union spoolss_Field, option->types[i].count);
2730 if (!option->types[i].fields) {
2731 talloc_free(option);
2732 return NULL;
2733 }
2734 for (k=0; k<option->types[i].count; k++) {
2735 option->types[i].fields[k] =
2736 r->types[i].fields[k];
2737 }
2738 }
2739 }
2740
2741 return option;
2742 }
2743
2744 /****************************************************************
2745 * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2746 *
2747 * before replying OK: status=0 a rpc call is made to the workstation
2748 * asking ReplyOpenPrinter
2749 *
2750 * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2751 * called from api_spoolss_rffpcnex
2752 ****************************************************************/
2753
2754 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2755 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2756 {
2757 int snum = -1;
2758 struct spoolss_NotifyOption *option = r->in.notify_options;
2759 struct sockaddr_storage client_ss;
2760
2761 /* store the notify value in the printer struct */
2762
2763 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2764
2765 if (!Printer) {
2766 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2767 "Invalid handle (%s:%u:%u).\n",
2768 OUR_HANDLE(r->in.handle)));
2769 return WERR_BADFID;
2770 }
2771
2772 Printer->notify.flags = r->in.flags;
2773 Printer->notify.options = r->in.options;
2774 Printer->notify.printerlocal = r->in.printer_local;
2775
2776 TALLOC_FREE(Printer->notify.option);
2777 Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2778
2779 fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2780
2781 /* Connect to the client machine and send a ReplyOpenPrinter */
2782
2783 if ( Printer->printer_type == SPLHND_SERVER)
2784 snum = -1;
2785 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2786 !get_printer_snum(p, r->in.handle, &snum, NULL) )
2787 return WERR_BADFID;
2788
2789 if (!interpret_string_addr(&client_ss, p->client_address,
2790 AI_NUMERICHOST)) {
2791 return WERR_SERVER_UNAVAILABLE;
2792 }
2793
2794 if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2795 Printer->notify.printerlocal, 1,
2796 &Printer->notify.client_hnd, &client_ss))
2797 return WERR_SERVER_UNAVAILABLE;
2798
2799 Printer->notify.client_connected = true;
2800
2801 return WERR_OK;
2802 }
2803
2804 /*******************************************************************
2805 * fill a notify_info_data with the servername
2806 ********************************************************************/
2807
2808 void spoolss_notify_server_name(int snum,
2809 struct spoolss_Notify *data,
2810 print_queue_struct *queue,
2811 NT_PRINTER_INFO_LEVEL *printer,
2812 TALLOC_CTX *mem_ctx)
2813 {
2814 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2815 }
2816
2817 /*******************************************************************
2818 * fill a notify_info_data with the printername (not including the servername).
2819 ********************************************************************/
2820
2821 void spoolss_notify_printer_name(int snum,
2822 struct spoolss_Notify *data,
2823 print_queue_struct *queue,
2824 NT_PRINTER_INFO_LEVEL *printer,
2825 TALLOC_CTX *mem_ctx)
2826 {
2827 /* the notify name should not contain the \\server\ part */
2828 char *p = strrchr(printer->info_2->printername, '\\');
2829
2830 if (!p) {
2831 p = printer->info_2->printername;
2832 } else {
2833 p++;
2834 }
2835
2836 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2837 }
2838
2839 /*******************************************************************
2840 * fill a notify_info_data with the servicename
2841 ********************************************************************/
2842
2843 void spoolss_notify_share_name(int snum,
2844 struct spoolss_Notify *data,
2845 print_queue_struct *queue,
2846 NT_PRINTER_INFO_LEVEL *printer,
2847 TALLOC_CTX *mem_ctx)
2848 {
2849 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2850 }
2851
2852 /*******************************************************************
2853 * fill a notify_info_data with the port name
2854 ********************************************************************/
2855
2856 void spoolss_notify_port_name(int snum,
2857 struct spoolss_Notify *data,
2858 print_queue_struct *queue,
2859 NT_PRINTER_INFO_LEVEL *printer,
2860 TALLOC_CTX *mem_ctx)
2861 {
2862 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2863 }
2864
2865 /*******************************************************************
2866 * fill a notify_info_data with the printername
2867 * but it doesn't exist, have to see what to do
2868 ********************************************************************/
2869
2870 void spoolss_notify_driver_name(int snum,
2871 struct spoolss_Notify *data,
2872 print_queue_struct *queue,
2873 NT_PRINTER_INFO_LEVEL *printer,
2874 TALLOC_CTX *mem_ctx)
2875 {
2876 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2877 }
2878
2879 /*******************************************************************
2880 * fill a notify_info_data with the comment
2881 ********************************************************************/
2882
2883 void spoolss_notify_comment(int snum,
2884 struct spoolss_Notify *data,
2885 print_queue_struct *queue,
2886 NT_PRINTER_INFO_LEVEL *printer,
2887 TALLOC_CTX *mem_ctx)
2888 {
2889 char *p;
2890
2891 if (*printer->info_2->comment == '\0') {
2892 p = lp_comment(snum);
2893 } else {
2894 p = printer->info_2->comment;
2895 }
2896
2897 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2898 }
2899
2900 /*******************************************************************
2901 * fill a notify_info_data with the comment
2902 * location = "Room 1, floor 2, building 3"
2903 ********************************************************************/
2904
2905 void spoolss_notify_location(int snum,
2906 struct spoolss_Notify *data,
2907 print_queue_struct *queue,
2908 NT_PRINTER_INFO_LEVEL *printer,
2909 TALLOC_CTX *mem_ctx)
2910 {
2911 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2912 }
2913
2914 /*******************************************************************
2915 * fill a notify_info_data with the device mode
2916 * jfm:xxxx don't to it for know but that's a real problem !!!
2917 ********************************************************************/
2918
2919 static void spoolss_notify_devmode(int snum,
2920 struct spoolss_Notify *data,
2921 print_queue_struct *queue,
2922 NT_PRINTER_INFO_LEVEL *printer,
2923 TALLOC_CTX *mem_ctx)
2924 {
2925 /* for a dummy implementation we have to zero the fields */
2926 SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2927 }
2928
2929 /*******************************************************************
2930 * fill a notify_info_data with the separator file name
2931 ********************************************************************/
2932
2933 void spoolss_notify_sepfile(int snum,
2934 struct spoolss_Notify *data,
2935 print_queue_struct *queue,
2936 NT_PRINTER_INFO_LEVEL *printer,
2937 TALLOC_CTX *mem_ctx)
2938 {
2939 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2940 }
2941
2942 /*******************************************************************
2943 * fill a notify_info_data with the print processor
2944 * jfm:xxxx return always winprint to indicate we don't do anything to it
2945 ********************************************************************/
2946
2947 void spoolss_notify_print_processor(int snum,
2948 struct spoolss_Notify *data,
2949 print_queue_struct *queue,
2950 NT_PRINTER_INFO_LEVEL *printer,
2951 TALLOC_CTX *mem_ctx)
2952 {
2953 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2954 }
2955
2956 /*******************************************************************
2957 * fill a notify_info_data with the print processor options
2958 * jfm:xxxx send an empty string
2959 ********************************************************************/
2960
2961 void spoolss_notify_parameters(int snum,
2962 struct spoolss_Notify *data,
2963 print_queue_struct *queue,
2964 NT_PRINTER_INFO_LEVEL *printer,
2965 TALLOC_CTX *mem_ctx)
2966 {
2967 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2968 }
2969
2970 /*******************************************************************
2971 * fill a notify_info_data with the data type
2972 * jfm:xxxx always send RAW as data type
2973 ********************************************************************/
2974
2975 void spoolss_notify_datatype(int snum,
2976 struct spoolss_Notify *data,
2977 print_queue_struct *queue,
2978 NT_PRINTER_INFO_LEVEL *printer,
2979 TALLOC_CTX *mem_ctx)
2980 {
2981 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
2982 }
2983
2984 /*******************************************************************
2985 * fill a notify_info_data with the security descriptor
2986 * jfm:xxxx send an null pointer to say no security desc
2987 * have to implement security before !
2988 ********************************************************************/
2989
2990 static void spoolss_notify_security_desc(int snum,
2991 struct spoolss_Notify *data,
2992 print_queue_struct *queue,
2993 NT_PRINTER_INFO_LEVEL *printer,
2994 TALLOC_CTX *mem_ctx)
2995 {
2996 SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
2997 printer->info_2->secdesc_buf->sd_size,
2998 printer->info_2->secdesc_buf->sd);
2999 }
3000
3001 /*******************************************************************
3002 * fill a notify_info_data with the attributes
3003 * jfm:xxxx a samba printer is always shared
3004 ********************************************************************/
3005
3006 void spoolss_notify_attributes(int snum,
3007 struct spoolss_Notify *data,
3008 print_queue_struct *queue,
3009 NT_PRINTER_INFO_LEVEL *printer,
3010 TALLOC_CTX *mem_ctx)
3011 {
3012 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
3013 }
3014
3015 /*******************************************************************
3016 * fill a notify_info_data with the priority
3017 ********************************************************************/
3018
3019 static void spoolss_notify_priority(int snum,
3020 struct spoolss_Notify *data,
3021 print_queue_struct *queue,
3022 NT_PRINTER_INFO_LEVEL *printer,
3023 TALLOC_CTX *mem_ctx)
3024 {
3025 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
3026 }
3027
3028 /*******************************************************************
3029 * fill a notify_info_data with the default priority
3030 ********************************************************************/
3031
3032 static void spoolss_notify_default_priority(int snum,
3033 struct spoolss_Notify *data,
3034 print_queue_struct *queue,
3035 NT_PRINTER_INFO_LEVEL *printer,
3036 TALLOC_CTX *mem_ctx)
3037 {
3038 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
3039 }
3040
3041 /*******************************************************************
3042 * fill a notify_info_data with the start time
3043 ********************************************************************/
3044
3045 static void spoolss_notify_start_time(int snum,
3046 struct spoolss_Notify *data,
3047 print_queue_struct *queue,
3048 NT_PRINTER_INFO_LEVEL *printer,
3049 TALLOC_CTX *mem_ctx)
3050 {
3051 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
3052 }
3053
3054 /*******************************************************************
3055 * fill a notify_info_data with the until time
3056 ********************************************************************/
3057
3058 static void spoolss_notify_until_time(int snum,
3059 struct spoolss_Notify *data,
3060 print_queue_struct *queue,
3061 NT_PRINTER_INFO_LEVEL *printer,
3062 TALLOC_CTX *mem_ctx)
3063 {
3064 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
3065 }
3066
3067 /*******************************************************************
3068 * fill a notify_info_data with the status
3069 ********************************************************************/
3070
3071 static void spoolss_notify_status(int snum,
3072 struct spoolss_Notify *data,
3073 print_queue_struct *queue,
3074 NT_PRINTER_INFO_LEVEL *printer,
3075 TALLOC_CTX *mem_ctx)
3076 {
3077 print_status_struct status;
3078
3079 print_queue_length(snum, &status);
3080 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3081 }
3082
3083 /*******************************************************************
3084 * fill a notify_info_data with the number of jobs queued
3085 ********************************************************************/
3086
3087 void spoolss_notify_cjobs(int snum,
3088 struct spoolss_Notify *data,
3089 print_queue_struct *queue,
3090 NT_PRINTER_INFO_LEVEL *printer,
3091 TALLOC_CTX *mem_ctx)
3092 {
3093 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
3094 }
3095
3096 /*******************************************************************
3097 * fill a notify_info_data with the average ppm
3098 ********************************************************************/
3099
3100 static void spoolss_notify_average_ppm(int snum,
3101 struct spoolss_Notify *data,
3102 print_queue_struct *queue,
3103 NT_PRINTER_INFO_LEVEL *printer,
3104 TALLOC_CTX *mem_ctx)
3105 {
3106 /* always respond 8 pages per minutes */
3107 /* a little hard ! */
3108 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
3109 }
3110
3111 /*******************************************************************
3112 * fill a notify_info_data with username
3113 ********************************************************************/
3114
3115 static void spoolss_notify_username(int snum,
3116 struct spoolss_Notify *data,
3117 print_queue_struct *queue,
3118 NT_PRINTER_INFO_LEVEL *printer,
3119 TALLOC_CTX *mem_ctx)
3120 {
3121 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3122 }
3123
3124 /*******************************************************************
3125 * fill a notify_info_data with job status
3126 ********************************************************************/
3127
3128 static void spoolss_notify_job_status(int snum,
3129 struct spoolss_Notify *data,
3130 print_queue_struct *queue,
3131 NT_PRINTER_INFO_LEVEL *printer,
3132 TALLOC_CTX *mem_ctx)
3133 {
3134 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3135 }
3136
3137 /*******************************************************************
3138 * fill a notify_info_data with job name
3139 ********************************************************************/
3140
3141 static void spoolss_notify_job_name(int snum,
3142 struct spoolss_Notify *data,
3143 print_queue_struct *queue,
3144 NT_PRINTER_INFO_LEVEL *printer,
3145 TALLOC_CTX *mem_ctx)
3146 {
3147 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3148 }
3149
3150 /*******************************************************************
3151 * fill a notify_info_data with job status
3152 ********************************************************************/
3153
3154 static void spoolss_notify_job_status_string(int snum,
3155 struct spoolss_Notify *data,
3156 print_queue_struct *queue,
3157 NT_PRINTER_INFO_LEVEL *printer,
3158 TALLOC_CTX *mem_ctx)
3159 {
3160 /*
3161 * Now we're returning job status codes we just return a "" here. JRA.
3162 */
3163
3164 const char *p = "";
3165
3166 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3167 p = "unknown";
3168
3169 switch (queue->status) {
3170 case LPQ_QUEUED:
3171 p = "Queued";
3172 break;
3173 case LPQ_PAUSED:
3174 p = ""; /* NT provides the paused string */
3175 break;
3176 case LPQ_SPOOLING:
3177 p = "Spooling";
3178 break;
3179 case LPQ_PRINTING:
3180 p = "Printing";
3181 break;
3182 }
3183 #endif /* NO LONGER NEEDED. */
3184
3185 SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3186 }
3187
3188 /*******************************************************************
3189 * fill a notify_info_data with job time
3190 ********************************************************************/
3191
3192 static void spoolss_notify_job_time(int snum,
3193 struct spoolss_Notify *data,
3194 print_queue_struct *queue,
3195 NT_PRINTER_INFO_LEVEL *printer,
3196 TALLOC_CTX *mem_ctx)
3197 {
3198 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3199 }
3200
3201 /*******************************************************************
3202 * fill a notify_info_data with job size
3203 ********************************************************************/
3204
3205 static void spoolss_notify_job_size(int snum,
3206 struct spoolss_Notify *data,
3207 print_queue_struct *queue,
3208 NT_PRINTER_INFO_LEVEL *printer,
3209 TALLOC_CTX *mem_ctx)
3210 {
3211 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3212 }
3213
3214 /*******************************************************************
3215 * fill a notify_info_data with page info
3216 ********************************************************************/
3217 static void spoolss_notify_total_pages(int snum,
3218 struct spoolss_Notify *data,
3219 print_queue_struct *queue,
3220 NT_PRINTER_INFO_LEVEL *printer,
3221 TALLOC_CTX *mem_ctx)
3222 {
3223 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3224 }
3225
3226 /*******************************************************************
3227 * fill a notify_info_data with pages printed info.
3228 ********************************************************************/
3229 static void spoolss_notify_pages_printed(int snum,
3230 struct spoolss_Notify *data,
3231 print_queue_struct *queue,
3232 NT_PRINTER_INFO_LEVEL *printer,
3233 TALLOC_CTX *mem_ctx)
3234 {
3235 /* Add code when back-end tracks this */
3236 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3237 }
3238
3239 /*******************************************************************
3240 Fill a notify_info_data with job position.
3241 ********************************************************************/
3242
3243 static void spoolss_notify_job_position(int snum,
3244 struct spoolss_Notify *data,
3245 print_queue_struct *queue,
3246 NT_PRINTER_INFO_LEVEL *printer,
3247 TALLOC_CTX *mem_ctx)
3248 {
3249 SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3250 }
3251
3252 /*******************************************************************
3253 Fill a notify_info_data with submitted time.
3254 ********************************************************************/
3255
3256 static void spoolss_notify_submitted_time(int snum,
3257 struct spoolss_Notify *data,
3258 print_queue_struct *queue,
3259 NT_PRINTER_INFO_LEVEL *printer,
3260 TALLOC_CTX *mem_ctx)
3261 {
3262 data->data.string.string = NULL;
3263 data->data.string.size = 0;
3264
3265 init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3266 &data->data.string.string,
3267 &data->data.string.size);
3268
3269 }
3270
3271 struct s_notify_info_data_table
3272 {
3273 enum spoolss_NotifyType type;
3274 uint16_t field;
3275 const char *name;
3276 enum spoolss_NotifyTable variable_type;
3277 void (*fn) (int snum, struct spoolss_Notify *data,
3278 print_queue_struct *queue,
3279 NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3280 };
3281
3282 /* A table describing the various print notification constants and
3283 whether the notification data is a pointer to a variable sized
3284 buffer, a one value uint32_t or a two value uint32_t. */
3285
3286 static const struct s_notify_info_data_table notify_info_data_table[] =
3287 {
3288 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME, "PRINTER_NOTIFY_FIELD_SERVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3289 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, "PRINTER_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3290 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, "PRINTER_NOTIFY_FIELD_SHARE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_share_name },
3291 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, "PRINTER_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3292 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, "PRINTER_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3293 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, "PRINTER_NOTIFY_FIELD_COMMENT", NOTIFY_TABLE_STRING, spoolss_notify_comment },
3294 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, "PRINTER_NOTIFY_FIELD_LOCATION", NOTIFY_TABLE_STRING, spoolss_notify_location },
3295 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE, "PRINTER_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3296 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, "PRINTER_NOTIFY_FIELD_SEPFILE", NOTIFY_TABLE_STRING, spoolss_notify_sepfile },
3297 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR, "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3298 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS, "PRINTER_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3299 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE, "PRINTER_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3300 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, spoolss_notify_security_desc },
3301 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES, "PRINTER_NOTIFY_FIELD_ATTRIBUTES", NOTIFY_TABLE_DWORD, spoolss_notify_attributes },
3302 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY, "PRINTER_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3303 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY, "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_default_priority },
3304 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME, "PRINTER_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3305 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME, "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3306 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS, "PRINTER_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_status },
3307 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING, "PRINTER_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, NULL },
3308 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS, "PRINTER_NOTIFY_FIELD_CJOBS", NOTIFY_TABLE_DWORD, spoolss_notify_cjobs },
3309 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM, "PRINTER_NOTIFY_FIELD_AVERAGE_PPM", NOTIFY_TABLE_DWORD, spoolss_notify_average_ppm },
3310 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES, "PRINTER_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, NULL },
3311 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED, "PRINTER_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3312 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES, "PRINTER_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, NULL },
3313 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED, "PRINTER_NOTIFY_FIELD_BYTES_PRINTED", NOTIFY_TABLE_DWORD, NULL },
3314 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINTER_NAME, "JOB_NOTIFY_FIELD_PRINTER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_printer_name },
3315 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_MACHINE_NAME, "JOB_NOTIFY_FIELD_MACHINE_NAME", NOTIFY_TABLE_STRING, spoolss_notify_server_name },
3316 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PORT_NAME, "JOB_NOTIFY_FIELD_PORT_NAME", NOTIFY_TABLE_STRING, spoolss_notify_port_name },
3317 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, "JOB_NOTIFY_FIELD_USER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3318 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_NOTIFY_NAME, "JOB_NOTIFY_FIELD_NOTIFY_NAME", NOTIFY_TABLE_STRING, spoolss_notify_username },
3319 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DATATYPE, "JOB_NOTIFY_FIELD_DATATYPE", NOTIFY_TABLE_STRING, spoolss_notify_datatype },
3320 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRINT_PROCESSOR, "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NOTIFY_TABLE_STRING, spoolss_notify_print_processor },
3321 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PARAMETERS, "JOB_NOTIFY_FIELD_PARAMETERS", NOTIFY_TABLE_STRING, spoolss_notify_parameters },
3322 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DRIVER_NAME, "JOB_NOTIFY_FIELD_DRIVER_NAME", NOTIFY_TABLE_STRING, spoolss_notify_driver_name },
3323 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DEVMODE, "JOB_NOTIFY_FIELD_DEVMODE", NOTIFY_TABLE_DEVMODE, spoolss_notify_devmode },
3324 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS, "JOB_NOTIFY_FIELD_STATUS", NOTIFY_TABLE_DWORD, spoolss_notify_job_status },
3325 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_STATUS_STRING, "JOB_NOTIFY_FIELD_STATUS_STRING", NOTIFY_TABLE_STRING, spoolss_notify_job_status_string },
3326 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR, NULL },
3327 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, "JOB_NOTIFY_FIELD_DOCUMENT", NOTIFY_TABLE_STRING, spoolss_notify_job_name },
3328 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PRIORITY, "JOB_NOTIFY_FIELD_PRIORITY", NOTIFY_TABLE_DWORD, spoolss_notify_priority },
3329 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_POSITION, "JOB_NOTIFY_FIELD_POSITION", NOTIFY_TABLE_DWORD, spoolss_notify_job_position },
3330 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, "JOB_NOTIFY_FIELD_SUBMITTED", NOTIFY_TABLE_TIME, spoolss_notify_submitted_time },
3331 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_START_TIME, "JOB_NOTIFY_FIELD_START_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_start_time },
3332 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_UNTIL_TIME, "JOB_NOTIFY_FIELD_UNTIL_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_until_time },
3333 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TIME, "JOB_NOTIFY_FIELD_TIME", NOTIFY_TABLE_DWORD, spoolss_notify_job_time },
3334 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_PAGES, "JOB_NOTIFY_FIELD_TOTAL_PAGES", NOTIFY_TABLE_DWORD, spoolss_notify_total_pages },
3335 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_PAGES_PRINTED, "JOB_NOTIFY_FIELD_PAGES_PRINTED", NOTIFY_TABLE_DWORD, spoolss_notify_pages_printed },
3336 { JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_TOTAL_BYTES, "JOB_NOTIFY_FIELD_TOTAL_BYTES", NOTIFY_TABLE_DWORD, spoolss_notify_job_size },
3337 };
3338
3339 /*******************************************************************
3340 Return the variable_type of info_data structure.
3341 ********************************************************************/
3342
3343 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3344 uint16_t field)
3345 {
3346 int i=0;
3347
3348 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3349 if ( (notify_info_data_table[i].type == type) &&
3350 (notify_info_data_table[i].field == field) ) {
3351 return notify_info_data_table[i].variable_type;
3352 }
3353 }
3354
3355 DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3356
3357 return 0;
3358 }
3359
3360 /****************************************************************************
3361 ****************************************************************************/
3362
3363 static bool search_notify(enum spoolss_NotifyType type,
3364 uint16_t field,
3365 int *value)
3366 {
3367 int i;
3368
3369 for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3370 if (notify_info_data_table[i].type == type &&
3371 notify_info_data_table[i].field == field &&
3372 notify_info_data_table[i].fn != NULL) {
3373 *value = i;
3374 return true;
3375 }
3376 }
3377
3378 return false;
3379 }
3380
3381 /****************************************************************************
3382 ****************************************************************************/
3383
3384 void construct_info_data(struct spoolss_Notify *info_data,
3385 enum spoolss_NotifyType type,
3386 uint16_t field,
3387 int id)
3388 {
3389 info_data->type = type;
3390 info_data->field.field = field;
3391 info_data->variable_type = variable_type_of_notify_info_data(type, field);
3392 info_data->job_id = id;
3393 }
3394
3395 /*******************************************************************
3396 *
3397 * fill a notify_info struct with info asked
3398 *
3399 ********************************************************************/
3400
3401 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3402 struct spoolss_NotifyInfo *info,
3403 int snum,
3404 const struct spoolss_NotifyOptionType *option_type,
3405 uint32_t id,
3406 TALLOC_CTX *mem_ctx)
3407 {
3408 int field_num,j;
3409 enum spoolss_NotifyType type;
3410 uint16_t field;
3411
3412 struct spoolss_Notify *current_data;
3413 NT_PRINTER_INFO_LEVEL *printer = NULL;
3414 print_queue_struct *queue=NULL;
3415
3416 type = option_type->type;
3417
3418 DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3419 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3420 option_type->count, lp_servicename(snum)));
3421
3422 if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3423 return false;
3424
3425 for(field_num=0; field_num < option_type->count; field_num++) {
3426 field = option_type->fields[field_num].field;
3427
3428 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3429
3430 if (!search_notify(type, field, &j) )
3431 continue;
3432
3433 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3434 struct spoolss_Notify,
3435 info->count + 1);
3436 if (info->notifies == NULL) {
3437 DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3438 free_a_printer(&printer, 2);
3439 return false;
3440 }
3441
3442 current_data = &info->notifies[info->count];
3443
3444 construct_info_data(current_data, type, field, id);
3445
3446 DEBUG(10,("construct_notify_printer_info: calling [%s] snum=%d printername=[%s])\n",
3447 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3448
3449 notify_info_data_table[j].fn(snum, current_data, queue,
3450 printer, mem_ctx);
3451
3452 info->count++;
3453 }
3454
3455 free_a_printer(&printer, 2);
3456 return true;
3457 }
3458
3459 /*******************************************************************
3460 *
3461 * fill a notify_info struct with info asked
3462 *
3463 ********************************************************************/
3464
3465 static bool construct_notify_jobs_info(print_queue_struct *queue,
3466 struct spoolss_NotifyInfo *info,
3467 NT_PRINTER_INFO_LEVEL *printer,
3468 int snum,
3469 const struct spoolss_NotifyOptionType *option_type,
3470 uint32_t id,
3471 TALLOC_CTX *mem_ctx)
3472 {
3473 int field_num,j;
3474 enum spoolss_NotifyType type;
3475 uint16_t field;
3476 struct spoolss_Notify *current_data;
3477
3478 DEBUG(4,("construct_notify_jobs_info\n"));
3479
3480 type = option_type->type;
3481
3482 DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3483 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3484 option_type->count));
3485
3486 for(field_num=0; field_num<option_type->count; field_num++) {
3487 field = option_type->fields[field_num].field;
3488
3489 if (!search_notify(type, field, &j) )
3490 continue;
3491
3492 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3493 struct spoolss_Notify,
3494 info->count + 1);
3495 if (info->notifies == NULL) {
3496 DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3497 return false;
3498 }
3499
3500 current_data=&(info->notifies[info->count]);
3501
3502 construct_info_data(current_data, type, field, id);
3503 notify_info_data_table[j].fn(snum, current_data, queue,
3504 printer, mem_ctx);
3505 info->count++;
3506 }
3507
3508 return true;
3509 }
3510
3511 /*
3512 * JFM: The enumeration is not that simple, it's even non obvious.
3513 *
3514 * let's take an example: I want to monitor the PRINTER SERVER for
3515 * the printer's name and the number of jobs currently queued.
3516 * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3517 * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3518 *
3519 * I have 3 printers on the back of my server.
3520 *
3521 * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3522 * structures.
3523 * Number Data Id
3524 * 1 printer 1 name 1
3525 * 2 printer 1 cjob 1
3526 * 3 printer 2 name 2
3527 * 4 printer 2 cjob 2
3528 * 5 printer 3 name 3
3529 * 6 printer 3 name 3
3530 *
3531 * that's the print server case, the printer case is even worse.
3532 */
3533
3534 /*******************************************************************
3535 *
3536 * enumerate all printers on the printserver
3537 * fill a notify_info struct with info asked
3538 *
3539 ********************************************************************/
3540
3541 static WERROR printserver_notify_info(pipes_struct *p,
3542 struct policy_handle *hnd,
3543 struct spoolss_NotifyInfo *info,
3544 TALLOC_CTX *mem_ctx)
3545 {
3546 int snum;
3547 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3548 int n_services=lp_numservices();
3549 int i;
3550 struct spoolss_NotifyOption *option;
3551 struct spoolss_NotifyOptionType option_type;
3552
3553 DEBUG(4,("printserver_notify_info\n"));
3554
3555 if (!Printer)
3556 return WERR_BADFID;
3557
3558 option = Printer->notify.option;
3559
3560 info->version = 2;
3561 info->notifies = NULL;
3562 info->count = 0;
3563
3564 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3565 sending a ffpcn() request first */
3566
3567 if ( !option )
3568 return WERR_BADFID;
3569
3570 for (i=0; i<option->count; i++) {
3571 option_type = option->types[i];
3572
3573 if (option_type.type != PRINTER_NOTIFY_TYPE)
3574 continue;
3575
3576 for (snum=0; snum<n_services; snum++)
3577 {
3578 if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3579 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3580 }
3581 }
3582
3583 #if 0
3584 /*
3585 * Debugging information, don't delete.
3586 */
3587
3588 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3589 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3590 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3591
3592 for (i=0; i<info->count; i++) {
3593 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3594 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3595 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3596 }
3597 #endif
3598
3599 return WERR_OK;
3600 }
3601
3602 /*******************************************************************
3603 *
3604 * fill a notify_info struct with info asked
3605 *
3606 ********************************************************************/
3607
3608 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3609 struct spoolss_NotifyInfo *info,
3610 TALLOC_CTX *mem_ctx)
3611 {
3612 int snum;
3613 Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3614 int i;
3615 uint32_t id;
3616 struct spoolss_NotifyOption *option;
3617 struct spoolss_NotifyOptionType option_type;
3618 int count,j;
3619 print_queue_struct *queue=NULL;
3620 print_status_struct status;
3621
3622 DEBUG(4,("printer_notify_info\n"));
3623
3624 if (!Printer)
3625 return WERR_BADFID;
3626
3627 option = Printer->notify.option;
3628 id = 0x0;
3629
3630 info->version = 2;
3631 info->notifies = NULL;
3632 info->count = 0;
3633
3634 /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3635 sending a ffpcn() request first */
3636
3637 if ( !option )
3638 return WERR_BADFID;
3639
3640 get_printer_snum(p, hnd, &snum, NULL);
3641
3642 for (i=0; i<option->count; i++) {
3643 option_type = option->types[i];
3644
3645 switch (option_type.type) {
3646 case PRINTER_NOTIFY_TYPE:
3647 if(construct_notify_printer_info(Printer, info, snum,
3648 &option_type, id,
3649 mem_ctx))
3650 id--;
3651 break;
3652
3653 case JOB_NOTIFY_TYPE: {
3654 NT_PRINTER_INFO_LEVEL *printer = NULL;
3655
3656 count = print_queue_status(snum, &queue, &status);
3657
3658 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3659 goto done;
3660
3661 for (j=0; j<count; j++) {
3662 construct_notify_jobs_info(&queue[j], info,
3663 printer, snum,
3664 &option_type,
3665 queue[j].job,
3666 mem_ctx);
3667 }
3668
3669 free_a_printer(&printer, 2);
3670
3671 done:
3672 SAFE_FREE(queue);
3673 break;
3674 }
3675 }
3676 }
3677
3678 /*
3679 * Debugging information, don't delete.
3680 */
3681 /*
3682 DEBUG(1,("dumping the NOTIFY_INFO\n"));
3683 DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3684 DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3685
3686 for (i=0; i<info->count; i++) {
3687 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3688 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3689 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3690 }
3691 */
3692 return WERR_OK;
3693 }
3694
3695 /****************************************************************
3696 _spoolss_RouterRefreshPrinterChangeNotify
3697 ****************************************************************/
3698
3699 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3700 struct spoolss_RouterRefreshPrinterChangeNotify *r)
3701 {
3702 struct spoolss_NotifyInfo *info;
3703
3704 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3705 WERROR result = WERR_BADFID;
3706
3707 /* we always have a spoolss_NotifyInfo struct */
3708 info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3709 if (!info) {
3710 result = WERR_NOMEM;
3711 goto done;
3712 }
3713
3714 *r->out.info = info;
3715
3716 if (!Printer) {
3717 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3718 "Invalid handle (%s:%u:%u).\n",
3719 OUR_HANDLE(r->in.handle)));
3720 goto done;
3721 }
3722
3723 DEBUG(4,("Printer type %x\n",Printer->printer_type));
3724
3725 /*
3726 * We are now using the change value, and
3727 * I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3728 * I don't have a global notification system, I'm sending back all the
3729 * informations even when _NOTHING_ has changed.
3730 */
3731
3732 /* We need to keep track of the change value to send back in
3733 RRPCN replies otherwise our updates are ignored. */
3734
3735 Printer->notify.fnpcn = true;
3736
3737 if (Printer->notify.client_connected) {
3738 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3739 "Saving change value in request [%x]\n",
3740 r->in.change_low));
3741 Printer->notify.change = r->in.change_low;
3742 }
3743
3744 /* just ignore the spoolss_NotifyOption */
3745
3746 switch (Printer->printer_type) {
3747 case SPLHND_SERVER:
3748 result = printserver_notify_info(p, r->in.handle,
3749 info, p->mem_ctx);
3750 break;
3751
3752 case SPLHND_PRINTER:
3753 result = printer_notify_info(p, r->in.handle,
3754 info, p->mem_ctx);
3755 break;
3756 }
3757
3758 Printer->notify.fnpcn = false;
3759
3760 done:
3761 return result;
3762 }
3763
3764 /********************************************************************
3765 * construct_printer_info_0
3766 * fill a printer_info_0 struct
3767 ********************************************************************/
3768
3769 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3770 const NT_PRINTER_INFO_LEVEL *ntprinter,
3771 struct spoolss_PrinterInfo0 *r,
3772 int snum)
3773 {
3774 int count;
3775 counter_printer_0 *session_counter;
3776 time_t setuptime;
3777 print_status_struct status;
3778
3779 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3780 W_ERROR_HAVE_NO_MEMORY(r->printername);
3781
3782 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3783 W_ERROR_HAVE_NO_MEMORY(r->servername);
3784
3785 count = print_queue_length(snum, &status);
3786
3787 /* check if we already have a counter for this printer */
3788 for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3789 if (session_counter->snum == snum)
3790 break;
3791 }
3792
3793 /* it's the first time, add it to the list */
3794 if (session_counter == NULL) {
3795 session_counter = SMB_MALLOC_P(counter_printer_0);
3796 W_ERROR_HAVE_NO_MEMORY(session_counter);
3797 ZERO_STRUCTP(session_counter);
3798 session_counter->snum = snum;
3799 session_counter->counter = 0;
3800 DLIST_ADD(counter_list, session_counter);
3801 }
3802
3803 /* increment it */
3804 session_counter->counter++;
3805
3806 r->cjobs = count;
3807 r->total_jobs = 0;
3808 r->total_bytes = 0;
3809
3810 setuptime = (time_t)ntprinter->info_2->setuptime;
3811
3812 init_systemtime(&r->time, gmtime(&setuptime));
3813
3814 /* JFM:
3815 * the global_counter should be stored in a TDB as it's common to all the clients
3816 * and should be zeroed on samba startup
3817 */
3818 r->global_counter = session_counter->counter;
3819 r->total_pages = 0;
3820 /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3821 r->version = 0x0005; /* NT 5 */
3822 r->free_build = 0x0893; /* build 2195 */
3823 r->spooling = 0;
3824 r->max_spooling = 0;
3825 r->session_counter = session_counter->counter;
3826 r->num_error_out_of_paper = 0x0;
3827 r->num_error_not_ready = 0x0; /* number of print failure */
3828 r->job_error = 0x0;
3829 r->number_of_processors = 0x1;
3830 r->processor_type = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3831 r->high_part_total_bytes = 0x0;
3832 r->change_id = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3833 r->last_error = WERR_OK;
3834 r->status = nt_printq_status(status.status);
3835 r->enumerate_network_printers = 0x0;
3836 r->c_setprinter = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3837 r->processor_architecture = 0x0;
3838 r->processor_level = 0x6; /* 6 ???*/
3839 r->ref_ic = 0;
3840 r->reserved2 = 0;
3841 r->reserved3 = 0;
3842
3843 return WERR_OK;
3844 }
3845
3846 /****************************************************************************
3847 Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure. Both pointers
3848 should be valid upon entry
3849 ****************************************************************************/
3850
3851 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3852 struct spoolss_DeviceMode *r,
3853 const NT_DEVICEMODE *ntdevmode)
3854 {
3855 if (!r || !ntdevmode) {
3856 return WERR_INVALID_PARAM;
3857 }
3858
3859 r->devicename = talloc_strdup(mem_ctx, ntdevmode->devicename);
3860 W_ERROR_HAVE_NO_MEMORY(r->devicename);
3861
3862 r->specversion = ntdevmode->specversion;
3863 r->driverversion = ntdevmode->driverversion;
3864 r->size = ntdevmode->size;
3865 r->__driverextra_length = ntdevmode->driverextra;
3866 r->fields = ntdevmode->fields;
3867
3868 r->orientation = ntdevmode->orientation;
3869 r->papersize = ntdevmode->papersize;
3870 r->paperlength = ntdevmode->paperlength;
3871 r->paperwidth = ntdevmode->paperwidth;
3872 r->scale = ntdevmode->scale;
3873 r->copies = ntdevmode->copies;
3874 r->defaultsource = ntdevmode->defaultsource;
3875 r->printquality = ntdevmode->printquality;
3876 r->color = ntdevmode->color;
3877 r->duplex = ntdevmode->duplex;
3878 r->yresolution = ntdevmode->yresolution;
3879 r->ttoption = ntdevmode->ttoption;
3880 r->collate = ntdevmode->collate;
3881
3882 r->formname = talloc_strdup(mem_ctx, ntdevmode->formname);
3883 W_ERROR_HAVE_NO_MEMORY(r->formname);
3884
3885 /* all 0 below are values that have not been set in the old parsing/copy
3886 * function, maybe they should... - gd */
3887
3888 r->logpixels = 0;
3889 r->bitsperpel = 0;
3890 r->pelswidth = 0;
3891 r->pelsheight = 0;
3892 r->displayflags = 0;
3893 r->displayfrequency = 0;
3894 r->icmmethod = ntdevmode->icmmethod;
3895 r->icmintent = ntdevmode->icmintent;
3896 r->mediatype = ntdevmode->mediatype;
3897 r->dithertype = ntdevmode->dithertype;
3898 r->reserved1 = 0;
3899 r->reserved2 = 0;
3900 r->panningwidth = 0;
3901 r->panningheight = 0;
3902
3903 if (ntdevmode->nt_dev_private != NULL) {
3904 r->driverextra_data = data_blob_talloc(mem_ctx,
3905 ntdevmode->nt_dev_private,
3906 ntdevmode->driverextra);
3907 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3908 }
3909
3910 return WERR_OK;
3911 }
3912
3913
3914 /****************************************************************************
3915 Create a spoolss_DeviceMode struct. Returns talloced memory.
3916 ****************************************************************************/
3917
3918 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3919 const char *servicename)
3920 {
3921 WERROR result;
3922 NT_PRINTER_INFO_LEVEL *printer = NULL;
3923 struct spoolss_DeviceMode *devmode = NULL;
3924
3925 DEBUG(7,("construct_dev_mode\n"));
3926
3927 DEBUGADD(8,("getting printer characteristics\n"));
3928
3929 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3930 return NULL;
3931
3932 if (!printer->info_2->devmode) {
3933 DEBUG(5, ("BONG! There was no device mode!\n"));
3934 goto done;
3935 }
3936
3937 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3938 if (!devmode) {
3939 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3940 goto done;
3941 }
3942
3943 DEBUGADD(8,("loading DEVICEMODE\n"));
3944
3945 result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3946 if (!W_ERROR_IS_OK(result)) {
3947 TALLOC_FREE(devmode);
3948 }
3949
3950 done:
3951 free_a_printer(&printer,2);
3952
3953 return devmode;
3954 }
3955
3956 /********************************************************************
3957 * construct_printer_info3
3958 * fill a spoolss_PrinterInfo3 struct
3959 ********************************************************************/
3960
3961 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3962 const NT_PRINTER_INFO_LEVEL *ntprinter,
3963 struct spoolss_PrinterInfo3 *r,
3964 int snum)
3965 {
3966 /* These are the components of the SD we are returning. */
3967
3968 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3969 /* don't use talloc_steal() here unless you do a deep steal of all
3970 the SEC_DESC members */
3971
3972 r->secdesc = dup_sec_desc(mem_ctx,
3973 ntprinter->info_2->secdesc_buf->sd);
3974 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3975 }
3976
3977 return WERR_OK;
3978 }
3979
3980 /********************************************************************
3981 * construct_printer_info4
3982 * fill a spoolss_PrinterInfo4 struct
3983 ********************************************************************/
3984
3985 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
3986 const NT_PRINTER_INFO_LEVEL *ntprinter,
3987 struct spoolss_PrinterInfo4 *r,
3988 int snum)
3989 {
3990 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3991 W_ERROR_HAVE_NO_MEMORY(r->printername);
3992 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3993 W_ERROR_HAVE_NO_MEMORY(r->servername);
3994
3995 r->attributes = ntprinter->info_2->attributes;
3996
3997 return WERR_OK;
3998 }
3999
4000 /********************************************************************
4001 * construct_printer_info5
4002 * fill a spoolss_PrinterInfo5 struct
4003 ********************************************************************/
4004
4005 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
4006 const NT_PRINTER_INFO_LEVEL *ntprinter,
4007 struct spoolss_PrinterInfo5 *r,
4008 int snum)
4009 {
4010 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4011 W_ERROR_HAVE_NO_MEMORY(r->printername);
4012 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4013 W_ERROR_HAVE_NO_MEMORY(r->portname);
4014
4015 r->attributes = ntprinter->info_2->attributes;
4016
4017 /* these two are not used by NT+ according to MSDN */
4018
4019 r->device_not_selected_timeout = 0x0; /* have seen 0x3a98 */
4020 r->transmission_retry_timeout = 0x0; /* have seen 0xafc8 */
4021
4022 return WERR_OK;
4023 }
4024
4025 /********************************************************************
4026 * construct_printer_info_6
4027 * fill a spoolss_PrinterInfo6 struct
4028 ********************************************************************/
4029
4030 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
4031 const NT_PRINTER_INFO_LEVEL *ntprinter,
4032 struct spoolss_PrinterInfo6 *r,
4033 int snum)
4034 {
4035 int count;
4036 print_status_struct status;
4037
4038 count = print_queue_length(snum, &status);
4039
4040 r->status = nt_printq_status(status.status);
4041
4042 return WERR_OK;
4043 }
4044
4045 /********************************************************************
4046 * construct_printer_info7
4047 * fill a spoolss_PrinterInfo7 struct
4048 ********************************************************************/
4049
4050 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4051 Printer_entry *print_hnd,
4052 struct spoolss_PrinterInfo7 *r,
4053 int snum)
4054 {
4055 struct GUID guid;
4056
4057 if (is_printer_published(print_hnd, snum, &guid)) {
4058 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
4059 r->action = DSPRINT_PUBLISH;
4060 } else {
4061 r->guid = talloc_strdup(mem_ctx, "");
4062 r->action = DSPRINT_UNPUBLISH;
4063 }
4064 W_ERROR_HAVE_NO_MEMORY(r->guid);
4065
4066 return WERR_OK;
4067 }
4068
4069 /********************************************************************
4070 * construct_printer_info8
4071 * fill a spoolss_PrinterInfo8 struct
4072 ********************************************************************/
4073
4074 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4075 const NT_PRINTER_INFO_LEVEL *ntprinter,
4076 struct spoolss_DeviceModeInfo *r,
4077 int snum)
4078 {
4079 struct spoolss_DeviceMode *devmode;
4080 WERROR result;
4081
4082 if (!ntprinter->info_2->devmode) {
4083 r->devmode = NULL;
4084 return WERR_OK;
4085 }
4086
4087 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
4088 W_ERROR_HAVE_NO_MEMORY(devmode);
4089
4090 result = convert_nt_devicemode(mem_ctx, devmode, ntprinter->info_2->devmode);
4091 if (!W_ERROR_IS_OK(result)) {
4092 TALLOC_FREE(devmode);
4093 return result;
4094 }
4095
4096 r->devmode = devmode;
4097
4098 return WERR_OK;
4099 }
4100
4101
4102 /********************************************************************
4103 * construct_printer_info1
4104 * fill a spoolss_PrinterInfo1 struct
4105 ********************************************************************/
4106
4107 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
4108 const NT_PRINTER_INFO_LEVEL *ntprinter,
4109 uint32_t flags,
4110 struct spoolss_PrinterInfo1 *r,
4111 int snum)
4112 {
4113 r->flags = flags;
4114
4115 r->description = talloc_asprintf(mem_ctx, "%s,%s,%s",
4116 ntprinter->info_2->printername,
4117 ntprinter->info_2->drivername,
4118 ntprinter->info_2->location);
4119 W_ERROR_HAVE_NO_MEMORY(r->description);
4120
4121 if (*ntprinter->info_2->comment == '\0') {
4122 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
4123 } else {
4124 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
4125 }
4126 W_ERROR_HAVE_NO_MEMORY(r->comment);
4127
4128 r->name = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4129 W_ERROR_HAVE_NO_MEMORY(r->name);
4130
4131 return WERR_OK;
4132 }
4133
4134 /********************************************************************
4135 * construct_printer_info2
4136 * fill a spoolss_PrinterInfo2 struct
4137 ********************************************************************/
4138
4139 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
4140 const NT_PRINTER_INFO_LEVEL *ntprinter,
4141 struct spoolss_PrinterInfo2 *r,
4142 int snum)
4143 {
4144 int count;
4145
4146 print_status_struct status;
4147
4148 count = print_queue_length(snum, &status);
4149
4150 r->servername = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
4151 W_ERROR_HAVE_NO_MEMORY(r->servername);
4152 r->printername = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4153 W_ERROR_HAVE_NO_MEMORY(r->printername);
4154 r->sharename = talloc_strdup(mem_ctx, lp_servicename(snum));
4155 W_ERROR_HAVE_NO_MEMORY(r->sharename);
4156 r->portname = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4157 W_ERROR_HAVE_NO_MEMORY(r->portname);
4158 r->drivername = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
4159 W_ERROR_HAVE_NO_MEMORY(r->drivername);
4160
4161 if (*ntprinter->info_2->comment == '\0') {
4162 r->comment = talloc_strdup(mem_ctx, lp_comment(snum));
4163 } else {
4164 r->comment = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
4165 }
4166 W_ERROR_HAVE_NO_MEMORY(r->comment);
4167
4168 r->location = talloc_strdup(mem_ctx, ntprinter->info_2->location);
4169 W_ERROR_HAVE_NO_MEMORY(r->location);
4170 r->sepfile = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
4171 W_ERROR_HAVE_NO_MEMORY(r->sepfile);
4172 r->printprocessor = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
4173 W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
4174 r->datatype = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
4175 W_ERROR_HAVE_NO_MEMORY(r->datatype);
4176 r->parameters = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
4177 W_ERROR_HAVE_NO_MEMORY(r->parameters);
4178
4179 r->attributes = ntprinter->info_2->attributes;
4180
4181 r->priority = ntprinter->info_2->priority;
4182 r->defaultpriority = ntprinter->info_2->default_priority;
4183 r->starttime = ntprinter->info_2->starttime;
4184 r->untiltime = ntprinter->info_2->untiltime;
4185 r->status = nt_printq_status(status.status);
4186 r->cjobs = count;
4187 r->averageppm = ntprinter->info_2->averageppm;
4188
4189 r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
4190 if (!r->devmode) {
4191 DEBUG(8,("Returning NULL Devicemode!\n"));
4192 }
4193
4194 r->secdesc = NULL;
4195
4196 if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
4197 /* don't use talloc_steal() here unless you do a deep steal of all
4198 the SEC_DESC members */
4199
4200 r->secdesc = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
4201 }
4202
4203 return WERR_OK;
4204 }
4205
4206 /********************************************************************
4207 ********************************************************************/
4208
4209 static bool snum_is_shared_printer(int snum)
4210 {
4211 return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
4212 }
4213
4214 /********************************************************************
4215 Spoolss_enumprinters.
4216 ********************************************************************/
4217
4218 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4219 uint32_t level,
4220 uint32_t flags,
4221 union spoolss_PrinterInfo **info_p,
4222 uint32_t *count_p)
4223 {
4224 int snum;
4225 int n_services = lp_numservices();
4226 union spoolss_PrinterInfo *info = NULL;
4227 uint32_t count = 0;
4228 WERROR result = WERR_OK;
4229
4230 *count_p = 0;
4231 *info_p = NULL;
4232
4233 for (snum = 0; snum < n_services; snum++) {
4234
4235 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4236
4237 if (!snum_is_shared_printer(snum)) {
4238 continue;
4239 }
4240
4241 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4242 lp_servicename(snum), snum));
4243
4244 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4245 union spoolss_PrinterInfo,
4246 count + 1);
4247 if (!info) {
4248 result = WERR_NOMEM;
4249 goto out;
4250 }
4251
4252 result = get_a_printer(NULL, &ntprinter, 2,
4253 lp_const_servicename(snum));
4254 if (!W_ERROR_IS_OK(result)) {
4255 goto out;
4256 }
4257
4258 switch (level) {
4259 case 0:
4260 result = construct_printer_info0(info, ntprinter,
4261 &info[count].info0, snum);
4262 break;
4263 case 1:
4264 result = construct_printer_info1(info, ntprinter, flags,
4265 &info[count].info1, snum);
4266 break;
4267 case 2:
4268 result = construct_printer_info2(info, ntprinter,
4269 &info[count].info2, snum);
4270 break;
4271 case 4:
4272 result = construct_printer_info4(info, ntprinter,
4273 &info[count].info4, snum);
4274 break;
4275 case 5:
4276 result = construct_printer_info5(info, ntprinter,
4277 &info[count].info5, snum);
4278 break;
4279
4280 default:
4281 result = WERR_UNKNOWN_LEVEL;
4282 free_a_printer(&ntprinter, 2);
4283 goto out;
4284 }
4285
4286 free_a_printer(&ntprinter, 2);
4287 if (!W_ERROR_IS_OK(result)) {
4288 goto out;
4289 }
4290
4291 count++;
4292 }
4293
4294 *count_p = count;
4295 *info_p = info;
4296
4297 out:
4298 if (!W_ERROR_IS_OK(result)) {
4299 TALLOC_FREE(info);
4300 return result;
4301 }
4302
4303 *info_p = info;
4304
4305 return WERR_OK;
4306 }
4307
4308 /********************************************************************
4309 * handle enumeration of printers at level 0
4310 ********************************************************************/
4311
4312 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4313 uint32_t flags,
4314 const char *servername,
4315 union spoolss_PrinterInfo **info,
4316 uint32_t *count)
4317 {
4318 DEBUG(4,("enum_all_printers_info_0\n"));
4319
4320 return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4321 }
4322
4323
4324 /********************************************************************
4325 ********************************************************************/
4326
4327 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4328 uint32_t flags,
4329 union spoolss_PrinterInfo **info,
4330 uint32_t *count)
4331 {
4332 DEBUG(4,("enum_all_printers_info_1\n"));
4333
4334 return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4335 }
4336
4337 /********************************************************************
4338 enum_all_printers_info_1_local.
4339 *********************************************************************/
4340
4341 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4342 union spoolss_PrinterInfo **info,
4343 uint32_t *count)
4344 {
4345 DEBUG(4,("enum_all_printers_info_1_local\n"));
4346
4347 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4348 }
4349
4350 /********************************************************************
4351 enum_all_printers_info_1_name.
4352 *********************************************************************/
4353
4354 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4355 const char *name,
4356 union spoolss_PrinterInfo **info,
4357 uint32_t *count)
4358 {
4359 const char *s = name;
4360
4361 DEBUG(4,("enum_all_printers_info_1_name\n"));
4362
4363 if ((name[0] == '\\') && (name[1] == '\\')) {
4364 s = name + 2;
4365 }
4366
4367 if (!is_myname_or_ipaddr(s)) {
4368 return WERR_INVALID_NAME;
4369 }
4370
4371 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4372 }
4373
4374 /********************************************************************
4375 enum_all_printers_info_1_network.
4376 *********************************************************************/
4377
4378 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4379 const char *name,
4380 union spoolss_PrinterInfo **info,
4381 uint32_t *count)
4382 {
4383 const char *s = name;
4384
4385 DEBUG(4,("enum_all_printers_info_1_network\n"));
4386
4387 /* If we respond to a enum_printers level 1 on our name with flags
4388 set to PRINTER_ENUM_REMOTE with a list of printers then these
4389 printers incorrectly appear in the APW browse list.
4390 Specifically the printers for the server appear at the workgroup
4391 level where all the other servers in the domain are
4392 listed. Windows responds to this call with a
4393 WERR_CAN_NOT_COMPLETE so we should do the same. */
4394
4395 if (name[0] == '\\' && name[1] == '\\') {
4396 s = name + 2;
4397 }
4398
4399 if (is_myname_or_ipaddr(s)) {
4400 return WERR_CAN_NOT_COMPLETE;
4401 }
4402
4403 return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4404 }
4405
4406 /********************************************************************
4407 * api_spoolss_enumprinters
4408 *
4409 * called from api_spoolss_enumprinters (see this to understand)
4410 ********************************************************************/
4411
4412 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4413 union spoolss_PrinterInfo **info,
4414 uint32_t *count)
4415 {
4416 DEBUG(4,("enum_all_printers_info_2\n"));
4417
4418 return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4419 }
4420
4421 /********************************************************************
4422 * handle enumeration of printers at level 1
4423 ********************************************************************/
4424
4425 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4426 uint32_t flags,
4427 const char *name,
4428 union spoolss_PrinterInfo **info,
4429 uint32_t *count)
4430 {
4431 /* Not all the flags are equals */
4432
4433 if (flags & PRINTER_ENUM_LOCAL) {
4434 return enum_all_printers_info_1_local(mem_ctx, info, count);
4435 }
4436
4437 if (flags & PRINTER_ENUM_NAME) {
4438 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4439 }
4440
4441 if (flags & PRINTER_ENUM_NETWORK) {
4442 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4443 }
4444
4445 return WERR_OK; /* NT4sp5 does that */
4446 }
4447
4448 /********************************************************************
4449 * handle enumeration of printers at level 2
4450 ********************************************************************/
4451
4452 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4453 uint32_t flags,
4454 const char *servername,
4455 union spoolss_PrinterInfo **info,
4456 uint32_t *count)
4457 {
4458 if (flags & PRINTER_ENUM_LOCAL) {
4459 return enum_all_printers_info_2(mem_ctx, info, count);
4460 }
4461
4462 if (flags & PRINTER_ENUM_NAME) {
4463 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4464 return WERR_INVALID_NAME;
4465 }
4466
4467 return enum_all_printers_info_2(mem_ctx, info, count);
4468 }
4469
4470 if (flags & PRINTER_ENUM_REMOTE) {
4471 return WERR_UNKNOWN_LEVEL;
4472 }
4473
4474 return WERR_OK;
4475 }
4476
4477 /********************************************************************
4478 * handle enumeration of printers at level 4
4479 ********************************************************************/
4480
4481 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4482 uint32_t flags,
4483 const char *servername,
4484 union spoolss_PrinterInfo **info,
4485 uint32_t *count)
4486 {
4487 DEBUG(4,("enum_all_printers_info_4\n"));
4488
4489 return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4490 }
4491
4492
4493 /********************************************************************
4494 * handle enumeration of printers at level 5
4495 ********************************************************************/
4496
4497 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4498 uint32_t flags,
4499 const char *servername,
4500 union spoolss_PrinterInfo **info,
4501 uint32_t *count)
4502 {
4503 DEBUG(4,("enum_all_printers_info_5\n"));
4504
4505 return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4506 }
4507
4508 /****************************************************************
4509 _spoolss_EnumPrinters
4510 ****************************************************************/
4511
4512 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4513 struct spoolss_EnumPrinters *r)
4514 {
4515 const char *name;
4516 WERROR result;
4517
4518 /* that's an [in out] buffer */
4519
4520 if (!r->in.buffer && (r->in.offered != 0)) {
4521 return WERR_INVALID_PARAM;
4522 }
4523
4524 DEBUG(4,("_spoolss_EnumPrinters\n"));
4525
4526 *r->out.needed = 0;
4527 *r->out.count = 0;
4528 *r->out.info = NULL;
4529
4530 /*
4531 * Level 1:
4532 * flags==PRINTER_ENUM_NAME
4533 * if name=="" then enumerates all printers
4534 * if name!="" then enumerate the printer
4535 * flags==PRINTER_ENUM_REMOTE
4536 * name is NULL, enumerate printers
4537 * Level 2: name!="" enumerates printers, name can't be NULL
4538 * Level 3: doesn't exist
4539 * Level 4: does a local registry lookup
4540 * Level 5: same as Level 2
4541 */
4542
4543 name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4544 W_ERROR_HAVE_NO_MEMORY(name);
4545
4546 switch (r->in.level) {
4547 case 0:
4548 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4549 r->out.info, r->out.count);
4550 break;
4551 case 1:
4552 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4553 r->out.info, r->out.count);
4554 break;
4555 case 2:
4556 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4557 r->out.info, r->out.count);
4558 break;
4559 case 4:
4560 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4561 r->out.info, r->out.count);
4562 break;
4563 case 5:
4564 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4565 r->out.info, r->out.count);
4566 break;
4567 default:
4568 return WERR_UNKNOWN_LEVEL;
4569 }
4570
4571 if (!W_ERROR_IS_OK(result)) {
4572 return result;
4573 }
4574
4575 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4576 spoolss_EnumPrinters, NULL,
4577 *r->out.info, r->in.level,
4578 *r->out.count);
4579 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4580 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4581
4582 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4583 }
4584
4585 /****************************************************************
4586 _spoolss_GetPrinter
4587 ****************************************************************/
4588
4589 WERROR _spoolss_GetPrinter(pipes_struct *p,
4590 struct spoolss_GetPrinter *r)
4591 {
4592 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4593 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4594 WERROR result = WERR_OK;
4595
4596 int snum;
4597
4598 /* that's an [in out] buffer */
4599
4600 if (!r->in.buffer && (r->in.offered != 0)) {
4601 return WERR_INVALID_PARAM;
4602 }
4603
4604 *r->out.needed = 0;
4605
4606 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4607 return WERR_BADFID;
4608 }
4609
4610 result = get_a_printer(Printer, &ntprinter, 2,
4611 lp_const_servicename(snum));
4612 if (!W_ERROR_IS_OK(result)) {
4613 return result;
4614 }
4615
4616 switch (r->in.level) {
4617 case 0:
4618 result = construct_printer_info0(p->mem_ctx, ntprinter,
4619 &r->out.info->info0, snum);
4620 break;
4621 case 1:
4622 result = construct_printer_info1(p->mem_ctx, ntprinter,
4623 PRINTER_ENUM_ICON8,
4624 &r->out.info->info1, snum);
4625 break;
4626 case 2:
4627 result = construct_printer_info2(p->mem_ctx, ntprinter,
4628 &r->out.info->info2, snum);
4629 break;
4630 case 3:
4631 result = construct_printer_info3(p->mem_ctx, ntprinter,
4632 &r->out.info->info3, snum);
4633 break;
4634 case 4:
4635 result = construct_printer_info4(p->mem_ctx, ntprinter,
4636 &r->out.info->info4, snum);
4637 break;
4638 case 5:
4639 result = construct_printer_info5(p->mem_ctx, ntprinter,
4640 &r->out.info->info5, snum);
4641 break;
4642 case 6:
4643 result = construct_printer_info6(p->mem_ctx, ntprinter,
4644 &r->out.info->info6, snum);
4645 break;
4646 case 7:
4647 result = construct_printer_info7(p->mem_ctx, Printer,
4648 &r->out.info->info7, snum);
4649 break;
4650 case 8:
4651 result = construct_printer_info8(p->mem_ctx, ntprinter,
4652 &r->out.info->info8, snum);
4653 break;
4654 default:
4655 result = WERR_UNKNOWN_LEVEL;
4656 break;
4657 }
4658
4659 free_a_printer(&ntprinter, 2);
4660
4661 if (!W_ERROR_IS_OK(result)) {
4662 TALLOC_FREE(r->out.info);
4663 return result;
4664 }
4665
4666 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4667 r->out.info, r->in.level);
4668 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4669
4670 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4671 }
4672
4673 /********************************************************************
4674 ********************************************************************/
4675
4676 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4677 fstring *fstring_array,
4678 const char *cservername)
4679 {
4680 int i, num_strings = 0;
4681 const char **array = NULL;
4682
4683 for (i=0; fstring_array && fstring_array[i][0] != '\0'; i++) {
4684
4685 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4686 cservername, fstring_array[i]);
4687 if (!str) {
4688 TALLOC_FREE(array);
4689 return NULL;
4690 }
4691
4692
4693 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4694 TALLOC_FREE(array);
4695 return NULL;
4696 }
4697 }
4698
4699 if (i > 0) {
4700 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4701 &array, &num_strings);
4702 }
4703
4704 return array;
4705 }
4706
4707 /********************************************************************
4708 * fill a spoolss_DriverInfo1 struct
4709 ********************************************************************/
4710
4711 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4712 struct spoolss_DriverInfo1 *r,
4713 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4714 const char *servername,
4715 const char *architecture)
4716 {
4717 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4718 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4719
4720 return WERR_OK;
4721 }
4722
4723 /********************************************************************
4724 * fill a spoolss_DriverInfo2 struct
4725 ********************************************************************/
4726
4727 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4728 struct spoolss_DriverInfo2 *r,
4729 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4730 const char *servername)
4731
4732 {
4733 const char *cservername = canon_servername(servername);
4734
4735 r->version = driver->info_3->cversion;
4736
4737 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4738 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4739 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4740 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4741
4742 if (strlen(driver->info_3->driverpath)) {
4743 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4744 cservername, driver->info_3->driverpath);
4745 } else {
4746 r->driver_path = talloc_strdup(mem_ctx, "");
4747 }
4748 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4749
4750 if (strlen(driver->info_3->datafile)) {
4751 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4752 cservername, driver->info_3->datafile);
4753 } else {
4754 r->data_file = talloc_strdup(mem_ctx, "");
4755 }
4756 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4757
4758 if (strlen(driver->info_3->configfile)) {
4759 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4760 cservername, driver->info_3->configfile);
4761 } else {
4762 r->config_file = talloc_strdup(mem_ctx, "");
4763 }
4764 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4765
4766 return WERR_OK;
4767 }
4768
4769 /********************************************************************
4770 * fill a spoolss_DriverInfo3 struct
4771 ********************************************************************/
4772
4773 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4774 struct spoolss_DriverInfo3 *r,
4775 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4776 const char *servername)
4777 {
4778 const char *cservername = canon_servername(servername);
4779
4780 r->version = driver->info_3->cversion;
4781
4782 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4783 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4784 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4785 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4786
4787 if (strlen(driver->info_3->driverpath)) {
4788 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4789 cservername, driver->info_3->driverpath);
4790 } else {
4791 r->driver_path = talloc_strdup(mem_ctx, "");
4792 }
4793 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4794
4795 if (strlen(driver->info_3->datafile)) {
4796 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4797 cservername, driver->info_3->datafile);
4798 } else {
4799 r->data_file = talloc_strdup(mem_ctx, "");
4800 }
4801 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4802
4803 if (strlen(driver->info_3->configfile)) {
4804 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4805 cservername, driver->info_3->configfile);
4806 } else {
4807 r->config_file = talloc_strdup(mem_ctx, "");
4808 }
4809 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4810
4811 if (strlen(driver->info_3->helpfile)) {
4812 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4813 cservername, driver->info_3->helpfile);
4814 } else {
4815 r->help_file = talloc_strdup(mem_ctx, "");
4816 }
4817 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4818
4819 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4820 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4821 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4822 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4823
4824 r->dependent_files = string_array_from_driver_info(mem_ctx,
4825 driver->info_3->dependentfiles,
4826 cservername);
4827 return WERR_OK;
4828 }
4829
4830 /********************************************************************
4831 * fill a spoolss_DriverInfo4 struct
4832 ********************************************************************/
4833
4834 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4835 struct spoolss_DriverInfo4 *r,
4836 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4837 const char *servername)
4838 {
4839 const char *cservername = canon_servername(servername);
4840
4841 r->version = driver->info_3->cversion;
4842
4843 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4844 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4845 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4846 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4847
4848 if (strlen(driver->info_3->driverpath)) {
4849 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4850 cservername, driver->info_3->driverpath);
4851 } else {
4852 r->driver_path = talloc_strdup(mem_ctx, "");
4853 }
4854 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4855
4856 if (strlen(driver->info_3->datafile)) {
4857 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4858 cservername, driver->info_3->datafile);
4859 } else {
4860 r->data_file = talloc_strdup(mem_ctx, "");
4861 }
4862 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4863
4864 if (strlen(driver->info_3->configfile)) {
4865 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4866 cservername, driver->info_3->configfile);
4867 } else {
4868 r->config_file = talloc_strdup(mem_ctx, "");
4869 }
4870 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4871
4872 if (strlen(driver->info_3->helpfile)) {
4873 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4874 cservername, driver->info_3->helpfile);
4875 } else {
4876 r->help_file = talloc_strdup(mem_ctx, "");
4877 }
4878 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4879
4880 r->dependent_files = string_array_from_driver_info(mem_ctx,
4881 driver->info_3->dependentfiles,
4882 cservername);
4883
4884
4885 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4886 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4887 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4888 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4889
4890 r->previous_names = string_array_from_driver_info(mem_ctx,
4891 NULL,
4892 cservername);
4893
4894 return WERR_OK;
4895 }
4896
4897 /********************************************************************
4898 * fill a spoolss_DriverInfo5 struct
4899 ********************************************************************/
4900
4901 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4902 struct spoolss_DriverInfo5 *r,
4903 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4904 const char *servername)
4905 {
4906 const char *cservername = canon_servername(servername);
4907
4908 r->version = driver->info_3->cversion;
4909
4910 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4911 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4912 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4913 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4914
4915 if (strlen(driver->info_3->driverpath)) {
4916 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4917 cservername, driver->info_3->driverpath);
4918 } else {
4919 r->driver_path = talloc_strdup(mem_ctx, "");
4920 }
4921 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4922
4923 if (strlen(driver->info_3->datafile)) {
4924 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4925 cservername, driver->info_3->datafile);
4926 } else {
4927 r->data_file = talloc_strdup(mem_ctx, "");
4928 }
4929 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4930
4931 if (strlen(driver->info_3->configfile)) {
4932 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4933 cservername, driver->info_3->configfile);
4934 } else {
4935 r->config_file = talloc_strdup(mem_ctx, "");
4936 }
4937 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4938
4939 r->driver_attributes = 0;
4940 r->config_version = 0;
4941 r->driver_version = 0;
4942
4943 return WERR_OK;
4944 }
4945 /********************************************************************
4946 * fill a spoolss_DriverInfo6 struct
4947 ********************************************************************/
4948
4949 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4950 struct spoolss_DriverInfo6 *r,
4951 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4952 const char *servername)
4953 {
4954 const char *cservername = canon_servername(servername);
4955
4956 r->version = driver->info_3->cversion;
4957
4958 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
4959 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4960 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
4961 W_ERROR_HAVE_NO_MEMORY(r->architecture);
4962
4963 if (strlen(driver->info_3->driverpath)) {
4964 r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
4965 cservername, driver->info_3->driverpath);
4966 } else {
4967 r->driver_path = talloc_strdup(mem_ctx, "");
4968 }
4969 W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4970
4971 if (strlen(driver->info_3->datafile)) {
4972 r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4973 cservername, driver->info_3->datafile);
4974 } else {
4975 r->data_file = talloc_strdup(mem_ctx, "");
4976 }
4977 W_ERROR_HAVE_NO_MEMORY(r->data_file);
4978
4979 if (strlen(driver->info_3->configfile)) {
4980 r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4981 cservername, driver->info_3->configfile);
4982 } else {
4983 r->config_file = talloc_strdup(mem_ctx, "");
4984 }
4985 W_ERROR_HAVE_NO_MEMORY(r->config_file);
4986
4987 if (strlen(driver->info_3->helpfile)) {
4988 r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
4989 cservername, driver->info_3->helpfile);
4990 } else {
4991 r->help_file = talloc_strdup(mem_ctx, "");
4992 }
4993 W_ERROR_HAVE_NO_MEMORY(r->help_file);
4994
4995 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4996 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4997 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4998 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4999
5000 r->dependent_files = string_array_from_driver_info(mem_ctx,
5001 driver->info_3->dependentfiles,
5002 cservername);
5003 r->previous_names = string_array_from_driver_info(mem_ctx,
5004 NULL,
5005 cservername);
5006
5007 r->driver_date = 0;
5008 r->driver_version = 0;
5009
5010 r->manufacturer_name = talloc_strdup(mem_ctx, "");
5011 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5012 r->manufacturer_url = talloc_strdup(mem_ctx, "");
5013 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5014 r->hardware_id = talloc_strdup(mem_ctx, "");
5015 W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5016 r->provider = talloc_strdup(mem_ctx, "");
5017 W_ERROR_HAVE_NO_MEMORY(r->provider);
5018
5019 return WERR_OK;
5020 }
5021
5022 /********************************************************************
5023 ********************************************************************/
5024
5025 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5026 struct spoolss_DriverFileInfo *r,
5027 const char *cservername,
5028 const char *file_name,
5029 enum spoolss_DriverFileType file_type,
5030 uint32_t file_version)
5031 {
5032 r->file_name = talloc_asprintf(mem_ctx, "\\\\%s%s",
5033 cservername, file_name);
5034 W_ERROR_HAVE_NO_MEMORY(r->file_name);
5035 r->file_type = file_type;
5036 r->file_version = file_version;
5037
5038 return WERR_OK;
5039 }
5040
5041 /********************************************************************
5042 ********************************************************************/
5043
5044 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5045 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5046 const char *cservername,
5047 struct spoolss_DriverFileInfo **info_p,
5048 uint32_t *count_p)
5049 {
5050 struct spoolss_DriverFileInfo *info = NULL;
5051 uint32_t count = 0;
5052 WERROR result;
5053 uint32_t i;
5054
5055 *info_p = NULL;
5056 *count_p = 0;
5057
5058 if (strlen(driver->info_3->driverpath)) {
5059 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5060 struct spoolss_DriverFileInfo,
5061 count + 1);
5062 W_ERROR_HAVE_NO_MEMORY(info);
5063 result = fill_spoolss_DriverFileInfo(info,
5064 &info[count],
5065 cservername,
5066 driver->info_3->driverpath,
5067 SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5068 0);
5069 W_ERROR_NOT_OK_RETURN(result);
5070 count++;
5071 }
5072
5073 if (strlen(driver->info_3->configfile)) {
5074 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5075 struct spoolss_DriverFileInfo,
5076 count + 1);
5077 W_ERROR_HAVE_NO_MEMORY(info);
5078 result = fill_spoolss_DriverFileInfo(info,
5079 &info[count],
5080 cservername,
5081 driver->info_3->configfile,
5082 SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5083 0);
5084 W_ERROR_NOT_OK_RETURN(result);
5085 count++;
5086 }
5087
5088 if (strlen(driver->info_3->datafile)) {
5089 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5090 struct spoolss_DriverFileInfo,
5091 count + 1);
5092 W_ERROR_HAVE_NO_MEMORY(info);
5093 result = fill_spoolss_DriverFileInfo(info,
5094 &info[count],
5095 cservername,
5096 driver->info_3->datafile,
5097 SPOOLSS_DRIVER_FILE_TYPE_DATA,
5098 0);
5099 W_ERROR_NOT_OK_RETURN(result);
5100 count++;
5101 }
5102
5103 if (strlen(driver->info_3->helpfile)) {
5104 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5105 struct spoolss_DriverFileInfo,
5106 count + 1);
5107 W_ERROR_HAVE_NO_MEMORY(info);
5108 result = fill_spoolss_DriverFileInfo(info,
5109 &info[count],
5110 cservername,
5111 driver->info_3->helpfile,
5112 SPOOLSS_DRIVER_FILE_TYPE_HELP,
5113 0);
5114 W_ERROR_NOT_OK_RETURN(result);
5115 count++;
5116 }
5117
5118 for (i=0; driver->info_3->dependentfiles[i][0] != '\0'; i++) {
5119 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5120 struct spoolss_DriverFileInfo,
5121 count + 1);
5122 W_ERROR_HAVE_NO_MEMORY(info);
5123 result = fill_spoolss_DriverFileInfo(info,
5124 &info[count],
5125 cservername,
5126 driver->info_3->dependentfiles[i],
5127 SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5128 0);
5129 W_ERROR_NOT_OK_RETURN(result);
5130 count++;
5131 }
5132
5133 *info_p = info;
5134 *count_p = count;
5135
5136 return WERR_OK;
5137 }
5138
5139 /********************************************************************
5140 * fill a spoolss_DriverInfo101 sttruct
5141 ********************************************************************/
5142
5143 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5144 struct spoolss_DriverInfo101 *r,
5145 const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5146 const char *servername)
5147 {
5148 const char *cservername = canon_servername(servername);
5149 WERROR result;
5150
5151 r->version = driver->info_3->cversion;
5152
5153 r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
5154 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5155 r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
5156 W_ERROR_HAVE_NO_MEMORY(r->architecture);
5157
5158 result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5159 cservername,
5160 &r->file_info,
5161 &r->file_count);
5162 if (!W_ERROR_IS_OK(result)) {
5163 return result;
5164 }
5165
5166 r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
5167 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
5168
5169 r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
5170 W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
5171
5172 r->previous_names = string_array_from_driver_info(mem_ctx,
5173 NULL,
5174 cservername);
5175 r->driver_date = 0;
5176 r->driver_version = 0;
5177
5178 r->manufacturer_name = talloc_strdup(mem_ctx, "");
5179 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5180 r->manufacturer_url = talloc_strdup(mem_ctx, "");
5181 W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5182 r->hardware_id = talloc_strdup(mem_ctx, "");
5183 W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5184 r->provider = talloc_strdup(mem_ctx, "");
5185 W_ERROR_HAVE_NO_MEMORY(r->provider);
5186
5187 return WERR_OK;
5188 }
5189
5190 /********************************************************************
5191 * construct_printer_driver_info_1
5192 ********************************************************************/
5193
5194 static WERROR construct_printer_driver_info_1(TALLOC_CTX *mem_ctx,
5195 struct spoolss_DriverInfo1 *r,
5196 int snum,
5197 const char *servername,
5198 const char *architecture,
5199 uint32_t version)
5200 {
5201 NT_PRINTER_INFO_LEVEL *printer = NULL;
5202 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5203 WERROR result;
5204
5205 ZERO_STRUCT(driver);
5206
5207 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5208 return WERR_INVALID_PRINTER_NAME;
5209
5210 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5211 free_a_printer(&printer, 2);
5212 return WERR_UNKNOWN_PRINTER_DRIVER;
5213 }
5214
5215 result = fill_printer_driver_info1(mem_ctx, r, &driver, servername, architecture);
5216
5217 free_a_printer(&printer,2);
5218
5219 return result;
5220 }
5221
5222 /********************************************************************
5223 * construct_printer_driver_info_2
5224 * fill a printer_info_2 struct
5225 ********************************************************************/
5226
5227 static WERROR construct_printer_driver_info_2(TALLOC_CTX *mem_ctx,
5228 struct spoolss_DriverInfo2 *r,
5229 int snum,
5230 const char *servername,
5231 const char *architecture,
5232 uint32_t version)
5233 {
5234 NT_PRINTER_INFO_LEVEL *printer = NULL;
5235 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5236 WERROR result;
5237
5238 ZERO_STRUCT(printer);
5239 ZERO_STRUCT(driver);
5240
5241 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5242 return WERR_INVALID_PRINTER_NAME;
5243
5244 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5245 free_a_printer(&printer, 2);
5246 return WERR_UNKNOWN_PRINTER_DRIVER;
5247 }
5248
5249 result = fill_printer_driver_info2(mem_ctx, r, &driver, servername);
5250
5251 free_a_printer(&printer,2);
5252
5253 return result;
5254 }
5255
5256 /********************************************************************
5257 * construct_printer_info_3
5258 * fill a printer_info_3 struct
5259 ********************************************************************/
5260
5261 static WERROR construct_printer_driver_info_3(TALLOC_CTX *mem_ctx,
5262 struct spoolss_DriverInfo3 *r,
5263 int snum,
5264 const char *servername,
5265 const char *architecture,
5266 uint32_t version)
5267 {
5268 NT_PRINTER_INFO_LEVEL *printer = NULL;
5269 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5270 WERROR status;
5271 ZERO_STRUCT(driver);
5272
5273 status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5274 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5275 if (!W_ERROR_IS_OK(status))
5276 return WERR_INVALID_PRINTER_NAME;
5277
5278 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5279 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5280
5281 #if 0 /* JERRY */
5282
5283 /*
5284 * I put this code in during testing. Helpful when commenting out the
5285 * support for DRIVER_INFO_6 in regards to win2k. Not needed in general
5286 * as win2k always queries the driver using an infor level of 6.
5287 * I've left it in (but ifdef'd out) because I'll probably
5288 * use it in experimentation again in the future. --jerry 22/01/2002
5289 */
5290
5291 if (!W_ERROR_IS_OK(status)) {
5292 /*
5293 * Is this a W2k client ?
5294 */
5295 if (version == 3) {
5296 /* Yes - try again with a WinNT driver. */
5297 version = 2;
5298 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5299 DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5300 }
5301 #endif
5302
5303 if (!W_ERROR_IS_OK(status)) {
5304 free_a_printer(&printer,2);
5305 return WERR_UNKNOWN_PRINTER_DRIVER;
5306 }
5307
5308 #if 0 /* JERRY */
5309 }
5310 #endif
5311
5312
5313 status = fill_printer_driver_info3(mem_ctx, r, &driver, servername);
5314
5315 free_a_printer(&printer,2);
5316
5317 return status;
5318 }
5319
5320 /********************************************************************
5321 * construct_printer_info_6
5322 * fill a printer_info_6 struct
5323 ********************************************************************/
5324
5325 static WERROR construct_printer_driver_info_6(TALLOC_CTX *mem_ctx,
5326 struct spoolss_DriverInfo6 *r,
5327 int snum,
5328 const char *servername,
5329 const char *architecture,
5330 uint32_t version)
5331 {
5332 NT_PRINTER_INFO_LEVEL *printer = NULL;
5333 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5334 WERROR status;
5335
5336 ZERO_STRUCT(driver);
5337
5338 status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5339
5340 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5341
5342 if (!W_ERROR_IS_OK(status))
5343 return WERR_INVALID_PRINTER_NAME;
5344
5345 status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5346
5347 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5348
5349 if (!W_ERROR_IS_OK(status))
5350 {
5351 /*
5352 * Is this a W2k client ?
5353 */
5354
5355 if (version < 3) {
5356 free_a_printer(&printer,2);
5357 return WERR_UNKNOWN_PRINTER_DRIVER;
5358 }
5359
5360 /* Yes - try again with a WinNT driver. */
5361 version = 2;
5362 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5363 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5364 if (!W_ERROR_IS_OK(status)) {
5365 free_a_printer(&printer,2);
5366 return WERR_UNKNOWN_PRINTER_DRIVER;
5367 }
5368 }
5369
5370 status = fill_printer_driver_info6(mem_ctx, r, &driver, servername);
5371
5372 free_a_printer(&printer,2);
5373 free_a_printer_driver(driver, 3);
5374
5375 return status;
5376 }
5377
5378 /********************************************************************
5379 * construct_printer_info_101
5380 * fill a printer_info_101 struct
5381 ********************************************************************/
5382
5383 static WERROR construct_printer_driver_info_101(TALLOC_CTX *mem_ctx,
5384 struct spoolss_DriverInfo101 *r,
5385 int snum,
5386 const char *servername,
5387 const char *architecture,
5388 uint32_t version)
5389 {
5390 NT_PRINTER_INFO_LEVEL *printer = NULL;
5391 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5392 WERROR result;
5393
5394 ZERO_STRUCT(driver);
5395
5396 result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5397
5398 DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5399 win_errstr(result)));
5400
5401 if (!W_ERROR_IS_OK(result)) {
5402 return WERR_INVALID_PRINTER_NAME;
5403 }
5404
5405 result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5406 architecture, version);
5407
5408 DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5409 win_errstr(result)));
5410
5411 if (!W_ERROR_IS_OK(result)) {
5412 /*
5413 * Is this a W2k client ?
5414 */
5415
5416 if (version < 3) {
5417 free_a_printer(&printer, 2);
5418 return WERR_UNKNOWN_PRINTER_DRIVER;
5419 }
5420
5421 /* Yes - try again with a WinNT driver. */
5422 version = 2;
5423 result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5424 architecture, version);
5425 DEBUG(8,("construct_printer_driver_info_6: status: %s\n",
5426 win_errstr(result)));
5427 if (!W_ERROR_IS_OK(result)) {
5428 free_a_printer(&printer, 2);
5429 return WERR_UNKNOWN_PRINTER_DRIVER;
5430 }
5431 }
5432
5433 result = fill_printer_driver_info101(mem_ctx, r, &driver, servername);
5434
5435 free_a_printer(&printer, 2);
5436 free_a_printer_driver(driver, 3);
5437
5438 return result;
5439 }
5440
5441 /****************************************************************
5442 _spoolss_GetPrinterDriver2
5443 ****************************************************************/
5444
5445 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5446 struct spoolss_GetPrinterDriver2 *r)
5447 {
5448 Printer_entry *printer;
5449 WERROR result;
5450
5451 const char *servername;
5452 int snum;
5453
5454 /* that's an [in out] buffer */
5455
5456 if (!r->in.buffer && (r->in.offered != 0)) {
5457 return WERR_INVALID_PARAM;
5458 }
5459
5460 DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5461
5462 if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5463 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5464 return WERR_INVALID_PRINTER_NAME;
5465 }
5466
5467 *r->out.needed = 0;
5468 *r->out.server_major_version = 0;
5469 *r->out.server_minor_version = 0;
5470
5471 servername = get_server_name(printer);
5472
5473 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5474 return WERR_BADFID;
5475 }
5476
5477 switch (r->in.level) {
5478 case 1:
5479 result = construct_printer_driver_info_1(p->mem_ctx,
5480 &r->out.info->info1,
5481 snum,
5482 servername,
5483 r->in.architecture,
5484 r->in.client_major_version);
5485 break;
5486 case 2:
5487 result = construct_printer_driver_info_2(p->mem_ctx,
5488 &r->out.info->info2,
5489 snum,
5490 servername,
5491 r->in.architecture,
5492 r->in.client_major_version);
5493 break;
5494 case 3:
5495 result = construct_printer_driver_info_3(p->mem_ctx,
5496 &r->out.info->info3,
5497 snum,
5498 servername,
5499 r->in.architecture,
5500 r->in.client_major_version);
5501 break;
5502 case 6:
5503 result = construct_printer_driver_info_6(p->mem_ctx,
5504 &r->out.info->info6,
5505 snum,
5506 servername,
5507 r->in.architecture,
5508 r->in.client_major_version);
5509 break;
5510 case 101:
5511 result = construct_printer_driver_info_101(p->mem_ctx,
5512 &r->out.info->info101,
5513 snum,
5514 servername,
5515 r->in.architecture,
5516 r->in.client_major_version);
5517 break;
5518 default:
5519 result = WERR_UNKNOWN_LEVEL;
5520 break;
5521 }
5522
5523 if (!W_ERROR_IS_OK(result)) {
5524 TALLOC_FREE(r->out.info);
5525 return result;
5526 }
5527
5528 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5529 r->out.info, r->in.level);
5530 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5531
5532 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5533 }
5534
5535
5536 /****************************************************************
5537 _spoolss_StartPagePrinter
5538 ****************************************************************/
5539
5540 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5541 struct spoolss_StartPagePrinter *r)
5542 {
5543 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5544
5545 if (!Printer) {
5546 DEBUG(3,("_spoolss_StartPagePrinter: "
5547 "Error in startpageprinter printer handle\n"));
5548 return WERR_BADFID;
5549 }
5550
5551 Printer->page_started = true;
5552 return WERR_OK;
5553 }
5554
5555 /****************************************************************
5556 _spoolss_EndPagePrinter
5557 ****************************************************************/
5558
5559 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5560 struct spoolss_EndPagePrinter *r)
5561 {
5562 int snum;
5563
5564 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5565
5566 if (!Printer) {
5567 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5568 OUR_HANDLE(r->in.handle)));
5569 return WERR_BADFID;
5570 }
5571
5572 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5573 return WERR_BADFID;
5574
5575 Printer->page_started = false;
5576 print_job_endpage(snum, Printer->jobid);
5577
5578 return WERR_OK;
5579 }
5580
5581 /****************************************************************
5582 _spoolss_StartDocPrinter
5583 ****************************************************************/
5584
5585 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5586 struct spoolss_StartDocPrinter *r)
5587 {
5588 struct spoolss_DocumentInfo1 *info_1;
5589 int snum;
5590 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5591
5592 if (!Printer) {
5593 DEBUG(2,("_spoolss_StartDocPrinter: "
5594 "Invalid handle (%s:%u:%u)\n",
5595 OUR_HANDLE(r->in.handle)));
5596 return WERR_BADFID;
5597 }
5598
5599 if (r->in.level != 1) {
5600 return WERR_UNKNOWN_LEVEL;
5601 }
5602
5603 info_1 = r->in.info.info1;
5604
5605 /*
5606 * a nice thing with NT is it doesn't listen to what you tell it.
5607 * when asked to send _only_ RAW datas, it tries to send datas
5608 * in EMF format.
5609 *
5610 * So I add checks like in NT Server ...
5611 */
5612
5613 if (info_1->datatype) {
5614 if (strcmp(info_1->datatype, "RAW") != 0) {
5615 *r->out.job_id = 0;
5616 return WERR_INVALID_DATATYPE;
5617 }
5618 }
5619
5620 /* get the share number of the printer */
5621 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5622 return WERR_BADFID;
5623 }
5624
5625 Printer->jobid = print_job_start(p->server_info, snum,
5626 info_1->document_name,
5627 Printer->nt_devmode);
5628
5629 /* An error occured in print_job_start() so return an appropriate
5630 NT error code. */
5631
5632 if (Printer->jobid == -1) {
5633 return map_werror_from_unix(errno);
5634 }
5635
5636 Printer->document_started = true;
5637 *r->out.job_id = Printer->jobid;
5638
5639 return WERR_OK;
5640 }
5641
5642 /****************************************************************
5643 _spoolss_EndDocPrinter
5644 ****************************************************************/
5645
5646 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5647 struct spoolss_EndDocPrinter *r)
5648 {
5649 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5650 int snum;
5651
5652 if (!Printer) {
5653 DEBUG(2,("_spoolss_EndDocPrinter: Invalid handle (%s:%u:%u)\n",
5654 OUR_HANDLE(r->in.handle)));
5655 return WERR_BADFID;
5656 }
5657
5658 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5659 return WERR_BADFID;
5660 }
5661
5662 Printer->document_started = false;
5663 print_job_end(snum, Printer->jobid, NORMAL_CLOSE);
5664 /* error codes unhandled so far ... */
5665
5666 return WERR_OK;
5667 }
5668
5669 /****************************************************************
5670 _spoolss_WritePrinter
5671 ****************************************************************/
5672
5673 WERROR _spoolss_WritePrinter(pipes_struct *p,
5674 struct spoolss_WritePrinter *r)
5675 {
5676 uint32_t buffer_written;
5677 int snum;
5678 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5679
5680 if (!Printer) {
5681 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5682 OUR_HANDLE(r->in.handle)));
5683 *r->out.num_written = r->in._data_size;
5684 return WERR_BADFID;
5685 }
5686
5687 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5688 return WERR_BADFID;
5689
5690 buffer_written = (uint32_t)print_job_write(snum, Printer->jobid,
5691 (const char *)r->in.data.data,
5692 (SMB_OFF_T)-1,
5693 (size_t)r->in._data_size);
5694 if (buffer_written == (uint32_t)-1) {
5695 *r->out.num_written = 0;
5696 if (errno == ENOSPC)
5697 return WERR_NO_SPOOL_SPACE;
5698 else
5699 return WERR_ACCESS_DENIED;
5700 }
5701
5702 *r->out.num_written = r->in._data_size;
5703
5704 return WERR_OK;
5705 }
5706
5707 /********************************************************************
5708 * api_spoolss_getprinter
5709 * called from the spoolss dispatcher
5710 *
5711 ********************************************************************/
5712
5713 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5714 pipes_struct *p)
5715 {
5716 int snum;
5717 WERROR errcode = WERR_BADFUNC;
5718 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5719
5720 if (!Printer) {
5721 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5722 OUR_HANDLE(handle)));
5723 return WERR_BADFID;
5724 }
5725
5726 if (!get_printer_snum(p, handle, &snum, NULL))
5727 return WERR_BADFID;
5728
5729 switch (command) {
5730 case SPOOLSS_PRINTER_CONTROL_PAUSE:
5731 errcode = print_queue_pause(p->server_info, snum);
5732 break;
5733 case SPOOLSS_PRINTER_CONTROL_RESUME:
5734 case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5735 errcode = print_queue_resume(p->server_info, snum);
5736 break;
5737 case SPOOLSS_PRINTER_CONTROL_PURGE:
5738 errcode = print_queue_purge(p->server_info, snum);
5739 break;
5740 default:
5741 return WERR_UNKNOWN_LEVEL;
5742 }
5743
5744 return errcode;
5745 }
5746
5747
5748 /****************************************************************
5749 _spoolss_AbortPrinter
5750 * From MSDN: "Deletes printer's spool file if printer is configured
5751 * for spooling"
5752 ****************************************************************/
5753
5754 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5755 struct spoolss_AbortPrinter *r)
5756 {
5757 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5758 int snum;
5759 WERROR errcode = WERR_OK;
5760
5761 if (!Printer) {
5762 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5763 OUR_HANDLE(r->in.handle)));
5764 return WERR_BADFID;
5765 }
5766
5767 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5768 return WERR_BADFID;
5769
5770 print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5771
5772 return errcode;
5773 }
5774
5775 /********************************************************************
5776 * called by spoolss_api_setprinter
5777 * when updating a printer description
5778 ********************************************************************/
5779
5780 static WERROR update_printer_sec(struct policy_handle *handle,
5781 pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5782 {
5783 SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5784 WERROR result;
5785 int snum;
5786
5787 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5788
5789 if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5790 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5791 OUR_HANDLE(handle)));
5792
5793 result = WERR_BADFID;
5794 goto done;
5795 }
5796
5797 if (!secdesc_ctr) {
5798 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5799 result = WERR_INVALID_PARAM;
5800 goto done;
5801 }
5802
5803 /* Check the user has permissions to change the security
5804 descriptor. By experimentation with two NT machines, the user
5805 requires Full Access to the printer to change security
5806 information. */
5807
5808 if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5809 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5810 result = WERR_ACCESS_DENIED;
5811 goto done;
5812 }
5813
5814 /* NT seems to like setting the security descriptor even though
5815 nothing may have actually changed. */
5816
5817 if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5818 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5819 result = WERR_BADFID;
5820 goto done;
5821 }
5822
5823 if (DEBUGLEVEL >= 10) {
5824 SEC_ACL *the_acl;
5825 int i;
5826
5827 the_acl = old_secdesc_ctr->sd->dacl;
5828 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5829 PRINTERNAME(snum), the_acl->num_aces));
5830
5831 for (i = 0; i < the_acl->num_aces; i++) {
5832 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5833 &the_acl->aces[i].trustee),
5834 the_acl->aces[i].access_mask));
5835 }
5836
5837 the_acl = secdesc_ctr->sd->dacl;
5838
5839 if (the_acl) {
5840 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5841 PRINTERNAME(snum), the_acl->num_aces));
5842
5843 for (i = 0; i < the_acl->num_aces; i++) {
5844 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5845 &the_acl->aces[i].trustee),
5846 the_acl->aces[i].access_mask));
5847 }
5848 } else {
5849 DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5850 }
5851 }
5852
5853 new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5854 if (!new_secdesc_ctr) {
5855 result = WERR_NOMEM;
5856 goto done;
5857 }
5858
5859 if (security_descriptor_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5860 result = WERR_OK;
5861 goto done;
5862 }
5863
5864 result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5865
5866 done:
5867
5868 return result;
5869 }
5870
5871 /********************************************************************
5872 Canonicalize printer info from a client
5873
5874 ATTN: It does not matter what we set the servername to hear
5875 since we do the necessary work in get_a_printer() to set it to
5876 the correct value based on what the client sent in the
5877 _spoolss_open_printer_ex().
5878 ********************************************************************/
5879
5880 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5881 {
5882 fstring printername;
5883 const char *p;
5884
5885 DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5886 "portname=%s drivername=%s comment=%s location=%s\n",
5887 info->servername, info->printername, info->sharename,
5888 info->portname, info->drivername, info->comment, info->location));
5889
5890 /* we force some elements to "correct" values */
5891 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5892 fstrcpy(info->sharename, lp_servicename(snum));
5893
5894 /* check to see if we allow printername != sharename */
5895
5896 if ( lp_force_printername(snum) ) {
5897 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5898 global_myname(), info->sharename );
5899 } else {
5900
5901 /* make sure printername is in \\server\printername format */
5902
5903 fstrcpy( printername, info->printername );
5904 p = printername;
5905 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5906 if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5907 p++;
5908 }
5909
5910 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5911 global_myname(), p );
5912 }
5913
5914 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5915 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5916
5917
5918
5919 return true;
5920 }
5921
5922 /****************************************************************************
5923 ****************************************************************************/
5924
5925 static WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri)
5926 {
5927 char *cmd = lp_addport_cmd();
5928 char *command = NULL;
5929 int ret;
5930 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5931 bool is_print_op = false;
5932
5933 if ( !*cmd ) {
5934 return WERR_ACCESS_DENIED;
5935 }
5936
5937 command = talloc_asprintf(ctx,
5938 "%s \"%s\" \"%s\"", cmd, portname, uri );
5939 if (!command) {
5940 return WERR_NOMEM;
5941 }
5942
5943 if ( token )
5944 is_print_op = user_has_privileges( token, &se_printop );
5945
5946 DEBUG(10,("Running [%s]\n", command));
5947
5948 /********* BEGIN SePrintOperatorPrivilege **********/
5949
5950 if ( is_print_op )
5951 become_root();
5952
5953 ret = smbrun(command, NULL);
5954
5955 if ( is_print_op )
5956 unbecome_root();
5957
5958 /********* END SePrintOperatorPrivilege **********/
5959
5960 DEBUGADD(10,("returned [%d]\n", ret));
5961
5962 TALLOC_FREE(command);
5963
5964 if ( ret != 0 ) {
5965 return WERR_ACCESS_DENIED;
5966 }
5967
5968 return WERR_OK;
5969 }
5970
5971 /****************************************************************************
5972 ****************************************************************************/
5973
5974 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5975 {
5976 char *cmd = lp_addprinter_cmd();
5977 char **qlines;
5978 char *command = NULL;
5979 int numlines;
5980 int ret;
5981 int fd;
5982 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5983 bool is_print_op = false;
5984 char *remote_machine = talloc_strdup(ctx, "%m");
5985
5986 if (!remote_machine) {
5987 return false;
5988 }
5989 remote_machine = talloc_sub_basic(ctx,
5990 current_user_info.smb_name,
5991 current_user_info.domain,
5992 remote_machine);
5993 if (!remote_machine) {
5994 return false;
5995 }
5996
5997 command = talloc_asprintf(ctx,
5998 "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
5999 cmd, printer->info_2->printername, printer->info_2->sharename,
6000 printer->info_2->portname, printer->info_2->drivername,
6001 printer->info_2->location, printer->info_2->comment, remote_machine);
6002 if (!command) {
6003 return false;
6004 }
6005
6006 if ( token )
6007 is_print_op = user_has_privileges( token, &se_printop );
6008
6009 DEBUG(10,("Running [%s]\n", command));
6010
6011 /********* BEGIN SePrintOperatorPrivilege **********/
6012
6013 if ( is_print_op )
6014 become_root();
6015
6016 if ( (ret = smbrun(command, &fd)) == 0 ) {
6017 /* Tell everyone we updated smb.conf. */
6018 message_send_all(smbd_messaging_context(),
6019 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6020 }
6021
6022 if ( is_print_op )
6023 unbecome_root();
6024
6025 /********* END SePrintOperatorPrivilege **********/
6026
6027 DEBUGADD(10,("returned [%d]\n", ret));
6028
6029 TALLOC_FREE(command);
6030 TALLOC_FREE(remote_machine);
6031
6032 if ( ret != 0 ) {
6033 if (fd != -1)
6034 close(fd);
6035 return false;
6036 }
6037
6038 /* reload our services immediately */
6039 become_root();
6040 reload_services(false);
6041 unbecome_root();
6042
6043 numlines = 0;
6044 /* Get lines and convert them back to dos-codepage */
6045 qlines = fd_lines_load(fd, &numlines, 0, NULL);
6046 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6047 close(fd);
6048
6049 /* Set the portname to what the script says the portname should be. */
6050 /* but don't require anything to be return from the script exit a good error code */
6051
6052 if (numlines) {
6053 /* Set the portname to what the script says the portname should be. */
6054 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
6055 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6056 }
6057
6058 TALLOC_FREE(qlines);
6059 return true;
6060 }
6061
6062
6063 /********************************************************************
6064 * Called by spoolss_api_setprinter
6065 * when updating a printer description.
6066 ********************************************************************/
6067
6068 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
6069 struct spoolss_SetPrinterInfoCtr *info_ctr,
6070 struct spoolss_DeviceMode *devmode)
6071 {
6072 int snum;
6073 NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
6074 Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6075 WERROR result;
6076 UNISTR2 buffer;
6077 fstring asc_buffer;
6078
6079 DEBUG(8,("update_printer\n"));
6080
6081 result = WERR_OK;
6082
6083 if (!Printer) {
6084 result = WERR_BADFID;
6085 goto done;
6086 }
6087
6088 if (!get_printer_snum(p, handle, &snum, NULL)) {
6089 result = WERR_BADFID;
6090 goto done;
6091 }
6092
6093 if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
6094 (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
6095 result = WERR_BADFID;
6096 goto done;
6097 }
6098
6099 DEBUGADD(8,("Converting info_2 struct\n"));
6100
6101 /*
6102 * convert_printer_info converts the incoming
6103 * info from the client and overwrites the info
6104 * just read from the tdb in the pointer 'printer'.
6105 */
6106
6107 if (!convert_printer_info(info_ctr, printer)) {
6108 result = WERR_NOMEM;
6109 goto done;
6110 }
6111
6112 if (devmode) {
6113 /* we have a valid devmode
6114 convert it and link it*/
6115
6116 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
6117 if (!convert_devicemode(printer->info_2->printername, devmode,
6118 &printer->info_2->devmode)) {
6119 result = WERR_NOMEM;
6120 goto done;
6121 }
6122 }
6123
6124 /* Do sanity check on the requested changes for Samba */
6125
6126 if (!check_printer_ok(printer->info_2, snum)) {
6127 result = WERR_INVALID_PARAM;
6128 goto done;
6129 }
6130
6131 /* FIXME!!! If the driver has changed we really should verify that
6132 it is installed before doing much else --jerry */
6133
6134 /* Check calling user has permission to update printer description */
6135
6136 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6137 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6138 result = WERR_ACCESS_DENIED;
6139 goto done;
6140 }
6141
6142 /* Call addprinter hook */
6143 /* Check changes to see if this is really needed */
6144
6145 if ( *lp_addprinter_cmd()
6146 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
6147 || !strequal(printer->info_2->comment, old_printer->info_2->comment)
6148 || !strequal(printer->info_2->portname, old_printer->info_2->portname)
6149 || !strequal(printer->info_2->location, old_printer->info_2->location)) )
6150 {
6151 /* add_printer_hook() will call reload_services() */
6152
6153 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
6154 printer) ) {
6155 result = WERR_ACCESS_DENIED;
6156 goto done;
6157 }
6158 }
6159
6160 /*
6161 * When a *new* driver is bound to a printer, the drivername is used to
6162 * lookup previously saved driver initialization info, which is then
6163 * bound to the printer, simulating what happens in the Windows arch.
6164 */
6165 if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
6166 {
6167 if (!set_driver_init(printer, 2))
6168 {
6169 DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
6170 printer->info_2->drivername));
6171 }
6172
6173 DEBUG(10,("update_printer: changing driver [%s]! Sending event!\n",
6174 printer->info_2->drivername));
6175
6176 notify_printer_driver(snum, printer->info_2->drivername);
6177 }
6178
6179 /*
6180 * flag which changes actually occured. This is a small subset of
6181 * all the possible changes. We also have to update things in the
6182 * DsSpooler key.
6183 */
6184
6185 if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
6186 init_unistr2( &buffer, printer->info_2->comment, UNI_STR_TERMINATE);
6187 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
6188 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6189
6190 notify_printer_comment(snum, printer->info_2->comment);
6191 }
6192
6193 if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
6194 init_unistr2( &buffer, printer->info_2->sharename, UNI_STR_TERMINATE);
6195 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
6196 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6197
6198 notify_printer_sharename(snum, printer->info_2->sharename);
6199 }
6200
6201 if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
6202 char *pname;
6203
6204 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
6205 pname++;
6206 else
6207 pname = printer->info_2->printername;
6208
6209
6210 init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
6211 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
6212 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6213
6214 notify_printer_printername( snum, pname );
6215 }
6216
6217 if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
6218 init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
6219 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
6220 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6221
6222 notify_printer_port(snum, printer->info_2->portname);
6223 }
6224
6225 if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
6226 init_unistr2( &buffer, printer->info_2->location, UNI_STR_TERMINATE);
6227 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
6228 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6229
6230 notify_printer_location(snum, printer->info_2->location);
6231 }
6232
6233 /* here we need to update some more DsSpooler keys */
6234 /* uNCName, serverName, shortServerName */
6235
6236 init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
6237 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
6238 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6239 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
6240 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6241
6242 slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
6243 global_myname(), printer->info_2->sharename );
6244 init_unistr2( &buffer, asc_buffer, UNI_STR_TERMINATE);
6245 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
6246 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6247
6248 /* Update printer info */
6249 result = mod_a_printer(printer, 2);
6250
6251 done:
6252 free_a_printer(&printer, 2);
6253 free_a_printer(&old_printer, 2);
6254
6255
6256 return result;
6257 }
6258
6259 /****************************************************************************
6260 ****************************************************************************/
6261 static WERROR publish_or_unpublish_printer(pipes_struct *p,
6262 struct policy_handle *handle,
6263 struct spoolss_SetPrinterInfo7 *info7)
6264 {
6265 #ifdef HAVE_ADS
6266 int snum;
6267 Printer_entry *Printer;
6268
6269 if ( lp_security() != SEC_ADS ) {
6270 return WERR_UNKNOWN_LEVEL;
6271 }
6272
6273 Printer = find_printer_index_by_hnd(p, handle);
6274
6275 DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6276
6277 if (!Printer)
6278 return WERR_BADFID;
6279
6280 if (!get_printer_snum(p, handle, &snum, NULL))
6281 return WERR_BADFID;
6282
6283 nt_printer_publish(Printer, snum, info7->action);
6284
6285 return WERR_OK;
6286 #else
6287 return WERR_UNKNOWN_LEVEL;
6288 #endif
6289 }
6290
6291 /****************************************************************
6292 _spoolss_SetPrinter
6293 ****************************************************************/
6294
6295 WERROR _spoolss_SetPrinter(pipes_struct *p,
6296 struct spoolss_SetPrinter *r)
6297 {
6298 WERROR result;
6299
6300 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6301
6302 if (!Printer) {
6303 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6304 OUR_HANDLE(r->in.handle)));
6305 return WERR_BADFID;
6306 }
6307
6308 /* check the level */
6309 switch (r->in.info_ctr->level) {
6310 case 0:
6311 return control_printer(r->in.handle, r->in.command, p);
6312 case 2:
6313 result = update_printer(p, r->in.handle,
6314 r->in.info_ctr,
6315 r->in.devmode_ctr->devmode);
6316 if (!W_ERROR_IS_OK(result))
6317 return result;
6318 if (r->in.secdesc_ctr->sd)
6319 result = update_printer_sec(r->in.handle, p,
6320 r->in.secdesc_ctr);
6321 return result;
6322 case 3:
6323 return update_printer_sec(r->in.handle, p,
6324 r->in.secdesc_ctr);
6325 case 7:
6326 return publish_or_unpublish_printer(p, r->in.handle,
6327 r->in.info_ctr->info.info7);
6328 default:
6329 return WERR_UNKNOWN_LEVEL;
6330 }
6331 }
6332
6333 /****************************************************************
6334 _spoolss_FindClosePrinterNotify
6335 ****************************************************************/
6336
6337 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
6338 struct spoolss_FindClosePrinterNotify *r)
6339 {
6340 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6341
6342 if (!Printer) {
6343 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6344 "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6345 return WERR_BADFID;
6346 }
6347
6348 if (Printer->notify.client_connected == true) {
6349 int snum = -1;
6350
6351 if ( Printer->printer_type == SPLHND_SERVER)
6352 snum = -1;
6353 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6354 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6355 return WERR_BADFID;
6356
6357 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6358 }
6359
6360 Printer->notify.flags=0;
6361 Printer->notify.options=0;
6362 Printer->notify.localmachine[0]='\0';
6363 Printer->notify.printerlocal=0;
6364 TALLOC_FREE(Printer->notify.option);
6365 Printer->notify.client_connected = false;
6366
6367 return WERR_OK;
6368 }
6369
6370 /****************************************************************
6371 _spoolss_AddJob
6372 ****************************************************************/
6373
6374 WERROR _spoolss_AddJob(pipes_struct *p,
6375 struct spoolss_AddJob *r)
6376 {
6377 if (!r->in.buffer && (r->in.offered != 0)) {
6378 return WERR_INVALID_PARAM;
6379 }
6380
6381 /* this is what a NT server returns for AddJob. AddJob must fail on
6382 * non-local printers */
6383
6384 if (r->in.level != 1) {
6385 return WERR_UNKNOWN_LEVEL;
6386 }
6387
6388 return WERR_INVALID_PARAM;
6389 }
6390
6391 /****************************************************************************
6392 fill_job_info1
6393 ****************************************************************************/
6394
6395 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6396 struct spoolss_JobInfo1 *r,
6397 const print_queue_struct *queue,
6398 int position, int snum,
6399 const NT_PRINTER_INFO_LEVEL *ntprinter)
6400 {
6401 struct tm *t;
6402
6403 t = gmtime(&queue->time);
6404
6405 r->job_id = queue->job;
6406
6407 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6408 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6409 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6410 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6411 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6412 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6413 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6414 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6415 r->data_type = talloc_strdup(mem_ctx, "RAW");
6416 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6417 r->text_status = talloc_strdup(mem_ctx, "");
6418 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6419
6420 r->status = nt_printj_status(queue->status);
6421 r->priority = queue->priority;
6422 r->position = position;
6423 r->total_pages = queue->page_count;
6424 r->pages_printed = 0; /* ??? */
6425
6426 init_systemtime(&r->submitted, t);
6427
6428 return WERR_OK;
6429 }
6430
6431 /****************************************************************************
6432 fill_job_info2
6433 ****************************************************************************/
6434
6435 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6436 struct spoolss_JobInfo2 *r,
6437 const print_queue_struct *queue,
6438 int position, int snum,
6439 const NT_PRINTER_INFO_LEVEL *ntprinter,
6440 struct spoolss_DeviceMode *devmode)
6441 {
6442 struct tm *t;
6443
6444 t = gmtime(&queue->time);
6445
6446 r->job_id = queue->job;
6447
6448 r->printer_name = talloc_strdup(mem_ctx, lp_servicename(snum));
6449 W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6450 r->server_name = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6451 W_ERROR_HAVE_NO_MEMORY(r->server_name);
6452 r->user_name = talloc_strdup(mem_ctx, queue->fs_user);
6453 W_ERROR_HAVE_NO_MEMORY(r->user_name);
6454 r->document_name = talloc_strdup(mem_ctx, queue->fs_file);
6455 W_ERROR_HAVE_NO_MEMORY(r->document_name);
6456 r->notify_name = talloc_strdup(mem_ctx, queue->fs_user);
6457 W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6458 r->data_type = talloc_strdup(mem_ctx, "RAW");
6459 W_ERROR_HAVE_NO_MEMORY(r->data_type);
6460 r->print_processor = talloc_strdup(mem_ctx, "winprint");
6461 W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6462 r->parameters = talloc_strdup(mem_ctx, "");
6463 W_ERROR_HAVE_NO_MEMORY(r->parameters);
6464 r->driver_name = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6465 W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6466
6467 r->devmode = devmode;
6468
6469 r->text_status = talloc_strdup(mem_ctx, "");
6470 W_ERROR_HAVE_NO_MEMORY(r->text_status);
6471
6472 r->secdesc = NULL;
6473
6474 r->status = nt_printj_status(queue->status);
6475 r->priority = queue->priority;
6476 r->position = position;
6477 r->start_time = 0;
6478 r->until_time = 0;
6479 r->total_pages = queue->page_count;
6480 r->size = queue->size;
6481 init_systemtime(&r->submitted, t);
6482 r->time = 0;
6483 r->pages_printed = 0; /* ??? */
6484
6485 return WERR_OK;
6486 }
6487
6488 /****************************************************************************
6489 Enumjobs at level 1.
6490 ****************************************************************************/
6491
6492 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6493 const print_queue_struct *queue,
6494 uint32_t num_queues, int snum,
6495 const NT_PRINTER_INFO_LEVEL *ntprinter,
6496 union spoolss_JobInfo **info_p,
6497 uint32_t *count)
6498 {
6499 union spoolss_JobInfo *info;
6500 int i;
6501 WERROR result = WERR_OK;
6502
6503 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6504 W_ERROR_HAVE_NO_MEMORY(info);
6505
6506 *count = num_queues;
6507
6508 for (i=0; i<*count; i++) {
6509 result = fill_job_info1(info,
6510 &info[i].info1,
6511 &queue[i],
6512 i,
6513 snum,
6514 ntprinter);
6515 if (!W_ERROR_IS_OK(result)) {
6516 goto out;
6517 }
6518 }
6519
6520 out:
6521 if (!W_ERROR_IS_OK(result)) {
6522 TALLOC_FREE(info);
6523 *count = 0;
6524 return result;
6525 }
6526
6527 *info_p = info;
6528
6529 return WERR_OK;
6530 }
6531
6532 /****************************************************************************
6533 Enumjobs at level 2.
6534 ****************************************************************************/
6535
6536 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6537 const print_queue_struct *queue,
6538 uint32_t num_queues, int snum,
6539 const NT_PRINTER_INFO_LEVEL *ntprinter,
6540 union spoolss_JobInfo **info_p,
6541 uint32_t *count)
6542 {
6543 union spoolss_JobInfo *info;
6544 int i;
6545 WERROR result = WERR_OK;
6546
6547 info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6548 W_ERROR_HAVE_NO_MEMORY(info);
6549
6550 *count = num_queues;
6551
6552 for (i=0; i<*count; i++) {
6553
6554 struct spoolss_DeviceMode *devmode;
6555
6556 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6557 if (!devmode) {
6558 result = WERR_NOMEM;
6559 goto out;
6560 }
6561
6562 result = fill_job_info2(info,
6563 &info[i].info2,
6564 &queue[i],
6565 i,
6566 snum,
6567 ntprinter,
6568 devmode);
6569 if (!W_ERROR_IS_OK(result)) {
6570 goto out;
6571 }
6572 }
6573
6574 out:
6575 if (!W_ERROR_IS_OK(result)) {
6576 TALLOC_FREE(info);
6577 *count = 0;
6578 return result;
6579 }
6580
6581 *info_p = info;
6582
6583 return WERR_OK;
6584 }
6585
6586 /****************************************************************
6587 _spoolss_EnumJobs
6588 ****************************************************************/
6589
6590 WERROR _spoolss_EnumJobs(pipes_struct *p,
6591 struct spoolss_EnumJobs *r)
6592 {
6593 WERROR result;
6594 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6595 int snum;
6596 print_status_struct prt_status;
6597 print_queue_struct *queue = NULL;
6598 uint32_t count;
6599
6600 /* that's an [in out] buffer */
6601
6602 if (!r->in.buffer && (r->in.offered != 0)) {
6603 return WERR_INVALID_PARAM;
6604 }
6605
6606 DEBUG(4,("_spoolss_EnumJobs\n"));
6607
6608 *r->out.needed = 0;
6609 *r->out.count = 0;
6610 *r->out.info = NULL;
6611
6612 /* lookup the printer snum and tdb entry */
6613
6614 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6615 return WERR_BADFID;
6616 }
6617
6618 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6619 if (!W_ERROR_IS_OK(result)) {
6620 return result;
6621 }
6622
6623 count = print_queue_status(snum, &queue, &prt_status);
6624 DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6625 count, prt_status.status, prt_status.message));
6626
6627 if (count == 0) {
6628 SAFE_FREE(queue);
6629 free_a_printer(&ntprinter, 2);
6630 return WERR_OK;
6631 }
6632
6633 switch (r->in.level) {
6634 case 1:
6635 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6636 ntprinter, r->out.info, r->out.count);
6637 break;
6638 case 2:
6639 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6640 ntprinter, r->out.info, r->out.count);
6641 break;
6642 default:
6643 result = WERR_UNKNOWN_LEVEL;
6644 break;
6645 }
6646
6647 SAFE_FREE(queue);
6648 free_a_printer(&ntprinter, 2);
6649
6650 if (!W_ERROR_IS_OK(result)) {
6651 return result;
6652 }
6653
6654 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6655 spoolss_EnumJobs, NULL,
6656 *r->out.info, r->in.level,
6657 *r->out.count);
6658 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6659 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6660
6661 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6662 }
6663
6664 /****************************************************************
6665 _spoolss_ScheduleJob
6666 ****************************************************************/
6667
6668 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6669 struct spoolss_ScheduleJob *r)
6670 {
6671 return WERR_OK;
6672 }
6673
6674 /****************************************************************
6675 _spoolss_SetJob
6676 ****************************************************************/
6677
6678 WERROR _spoolss_SetJob(pipes_struct *p,
6679 struct spoolss_SetJob *r)
6680 {
6681 int snum;
6682 WERROR errcode = WERR_BADFUNC;
6683
6684 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6685 return WERR_BADFID;
6686 }
6687
6688 if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6689 return WERR_INVALID_PRINTER_NAME;
6690 }
6691
6692 switch (r->in.command) {
6693 case SPOOLSS_JOB_CONTROL_CANCEL:
6694 case SPOOLSS_JOB_CONTROL_DELETE:
6695 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6696 errcode = WERR_OK;
6697 }
6698 break;
6699 case SPOOLSS_JOB_CONTROL_PAUSE:
6700 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6701 errcode = WERR_OK;
6702 }
6703 break;
6704 case SPOOLSS_JOB_CONTROL_RESTART:
6705 case SPOOLSS_JOB_CONTROL_RESUME:
6706 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6707 errcode = WERR_OK;
6708 }
6709 break;
6710 default:
6711 return WERR_UNKNOWN_LEVEL;
6712 }
6713
6714 return errcode;
6715 }
6716
6717 static const struct print_architecture_table_node archi_table[]= {
6718
6719 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
6720 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
6721 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
6722 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
6723 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
6724 {"Windows IA64", SPL_ARCH_IA64, 3 },
6725 {"Windows x64", SPL_ARCH_X64, 3 },
6726 {NULL, "", -1 }
6727 };
6728
6729 /****************************************************************************
6730 Enumerates all printer drivers by level and architecture.
6731 ****************************************************************************/
6732
6733 static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
6734 const char *servername,
6735 const char *architecture,
6736 uint32_t level,
6737 union spoolss_DriverInfo **info_p,
6738 uint32_t *count_p)
6739 {
6740 int i;
6741 int ndrivers;
6742 uint32_t version;
6743 fstring *list = NULL;
6744 NT_PRINTER_DRIVER_INFO_LEVEL driver;
6745 union spoolss_DriverInfo *info = NULL;
6746 uint32_t count = 0;
6747 WERROR result = WERR_OK;
6748
6749 *count_p = 0;
6750 *info_p = NULL;
6751
6752 for (version=0; version<DRIVER_MAX_VERSION; version++) {
6753 list = NULL;
6754 ndrivers = get_ntdrivers(&list, architecture, version);
6755 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6756 ndrivers, architecture, version));
6757
6758 if (ndrivers == -1) {
6759 result = WERR_NOMEM;
6760 goto out;
6761 }
6762
6763 if (ndrivers != 0) {
6764 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6765 union spoolss_DriverInfo,
6766 count + ndrivers);
6767 if (!info) {
6768 DEBUG(0,("enumprinterdrivers_level1: "
6769 "failed to enlarge driver info buffer!\n"));
6770 result = WERR_NOMEM;
6771 goto out;
6772 }
6773 }
6774
6775 for (i=0; i<ndrivers; i++) {
6776 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6777 ZERO_STRUCT(driver);
6778 result = get_a_printer_driver(&driver, 3, list[i],
6779 architecture, version);
6780 if (!W_ERROR_IS_OK(result)) {
6781 goto out;
6782 }
6783
6784 switch (level) {
6785 case 1:
6786 result = fill_printer_driver_info1(info, &info[count+i].info1,
6787 &driver, servername,
6788 architecture);
6789 break;
6790 case 2:
6791 result = fill_printer_driver_info2(info, &info[count+i].info2,
6792 &driver, servername);
6793 break;
6794 case 3:
6795 result = fill_printer_driver_info3(info, &info[count+i].info3,
6796 &driver, servername);
6797 break;
6798 case 4:
6799 result = fill_printer_driver_info4(info, &info[count+i].info4,
6800 &driver, servername);
6801 break;
6802 case 5:
6803 result = fill_printer_driver_info5(info, &info[count+i].info5,
6804 &driver, servername);
6805 break;
6806 case 6:
6807 result = fill_printer_driver_info6(info, &info[count+i].info6,
6808 &driver, servername);
6809 break;
6810 default:
6811 result = WERR_UNKNOWN_LEVEL;
6812 break;
6813 }
6814
6815 if (!W_ERROR_IS_OK(result)) {
6816 free_a_printer_driver(driver, 3);
6817 goto out;
6818 }
6819 free_a_printer_driver(driver, 3);
6820 }
6821
6822 count += ndrivers;
6823 SAFE_FREE(list);
6824 }
6825
6826 out:
6827 SAFE_FREE(list);
6828
6829 if (!W_ERROR_IS_OK(result)) {
6830 TALLOC_FREE(info);
6831 return result;
6832 }
6833
6834 *info_p = info;
6835 *count_p = count;
6836
6837 return WERR_OK;
6838 }
6839
6840 /****************************************************************************
6841 Enumerates all printer drivers by level.
6842 ****************************************************************************/
6843
6844 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6845 const char *servername,
6846 const char *architecture,
6847 uint32_t level,
6848 union spoolss_DriverInfo **info_p,
6849 uint32_t *count_p)
6850 {
6851 uint32_t a,i;
6852 WERROR result = WERR_OK;
6853
6854 if (strequal(architecture, "all")) {
6855
6856 for (a=0; archi_table[a].long_archi != NULL; a++) {
6857
6858 union spoolss_DriverInfo *info = NULL;
6859 uint32_t count = 0;
6860
6861 result = enumprinterdrivers_level_by_architecture(mem_ctx,
6862 servername,
6863 archi_table[a].long_archi,
6864 level,
6865 &info,
6866 &count);
6867 if (!W_ERROR_IS_OK(result)) {
6868 continue;
6869 }
6870
6871 for (i=0; i < count; i++) {
6872 ADD_TO_ARRAY(mem_ctx, union spoolss_DriverInfo,
6873 info[i], info_p, count_p);
6874 }
6875 }
6876
6877 return result;
6878 }
6879
6880 return enumprinterdrivers_level_by_architecture(mem_ctx,
6881 servername,
6882 architecture,
6883 level,
6884 info_p,
6885 count_p);
6886 }
6887
6888 /****************************************************************************
6889 Enumerates all printer drivers at level 1.
6890 ****************************************************************************/
6891
6892 static WERROR enumprinterdrivers_level1(TALLOC_CTX *mem_ctx,
6893 const char *servername,
6894 const char *architecture,
6895 union spoolss_DriverInfo **info_p,
6896 uint32_t *count)
6897 {
6898 return enumprinterdrivers_level(mem_ctx, servername, architecture, 1,
6899 info_p, count);
6900 }
6901
6902 /****************************************************************************
6903 Enumerates all printer drivers at level 2.
6904 ****************************************************************************/
6905
6906 static WERROR enumprinterdrivers_level2(TALLOC_CTX *mem_ctx,
6907 const char *servername,
6908 const char *architecture,
6909 union spoolss_DriverInfo **info_p,
6910 uint32_t *count)
6911 {
6912 return enumprinterdrivers_level(mem_ctx, servername, architecture, 2,
6913 info_p, count);
6914 }
6915
6916 /****************************************************************************
6917 Enumerates all printer drivers at level 3.
6918 ****************************************************************************/
6919
6920 static WERROR enumprinterdrivers_level3(TALLOC_CTX *mem_ctx,
6921 const char *servername,
6922 const char *architecture,
6923 union spoolss_DriverInfo **info_p,
6924 uint32_t *count)
6925 {
6926 return enumprinterdrivers_level(mem_ctx, servername, architecture, 3,
6927 info_p, count);
6928 }
6929
6930 /****************************************************************************
6931 Enumerates all printer drivers at level 4.
6932 ****************************************************************************/
6933
6934 static WERROR enumprinterdrivers_level4(TALLOC_CTX *mem_ctx,
6935 const char *servername,
6936 const char *architecture,
6937 union spoolss_DriverInfo **info_p,
6938 uint32_t *count)
6939 {
6940 return enumprinterdrivers_level(mem_ctx, servername, architecture, 4,
6941 info_p, count);
6942 }
6943
6944 /****************************************************************************
6945 Enumerates all printer drivers at level 5.
6946 ****************************************************************************/
6947
6948 static WERROR enumprinterdrivers_level5(TALLOC_CTX *mem_ctx,
6949 const char *servername,
6950 const char *architecture,
6951 union spoolss_DriverInfo **info_p,
6952 uint32_t *count)
6953 {
6954 return enumprinterdrivers_level(mem_ctx, servername, architecture, 5,
6955 info_p, count);
6956 }
6957
6958 /****************************************************************************
6959 Enumerates all printer drivers at level 6.
6960 ****************************************************************************/
6961
6962 static WERROR enumprinterdrivers_level6(TALLOC_CTX *mem_ctx,
6963 const char *servername,
6964 const char *architecture,
6965 union spoolss_DriverInfo **info_p,
6966 uint32_t *count)
6967 {
6968 return enumprinterdrivers_level(mem_ctx, servername, architecture, 6,
6969 info_p, count);
6970 }
6971
6972
6973 /****************************************************************
6974 _spoolss_EnumPrinterDrivers
6975 ****************************************************************/
6976
6977 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6978 struct spoolss_EnumPrinterDrivers *r)
6979 {
6980 const char *cservername;
6981 WERROR result;
6982
6983 /* that's an [in out] buffer */
6984
6985 if (!r->in.buffer && (r->in.offered != 0)) {
6986 return WERR_INVALID_PARAM;
6987 }
6988
6989 DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6990
6991 *r->out.needed = 0;
6992 *r->out.count = 0;
6993 *r->out.info = NULL;
6994
6995 cservername = canon_servername(r->in.server);
6996
6997 if (!is_myname_or_ipaddr(cservername)) {
6998 return WERR_UNKNOWN_PRINTER_DRIVER;
6999 }
7000
7001 switch (r->in.level) {
7002 case 1:
7003 result = enumprinterdrivers_level1(p->mem_ctx, cservername,
7004 r->in.environment,
7005 r->out.info, r->out.count);
7006 break;
7007 case 2:
7008 result = enumprinterdrivers_level2(p->mem_ctx, cservername,
7009 r->in.environment,
7010 r->out.info, r->out.count);
7011 break;
7012 case 3:
7013 result = enumprinterdrivers_level3(p->mem_ctx, cservername,
7014 r->in.environment,
7015 r->out.info, r->out.count);
7016 break;
7017 case 4:
7018 result = enumprinterdrivers_level4(p->mem_ctx, cservername,
7019 r->in.environment,
7020 r->out.info, r->out.count);
7021 break;
7022 case 5:
7023 result = enumprinterdrivers_level5(p->mem_ctx, cservername,
7024 r->in.environment,
7025 r->out.info, r->out.count);
7026 break;
7027 case 6:
7028 result = enumprinterdrivers_level6(p->mem_ctx, cservername,
7029 r->in.environment,
7030 r->out.info, r->out.count);
7031 break;
7032 default:
7033 return WERR_UNKNOWN_LEVEL;
7034 }
7035
7036 if (!W_ERROR_IS_OK(result)) {
7037 return result;
7038 }
7039
7040 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7041 spoolss_EnumPrinterDrivers, NULL,
7042 *r->out.info, r->in.level,
7043 *r->out.count);
7044 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7045 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7046
7047 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7048 }
7049
7050 /****************************************************************************
7051 ****************************************************************************/
7052
7053 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
7054 struct spoolss_FormInfo1 *r,
7055 const nt_forms_struct *form)
7056 {
7057 r->form_name = talloc_strdup(mem_ctx, form->name);
7058 W_ERROR_HAVE_NO_MEMORY(r->form_name);
7059
7060 r->flags = form->flag;
7061 r->size.width = form->width;
7062 r->size.height = form->length;
7063 r->area.left = form->left;
7064 r->area.top = form->top;
7065 r->area.right = form->right;
7066 r->area.bottom = form->bottom;
7067
7068 return WERR_OK;
7069 }
7070
7071 /****************************************************************
7072 spoolss_enumforms_level1
7073 ****************************************************************/
7074
7075 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
7076 const nt_forms_struct *builtin_forms,
7077 uint32_t num_builtin_forms,
7078 const nt_forms_struct *user_forms,
7079 uint32_t num_user_forms,
7080 union spoolss_FormInfo **info_p,
7081 uint32_t *count)
7082 {
7083 union spoolss_FormInfo *info;
7084 WERROR result = WERR_OK;
7085 int i;
7086
7087 *count = num_builtin_forms + num_user_forms;
7088
7089 info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
7090 W_ERROR_HAVE_NO_MEMORY(info);
7091
7092 /* construct the list of form structures */
7093 for (i=0; i<num_builtin_forms; i++) {
7094 DEBUGADD(6,("Filling builtin form number [%d]\n",i));
7095 result = fill_form_info_1(info, &info[i].info1,
7096 &builtin_forms[i]);
7097 if (!W_ERROR_IS_OK(result)) {
7098 goto out;
7099 }
7100 }
7101
7102 for (i=0; i<num_user_forms; i++) {
7103 DEBUGADD(6,("Filling user form number [%d]\n",i));
7104 result = fill_form_info_1(info, &info[i+num_builtin_forms].info1,
7105 &user_forms[i]);
7106 if (!W_ERROR_IS_OK(result)) {
7107 goto out;
7108 }
7109 }
7110
7111 out:
7112 if (!W_ERROR_IS_OK(result)) {
7113 TALLOC_FREE(info);
7114 *count = 0;
7115 return result;
7116 }
7117
7118 *info_p = info;
7119
7120 return WERR_OK;
7121 }
7122
7123 /****************************************************************
7124 _spoolss_EnumForms
7125 ****************************************************************/
7126
7127 WERROR _spoolss_EnumForms(pipes_struct *p,
7128 struct spoolss_EnumForms *r)
7129 {
7130 WERROR result;
7131 nt_forms_struct *user_forms = NULL;
7132 nt_forms_struct *builtin_forms = NULL;
7133 uint32_t num_user_forms;
7134 uint32_t num_builtin_forms;
7135
7136 *r->out.count = 0;
7137 *r->out.needed = 0;
7138 *r->out.info = NULL;
7139
7140 /* that's an [in out] buffer */
7141
7142 if (!r->in.buffer && (r->in.offered != 0) ) {
7143 return WERR_INVALID_PARAM;
7144 }
7145
7146 DEBUG(4,("_spoolss_EnumForms\n"));
7147 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7148 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7149
7150 num_builtin_forms = get_builtin_ntforms(&builtin_forms);
7151 DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
7152 num_user_forms = get_ntforms(&user_forms);
7153 DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
7154
7155 if (num_user_forms + num_builtin_forms == 0) {
7156 SAFE_FREE(builtin_forms);
7157 SAFE_FREE(user_forms);
7158 return WERR_NO_MORE_ITEMS;
7159 }
7160
7161 switch (r->in.level) {
7162 case 1:
7163 result = spoolss_enumforms_level1(p->mem_ctx,
7164 builtin_forms,
7165 num_builtin_forms,
7166 user_forms,
7167 num_user_forms,
7168 r->out.info,
7169 r->out.count);
7170 break;
7171 default:
7172 result = WERR_UNKNOWN_LEVEL;
7173 break;
7174 }
7175
7176 SAFE_FREE(user_forms);
7177 SAFE_FREE(builtin_forms);
7178
7179 if (!W_ERROR_IS_OK(result)) {
7180 return result;
7181 }
7182
7183 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7184 spoolss_EnumForms, NULL,
7185 *r->out.info, r->in.level,
7186 *r->out.count);
7187 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7188 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7189
7190 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7191 }
7192
7193 /****************************************************************
7194 ****************************************************************/
7195
7196 static WERROR find_form_byname(const char *name,
7197 nt_forms_struct *form)
7198 {
7199 nt_forms_struct *list = NULL;
7200 int num_forms = 0, i = 0;
7201
7202 if (get_a_builtin_ntform_by_string(name, form)) {
7203 return WERR_OK;
7204 }
7205
7206 num_forms = get_ntforms(&list);
7207 DEBUGADD(5,("Number of forms [%d]\n", num_forms));
7208
7209 if (num_forms == 0) {
7210 return WERR_BADFID;
7211 }
7212
7213 /* Check if the requested name is in the list of form structures */
7214 for (i = 0; i < num_forms; i++) {
7215
7216 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
7217
7218 if (strequal(name, list[i].name)) {
7219 DEBUGADD(6,("Found form %s number [%d]\n", name, i));
7220 *form = list[i];
7221 SAFE_FREE(list);
7222 return WERR_OK;
7223 }
7224 }
7225
7226 SAFE_FREE(list);
7227
7228 return WERR_BADFID;
7229 }
7230
7231 /****************************************************************
7232 _spoolss_GetForm
7233 ****************************************************************/
7234
7235 WERROR _spoolss_GetForm(pipes_struct *p,
7236 struct spoolss_GetForm *r)
7237 {
7238 WERROR result;
7239 nt_forms_struct form;
7240
7241 /* that's an [in out] buffer */
7242
7243 if (!r->in.buffer && (r->in.offered != 0)) {
7244 return WERR_INVALID_PARAM;
7245 }
7246
7247 DEBUG(4,("_spoolss_GetForm\n"));
7248 DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7249 DEBUGADD(5,("Info level [%d]\n", r->in.level));
7250
7251 result = find_form_byname(r->in.form_name, &form);
7252 if (!W_ERROR_IS_OK(result)) {
7253 TALLOC_FREE(r->out.info);
7254 return result;
7255 }
7256
7257 switch (r->in.level) {
7258 case 1:
7259 result = fill_form_info_1(p->mem_ctx,
7260 &r->out.info->info1,
7261 &form);
7262 break;
7263
7264 default:
7265 result = WERR_UNKNOWN_LEVEL;
7266 break;
7267 }
7268
7269 if (!W_ERROR_IS_OK(result)) {
7270 TALLOC_FREE(r->out.info);
7271 return result;
7272 }
7273
7274 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
7275 r->out.info, r->in.level);
7276 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7277
7278 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7279 }
7280
7281 /****************************************************************************
7282 ****************************************************************************/
7283
7284 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7285 struct spoolss_PortInfo1 *r,
7286 const char *name)
7287 {
7288 r->port_name = talloc_strdup(mem_ctx, name);
7289 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7290
7291 return WERR_OK;
7292 }
7293
7294 /****************************************************************************
7295 TODO: This probably needs distinguish between TCP/IP and Local ports
7296 somehow.
7297 ****************************************************************************/
7298
7299 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7300 struct spoolss_PortInfo2 *r,
7301 const char *name)
7302 {
7303 r->port_name = talloc_strdup(mem_ctx, name);
7304 W_ERROR_HAVE_NO_MEMORY(r->port_name);
7305
7306 r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7307 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7308
7309 r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7310 W_ERROR_HAVE_NO_MEMORY(r->description);
7311
7312 r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7313 r->reserved = 0;
7314
7315 return WERR_OK;
7316 }
7317
7318
7319 /****************************************************************************
7320 wrapper around the enumer ports command
7321 ****************************************************************************/
7322
7323 static WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines)
7324 {
7325 char *cmd = lp_enumports_cmd();
7326 char **qlines = NULL;
7327 char *command = NULL;
7328 int numlines;
7329 int ret;
7330 int fd;
7331
7332 *count = 0;
7333 *lines = NULL;
7334
7335 /* if no hook then just fill in the default port */
7336
7337 if ( !*cmd ) {
7338 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7339 return WERR_NOMEM;
7340 }
7341 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7342 TALLOC_FREE(qlines);
7343 return WERR_NOMEM;
7344 }
7345 qlines[1] = NULL;
7346 numlines = 1;
7347 }
7348 else {
7349 /* we have a valid enumport command */
7350
7351 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7352 if (!command) {
7353 return WERR_NOMEM;
7354 }
7355
7356 DEBUG(10,("Running [%s]\n", command));
7357 ret = smbrun(command, &fd);
7358 DEBUG(10,("Returned [%d]\n", ret));
7359 TALLOC_FREE(command);
7360 if (ret != 0) {
7361 if (fd != -1) {
7362 close(fd);
7363 }
7364 return WERR_ACCESS_DENIED;
7365 }
7366
7367 numlines = 0;
7368 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7369 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7370 close(fd);
7371 }
7372
7373 *count = numlines;
7374 *lines = qlines;
7375
7376 return WERR_OK;
7377 }
7378
7379 /****************************************************************************
7380 enumports level 1.
7381 ****************************************************************************/
7382
7383 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7384 union spoolss_PortInfo **info_p,
7385 uint32_t *count)
7386 {
7387 union spoolss_PortInfo *info = NULL;
7388 int i=0;
7389 WERROR result = WERR_OK;
7390 char **qlines = NULL;
7391 int numlines = 0;
7392
7393 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7394 if (!W_ERROR_IS_OK(result)) {
7395 goto out;
7396 }
7397
7398 if (numlines) {
7399 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7400 if (!info) {
7401 DEBUG(10,("Returning WERR_NOMEM\n"));
7402 result = WERR_NOMEM;
7403 goto out;
7404 }
7405
7406 for (i=0; i<numlines; i++) {
7407 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7408 result = fill_port_1(info, &info[i].info1, qlines[i]);
7409 if (!W_ERROR_IS_OK(result)) {
7410 goto out;
7411 }
7412 }
7413 }
7414 TALLOC_FREE(qlines);
7415
7416 out:
7417 if (!W_ERROR_IS_OK(result)) {
7418 TALLOC_FREE(info);
7419 TALLOC_FREE(qlines);
7420 *count = 0;
7421 *info_p = NULL;
7422 return result;
7423 }
7424
7425 *info_p = info;
7426 *count = numlines;
7427
7428 return WERR_OK;
7429 }
7430
7431 /****************************************************************************
7432 enumports level 2.
7433 ****************************************************************************/
7434
7435 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7436 union spoolss_PortInfo **info_p,
7437 uint32_t *count)
7438 {
7439 union spoolss_PortInfo *info = NULL;
7440 int i=0;
7441 WERROR result = WERR_OK;
7442 char **qlines = NULL;
7443 int numlines = 0;
7444
7445 result = enumports_hook(talloc_tos(), &numlines, &qlines );
7446 if (!W_ERROR_IS_OK(result)) {
7447 goto out;
7448 }
7449
7450 if (numlines) {
7451 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7452 if (!info) {
7453 DEBUG(10,("Returning WERR_NOMEM\n"));
7454 result = WERR_NOMEM;
7455 goto out;
7456 }
7457
7458 for (i=0; i<numlines; i++) {
7459 DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7460 result = fill_port_2(info, &info[i].info2, qlines[i]);
7461 if (!W_ERROR_IS_OK(result)) {
7462 goto out;
7463 }
7464 }
7465 }
7466 TALLOC_FREE(qlines);
7467
7468 out:
7469 if (!W_ERROR_IS_OK(result)) {
7470 TALLOC_FREE(info);
7471 TALLOC_FREE(qlines);
7472 *count = 0;
7473 *info_p = NULL;
7474 return result;
7475 }
7476
7477 *info_p = info;
7478 *count = numlines;
7479
7480 return WERR_OK;
7481 }
7482
7483 /****************************************************************
7484 _spoolss_EnumPorts
7485 ****************************************************************/
7486
7487 WERROR _spoolss_EnumPorts(pipes_struct *p,
7488 struct spoolss_EnumPorts *r)
7489 {
7490 WERROR result;
7491
7492 /* that's an [in out] buffer */
7493
7494 if (!r->in.buffer && (r->in.offered != 0)) {
7495 return WERR_INVALID_PARAM;
7496 }
7497
7498 DEBUG(4,("_spoolss_EnumPorts\n"));
7499
7500 *r->out.count = 0;
7501 *r->out.needed = 0;
7502 *r->out.info = NULL;
7503
7504 switch (r->in.level) {
7505 case 1:
7506 result = enumports_level_1(p->mem_ctx, r->out.info,
7507 r->out.count);
7508 break;
7509 case 2:
7510 result = enumports_level_2(p->mem_ctx, r->out.info,
7511 r->out.count);
7512 break;
7513 default:
7514 return WERR_UNKNOWN_LEVEL;
7515 }
7516
7517 if (!W_ERROR_IS_OK(result)) {
7518 return result;
7519 }
7520
7521 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7522 spoolss_EnumPorts, NULL,
7523 *r->out.info, r->in.level,
7524 *r->out.count);
7525 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7526 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7527
7528 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7529 }
7530
7531 /****************************************************************************
7532 ****************************************************************************/
7533
7534 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7535 const char *server,
7536 struct spoolss_SetPrinterInfoCtr *info_ctr,
7537 struct spoolss_DeviceMode *devmode,
7538 struct security_descriptor *sec_desc,
7539 struct spoolss_UserLevelCtr *user_ctr,
7540 struct policy_handle *handle)
7541 {
7542 NT_PRINTER_INFO_LEVEL *printer = NULL;
7543 fstring name;
7544 int snum;
7545 WERROR err = WERR_OK;
7546
7547 if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7548 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7549 return WERR_NOMEM;
7550 }
7551
7552 /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7553 if (!convert_printer_info(info_ctr, printer)) {
7554 free_a_printer(&printer, 2);
7555 return WERR_NOMEM;
7556 }
7557
7558 /* check to see if the printer already exists */
7559
7560 if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7561 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7562 printer->info_2->sharename));
7563 free_a_printer(&printer, 2);
7564 return WERR_PRINTER_ALREADY_EXISTS;
7565 }
7566
7567 /* FIXME!!! smbd should check to see if the driver is installed before
7568 trying to add a printer like this --jerry */
7569
7570 if (*lp_addprinter_cmd() ) {
7571 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7572 printer) ) {
7573 free_a_printer(&printer,2);
7574 return WERR_ACCESS_DENIED;
7575 }
7576 } else {
7577 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7578 "smb.conf parameter \"addprinter command\" is defined. This"
7579 "parameter must exist for this call to succeed\n",
7580 printer->info_2->sharename ));
7581 }
7582
7583 /* use our primary netbios name since get_a_printer() will convert
7584 it to what the client expects on a case by case basis */
7585
7586 slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7587 printer->info_2->sharename);
7588
7589
7590 if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7591 free_a_printer(&printer,2);
7592 return WERR_ACCESS_DENIED;
7593 }
7594
7595 /* you must be a printer admin to add a new printer */
7596 if (!print_access_check(p->server_info, snum, PRINTER_ACCESS_ADMINISTER)) {
7597 free_a_printer(&printer,2);
7598 return WERR_ACCESS_DENIED;
7599 }
7600
7601 /*
7602 * Do sanity check on the requested changes for Samba.
7603 */
7604
7605 if (!check_printer_ok(printer->info_2, snum)) {
7606 free_a_printer(&printer,2);
7607 return WERR_INVALID_PARAM;
7608 }
7609
7610 /*
7611 * When a printer is created, the drivername bound to the printer is used
7612 * to lookup previously saved driver initialization info, which is then
7613 * bound to the new printer, simulating what happens in the Windows arch.
7614 */
7615
7616 if (!devmode)
7617 {
7618 set_driver_init(printer, 2);
7619 }
7620 else
7621 {
7622 /* A valid devmode was included, convert and link it
7623 */
7624 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7625
7626 if (!convert_devicemode(printer->info_2->printername, devmode,
7627 &printer->info_2->devmode)) {
7628 return WERR_NOMEM;
7629 }
7630 }
7631
7632 /* write the ASCII on disk */
7633 err = mod_a_printer(printer, 2);
7634 if (!W_ERROR_IS_OK(err)) {
7635 free_a_printer(&printer,2);
7636 return err;
7637 }
7638
7639 if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7640 /* Handle open failed - remove addition. */
7641 del_a_printer(printer->info_2->sharename);
7642 free_a_printer(&printer,2);
7643 ZERO_STRUCTP(handle);
7644 return WERR_ACCESS_DENIED;
7645 }
7646
7647 update_c_setprinter(false);
7648 free_a_printer(&printer,2);
7649
7650 return WERR_OK;
7651 }
7652
7653 /****************************************************************
7654 _spoolss_AddPrinterEx
7655 ****************************************************************/
7656
7657 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7658 struct spoolss_AddPrinterEx *r)
7659 {
7660 switch (r->in.info_ctr->level) {
7661 case 1:
7662 /* we don't handle yet */
7663 /* but I know what to do ... */
7664 return WERR_UNKNOWN_LEVEL;
7665 case 2:
7666 return spoolss_addprinterex_level_2(p, r->in.server,
7667 r->in.info_ctr,
7668 r->in.devmode_ctr->devmode,
7669 r->in.secdesc_ctr->sd,
7670 r->in.userlevel_ctr,
7671 r->out.handle);
7672 default:
7673 return WERR_UNKNOWN_LEVEL;
7674 }
7675 }
7676
7677 /****************************************************************
7678 _spoolss_AddPrinter
7679 ****************************************************************/
7680
7681 WERROR _spoolss_AddPrinter(pipes_struct *p,
7682 struct spoolss_AddPrinter *r)
7683 {
7684 struct spoolss_AddPrinterEx a;
7685 struct spoolss_UserLevelCtr userlevel_ctr;
7686
7687 ZERO_STRUCT(userlevel_ctr);
7688
7689 userlevel_ctr.level = 1;
7690
7691 a.in.server = r->in.server;
7692 a.in.info_ctr = r->in.info_ctr;
7693 a.in.devmode_ctr = r->in.devmode_ctr;
7694 a.in.secdesc_ctr = r->in.secdesc_ctr;
7695 a.in.userlevel_ctr = &userlevel_ctr;
7696 a.out.handle = r->out.handle;
7697
7698 return _spoolss_AddPrinterEx(p, &a);
7699 }
7700
7701 /****************************************************************
7702 _spoolss_AddPrinterDriver
7703 ****************************************************************/
7704
7705 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7706 struct spoolss_AddPrinterDriver *r)
7707 {
7708 uint32_t level = r->in.info_ctr->level;
7709 struct spoolss_AddDriverInfoCtr *info = r->in.info_ctr;
7710 WERROR err = WERR_OK;
7711 NT_PRINTER_DRIVER_INFO_LEVEL driver;
7712 const char *driver_name = NULL;
7713 uint32_t version;
7714 const char *fn;
7715
7716 switch (p->hdr_req.opnum) {
7717 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7718 fn = "_spoolss_AddPrinterDriver";
7719 break;
7720 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7721 fn = "_spoolss_AddPrinterDriverEx";
7722 break;
7723 default:
7724 return WERR_INVALID_PARAM;
7725 }
7726
7727
7728 /* FIXME */
7729 if (level != 3 && level != 6) {
7730 /* Clever hack from Martin Zielinski <mz@seh.de>
7731 * to allow downgrade from level 8 (Vista).
7732 */
7733 DEBUG(0,("%s: level %d not yet implemented\n", fn, level));
7734 return WERR_UNKNOWN_LEVEL;
7735 }
7736
7737 ZERO_STRUCT(driver);
7738
7739 if (!convert_printer_driver_info(info, &driver, level)) {
7740 err = WERR_NOMEM;
7741 goto done;
7742 }
7743
7744 DEBUG(5,("Cleaning driver's information\n"));
7745 err = clean_up_driver_struct(p, driver, level);
7746 if (!W_ERROR_IS_OK(err))
7747 goto done;
7748
7749 DEBUG(5,("Moving driver to final destination\n"));
7750 if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, driver, level,
7751 &err)) ) {
7752 goto done;
7753 }
7754
7755 if (add_a_printer_driver(driver, level)!=0) {
7756 err = WERR_ACCESS_DENIED;
7757 goto done;
7758 }
7759
7760 switch(level) {
7761 case 3:
7762 driver_name = driver.info_3->name ? driver.info_3->name : "";
7763 break;
7764 case 6:
7765 driver_name = driver.info_6->name ? driver.info_6->name : "";
7766 break;
7767 }
7768
7769 /*
7770 * I think this is where he DrvUpgradePrinter() hook would be
7771 * be called in a driver's interface DLL on a Windows NT 4.0/2k
7772 * server. Right now, we just need to send ourselves a message
7773 * to update each printer bound to this driver. --jerry
7774 */
7775
7776 if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7777 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7778 fn, driver_name));
7779 }
7780
7781 /*
7782 * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7783 * decide if the driver init data should be deleted. The rules are:
7784 * 1) never delete init data if it is a 9x driver, they don't use it anyway
7785 * 2) delete init data only if there is no 2k/Xp driver
7786 * 3) always delete init data
7787 * The generalized rule is always use init data from the highest order driver.
7788 * It is necessary to follow the driver install by an initialization step to
7789 * finish off this process.
7790 */
7791 if (level == 3)
7792 version = driver.info_3->cversion;
7793 else if (level == 6)
7794 version = driver.info_6->version;
7795 else
7796 version = -1;
7797 switch (version) {
7798 /*
7799 * 9x printer driver - never delete init data
7800 */
7801 case 0:
7802 DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7803 fn, driver_name));
7804 break;
7805
7806 /*
7807 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7808 * there is no 2k/Xp driver init data for this driver name.
7809 */
7810 case 2:
7811 {
7812 NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7813
7814 if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7815 /*
7816 * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7817 */
7818 if (!del_driver_init(driver_name))
7819 DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7820 fn, driver_name));
7821 } else {
7822 /*
7823 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7824 */
7825 free_a_printer_driver(driver1,3);
7826 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7827 fn, driver_name));
7828 }
7829 }
7830 break;
7831
7832 /*
7833 * 2k or Xp printer driver - always delete init data
7834 */
7835 case 3:
7836 if (!del_driver_init(driver_name))
7837 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7838 fn, driver_name));
7839 break;
7840
7841 default:
7842 DEBUG(0,("%s: invalid level=%d\n", fn, level));
7843 break;
7844 }
7845
7846
7847 done:
7848 free_a_printer_driver(driver, level);
7849 return err;
7850 }
7851
7852 /****************************************************************
7853 _spoolss_AddPrinterDriverEx
7854 ****************************************************************/
7855
7856 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7857 struct spoolss_AddPrinterDriverEx *r)
7858 {
7859 struct spoolss_AddPrinterDriver a;
7860
7861 /*
7862 * we only support the semantics of AddPrinterDriver()
7863 * i.e. only copy files that are newer than existing ones
7864 */
7865
7866 if (r->in.flags != APD_COPY_NEW_FILES) {
7867 return WERR_ACCESS_DENIED;
7868 }
7869
7870 a.in.servername = r->in.servername;
7871 a.in.info_ctr = r->in.info_ctr;
7872
7873 return _spoolss_AddPrinterDriver(p, &a);
7874 }
7875
7876 /****************************************************************************
7877 ****************************************************************************/
7878
7879 struct _spoolss_paths {
7880 int type;
7881 const char *share;
7882 const char *dir;
7883 };
7884
7885 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7886
7887 static const struct _spoolss_paths spoolss_paths[]= {
7888 { SPOOLSS_DRIVER_PATH, "print$", "DRIVERS" },
7889 { SPOOLSS_PRTPROCS_PATH, "prnproc$", "PRTPROCS" }
7890 };
7891
7892 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7893 const char *servername,
7894 const char *environment,
7895 int component,
7896 char **path)
7897 {
7898 const char *pservername = NULL;
7899 const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7900 const char *short_archi;
7901
7902 *path = NULL;
7903
7904 /* environment may be empty */
7905 if (environment && strlen(environment)) {
7906 long_archi = environment;
7907 }
7908
7909 /* servername may be empty */
7910 if (servername && strlen(servername)) {
7911 pservername = canon_servername(servername);
7912
7913 if (!is_myname_or_ipaddr(pservername)) {
7914 return WERR_INVALID_PARAM;
7915 }
7916 }
7917
7918 if (!(short_archi = get_short_archi(long_archi))) {
7919 return WERR_INVALID_ENVIRONMENT;
7920 }
7921
7922 switch (component) {
7923 case SPOOLSS_PRTPROCS_PATH:
7924 case SPOOLSS_DRIVER_PATH:
7925 if (pservername) {
7926 *path = talloc_asprintf(mem_ctx,
7927 "\\\\%s\\%s\\%s",
7928 pservername,
7929 spoolss_paths[component].share,
7930 short_archi);
7931 } else {
7932 *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7933 SPOOLSS_DEFAULT_SERVER_PATH,
7934 spoolss_paths[component].dir,
7935 short_archi);
7936 }
7937 break;
7938 default:
7939 return WERR_INVALID_PARAM;
7940 }
7941
7942 if (!*path) {
7943 return WERR_NOMEM;
7944 }
7945
7946 return WERR_OK;
7947 }
7948
7949 /****************************************************************************
7950 ****************************************************************************/
7951
7952 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7953 const char *servername,
7954 const char *environment,
7955 struct spoolss_DriverDirectoryInfo1 *r)
7956 {
7957 WERROR werr;
7958 char *path = NULL;
7959
7960 werr = compose_spoolss_server_path(mem_ctx,
7961 servername,
7962 environment,
7963 SPOOLSS_DRIVER_PATH,
7964 &path);
7965 if (!W_ERROR_IS_OK(werr)) {
7966 return werr;
7967 }
7968
7969 DEBUG(4,("printer driver directory: [%s]\n", path));
7970
7971 r->directory_name = path;
7972
7973 return WERR_OK;
7974 }
7975
7976 /****************************************************************
7977 _spoolss_GetPrinterDriverDirectory
7978 ****************************************************************/
7979
7980 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7981 struct spoolss_GetPrinterDriverDirectory *r)
7982 {
7983 WERROR werror;
7984
7985 /* that's an [in out] buffer */
7986
7987 if (!r->in.buffer && (r->in.offered != 0)) {
7988 return WERR_INVALID_PARAM;
7989 }
7990
7991 DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7992 r->in.level));
7993
7994 *r->out.needed = 0;
7995
7996 /* r->in.level is ignored */
7997
7998 werror = getprinterdriverdir_level_1(p->mem_ctx,
7999 r->in.server,
8000 r->in.environment,
8001 &r->out.info->info1);
8002 if (!W_ERROR_IS_OK(werror)) {
8003 TALLOC_FREE(r->out.info);
8004 return werror;
8005 }
8006
8007 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
8008 r->out.info, r->in.level);
8009 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
8010
8011 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8012 }
8013
8014 /****************************************************************
8015 _spoolss_EnumPrinterData
8016 ****************************************************************/
8017
8018 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
8019 struct spoolss_EnumPrinterData *r)
8020 {
8021 NT_PRINTER_INFO_LEVEL *printer = NULL;
8022 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8023 int snum;
8024 WERROR result;
8025 struct regval_blob *val = NULL;
8026 NT_PRINTER_DATA *p_data;
8027 int i, key_index, num_values;
8028 int name_length;
8029
8030 *r->out.value_needed = 0;
8031 *r->out.type = REG_NONE;
8032 *r->out.data_needed = 0;
8033
8034 DEBUG(5,("_spoolss_EnumPrinterData\n"));
8035
8036 if (!Printer) {
8037 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
8038 OUR_HANDLE(r->in.handle)));
8039 return WERR_BADFID;
8040 }
8041
8042 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8043 return WERR_BADFID;
8044 }
8045
8046 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8047 if (!W_ERROR_IS_OK(result)) {
8048 return result;
8049 }
8050
8051 p_data = printer->info_2->data;
8052 key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
8053
8054 result = WERR_OK;
8055
8056 /*
8057 * The NT machine wants to know the biggest size of value and data
8058 *
8059 * cf: MSDN EnumPrinterData remark section
8060 */
8061
8062 if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
8063
8064 uint32_t biggest_valuesize = 0;
8065 uint32_t biggest_datasize = 0;
8066
8067 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
8068
8069 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
8070
8071 for ( i=0; i<num_values; i++ )
8072 {
8073 val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
8074
8075 name_length = strlen(val->valuename);
8076 if ( strlen(val->valuename) > biggest_valuesize )
8077 biggest_valuesize = name_length;
8078
8079 if ( val->size > biggest_datasize )
8080 biggest_datasize = val->size;
8081
8082 DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8083 biggest_datasize));
8084 }
8085
8086 /* the value is an UNICODE string but real_value_size is the length
8087 in bytes including the trailing 0 */
8088
8089 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8090 *r->out.data_needed = biggest_datasize;
8091
8092 DEBUG(6,("final values: [%d], [%d]\n",
8093 *r->out.value_needed, *r->out.data_needed));
8094
8095 goto done;
8096 }
8097
8098 /*
8099 * the value len is wrong in NT sp3
8100 * that's the number of bytes not the number of unicode chars
8101 */
8102
8103 if (key_index != -1) {
8104 val = regval_ctr_specific_value(p_data->keys[key_index].values,
8105 r->in.enum_index);
8106 }
8107
8108 if (!val) {
8109
8110 /* out_value should default to "" or else NT4 has
8111 problems unmarshalling the response */
8112
8113 if (r->in.value_offered) {
8114 *r->out.value_needed = 1;
8115 r->out.value_name = talloc_strdup(r, "");
8116 if (!r->out.value_name) {
8117 result = WERR_NOMEM;
8118 goto done;
8119 }
8120 } else {
8121 r->out.value_name = NULL;
8122 *r->out.value_needed = 0;
8123 }
8124
8125 /* the data is counted in bytes */
8126
8127 *r->out.data_needed = r->in.data_offered;
8128
8129 result = WERR_NO_MORE_ITEMS;
8130 } else {
8131 /*
8132 * the value is:
8133 * - counted in bytes in the request
8134 * - counted in UNICODE chars in the max reply
8135 * - counted in bytes in the real size
8136 *
8137 * take a pause *before* coding not *during* coding
8138 */
8139
8140 /* name */
8141 if (r->in.value_offered) {
8142 r->out.value_name = talloc_strdup(r, regval_name(val));
8143 if (!r->out.value_name) {
8144 result = WERR_NOMEM;
8145 goto done;
8146 }
8147 *r->out.value_needed = strlen_m(regval_name(val));
8148 } else {
8149 r->out.value_name = NULL;
8150 *r->out.value_needed = 0;
8151 }
8152
8153 /* type */
8154
8155 *r->out.type = regval_type(val);
8156
8157 /* data - counted in bytes */
8158
8159 if (r->out.data && regval_size(val)) {
8160 memcpy(r->out.data, regval_data_p(val), regval_size(val));
8161 }
8162
8163 *r->out.data_needed = regval_size(val);
8164 }
8165
8166 done:
8167 free_a_printer(&printer, 2);
8168 return result;
8169 }
8170
8171 /****************************************************************
8172 _spoolss_SetPrinterData
8173 ****************************************************************/
8174
8175 WERROR _spoolss_SetPrinterData(pipes_struct *p,
8176 struct spoolss_SetPrinterData *r)
8177 {
8178 NT_PRINTER_INFO_LEVEL *printer = NULL;
8179 int snum=0;
8180 WERROR result = WERR_OK;
8181 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8182 DATA_BLOB blob;
8183
8184 DEBUG(5,("_spoolss_SetPrinterData\n"));
8185
8186 if (!Printer) {
8187 DEBUG(2,("_spoolss_SetPrinterData: Invalid handle (%s:%u:%u).\n",
8188 OUR_HANDLE(r->in.handle)));
8189 return WERR_BADFID;
8190 }
8191
8192 if (Printer->printer_type == SPLHND_SERVER) {
8193 DEBUG(10,("_spoolss_SetPrinterData: "
8194 "Not implemented for server handles yet\n"));
8195 return WERR_INVALID_PARAM;
8196 }
8197
8198 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8199 return WERR_BADFID;
8200 }
8201
8202 /*
8203 * Access check : NT returns "access denied" if you make a
8204 * SetPrinterData call without the necessary privildge.
8205 * we were originally returning OK if nothing changed
8206 * which made Win2k issue **a lot** of SetPrinterData
8207 * when connecting to a printer --jerry
8208 */
8209
8210 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8211 DEBUG(3,("_spoolss_SetPrinterData: "
8212 "change denied by handle access permissions\n"));
8213 result = WERR_ACCESS_DENIED;
8214 goto done;
8215 }
8216
8217 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8218 if (!W_ERROR_IS_OK(result)) {
8219 return result;
8220 }
8221
8222 result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8223 r->in.type, &r->in.data);
8224 if (!W_ERROR_IS_OK(result)) {
8225 goto done;
8226 }
8227
8228 /*
8229 * When client side code sets a magic printer data key, detect it and save
8230 * the current printer data and the magic key's data (its the DEVMODE) for
8231 * future printer/driver initializations.
8232 */
8233 if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8234 /* Set devmode and printer initialization info */
8235 result = save_driver_init(printer, 2, blob.data, blob.length);
8236
8237 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8238
8239 goto done;
8240 }
8241
8242 result = set_printer_dataex(printer, SPOOL_PRINTERDATA_KEY,
8243 r->in.value_name, r->in.type,
8244 blob.data, blob.length);
8245 if (W_ERROR_IS_OK(result)) {
8246 result = mod_a_printer(printer, 2);
8247 }
8248
8249 done:
8250 free_a_printer(&printer, 2);
8251
8252 return result;
8253 }
8254
8255 /****************************************************************
8256 _spoolss_ResetPrinter
8257 ****************************************************************/
8258
8259 WERROR _spoolss_ResetPrinter(pipes_struct *p,
8260 struct spoolss_ResetPrinter *r)
8261 {
8262 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8263 int snum;
8264
8265 DEBUG(5,("_spoolss_ResetPrinter\n"));
8266
8267 /*
8268 * All we do is to check to see if the handle and queue is valid.
8269 * This call really doesn't mean anything to us because we only
8270 * support RAW printing. --jerry
8271 */
8272
8273 if (!Printer) {
8274 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8275 OUR_HANDLE(r->in.handle)));
8276 return WERR_BADFID;
8277 }
8278
8279 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8280 return WERR_BADFID;
8281
8282
8283 /* blindly return success */
8284 return WERR_OK;
8285 }
8286
8287 /****************************************************************
8288 _spoolss_DeletePrinterData
8289 ****************************************************************/
8290
8291 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
8292 struct spoolss_DeletePrinterData *r)
8293 {
8294 NT_PRINTER_INFO_LEVEL *printer = NULL;
8295 int snum=0;
8296 WERROR status = WERR_OK;
8297 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8298
8299 DEBUG(5,("_spoolss_DeletePrinterData\n"));
8300
8301 if (!Printer) {
8302 DEBUG(2,("_spoolss_DeletePrinterData: Invalid handle (%s:%u:%u).\n",
8303 OUR_HANDLE(r->in.handle)));
8304 return WERR_BADFID;
8305 }
8306
8307 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8308 return WERR_BADFID;
8309
8310 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8311 DEBUG(3, ("_spoolss_DeletePrinterData: "
8312 "printer properties change denied by handle\n"));
8313 return WERR_ACCESS_DENIED;
8314 }
8315
8316 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8317 if (!W_ERROR_IS_OK(status))
8318 return status;
8319
8320 if (!r->in.value_name) {
8321 free_a_printer(&printer, 2);
8322 return WERR_NOMEM;
8323 }
8324
8325 status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY,
8326 r->in.value_name );
8327
8328 if ( W_ERROR_IS_OK(status) )
8329 mod_a_printer( printer, 2 );
8330
8331 free_a_printer(&printer, 2);
8332
8333 return status;
8334 }
8335
8336 /****************************************************************
8337 _spoolss_AddForm
8338 ****************************************************************/
8339
8340 WERROR _spoolss_AddForm(pipes_struct *p,
8341 struct spoolss_AddForm *r)
8342 {
8343 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8344 nt_forms_struct tmpForm;
8345 int snum = -1;
8346 WERROR status = WERR_OK;
8347 NT_PRINTER_INFO_LEVEL *printer = NULL;
8348 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8349
8350 int count=0;
8351 nt_forms_struct *list=NULL;
8352 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8353
8354 DEBUG(5,("_spoolss_AddForm\n"));
8355
8356 if (!Printer) {
8357 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8358 OUR_HANDLE(r->in.handle)));
8359 return WERR_BADFID;
8360 }
8361
8362
8363 /* forms can be added on printer of on the print server handle */
8364
8365 if ( Printer->printer_type == SPLHND_PRINTER )
8366 {
8367 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8368 return WERR_BADFID;
8369
8370 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8371 if (!W_ERROR_IS_OK(status))
8372 goto done;
8373 }
8374
8375 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8376 and not a printer admin, then fail */
8377
8378 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8379 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8380 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8381 NULL, NULL,
8382 p->server_info->ptok,
8383 lp_printer_admin(snum))) {
8384 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8385 return WERR_ACCESS_DENIED;
8386 }
8387
8388 /* can't add if builtin */
8389
8390 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8391 status = WERR_FILE_EXISTS;
8392 goto done;
8393 }
8394
8395 count = get_ntforms(&list);
8396
8397 if(!add_a_form(&list, form, &count)) {
8398 status = WERR_NOMEM;
8399 goto done;
8400 }
8401
8402 become_root();
8403 write_ntforms(&list, count);
8404 unbecome_root();
8405
8406 /*
8407 * ChangeID must always be set if this is a printer
8408 */
8409
8410 if ( Printer->printer_type == SPLHND_PRINTER )
8411 status = mod_a_printer(printer, 2);
8412
8413 done:
8414 if ( printer )
8415 free_a_printer(&printer, 2);
8416 SAFE_FREE(list);
8417
8418 return status;
8419 }
8420
8421 /****************************************************************
8422 _spoolss_DeleteForm
8423 ****************************************************************/
8424
8425 WERROR _spoolss_DeleteForm(pipes_struct *p,
8426 struct spoolss_DeleteForm *r)
8427 {
8428 const char *form_name = r->in.form_name;
8429 nt_forms_struct tmpForm;
8430 int count=0;
8431 nt_forms_struct *list=NULL;
8432 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8433 int snum = -1;
8434 WERROR status = WERR_OK;
8435 NT_PRINTER_INFO_LEVEL *printer = NULL;
8436 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8437 bool ret = false;
8438
8439 DEBUG(5,("_spoolss_DeleteForm\n"));
8440
8441 if (!Printer) {
8442 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8443 OUR_HANDLE(r->in.handle)));
8444 return WERR_BADFID;
8445 }
8446
8447 /* forms can be deleted on printer of on the print server handle */
8448
8449 if ( Printer->printer_type == SPLHND_PRINTER )
8450 {
8451 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8452 return WERR_BADFID;
8453
8454 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8455 if (!W_ERROR_IS_OK(status))
8456 goto done;
8457 }
8458
8459 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8460 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8461 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8462 NULL, NULL,
8463 p->server_info->ptok,
8464 lp_printer_admin(snum))) {
8465 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8466 return WERR_ACCESS_DENIED;
8467 }
8468
8469
8470 /* can't delete if builtin */
8471
8472 if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8473 status = WERR_INVALID_PARAM;
8474 goto done;
8475 }
8476
8477 count = get_ntforms(&list);
8478
8479 become_root();
8480 ret = delete_a_form(&list, form_name, &count, &status);
8481 unbecome_root();
8482 if (ret == false) {
8483 goto done;
8484 }
8485
8486 /*
8487 * ChangeID must always be set if this is a printer
8488 */
8489
8490 if ( Printer->printer_type == SPLHND_PRINTER )
8491 status = mod_a_printer(printer, 2);
8492
8493 done:
8494 if ( printer )
8495 free_a_printer(&printer, 2);
8496 SAFE_FREE(list);
8497
8498 return status;
8499 }
8500
8501 /****************************************************************
8502 _spoolss_SetForm
8503 ****************************************************************/
8504
8505 WERROR _spoolss_SetForm(pipes_struct *p,
8506 struct spoolss_SetForm *r)
8507 {
8508 struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8509 nt_forms_struct tmpForm;
8510 int snum = -1;
8511 WERROR status = WERR_OK;
8512 NT_PRINTER_INFO_LEVEL *printer = NULL;
8513 SE_PRIV se_printop = SE_PRINT_OPERATOR;
8514
8515 int count=0;
8516 nt_forms_struct *list=NULL;
8517 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8518
8519 DEBUG(5,("_spoolss_SetForm\n"));
8520
8521 if (!Printer) {
8522 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8523 OUR_HANDLE(r->in.handle)));
8524 return WERR_BADFID;
8525 }
8526
8527 /* forms can be modified on printer of on the print server handle */
8528
8529 if ( Printer->printer_type == SPLHND_PRINTER )
8530 {
8531 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8532 return WERR_BADFID;
8533
8534 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8535 if (!W_ERROR_IS_OK(status))
8536 goto done;
8537 }
8538
8539 /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8540 and not a printer admin, then fail */
8541
8542 if ((p->server_info->utok.uid != sec_initial_uid()) &&
8543 !user_has_privileges(p->server_info->ptok, &se_printop) &&
8544 !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8545 NULL, NULL,
8546 p->server_info->ptok,
8547 lp_printer_admin(snum))) {
8548 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8549 return WERR_ACCESS_DENIED;
8550 }
8551
8552 /* can't set if builtin */
8553 if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8554 status = WERR_INVALID_PARAM;
8555 goto done;
8556 }
8557
8558 count = get_ntforms(&list);
8559 update_a_form(&list, form, count);
8560 become_root();
8561 write_ntforms(&list, count);
8562 unbecome_root();
8563
8564 /*
8565 * ChangeID must always be set if this is a printer
8566 */
8567
8568 if ( Printer->printer_type == SPLHND_PRINTER )
8569 status = mod_a_printer(printer, 2);
8570
8571
8572 done:
8573 if ( printer )
8574 free_a_printer(&printer, 2);
8575 SAFE_FREE(list);
8576
8577 return status;
8578 }
8579
8580 /****************************************************************************
8581 fill_print_processor1
8582 ****************************************************************************/
8583
8584 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8585 struct spoolss_PrintProcessorInfo1 *r,
8586 const char *print_processor_name)
8587 {
8588 r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8589 W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8590
8591 return WERR_OK;
8592 }
8593
8594 /****************************************************************************
8595 enumprintprocessors level 1.
8596 ****************************************************************************/
8597
8598 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8599 union spoolss_PrintProcessorInfo **info_p,
8600 uint32_t *count)
8601 {
8602 union spoolss_PrintProcessorInfo *info;
8603 WERROR result;
8604
8605 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8606 W_ERROR_HAVE_NO_MEMORY(info);
8607
8608 *count = 1;
8609
8610 result = fill_print_processor1(info, &info[0].info1, "winprint");
8611 if (!W_ERROR_IS_OK(result)) {
8612 goto out;
8613 }
8614
8615 out:
8616 if (!W_ERROR_IS_OK(result)) {
8617 TALLOC_FREE(info);
8618 *count = 0;
8619 return result;
8620 }
8621
8622 *info_p = info;
8623
8624 return WERR_OK;
8625 }
8626
8627 /****************************************************************
8628 _spoolss_EnumPrintProcessors
8629 ****************************************************************/
8630
8631 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8632 struct spoolss_EnumPrintProcessors *r)
8633 {
8634 WERROR result;
8635
8636 /* that's an [in out] buffer */
8637
8638 if (!r->in.buffer && (r->in.offered != 0)) {
8639 return WERR_INVALID_PARAM;
8640 }
8641
8642 DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8643
8644 /*
8645 * Enumerate the print processors ...
8646 *
8647 * Just reply with "winprint", to keep NT happy
8648 * and I can use my nice printer checker.
8649 */
8650
8651 *r->out.count = 0;
8652 *r->out.needed = 0;
8653 *r->out.info = NULL;
8654
8655 switch (r->in.level) {
8656 case 1:
8657 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8658 r->out.count);
8659 break;
8660 default:
8661 return WERR_UNKNOWN_LEVEL;
8662 }
8663
8664 if (!W_ERROR_IS_OK(result)) {
8665 return result;
8666 }
8667
8668 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8669 spoolss_EnumPrintProcessors, NULL,
8670 *r->out.info, r->in.level,
8671 *r->out.count);
8672 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8673 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8674
8675 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8676 }
8677
8678 /****************************************************************************
8679 fill_printprocdatatype1
8680 ****************************************************************************/
8681
8682 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8683 struct spoolss_PrintProcDataTypesInfo1 *r,
8684 const char *name_array)
8685 {
8686 r->name_array = talloc_strdup(mem_ctx, name_array);
8687 W_ERROR_HAVE_NO_MEMORY(r->name_array);
8688
8689 return WERR_OK;
8690 }
8691
8692 /****************************************************************************
8693 enumprintprocdatatypes level 1.
8694 ****************************************************************************/
8695
8696 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8697 union spoolss_PrintProcDataTypesInfo **info_p,
8698 uint32_t *count)
8699 {
8700 WERROR result;
8701 union spoolss_PrintProcDataTypesInfo *info;
8702
8703 info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8704 W_ERROR_HAVE_NO_MEMORY(info);
8705
8706 *count = 1;
8707
8708 result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8709 if (!W_ERROR_IS_OK(result)) {
8710 goto out;
8711 }
8712
8713 out:
8714 if (!W_ERROR_IS_OK(result)) {
8715 TALLOC_FREE(info);
8716 *count = 0;
8717 return result;
8718 }
8719
8720 *info_p = info;
8721
8722 return WERR_OK;
8723 }
8724
8725 /****************************************************************
8726 _spoolss_EnumPrintProcDataTypes
8727 ****************************************************************/
8728
8729 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8730 struct spoolss_EnumPrintProcDataTypes *r)
8731 {
8732 WERROR result;
8733
8734 /* that's an [in out] buffer */
8735
8736 if (!r->in.buffer && (r->in.offered != 0)) {
8737 return WERR_INVALID_PARAM;
8738 }
8739
8740 DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8741
8742 *r->out.count = 0;
8743 *r->out.needed = 0;
8744 *r->out.info = NULL;
8745
8746 switch (r->in.level) {
8747 case 1:
8748 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8749 r->out.count);
8750 break;
8751 default:
8752 return WERR_UNKNOWN_LEVEL;
8753 }
8754
8755 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8756 spoolss_EnumPrintProcDataTypes, NULL,
8757 *r->out.info, r->in.level,
8758 *r->out.count);
8759 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8760 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8761
8762 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8763 }
8764
8765 /****************************************************************************
8766 fill_monitor_1
8767 ****************************************************************************/
8768
8769 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8770 struct spoolss_MonitorInfo1 *r,
8771 const char *monitor_name)
8772 {
8773 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8774 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8775
8776 return WERR_OK;
8777 }
8778
8779 /****************************************************************************
8780 fill_monitor_2
8781 ****************************************************************************/
8782
8783 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8784 struct spoolss_MonitorInfo2 *r,
8785 const char *monitor_name,
8786 const char *environment,
8787 const char *dll_name)
8788 {
8789 r->monitor_name = talloc_strdup(mem_ctx, monitor_name);
8790 W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8791 r->environment = talloc_strdup(mem_ctx, environment);
8792 W_ERROR_HAVE_NO_MEMORY(r->environment);
8793 r->dll_name = talloc_strdup(mem_ctx, dll_name);
8794 W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8795
8796 return WERR_OK;
8797 }
8798
8799 /****************************************************************************
8800 enumprintmonitors level 1.
8801 ****************************************************************************/
8802
8803 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8804 union spoolss_MonitorInfo **info_p,
8805 uint32_t *count)
8806 {
8807 union spoolss_MonitorInfo *info;
8808 WERROR result = WERR_OK;
8809
8810 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8811 W_ERROR_HAVE_NO_MEMORY(info);
8812
8813 *count = 2;
8814
8815 result = fill_monitor_1(info, &info[0].info1,
8816 SPL_LOCAL_PORT);
8817 if (!W_ERROR_IS_OK(result)) {
8818 goto out;
8819 }
8820
8821 result = fill_monitor_1(info, &info[1].info1,
8822 SPL_TCPIP_PORT);
8823 if (!W_ERROR_IS_OK(result)) {
8824 goto out;
8825 }
8826
8827 out:
8828 if (!W_ERROR_IS_OK(result)) {
8829 TALLOC_FREE(info);
8830 *count = 0;
8831 return result;
8832 }
8833
8834 *info_p = info;
8835
8836 return WERR_OK;
8837 }
8838
8839 /****************************************************************************
8840 enumprintmonitors level 2.
8841 ****************************************************************************/
8842
8843 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8844 union spoolss_MonitorInfo **info_p,
8845 uint32_t *count)
8846 {
8847 union spoolss_MonitorInfo *info;
8848 WERROR result = WERR_OK;
8849
8850 info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8851 W_ERROR_HAVE_NO_MEMORY(info);
8852
8853 *count = 2;
8854
8855 result = fill_monitor_2(info, &info[0].info2,
8856 SPL_LOCAL_PORT,
8857 "Windows NT X86", /* FIXME */
8858 "localmon.dll");
8859 if (!W_ERROR_IS_OK(result)) {
8860 goto out;
8861 }
8862
8863 result = fill_monitor_2(info, &info[1].info2,
8864 SPL_TCPIP_PORT,
8865 "Windows NT X86", /* FIXME */
8866 "tcpmon.dll");
8867 if (!W_ERROR_IS_OK(result)) {
8868 goto out;
8869 }
8870
8871 out:
8872 if (!W_ERROR_IS_OK(result)) {
8873 TALLOC_FREE(info);
8874 *count = 0;
8875 return result;
8876 }
8877
8878 *info_p = info;
8879
8880 return WERR_OK;
8881 }
8882
8883 /****************************************************************
8884 _spoolss_EnumMonitors
8885 ****************************************************************/
8886
8887 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8888 struct spoolss_EnumMonitors *r)
8889 {
8890 WERROR result;
8891
8892 /* that's an [in out] buffer */
8893
8894 if (!r->in.buffer && (r->in.offered != 0)) {
8895 return WERR_INVALID_PARAM;
8896 }
8897
8898 DEBUG(5,("_spoolss_EnumMonitors\n"));
8899
8900 /*
8901 * Enumerate the print monitors ...
8902 *
8903 * Just reply with "Local Port", to keep NT happy
8904 * and I can use my nice printer checker.
8905 */
8906
8907 *r->out.count = 0;
8908 *r->out.needed = 0;
8909 *r->out.info = NULL;
8910
8911 switch (r->in.level) {
8912 case 1:
8913 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8914 r->out.count);
8915 break;
8916 case 2:
8917 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8918 r->out.count);
8919 break;
8920 default:
8921 return WERR_UNKNOWN_LEVEL;
8922 }
8923
8924 if (!W_ERROR_IS_OK(result)) {
8925 return result;
8926 }
8927
8928 *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8929 spoolss_EnumMonitors, NULL,
8930 *r->out.info, r->in.level,
8931 *r->out.count);
8932 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8933 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8934
8935 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8936 }
8937
8938 /****************************************************************************
8939 ****************************************************************************/
8940
8941 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8942 const print_queue_struct *queue,
8943 int count, int snum,
8944 const NT_PRINTER_INFO_LEVEL *ntprinter,
8945 uint32_t jobid,
8946 struct spoolss_JobInfo1 *r)
8947 {
8948 int i = 0;
8949 bool found = false;
8950
8951 for (i=0; i<count && found == false; i++) {
8952 if (queue[i].job == (int)jobid) {
8953 found = true;
8954 }
8955 }
8956
8957 if (found == false) {
8958 /* NT treats not found as bad param... yet another bad choice */
8959 return WERR_INVALID_PARAM;
8960 }
8961
8962 return fill_job_info1(mem_ctx,
8963 r,
8964 &queue[i-1],
8965 i,
8966 snum,
8967 ntprinter);
8968 }
8969
8970 /****************************************************************************
8971 ****************************************************************************/
8972
8973 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8974 const print_queue_struct *queue,
8975 int count, int snum,
8976 const NT_PRINTER_INFO_LEVEL *ntprinter,
8977 uint32_t jobid,
8978 struct spoolss_JobInfo2 *r)
8979 {
8980 int i = 0;
8981 bool found = false;
8982 struct spoolss_DeviceMode *devmode;
8983 NT_DEVICEMODE *nt_devmode;
8984 WERROR result;
8985
8986 for (i=0; i<count && found == false; i++) {
8987 if (queue[i].job == (int)jobid) {
8988 found = true;
8989 }
8990 }
8991
8992 if (found == false) {
8993 /* NT treats not found as bad param... yet another bad
8994 choice */
8995 return WERR_INVALID_PARAM;
8996 }
8997
8998 /*
8999 * if the print job does not have a DEVMODE associated with it,
9000 * just use the one for the printer. A NULL devicemode is not
9001 * a failure condition
9002 */
9003
9004 nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
9005 if (nt_devmode) {
9006 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
9007 W_ERROR_HAVE_NO_MEMORY(devmode);
9008 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
9009 if (!W_ERROR_IS_OK(result)) {
9010 return result;
9011 }
9012 } else {
9013 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
9014 W_ERROR_HAVE_NO_MEMORY(devmode);
9015 }
9016
9017 return fill_job_info2(mem_ctx,
9018 r,
9019 &queue[i-1],
9020 i,
9021 snum,
9022 ntprinter,
9023 devmode);
9024 }
9025
9026 /****************************************************************
9027 _spoolss_GetJob
9028 ****************************************************************/
9029
9030 WERROR _spoolss_GetJob(pipes_struct *p,
9031 struct spoolss_GetJob *r)
9032 {
9033 WERROR result = WERR_OK;
9034 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
9035 int snum;
9036 int count;
9037 print_queue_struct *queue = NULL;
9038 print_status_struct prt_status;
9039
9040 /* that's an [in out] buffer */
9041
9042 if (!r->in.buffer && (r->in.offered != 0)) {
9043 return WERR_INVALID_PARAM;
9044 }
9045
9046 DEBUG(5,("_spoolss_GetJob\n"));
9047
9048 *r->out.needed = 0;
9049
9050 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9051 return WERR_BADFID;
9052 }
9053
9054 result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
9055 if (!W_ERROR_IS_OK(result)) {
9056 return result;
9057 }
9058
9059 count = print_queue_status(snum, &queue, &prt_status);
9060
9061 DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
9062 count, prt_status.status, prt_status.message));
9063
9064 switch (r->in.level) {
9065 case 1:
9066 result = getjob_level_1(p->mem_ctx,
9067 queue, count, snum, ntprinter,
9068 r->in.job_id, &r->out.info->info1);
9069 break;
9070 case 2:
9071 result = getjob_level_2(p->mem_ctx,
9072 queue, count, snum, ntprinter,
9073 r->in.job_id, &r->out.info->info2);
9074 break;
9075 default:
9076 result = WERR_UNKNOWN_LEVEL;
9077 break;
9078 }
9079
9080 SAFE_FREE(queue);
9081 free_a_printer(&ntprinter, 2);
9082
9083 if (!W_ERROR_IS_OK(result)) {
9084 TALLOC_FREE(r->out.info);
9085 return result;
9086 }
9087
9088 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
9089 r->out.info, r->in.level);
9090 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9091
9092 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9093 }
9094
9095 /****************************************************************
9096 _spoolss_GetPrinterDataEx
9097
9098 From MSDN documentation of GetPrinterDataEx: pass request
9099 to GetPrinterData if key is "PrinterDriverData".
9100 ****************************************************************/
9101
9102 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
9103 struct spoolss_GetPrinterDataEx *r)
9104 {
9105
9106 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9107 struct regval_blob *val = NULL;
9108 NT_PRINTER_INFO_LEVEL *printer = NULL;
9109 int snum = 0;
9110 WERROR result = WERR_OK;
9111
9112 DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9113
9114 DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9115 r->in.key_name, r->in.value_name));
9116
9117 /* in case of problem, return some default values */
9118
9119 *r->out.needed = 0;
9120 *r->out.type = REG_NONE;
9121
9122 if (!Printer) {
9123 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9124 OUR_HANDLE(r->in.handle)));
9125 result = WERR_BADFID;
9126 goto done;
9127 }
9128
9129 /* Is the handle to a printer or to the server? */
9130
9131 if (Printer->printer_type == SPLHND_SERVER) {
9132 DEBUG(10,("_spoolss_GetPrinterDataEx: "
9133 "Not implemented for server handles yet\n"));
9134 result = WERR_INVALID_PARAM;
9135 goto done;
9136 }
9137
9138 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9139 return WERR_BADFID;
9140 }
9141
9142 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9143 if (!W_ERROR_IS_OK(result)) {
9144 goto done;
9145 }
9146
9147 /* check to see if the keyname is valid */
9148 if (!strlen(r->in.key_name)) {
9149 result = WERR_INVALID_PARAM;
9150 goto done;
9151 }
9152
9153 if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
9154 DEBUG(4,("_spoolss_GetPrinterDataEx: "
9155 "Invalid keyname [%s]\n", r->in.key_name ));
9156 result = WERR_BADFILE;
9157 goto done;
9158 }
9159
9160 /* When given a new keyname, we should just create it */
9161
9162 val = get_printer_data(printer->info_2,
9163 r->in.key_name, r->in.value_name);
9164 if (!val) {
9165 result = WERR_BADFILE;
9166 goto done;
9167 }
9168
9169 *r->out.needed = regval_size(val);
9170
9171 if (*r->out.needed > r->in.offered) {
9172 result = WERR_MORE_DATA;
9173 goto done;
9174 }
9175
9176 *r->out.type = regval_type(val);
9177
9178 memcpy(r->out.buffer, regval_data_p(val), regval_size(val));
9179
9180 done:
9181 if (printer) {
9182 free_a_printer(&printer, 2);
9183 }
9184
9185 return result;
9186 }
9187
9188 /****************************************************************
9189 _spoolss_SetPrinterDataEx
9190 ****************************************************************/
9191
9192 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
9193 struct spoolss_SetPrinterDataEx *r)
9194 {
9195 NT_PRINTER_INFO_LEVEL *printer = NULL;
9196 int snum = 0;
9197 WERROR result = WERR_OK;
9198 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9199 char *oid_string;
9200
9201 DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9202
9203 /* From MSDN documentation of SetPrinterDataEx: pass request to
9204 SetPrinterData if key is "PrinterDriverData" */
9205
9206 if (!Printer) {
9207 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9208 OUR_HANDLE(r->in.handle)));
9209 return WERR_BADFID;
9210 }
9211
9212 if (Printer->printer_type == SPLHND_SERVER) {
9213 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9214 "Not implemented for server handles yet\n"));
9215 return WERR_INVALID_PARAM;
9216 }
9217
9218 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9219 return WERR_BADFID;
9220 }
9221
9222 /*
9223 * Access check : NT returns "access denied" if you make a
9224 * SetPrinterData call without the necessary privildge.
9225 * we were originally returning OK if nothing changed
9226 * which made Win2k issue **a lot** of SetPrinterData
9227 * when connecting to a printer --jerry
9228 */
9229
9230 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9231 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9232 "change denied by handle access permissions\n"));
9233 return WERR_ACCESS_DENIED;
9234 }
9235
9236 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9237 if (!W_ERROR_IS_OK(result)) {
9238 return result;
9239 }
9240
9241 /* check for OID in valuename */
9242
9243 oid_string = strchr(r->in.value_name, ',');
9244 if (oid_string) {
9245 *oid_string = '\0';
9246 oid_string++;
9247 }
9248
9249 /* save the registry data */
9250
9251 result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
9252 r->in.type, r->in.buffer, r->in.offered);
9253
9254 if (W_ERROR_IS_OK(result)) {
9255 /* save the OID if one was specified */
9256 if (oid_string) {
9257 char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
9258 r->in.key_name, SPOOL_OID_KEY);
9259 if (!str) {
9260 result = WERR_NOMEM;
9261 goto done;
9262 }
9263
9264 /*
9265 * I'm not checking the status here on purpose. Don't know
9266 * if this is right, but I'm returning the status from the
9267 * previous set_printer_dataex() call. I have no idea if
9268 * this is right. --jerry
9269 */
9270
9271 set_printer_dataex(printer, str, r->in.value_name,
9272 REG_SZ, (uint8_t *)oid_string,
9273 strlen(oid_string)+1);
9274 }
9275
9276 result = mod_a_printer(printer, 2);
9277 }
9278
9279 done:
9280 free_a_printer(&printer, 2);
9281
9282 return result;
9283 }
9284
9285 /****************************************************************
9286 _spoolss_DeletePrinterDataEx
9287 ****************************************************************/
9288
9289 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
9290 struct spoolss_DeletePrinterDataEx *r)
9291 {
9292 NT_PRINTER_INFO_LEVEL *printer = NULL;
9293 int snum=0;
9294 WERROR status = WERR_OK;
9295 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9296
9297 DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9298
9299 if (!Printer) {
9300 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9301 "Invalid handle (%s:%u:%u).\n",
9302 OUR_HANDLE(r->in.handle)));
9303 return WERR_BADFID;
9304 }
9305
9306 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9307 return WERR_BADFID;
9308
9309 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9310 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9311 "printer properties change denied by handle\n"));
9312 return WERR_ACCESS_DENIED;
9313 }
9314
9315 if (!r->in.value_name || !r->in.key_name) {
9316 return WERR_NOMEM;
9317 }
9318
9319 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9320 if (!W_ERROR_IS_OK(status))
9321 return status;
9322
9323 status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
9324
9325 if ( W_ERROR_IS_OK(status) )
9326 mod_a_printer( printer, 2 );
9327
9328 free_a_printer(&printer, 2);
9329
9330 return status;
9331 }
9332
9333 /****************************************************************
9334 _spoolss_EnumPrinterKey
9335 ****************************************************************/
9336
9337 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
9338 struct spoolss_EnumPrinterKey *r)
9339 {
9340 fstring *keynames = NULL;
9341 int num_keys;
9342 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9343 NT_PRINTER_DATA *data;
9344 NT_PRINTER_INFO_LEVEL *printer = NULL;
9345 int snum = 0;
9346 WERROR result = WERR_BADFILE;
9347 int i;
9348 const char **array = NULL;
9349
9350
9351 DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9352
9353 if (!Printer) {
9354 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9355 OUR_HANDLE(r->in.handle)));
9356 return WERR_BADFID;
9357 }
9358
9359 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9360 return WERR_BADFID;
9361 }
9362
9363 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9364 if (!W_ERROR_IS_OK(result)) {
9365 return result;
9366 }
9367
9368 /* get the list of subkey names */
9369
9370 data = printer->info_2->data;
9371
9372 num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
9373 if (num_keys == -1) {
9374 result = WERR_BADFILE;
9375 goto done;
9376 }
9377
9378 *r->out.needed = 4;
9379
9380 array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 1);
9381 if (!array) {
9382 result = WERR_NOMEM;
9383 goto done;
9384 }
9385
9386 for (i=0; i < num_keys; i++) {
9387 array[i] = talloc_strdup(array, keynames[i]);
9388 if (!array[i]) {
9389 result = WERR_NOMEM;
9390 goto done;
9391 }
9392
9393 *r->out.needed += strlen_m_term(keynames[i]) * 2;
9394 }
9395
9396 if (r->in.offered < *r->out.needed) {
9397 result = WERR_MORE_DATA;
9398 goto done;
9399 }
9400
9401 result = WERR_OK;
9402
9403 *r->out.key_buffer = array;
9404
9405 done:
9406 if (!W_ERROR_IS_OK(result)) {
9407 TALLOC_FREE(array);
9408 ZERO_STRUCTP(r->out.key_buffer);
9409 }
9410
9411 free_a_printer(&printer, 2);
9412 SAFE_FREE(keynames);
9413
9414 return result;
9415 }
9416
9417 /****************************************************************
9418 _spoolss_DeletePrinterKey
9419 ****************************************************************/
9420
9421 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9422 struct spoolss_DeletePrinterKey *r)
9423 {
9424 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9425 NT_PRINTER_INFO_LEVEL *printer = NULL;
9426 int snum=0;
9427 WERROR status;
9428
9429 DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9430
9431 if (!Printer) {
9432 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9433 OUR_HANDLE(r->in.handle)));
9434 return WERR_BADFID;
9435 }
9436
9437 /* if keyname == NULL, return error */
9438
9439 if ( !r->in.key_name )
9440 return WERR_INVALID_PARAM;
9441
9442 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9443 return WERR_BADFID;
9444
9445 if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9446 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9447 "printer properties change denied by handle\n"));
9448 return WERR_ACCESS_DENIED;
9449 }
9450
9451 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9452 if (!W_ERROR_IS_OK(status))
9453 return status;
9454
9455 /* delete the key and all subneys */
9456
9457 status = delete_all_printer_data( printer->info_2, r->in.key_name );
9458
9459 if ( W_ERROR_IS_OK(status) )
9460 status = mod_a_printer(printer, 2);
9461
9462 free_a_printer( &printer, 2 );
9463
9464 return status;
9465 }
9466
9467 /****************************************************************
9468 ****************************************************************/
9469
9470 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9471 struct regval_blob *v,
9472 struct spoolss_PrinterEnumValues *r)
9473 {
9474 WERROR result;
9475
9476 r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
9477 W_ERROR_HAVE_NO_MEMORY(r->data);
9478
9479 r->value_name = talloc_strdup(mem_ctx, regval_name(v));
9480 W_ERROR_HAVE_NO_MEMORY(r->value_name);
9481
9482 r->type = regval_type(v);
9483 r->data_length = regval_size(v);
9484
9485 if (r->data_length) {
9486 DATA_BLOB blob = data_blob_const(regval_data_p(v),
9487 regval_size(v));
9488 result = pull_spoolss_PrinterData(mem_ctx, &blob,
9489 r->data,
9490 r->type);
9491 if (!W_ERROR_IS_OK(result)) {
9492 return result;
9493 }
9494 }
9495
9496 return WERR_OK;
9497 }
9498
9499 /****************************************************************
9500 _spoolss_EnumPrinterDataEx
9501 ****************************************************************/
9502
9503 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9504 struct spoolss_EnumPrinterDataEx *r)
9505 {
9506 uint32_t count = 0;
9507 NT_PRINTER_INFO_LEVEL *printer = NULL;
9508 struct spoolss_PrinterEnumValues *info = NULL;
9509 NT_PRINTER_DATA *p_data;
9510 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9511 int snum;
9512 WERROR result;
9513 int key_index;
9514 int i;
9515
9516 DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9517
9518 *r->out.count = 0;
9519 *r->out.needed = 0;
9520 *r->out.info = NULL;
9521
9522 if (!Printer) {
9523 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9524 OUR_HANDLE(r->in.handle)));
9525 return WERR_BADFID;
9526 }
9527
9528 /*
9529 * first check for a keyname of NULL or "". Win2k seems to send
9530 * this a lot and we should send back WERR_INVALID_PARAM
9531 * no need to spend time looking up the printer in this case.
9532 * --jerry
9533 */
9534
9535 if (!strlen(r->in.key_name)) {
9536 result = WERR_INVALID_PARAM;
9537 goto done;
9538 }
9539
9540 /* get the printer off of disk */
9541
9542 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9543 return WERR_BADFID;
9544 }
9545
9546 ZERO_STRUCT(printer);
9547 result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9548 if (!W_ERROR_IS_OK(result)) {
9549 return result;
9550 }
9551
9552 /* now look for a match on the key name */
9553
9554 p_data = printer->info_2->data;
9555
9556 key_index = lookup_printerkey(p_data, r->in.key_name);
9557 if (key_index == -1) {
9558 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9559 r->in.key_name));
9560 result = WERR_INVALID_PARAM;
9561 goto done;
9562 }
9563
9564 /* allocate the memory for the array of pointers -- if necessary */
9565
9566 count = regval_ctr_numvals(p_data->keys[key_index].values);
9567 if (!count) {
9568 result = WERR_OK; /* ??? */
9569 goto done;
9570 }
9571
9572 info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9573 struct spoolss_PrinterEnumValues,
9574 count);
9575 if (!info) {
9576 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9577 result = WERR_NOMEM;
9578 goto done;
9579 }
9580
9581 /*
9582 * loop through all params and build the array to pass
9583 * back to the client
9584 */
9585
9586 for (i=0; i < count; i++) {
9587
9588 struct regval_blob *val;
9589
9590 /* lookup the registry value */
9591
9592 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9593
9594 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9595
9596 /* copy the data */
9597
9598 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9599 if (!W_ERROR_IS_OK(result)) {
9600 goto done;
9601 }
9602 }
9603
9604 #if 0 /* FIXME - gd */
9605 /* housekeeping information in the reply */
9606
9607 /* Fix from Martin Zielinski <mz@seh.de> - ensure
9608 * the hand marshalled container size is a multiple
9609 * of 4 bytes for RPC alignment.
9610 */
9611
9612 if (needed % 4) {
9613 needed += 4-(needed % 4);
9614 }
9615 #endif
9616 *r->out.count = count;
9617 *r->out.info = info;
9618
9619 done:
9620
9621 if (printer) {
9622 free_a_printer(&printer, 2);
9623 }
9624
9625 if (!W_ERROR_IS_OK(result)) {
9626 return result;
9627 }
9628
9629 *r->out.needed = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9630 spoolss_EnumPrinterDataEx, NULL,
9631 *r->out.info,
9632 *r->out.count);
9633 *r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9634 *r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9635
9636 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9637 }
9638
9639 /****************************************************************************
9640 ****************************************************************************/
9641
9642 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9643 const char *servername,
9644 const char *environment,
9645 struct spoolss_PrintProcessorDirectoryInfo1 *r)
9646 {
9647 WERROR werr;
9648 char *path = NULL;
9649
9650 werr = compose_spoolss_server_path(mem_ctx,
9651 servername,
9652 environment,
9653 SPOOLSS_PRTPROCS_PATH,
9654 &path);
9655 if (!W_ERROR_IS_OK(werr)) {
9656 return werr;
9657 }
9658
9659 DEBUG(4,("print processor directory: [%s]\n", path));
9660
9661 r->directory_name = path;
9662
9663 return WERR_OK;
9664 }
9665
9666 /****************************************************************
9667 _spoolss_GetPrintProcessorDirectory
9668 ****************************************************************/
9669
9670 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9671 struct spoolss_GetPrintProcessorDirectory *r)
9672 {
9673 WERROR result;
9674
9675 /* that's an [in out] buffer */
9676
9677 if (!r->in.buffer && (r->in.offered != 0)) {
9678 return WERR_INVALID_PARAM;
9679 }
9680
9681 DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9682 r->in.level));
9683
9684 *r->out.needed = 0;
9685
9686 /* r->in.level is ignored */
9687
9688 /* We always should reply with a local print processor directory so that
9689 * users are not forced to have a [prnproc$] share on the Samba spoolss
9690 * server - Guenther */
9691
9692 result = getprintprocessordirectory_level_1(p->mem_ctx,
9693 NULL, /* r->in.server */
9694 r->in.environment,
9695 &r->out.info->info1);
9696 if (!W_ERROR_IS_OK(result)) {
9697 TALLOC_FREE(r->out.info);
9698 return result;
9699 }
9700
9701 *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9702 r->out.info, r->in.level);
9703 r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9704
9705 return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9706 }
9707
9708 /*******************************************************************
9709 ********************************************************************/
9710
9711 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9712 const char *dllname)
9713 {
9714 enum ndr_err_code ndr_err;
9715 struct spoolss_MonitorUi ui;
9716
9717 ui.dll_name = dllname;
9718
9719 ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9720 (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9721 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9722 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9723 }
9724 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9725 }
9726
9727 /*******************************************************************
9728 Streams the monitor UI DLL name in UNICODE
9729 *******************************************************************/
9730
9731 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9732 NT_USER_TOKEN *token, DATA_BLOB *in,
9733 DATA_BLOB *out, uint32_t *needed)
9734 {
9735 const char *dllname = "tcpmonui.dll";
9736
9737 *needed = (strlen(dllname)+1) * 2;
9738
9739 if (out->length < *needed) {
9740 return WERR_INSUFFICIENT_BUFFER;
9741 }
9742
9743 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9744 return WERR_NOMEM;
9745 }
9746
9747 return WERR_OK;
9748 }
9749
9750 /*******************************************************************
9751 ********************************************************************/
9752
9753 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9754 struct spoolss_PortData1 *port1,
9755 const DATA_BLOB *buf)
9756 {
9757 enum ndr_err_code ndr_err;
9758 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9759 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9760 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9761 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9762 }
9763 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9764 }
9765
9766 /*******************************************************************
9767 ********************************************************************/
9768
9769 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9770 struct spoolss_PortData2 *port2,
9771 const DATA_BLOB *buf)
9772 {
9773 enum ndr_err_code ndr_err;
9774 ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9775 (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9776 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9777 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9778 }
9779 return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9780 }
9781
9782 /*******************************************************************
9783 Create a new TCP/IP port
9784 *******************************************************************/
9785
9786 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9787 NT_USER_TOKEN *token, DATA_BLOB *in,
9788 DATA_BLOB *out, uint32_t *needed)
9789 {
9790 struct spoolss_PortData1 port1;
9791 struct spoolss_PortData2 port2;
9792 char *device_uri = NULL;
9793 uint32_t version;
9794
9795 const char *portname;
9796 const char *hostaddress;
9797 const char *queue;
9798 uint32_t port_number;
9799 uint32_t protocol;
9800
9801 /* peek for spoolss_PortData version */
9802
9803 if (!in || (in->length < (128 + 4))) {
9804 return WERR_GENERAL_FAILURE;
9805 }
9806
9807 version = IVAL(in->data, 128);
9808
9809 switch (version) {
9810 case 1:
9811 ZERO_STRUCT(port1);
9812
9813 if (!pull_port_data_1(mem_ctx, &port1, in)) {
9814 return WERR_NOMEM;
9815 }
9816
9817 portname = port1.portname;
9818 hostaddress = port1.hostaddress;
9819 queue = port1.queue;
9820 protocol = port1.protocol;
9821 port_number = port1.port_number;
9822
9823 break;
9824 case 2:
9825 ZERO_STRUCT(port2);
9826
9827 if (!pull_port_data_2(mem_ctx, &port2, in)) {
9828 return WERR_NOMEM;
9829 }
9830
9831 portname = port2.portname;
9832 hostaddress = port2.hostaddress;
9833 queue = port2.queue;
9834 protocol = port2.protocol;
9835 port_number = port2.port_number;
9836
9837 break;
9838 default:
9839 DEBUG(1,("xcvtcp_addport: "
9840 "unknown version of port_data: %d\n", version));
9841 return WERR_UNKNOWN_PORT;
9842 }
9843
9844 /* create the device URI and call the add_port_hook() */
9845
9846 switch (protocol) {
9847 case PROTOCOL_RAWTCP_TYPE:
9848 device_uri = talloc_asprintf(mem_ctx,
9849 "socket://%s:%d/", hostaddress,
9850 port_number);
9851 break;
9852
9853 case PROTOCOL_LPR_TYPE:
9854 device_uri = talloc_asprintf(mem_ctx,
9855 "lpr://%s/%s", hostaddress, queue );
9856 break;
9857
9858 default:
9859 return WERR_UNKNOWN_PORT;
9860 }
9861
9862 if (!device_uri) {
9863 return WERR_NOMEM;
9864 }
9865
9866 return add_port_hook(mem_ctx, token, portname, device_uri);
9867 }
9868
9869 /*******************************************************************
9870 *******************************************************************/
9871
9872 struct xcv_api_table xcvtcp_cmds[] = {
9873 { "MonitorUI", xcvtcp_monitorui },
9874 { "AddPort", xcvtcp_addport},
9875 { NULL, NULL }
9876 };
9877
9878 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9879 NT_USER_TOKEN *token, const char *command,
9880 DATA_BLOB *inbuf,
9881 DATA_BLOB *outbuf,
9882 uint32_t *needed )
9883 {
9884 int i;
9885
9886 DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9887
9888 for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9889 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9890 return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9891 }
9892
9893 return WERR_BADFUNC;
9894 }
9895
9896 /*******************************************************************
9897 *******************************************************************/
9898 #if 0 /* don't support management using the "Local Port" monitor */
9899
9900 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9901 NT_USER_TOKEN *token, DATA_BLOB *in,
9902 DATA_BLOB *out, uint32_t *needed)
9903 {
9904 const char *dllname = "localui.dll";
9905
9906 *needed = (strlen(dllname)+1) * 2;
9907
9908 if (out->length < *needed) {
9909 return WERR_INSUFFICIENT_BUFFER;
9910 }
9911
9912 if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9913 return WERR_NOMEM;
9914 }
9915
9916 return WERR_OK;
9917 }
9918
9919 /*******************************************************************
9920 *******************************************************************/
9921
9922 struct xcv_api_table xcvlocal_cmds[] = {
9923 { "MonitorUI", xcvlocal_monitorui },
9924 { NULL, NULL }
9925 };
9926 #else
9927 struct xcv_api_table xcvlocal_cmds[] = {
9928 { NULL, NULL }
9929 };
9930 #endif
9931
9932
9933
9934 /*******************************************************************
9935 *******************************************************************/
9936
9937 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9938 NT_USER_TOKEN *token, const char *command,
9939 DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9940 uint32_t *needed)
9941 {
9942 int i;
9943
9944 DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9945
9946 for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9947 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9948 return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9949 }
9950 return WERR_BADFUNC;
9951 }
9952
9953 /****************************************************************
9954 _spoolss_XcvData
9955 ****************************************************************/
9956
9957 WERROR _spoolss_XcvData(pipes_struct *p,
9958 struct spoolss_XcvData *r)
9959 {
9960 Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9961 DATA_BLOB out_data = data_blob_null;
9962 WERROR werror;
9963
9964 if (!Printer) {
9965 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9966 OUR_HANDLE(r->in.handle)));
9967 return WERR_BADFID;
9968 }
9969
9970 /* Has to be a handle to the TCP/IP port monitor */
9971
9972 if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9973 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9974 return WERR_BADFID;
9975 }
9976
9977 /* requires administrative access to the server */
9978
9979 if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9980 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9981 return WERR_ACCESS_DENIED;
9982 }
9983
9984 /* Allocate the outgoing buffer */
9985
9986 if (r->in.out_data_size) {
9987 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9988 if (out_data.data == NULL) {
9989 return WERR_NOMEM;
9990 }
9991 }
9992
9993 switch ( Printer->printer_type ) {
9994 case SPLHND_PORTMON_TCP:
9995 werror = process_xcvtcp_command(p->mem_ctx,
9996 p->server_info->ptok,
9997 r->in.function_name,
9998 &r->in.in_data, &out_data,
9999 r->out.needed);
10000 break;
10001 case SPLHND_PORTMON_LOCAL:
10002 werror = process_xcvlocal_command(p->mem_ctx,
10003 p->server_info->ptok,
10004 r->in.function_name,
10005 &r->in.in_data, &out_data,
10006 r->out.needed);
10007 break;
10008 default:
10009 werror = WERR_INVALID_PRINT_MONITOR;
10010 }
10011
10012 if (!W_ERROR_IS_OK(werror)) {
10013 return werror;
10014 }
10015
10016 *r->out.status_code = 0;
10017
10018 memcpy(r->out.out_data, out_data.data, out_data.length);
10019
10020 return WERR_OK;
10021 }
10022
10023 /****************************************************************
10024 _spoolss_AddPrintProcessor
10025 ****************************************************************/
10026
10027 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
10028 struct spoolss_AddPrintProcessor *r)
10029 {
10030 /* for now, just indicate success and ignore the add. We'll
10031 automatically set the winprint processor for printer
10032 entries later. Used to debug the LexMark Optra S 1855 PCL
10033 driver --jerry */
10034
10035 return WERR_OK;
10036 }
10037
10038 /****************************************************************
10039 _spoolss_AddPort
10040 ****************************************************************/
10041
10042 WERROR _spoolss_AddPort(pipes_struct *p,
10043 struct spoolss_AddPort *r)
10044 {
10045 /* do what w2k3 does */
10046
10047 return WERR_NOT_SUPPORTED;
10048 }
10049
10050 /****************************************************************
10051 _spoolss_GetPrinterDriver
10052 ****************************************************************/
10053
10054 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
10055 struct spoolss_GetPrinterDriver *r)
10056 {
10057 p->rng_fault_state = true;
10058 return WERR_NOT_SUPPORTED;
10059 }
10060
10061 /****************************************************************
10062 _spoolss_ReadPrinter
10063 ****************************************************************/
10064
10065 WERROR _spoolss_ReadPrinter(pipes_struct *p,
10066 struct spoolss_ReadPrinter *r)
10067 {
10068 p->rng_fault_state = true;
10069 return WERR_NOT_SUPPORTED;
10070 }
10071
10072 /****************************************************************
10073 _spoolss_WaitForPrinterChange
10074 ****************************************************************/
10075
10076 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
10077 struct spoolss_WaitForPrinterChange *r)
10078 {
10079 p->rng_fault_state = true;
10080 return WERR_NOT_SUPPORTED;
10081 }
10082
10083 /****************************************************************
10084 _spoolss_ConfigurePort
10085 ****************************************************************/
10086
10087 WERROR _spoolss_ConfigurePort(pipes_struct *p,
10088 struct spoolss_ConfigurePort *r)
10089 {
10090 p->rng_fault_state = true;
10091 return WERR_NOT_SUPPORTED;
10092 }
10093
10094 /****************************************************************
10095 _spoolss_DeletePort
10096 ****************************************************************/
10097
10098 WERROR _spoolss_DeletePort(pipes_struct *p,
10099 struct spoolss_DeletePort *r)
10100 {
10101 p->rng_fault_state = true;
10102 return WERR_NOT_SUPPORTED;
10103 }
10104
10105 /****************************************************************
10106 _spoolss_CreatePrinterIC
10107 ****************************************************************/
10108
10109 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
10110 struct spoolss_CreatePrinterIC *r)
10111 {
10112 p->rng_fault_state = true;
10113 return WERR_NOT_SUPPORTED;
10114 }
10115
10116 /****************************************************************
10117 _spoolss_PlayGDIScriptOnPrinterIC
10118 ****************************************************************/
10119
10120 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
10121 struct spoolss_PlayGDIScriptOnPrinterIC *r)
10122 {
10123 p->rng_fault_state = true;
10124 return WERR_NOT_SUPPORTED;
10125 }
10126
10127 /****************************************************************
10128 _spoolss_DeletePrinterIC
10129 ****************************************************************/
10130
10131 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
10132 struct spoolss_DeletePrinterIC *r)
10133 {
10134 p->rng_fault_state = true;
10135 return WERR_NOT_SUPPORTED;
10136 }
10137
10138 /****************************************************************
10139 _spoolss_AddPrinterConnection
10140 ****************************************************************/
10141
10142 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
10143 struct spoolss_AddPrinterConnection *r)
10144 {
10145 p->rng_fault_state = true;
10146 return WERR_NOT_SUPPORTED;
10147 }
10148
10149 /****************************************************************
10150 _spoolss_DeletePrinterConnection
10151 ****************************************************************/
10152
10153 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
10154 struct spoolss_DeletePrinterConnection *r)
10155 {
10156 p->rng_fault_state = true;
10157 return WERR_NOT_SUPPORTED;
10158 }
10159
10160 /****************************************************************
10161 _spoolss_PrinterMessageBox
10162 ****************************************************************/
10163
10164 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
10165 struct spoolss_PrinterMessageBox *r)
10166 {
10167 p->rng_fault_state = true;
10168 return WERR_NOT_SUPPORTED;
10169 }
10170
10171 /****************************************************************
10172 _spoolss_AddMonitor
10173 ****************************************************************/
10174
10175 WERROR _spoolss_AddMonitor(pipes_struct *p,
10176 struct spoolss_AddMonitor *r)
10177 {
10178 p->rng_fault_state = true;
10179 return WERR_NOT_SUPPORTED;
10180 }
10181
10182 /****************************************************************
10183 _spoolss_DeleteMonitor
10184 ****************************************************************/
10185
10186 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
10187 struct spoolss_DeleteMonitor *r)
10188 {
10189 p->rng_fault_state = true;
10190 return WERR_NOT_SUPPORTED;
10191 }
10192
10193 /****************************************************************
10194 _spoolss_DeletePrintProcessor
10195 ****************************************************************/
10196
10197 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
10198 struct spoolss_DeletePrintProcessor *r)
10199 {
10200 p->rng_fault_state = true;
10201 return WERR_NOT_SUPPORTED;
10202 }
10203
10204 /****************************************************************
10205 _spoolss_AddPrintProvidor
10206 ****************************************************************/
10207
10208 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
10209 struct spoolss_AddPrintProvidor *r)
10210 {
10211 p->rng_fault_state = true;
10212 return WERR_NOT_SUPPORTED;
10213 }
10214
10215 /****************************************************************
10216 _spoolss_DeletePrintProvidor
10217 ****************************************************************/
10218
10219 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
10220 struct spoolss_DeletePrintProvidor *r)
10221 {
10222 p->rng_fault_state = true;
10223 return WERR_NOT_SUPPORTED;
10224 }
10225
10226 /****************************************************************
10227 _spoolss_FindFirstPrinterChangeNotification
10228 ****************************************************************/
10229
10230 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
10231 struct spoolss_FindFirstPrinterChangeNotification *r)
10232 {
10233 p->rng_fault_state = true;
10234 return WERR_NOT_SUPPORTED;
10235 }
10236
10237 /****************************************************************
10238 _spoolss_FindNextPrinterChangeNotification
10239 ****************************************************************/
10240
10241 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
10242 struct spoolss_FindNextPrinterChangeNotification *r)
10243 {
10244 p->rng_fault_state = true;
10245 return WERR_NOT_SUPPORTED;
10246 }
10247
10248 /****************************************************************
10249 _spoolss_RouterFindFirstPrinterChangeNotificationOld
10250 ****************************************************************/
10251
10252 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
10253 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10254 {
10255 p->rng_fault_state = true;
10256 return WERR_NOT_SUPPORTED;
10257 }
10258
10259 /****************************************************************
10260 _spoolss_ReplyOpenPrinter
10261 ****************************************************************/
10262
10263 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
10264 struct spoolss_ReplyOpenPrinter *r)
10265 {
10266 p->rng_fault_state = true;
10267 return WERR_NOT_SUPPORTED;
10268 }
10269
10270 /****************************************************************
10271 _spoolss_RouterReplyPrinter
10272 ****************************************************************/
10273
10274 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
10275 struct spoolss_RouterReplyPrinter *r)
10276 {
10277 p->rng_fault_state = true;
10278 return WERR_NOT_SUPPORTED;
10279 }
10280
10281 /****************************************************************
10282 _spoolss_ReplyClosePrinter
10283 ****************************************************************/
10284
10285 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
10286 struct spoolss_ReplyClosePrinter *r)
10287 {
10288 p->rng_fault_state = true;
10289 return WERR_NOT_SUPPORTED;
10290 }
10291
10292 /****************************************************************
10293 _spoolss_AddPortEx
10294 ****************************************************************/
10295
10296 WERROR _spoolss_AddPortEx(pipes_struct *p,
10297 struct spoolss_AddPortEx *r)
10298 {
10299 p->rng_fault_state = true;
10300 return WERR_NOT_SUPPORTED;
10301 }
10302
10303 /****************************************************************
10304 _spoolss_RouterFindFirstPrinterChangeNotification
10305 ****************************************************************/
10306
10307 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
10308 struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10309 {
10310 p->rng_fault_state = true;
10311 return WERR_NOT_SUPPORTED;
10312 }
10313
10314 /****************************************************************
10315 _spoolss_SpoolerInit
10316 ****************************************************************/
10317
10318 WERROR _spoolss_SpoolerInit(pipes_struct *p,
10319 struct spoolss_SpoolerInit *r)
10320 {
10321 p->rng_fault_state = true;
10322 return WERR_NOT_SUPPORTED;
10323 }
10324
10325 /****************************************************************
10326 _spoolss_ResetPrinterEx
10327 ****************************************************************/
10328
10329 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
10330 struct spoolss_ResetPrinterEx *r)
10331 {
10332 p->rng_fault_state = true;
10333 return WERR_NOT_SUPPORTED;
10334 }
10335
10336 /****************************************************************
10337 _spoolss_RouterReplyPrinterEx
10338 ****************************************************************/
10339
10340 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
10341 struct spoolss_RouterReplyPrinterEx *r)
10342 {
10343 p->rng_fault_state = true;
10344 return WERR_NOT_SUPPORTED;
10345 }
10346
10347 /****************************************************************
10348 _spoolss_44
10349 ****************************************************************/
10350
10351 WERROR _spoolss_44(pipes_struct *p,
10352 struct spoolss_44 *r)
10353 {
10354 p->rng_fault_state = true;
10355 return WERR_NOT_SUPPORTED;
10356 }
10357
10358 /****************************************************************
10359 _spoolss_47
10360 ****************************************************************/
10361
10362 WERROR _spoolss_47(pipes_struct *p,
10363 struct spoolss_47 *r)
10364 {
10365 p->rng_fault_state = true;
10366 return WERR_NOT_SUPPORTED;
10367 }
10368
10369 /****************************************************************
10370 _spoolss_4a
10371 ****************************************************************/
10372
10373 WERROR _spoolss_4a(pipes_struct *p,
10374 struct spoolss_4a *r)
10375 {
10376 p->rng_fault_state = true;
10377 return WERR_NOT_SUPPORTED;
10378 }
10379
10380 /****************************************************************
10381 _spoolss_4b
10382 ****************************************************************/
10383
10384 WERROR _spoolss_4b(pipes_struct *p,
10385 struct spoolss_4b *r)
10386 {
10387 p->rng_fault_state = true;
10388 return WERR_NOT_SUPPORTED;
10389 }
10390
10391 /****************************************************************
10392 _spoolss_4c
10393 ****************************************************************/
10394
10395 WERROR _spoolss_4c(pipes_struct *p,
10396 struct spoolss_4c *r)
10397 {
10398 p->rng_fault_state = true;
10399 return WERR_NOT_SUPPORTED;
10400 }
10401
10402 /****************************************************************
10403 _spoolss_53
10404 ****************************************************************/
10405
10406 WERROR _spoolss_53(pipes_struct *p,
10407 struct spoolss_53 *r)
10408 {
10409 p->rng_fault_state = true;
10410 return WERR_NOT_SUPPORTED;
10411 }
10412
10413 /****************************************************************
10414 _spoolss_55
10415 ****************************************************************/
10416
10417 WERROR _spoolss_55(pipes_struct *p,
10418 struct spoolss_55 *r)
10419 {
10420 p->rng_fault_state = true;
10421 return WERR_NOT_SUPPORTED;
10422 }
10423
10424 /****************************************************************
10425 _spoolss_56
10426 ****************************************************************/
10427
10428 WERROR _spoolss_56(pipes_struct *p,
10429 struct spoolss_56 *r)
10430 {
10431 p->rng_fault_state = true;
10432 return WERR_NOT_SUPPORTED;
10433 }
10434
10435 /****************************************************************
10436 _spoolss_57
10437 ****************************************************************/
10438
10439 WERROR _spoolss_57(pipes_struct *p,
10440 struct spoolss_57 *r)
10441 {
10442 p->rng_fault_state = true;
10443 return WERR_NOT_SUPPORTED;
10444 }
10445
10446 /****************************************************************
10447 _spoolss_5a
10448 ****************************************************************/
10449
10450 WERROR _spoolss_5a(pipes_struct *p,
10451 struct spoolss_5a *r)
10452 {
10453 p->rng_fault_state = true;
10454 return WERR_NOT_SUPPORTED;
10455 }
10456
10457 /****************************************************************
10458 _spoolss_5b
10459 ****************************************************************/
10460
10461 WERROR _spoolss_5b(pipes_struct *p,
10462 struct spoolss_5b *r)
10463 {
10464 p->rng_fault_state = true;
10465 return WERR_NOT_SUPPORTED;
10466 }
10467
10468 /****************************************************************
10469 _spoolss_5c
10470 ****************************************************************/
10471
10472 WERROR _spoolss_5c(pipes_struct *p,
10473 struct spoolss_5c *r)
10474 {
10475 p->rng_fault_state = true;
10476 return WERR_NOT_SUPPORTED;
10477 }
10478
10479 /****************************************************************
10480 _spoolss_5d
10481 ****************************************************************/
10482
10483 WERROR _spoolss_5d(pipes_struct *p,
10484 struct spoolss_5d *r)
10485 {
10486 p->rng_fault_state = true;
10487 return WERR_NOT_SUPPORTED;
10488 }
10489
10490 /****************************************************************
10491 _spoolss_5e
10492 ****************************************************************/
10493
10494 WERROR _spoolss_5e(pipes_struct *p,
10495 struct spoolss_5e *r)
10496 {
10497 p->rng_fault_state = true;
10498 return WERR_NOT_SUPPORTED;
10499 }
10500
10501 /****************************************************************
10502 _spoolss_5f
10503 ****************************************************************/
10504
10505 WERROR _spoolss_5f(pipes_struct *p,
10506 struct spoolss_5f *r)
10507 {
10508 p->rng_fault_state = true;
10509 return WERR_NOT_SUPPORTED;
10510 }
10511
aatanasov's samba4 branch