s3-spoolss: add support for _spoolss_EnumPrinterDrivers() level 6.
[ira/wip.git] / source3 / rpc_server / srv_spoolss_nt.c
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 struct table_node {
57         const char    *long_archi;
58         const char    *short_archi;
59         int     version;
60 };
61
62 static Printer_entry *printers_list;
63
64 typedef struct _counter_printer_0 {
65         struct _counter_printer_0 *next;
66         struct _counter_printer_0 *prev;
67
68         int snum;
69         uint32_t counter;
70 } counter_printer_0;
71
72 static counter_printer_0 *counter_list;
73
74 static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
75 static uint32_t smb_connections = 0;
76
77
78 /* in printing/nt_printing.c */
79
80 extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
81
82 /* API table for Xcv Monitor functions */
83
84 struct xcv_api_table {
85         const char *name;
86         WERROR(*fn) (TALLOC_CTX *mem_ctx, NT_USER_TOKEN *token, DATA_BLOB *in, DATA_BLOB *out, uint32_t *needed);
87 };
88
89 /********************************************************************
90  * Canonicalize servername.
91  ********************************************************************/
92
93 static const char *canon_servername(const char *servername)
94 {
95         const char *pservername = servername;
96         while (*pservername == '\\') {
97                 pservername++;
98         }
99         return pservername;
100 }
101
102 /* translate between internal status numbers and NT status numbers */
103 static int nt_printj_status(int v)
104 {
105         switch (v) {
106         case LPQ_QUEUED:
107                 return 0;
108         case LPQ_PAUSED:
109                 return JOB_STATUS_PAUSED;
110         case LPQ_SPOOLING:
111                 return JOB_STATUS_SPOOLING;
112         case LPQ_PRINTING:
113                 return JOB_STATUS_PRINTING;
114         case LPQ_ERROR:
115                 return JOB_STATUS_ERROR;
116         case LPQ_DELETING:
117                 return JOB_STATUS_DELETING;
118         case LPQ_OFFLINE:
119                 return JOB_STATUS_OFFLINE;
120         case LPQ_PAPEROUT:
121                 return JOB_STATUS_PAPEROUT;
122         case LPQ_PRINTED:
123                 return JOB_STATUS_PRINTED;
124         case LPQ_DELETED:
125                 return JOB_STATUS_DELETED;
126         case LPQ_BLOCKED:
127                 return JOB_STATUS_BLOCKED_DEVQ;
128         case LPQ_USER_INTERVENTION:
129                 return JOB_STATUS_USER_INTERVENTION;
130         }
131         return 0;
132 }
133
134 static int nt_printq_status(int v)
135 {
136         switch (v) {
137         case LPQ_PAUSED:
138                 return PRINTER_STATUS_PAUSED;
139         case LPQ_QUEUED:
140         case LPQ_SPOOLING:
141         case LPQ_PRINTING:
142                 return 0;
143         }
144         return 0;
145 }
146
147 /***************************************************************************
148  Disconnect from the client
149 ****************************************************************************/
150
151 static void srv_spoolss_replycloseprinter(int snum, struct policy_handle *handle)
152 {
153         WERROR result;
154         NTSTATUS status;
155
156         /*
157          * Tell the specific printing tdb we no longer want messages for this printer
158          * by deregistering our PID.
159          */
160
161         if (!print_notify_deregister_pid(snum))
162                 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", lp_const_servicename(snum) ));
163
164         /* weird if the test succeds !!! */
165         if (smb_connections==0) {
166                 DEBUG(0,("srv_spoolss_replycloseprinter:Trying to close non-existant notify backchannel !\n"));
167                 return;
168         }
169
170         status = rpccli_spoolss_ReplyClosePrinter(notify_cli_pipe, talloc_tos(),
171                                                   handle,
172                                                   &result);
173         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
174                 DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
175                         win_errstr(result)));
176
177         /* if it's the last connection, deconnect the IPC$ share */
178         if (smb_connections==1) {
179
180                 cli_shutdown( rpc_pipe_np_smb_conn(notify_cli_pipe) );
181                 notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
182
183                 messaging_deregister(smbd_messaging_context(),
184                                      MSG_PRINTER_NOTIFY2, NULL);
185
186                 /* Tell the connections db we're no longer interested in
187                  * printer notify messages. */
188
189                 register_message_flags(false, FLAG_MSG_PRINT_NOTIFY);
190         }
191
192         smb_connections--;
193 }
194
195 /****************************************************************************
196  Functions to free a printer entry datastruct.
197 ****************************************************************************/
198
199 static int printer_entry_destructor(Printer_entry *Printer)
200 {
201         if (Printer->notify.client_connected == true) {
202                 int snum = -1;
203
204                 if ( Printer->printer_type == SPLHND_SERVER) {
205                         snum = -1;
206                         srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
207                 } else if (Printer->printer_type == SPLHND_PRINTER) {
208                         snum = print_queue_snum(Printer->sharename);
209                         if (snum != -1)
210                                 srv_spoolss_replycloseprinter(snum,
211                                                 &Printer->notify.client_hnd);
212                 }
213         }
214
215         Printer->notify.flags=0;
216         Printer->notify.options=0;
217         Printer->notify.localmachine[0]='\0';
218         Printer->notify.printerlocal=0;
219         TALLOC_FREE(Printer->notify.option);
220         Printer->notify.client_connected = false;
221
222         free_nt_devicemode( &Printer->nt_devmode );
223         free_a_printer( &Printer->printer_info, 2 );
224
225         /* Remove from the internal list. */
226         DLIST_REMOVE(printers_list, Printer);
227         return 0;
228 }
229
230 /****************************************************************************
231   find printer index by handle
232 ****************************************************************************/
233
234 static Printer_entry *find_printer_index_by_hnd(pipes_struct *p,
235                                                 struct policy_handle *hnd)
236 {
237         Printer_entry *find_printer = NULL;
238
239         if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
240                 DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
241                 return NULL;
242         }
243
244         return find_printer;
245 }
246
247 /****************************************************************************
248  Close printer index by handle.
249 ****************************************************************************/
250
251 static bool close_printer_handle(pipes_struct *p, struct policy_handle *hnd)
252 {
253         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
254
255         if (!Printer) {
256                 DEBUG(2,("close_printer_handle: Invalid handle (%s:%u:%u)\n",
257                         OUR_HANDLE(hnd)));
258                 return false;
259         }
260
261         close_policy_hnd(p, hnd);
262
263         return true;
264 }
265
266 /****************************************************************************
267  Delete a printer given a handle.
268 ****************************************************************************/
269
270 WERROR delete_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *sharename )
271 {
272         char *cmd = lp_deleteprinter_cmd();
273         char *command = NULL;
274         int ret;
275         SE_PRIV se_printop = SE_PRINT_OPERATOR;
276         bool is_print_op = false;
277
278         /* can't fail if we don't try */
279
280         if ( !*cmd )
281                 return WERR_OK;
282
283         command = talloc_asprintf(ctx,
284                         "%s \"%s\"",
285                         cmd, sharename);
286         if (!command) {
287                 return WERR_NOMEM;
288         }
289         if ( token )
290                 is_print_op = user_has_privileges( token, &se_printop );
291
292         DEBUG(10,("Running [%s]\n", command));
293
294         /********** BEGIN SePrintOperatorPrivlege BLOCK **********/
295
296         if ( is_print_op )
297                 become_root();
298
299         if ( (ret = smbrun(command, NULL)) == 0 ) {
300                 /* Tell everyone we updated smb.conf. */
301                 message_send_all(smbd_messaging_context(),
302                                  MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
303         }
304
305         if ( is_print_op )
306                 unbecome_root();
307
308         /********** END SePrintOperatorPrivlege BLOCK **********/
309
310         DEBUGADD(10,("returned [%d]\n", ret));
311
312         TALLOC_FREE(command);
313
314         if (ret != 0)
315                 return WERR_BADFID; /* What to return here? */
316
317         /* go ahead and re-read the services immediately */
318         reload_services(false);
319
320         if ( lp_servicenumber( sharename )  < 0 )
321                 return WERR_ACCESS_DENIED;
322
323         return WERR_OK;
324 }
325
326 /****************************************************************************
327  Delete a printer given a handle.
328 ****************************************************************************/
329
330 static WERROR delete_printer_handle(pipes_struct *p, struct policy_handle *hnd)
331 {
332         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
333
334         if (!Printer) {
335                 DEBUG(2,("delete_printer_handle: Invalid handle (%s:%u:%u)\n",
336                         OUR_HANDLE(hnd)));
337                 return WERR_BADFID;
338         }
339
340         /*
341          * It turns out that Windows allows delete printer on a handle
342          * opened by an admin user, then used on a pipe handle created
343          * by an anonymous user..... but they're working on security.... riiight !
344          * JRA.
345          */
346
347         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
348                 DEBUG(3, ("delete_printer_handle: denied by handle\n"));
349                 return WERR_ACCESS_DENIED;
350         }
351
352         /* this does not need a become root since the access check has been
353            done on the handle already */
354
355         if (del_a_printer( Printer->sharename ) != 0) {
356                 DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
357                 return WERR_BADFID;
358         }
359
360         return delete_printer_hook(p->mem_ctx, p->server_info->ptok,
361                                    Printer->sharename );
362 }
363
364 /****************************************************************************
365  Return the snum of a printer corresponding to an handle.
366 ****************************************************************************/
367
368 static bool get_printer_snum(pipes_struct *p, struct policy_handle *hnd,
369                              int *number, struct share_params **params)
370 {
371         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
372
373         if (!Printer) {
374                 DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n",
375                         OUR_HANDLE(hnd)));
376                 return false;
377         }
378
379         switch (Printer->printer_type) {
380                 case SPLHND_PRINTER:
381                         DEBUG(4,("short name:%s\n", Printer->sharename));
382                         *number = print_queue_snum(Printer->sharename);
383                         return (*number != -1);
384                 case SPLHND_SERVER:
385                         return false;
386                 default:
387                         return false;
388         }
389 }
390
391 /****************************************************************************
392  Set printer handle type.
393  Check if it's \\server or \\server\printer
394 ****************************************************************************/
395
396 static bool set_printer_hnd_printertype(Printer_entry *Printer, const char *handlename)
397 {
398         DEBUG(3,("Setting printer type=%s\n", handlename));
399
400         if ( strlen(handlename) < 3 ) {
401                 DEBUGADD(4,("A print server must have at least 1 char ! %s\n", handlename));
402                 return false;
403         }
404
405         /* it's a print server */
406         if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
407                 DEBUGADD(4,("Printer is a print server\n"));
408                 Printer->printer_type = SPLHND_SERVER;
409         }
410         /* it's a printer (set_printer_hnd_name() will handle port monitors */
411         else {
412                 DEBUGADD(4,("Printer is a printer\n"));
413                 Printer->printer_type = SPLHND_PRINTER;
414         }
415
416         return true;
417 }
418
419 /****************************************************************************
420  Set printer handle name..  Accept names like \\server, \\server\printer,
421  \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port"    See
422  the MSDN docs regarding OpenPrinter() for details on the XcvData() and
423  XcvDataPort() interface.
424 ****************************************************************************/
425
426 static bool set_printer_hnd_name(Printer_entry *Printer, const char *handlename)
427 {
428         int snum;
429         int n_services=lp_numservices();
430         char *aprinter, *printername;
431         const char *servername;
432         fstring sname;
433         bool found = false;
434         NT_PRINTER_INFO_LEVEL *printer = NULL;
435         WERROR result;
436
437         DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename,
438                 (unsigned long)strlen(handlename)));
439
440         aprinter = CONST_DISCARD(char *, handlename);
441         if ( *handlename == '\\' ) {
442                 servername = canon_servername(handlename);
443                 if ( (aprinter = strchr_m( servername, '\\' )) != NULL ) {
444                         *aprinter = '\0';
445                         aprinter++;
446                 }
447         } else {
448                 servername = global_myname();
449         }
450
451         /* save the servername to fill in replies on this handle */
452
453         if ( !is_myname_or_ipaddr( servername ) )
454                 return false;
455
456         fstrcpy( Printer->servername, servername );
457
458         if ( Printer->printer_type == SPLHND_SERVER )
459                 return true;
460
461         if ( Printer->printer_type != SPLHND_PRINTER )
462                 return false;
463
464         DEBUGADD(5, ("searching for [%s]\n", aprinter ));
465
466         /* check for the Port Monitor Interface */
467
468         if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
469                 Printer->printer_type = SPLHND_PORTMON_TCP;
470                 fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
471                 found = true;
472         }
473         else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
474                 Printer->printer_type = SPLHND_PORTMON_LOCAL;
475                 fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
476                 found = true;
477         }
478
479         /* Search all sharenames first as this is easier than pulling
480            the printer_info_2 off of disk. Don't use find_service() since
481            that calls out to map_username() */
482
483         /* do another loop to look for printernames */
484
485         for (snum=0; !found && snum<n_services; snum++) {
486
487                 /* no point going on if this is not a printer */
488
489                 if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
490                         continue;
491
492                 fstrcpy(sname, lp_servicename(snum));
493                 if ( strequal( aprinter, sname ) ) {
494                         found = true;
495                         break;
496                 }
497
498                 /* no point looking up the printer object if
499                    we aren't allowing printername != sharename */
500
501                 if ( lp_force_printername(snum) )
502                         continue;
503
504                 fstrcpy(sname, lp_servicename(snum));
505
506                 printer = NULL;
507
508                 /* This call doesn't fill in the location or comment from
509                  * a CUPS server for efficiency with large numbers of printers.
510                  * JRA.
511                  */
512
513                 result = get_a_printer_search( NULL, &printer, 2, sname );
514                 if ( !W_ERROR_IS_OK(result) ) {
515                         DEBUG(0,("set_printer_hnd_name: failed to lookup printer [%s] -- result [%s]\n",
516                                 sname, win_errstr(result)));
517                         continue;
518                 }
519
520                 /* printername is always returned as \\server\printername */
521                 if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
522                         DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
523                                 printer->info_2->printername));
524                         free_a_printer( &printer, 2);
525                         continue;
526                 }
527
528                 printername++;
529
530                 if ( strequal(printername, aprinter) ) {
531                         free_a_printer( &printer, 2);
532                         found = true;
533                         break;
534                 }
535
536                 DEBUGADD(10, ("printername: %s\n", printername));
537
538                 free_a_printer( &printer, 2);
539         }
540
541         free_a_printer( &printer, 2);
542
543         if ( !found ) {
544                 DEBUGADD(4,("Printer not found\n"));
545                 return false;
546         }
547
548         DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
549
550         fstrcpy(Printer->sharename, sname);
551
552         return true;
553 }
554
555 /****************************************************************************
556  Find first available printer slot. creates a printer handle for you.
557  ****************************************************************************/
558
559 static bool open_printer_hnd(pipes_struct *p, struct policy_handle *hnd,
560                              const char *name, uint32_t access_granted)
561 {
562         Printer_entry *new_printer;
563
564         DEBUG(10,("open_printer_hnd: name [%s]\n", name));
565
566         new_printer = TALLOC_ZERO_P(NULL, Printer_entry);
567         if (new_printer == NULL) {
568                 return false;
569         }
570         talloc_set_destructor(new_printer, printer_entry_destructor);
571
572         if (!create_policy_hnd(p, hnd, new_printer)) {
573                 TALLOC_FREE(new_printer);
574                 return false;
575         }
576
577         /* Add to the internal list. */
578         DLIST_ADD(printers_list, new_printer);
579
580         new_printer->notify.option=NULL;
581
582         if (!set_printer_hnd_printertype(new_printer, name)) {
583                 close_printer_handle(p, hnd);
584                 return false;
585         }
586
587         if (!set_printer_hnd_name(new_printer, name)) {
588                 close_printer_handle(p, hnd);
589                 return false;
590         }
591
592         new_printer->access_granted = access_granted;
593
594         DEBUG(5, ("%d printer handles active\n", (int)p->pipe_handles->count ));
595
596         return true;
597 }
598
599 /***************************************************************************
600  check to see if the client motify handle is monitoring the notification
601  given by (notify_type, notify_field).
602  **************************************************************************/
603
604 static bool is_monitoring_event_flags(uint32_t flags, uint16_t notify_type,
605                                       uint16_t notify_field)
606 {
607         return true;
608 }
609
610 static bool is_monitoring_event(Printer_entry *p, uint16_t notify_type,
611                                 uint16_t notify_field)
612 {
613         struct spoolss_NotifyOption *option = p->notify.option;
614         uint32_t i, j;
615
616         /*
617          * Flags should always be zero when the change notify
618          * is registered by the client's spooler.  A user Win32 app
619          * might use the flags though instead of the NOTIFY_OPTION_INFO
620          * --jerry
621          */
622
623         if (!option) {
624                 return false;
625         }
626
627         if (p->notify.flags)
628                 return is_monitoring_event_flags(
629                         p->notify.flags, notify_type, notify_field);
630
631         for (i = 0; i < option->count; i++) {
632
633                 /* Check match for notify_type */
634
635                 if (option->types[i].type != notify_type)
636                         continue;
637
638                 /* Check match for field */
639
640                 for (j = 0; j < option->types[i].count; j++) {
641                         if (option->types[i].fields[j].field == notify_field) {
642                                 return true;
643                         }
644                 }
645         }
646
647         DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
648                    p->servername, p->sharename, notify_type, notify_field));
649
650         return false;
651 }
652
653 #define SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(_data, _integer) \
654         _data->data.integer[0] = _integer; \
655         _data->data.integer[1] = 0;
656
657
658 #define SETUP_SPOOLSS_NOTIFY_DATA_STRING(_data, _p) \
659         _data->data.string.string = talloc_strdup(mem_ctx, _p); \
660         if (!_data->data.string.string) {\
661                 _data->data.string.size = 0; \
662         } \
663         _data->data.string.size = strlen_m_term(_p) * 2;
664
665 #define SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(_data, _devmode) \
666         _data->data.devmode.devmode = _devmode;
667
668 #define SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(_data, _size, _sd) \
669         _data->data.sd.sd = dup_sec_desc(mem_ctx, _sd); \
670         if (!_data->data.sd.sd) { \
671                 _data->data.sd.sd_size = 0; \
672         } \
673         _data->data.sd.sd_size = _size;
674
675 static void init_systemtime_buffer(TALLOC_CTX *mem_ctx,
676                                    struct tm *t,
677                                    const char **pp,
678                                    uint32_t *plen)
679 {
680         struct spoolss_Time st;
681         uint32_t len = 16;
682         char *p;
683
684         if (!init_systemtime(&st, t)) {
685                 return;
686         }
687
688         p = talloc_array(mem_ctx, char, len);
689         if (!p) {
690                 return;
691         }
692
693         /*
694          * Systemtime must be linearized as a set of UINT16's.
695          * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
696          */
697
698         SSVAL(p, 0, st.year);
699         SSVAL(p, 2, st.month);
700         SSVAL(p, 4, st.day_of_week);
701         SSVAL(p, 6, st.day);
702         SSVAL(p, 8, st.hour);
703         SSVAL(p, 10, st.minute);
704         SSVAL(p, 12, st.second);
705         SSVAL(p, 14, st.millisecond);
706
707         *pp = p;
708         *plen = len;
709 }
710
711 /* Convert a notification message to a struct spoolss_Notify */
712
713 static void notify_one_value(struct spoolss_notify_msg *msg,
714                              struct spoolss_Notify *data,
715                              TALLOC_CTX *mem_ctx)
716 {
717         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, msg->notify.value[0]);
718 }
719
720 static void notify_string(struct spoolss_notify_msg *msg,
721                           struct spoolss_Notify *data,
722                           TALLOC_CTX *mem_ctx)
723 {
724         /* The length of the message includes the trailing \0 */
725
726         data->data.string.size = msg->len * 2;
727         data->data.string.string = talloc_strdup(mem_ctx, msg->notify.data);
728         if (!data->data.string.string) {
729                 data->data.string.size = 0;
730                 return;
731         }
732 }
733
734 static void notify_system_time(struct spoolss_notify_msg *msg,
735                                struct spoolss_Notify *data,
736                                TALLOC_CTX *mem_ctx)
737 {
738         data->data.string.string = NULL;
739         data->data.string.size = 0;
740
741         if (msg->len != sizeof(time_t)) {
742                 DEBUG(5, ("notify_system_time: received wrong sized message (%d)\n",
743                           msg->len));
744                 return;
745         }
746
747         init_systemtime_buffer(mem_ctx, gmtime((time_t *)msg->notify.data),
748                                &data->data.string.string,
749                                &data->data.string.size);
750 }
751
752 struct notify2_message_table {
753         const char *name;
754         void (*fn)(struct spoolss_notify_msg *msg,
755                    struct spoolss_Notify *data, TALLOC_CTX *mem_ctx);
756 };
757
758 static struct notify2_message_table printer_notify_table[] = {
759         /* 0x00 */ { "PRINTER_NOTIFY_FIELD_SERVER_NAME", notify_string },
760         /* 0x01 */ { "PRINTER_NOTIFY_FIELD_PRINTER_NAME", notify_string },
761         /* 0x02 */ { "PRINTER_NOTIFY_FIELD_SHARE_NAME", notify_string },
762         /* 0x03 */ { "PRINTER_NOTIFY_FIELD_PORT_NAME", notify_string },
763         /* 0x04 */ { "PRINTER_NOTIFY_FIELD_DRIVER_NAME", notify_string },
764         /* 0x05 */ { "PRINTER_NOTIFY_FIELD_COMMENT", notify_string },
765         /* 0x06 */ { "PRINTER_NOTIFY_FIELD_LOCATION", notify_string },
766         /* 0x07 */ { "PRINTER_NOTIFY_FIELD_DEVMODE", NULL },
767         /* 0x08 */ { "PRINTER_NOTIFY_FIELD_SEPFILE", notify_string },
768         /* 0x09 */ { "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR", notify_string },
769         /* 0x0a */ { "PRINTER_NOTIFY_FIELD_PARAMETERS", NULL },
770         /* 0x0b */ { "PRINTER_NOTIFY_FIELD_DATATYPE", notify_string },
771         /* 0x0c */ { "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
772         /* 0x0d */ { "PRINTER_NOTIFY_FIELD_ATTRIBUTES", notify_one_value },
773         /* 0x0e */ { "PRINTER_NOTIFY_FIELD_PRIORITY", notify_one_value },
774         /* 0x0f */ { "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY", NULL },
775         /* 0x10 */ { "PRINTER_NOTIFY_FIELD_START_TIME", NULL },
776         /* 0x11 */ { "PRINTER_NOTIFY_FIELD_UNTIL_TIME", NULL },
777         /* 0x12 */ { "PRINTER_NOTIFY_FIELD_STATUS", notify_one_value },
778 };
779
780 static struct notify2_message_table job_notify_table[] = {
781         /* 0x00 */ { "JOB_NOTIFY_FIELD_PRINTER_NAME", NULL },
782         /* 0x01 */ { "JOB_NOTIFY_FIELD_MACHINE_NAME", NULL },
783         /* 0x02 */ { "JOB_NOTIFY_FIELD_PORT_NAME", NULL },
784         /* 0x03 */ { "JOB_NOTIFY_FIELD_USER_NAME", notify_string },
785         /* 0x04 */ { "JOB_NOTIFY_FIELD_NOTIFY_NAME", NULL },
786         /* 0x05 */ { "JOB_NOTIFY_FIELD_DATATYPE", NULL },
787         /* 0x06 */ { "JOB_NOTIFY_FIELD_PRINT_PROCESSOR", NULL },
788         /* 0x07 */ { "JOB_NOTIFY_FIELD_PARAMETERS", NULL },
789         /* 0x08 */ { "JOB_NOTIFY_FIELD_DRIVER_NAME", NULL },
790         /* 0x09 */ { "JOB_NOTIFY_FIELD_DEVMODE", NULL },
791         /* 0x0a */ { "JOB_NOTIFY_FIELD_STATUS", notify_one_value },
792         /* 0x0b */ { "JOB_NOTIFY_FIELD_STATUS_STRING", NULL },
793         /* 0x0c */ { "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NULL },
794         /* 0x0d */ { "JOB_NOTIFY_FIELD_DOCUMENT", notify_string },
795         /* 0x0e */ { "JOB_NOTIFY_FIELD_PRIORITY", NULL },
796         /* 0x0f */ { "JOB_NOTIFY_FIELD_POSITION", NULL },
797         /* 0x10 */ { "JOB_NOTIFY_FIELD_SUBMITTED", notify_system_time },
798         /* 0x11 */ { "JOB_NOTIFY_FIELD_START_TIME", NULL },
799         /* 0x12 */ { "JOB_NOTIFY_FIELD_UNTIL_TIME", NULL },
800         /* 0x13 */ { "JOB_NOTIFY_FIELD_TIME", NULL },
801         /* 0x14 */ { "JOB_NOTIFY_FIELD_TOTAL_PAGES", notify_one_value },
802         /* 0x15 */ { "JOB_NOTIFY_FIELD_PAGES_PRINTED", NULL },
803         /* 0x16 */ { "JOB_NOTIFY_FIELD_TOTAL_BYTES", notify_one_value },
804         /* 0x17 */ { "JOB_NOTIFY_FIELD_BYTES_PRINTED", NULL },
805 };
806
807
808 /***********************************************************************
809  Allocate talloc context for container object
810  **********************************************************************/
811
812 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
813 {
814         if ( !ctr )
815                 return;
816
817         ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
818
819         return;
820 }
821
822 /***********************************************************************
823  release all allocated memory and zero out structure
824  **********************************************************************/
825
826 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
827 {
828         if ( !ctr )
829                 return;
830
831         if ( ctr->ctx )
832                 talloc_destroy(ctr->ctx);
833
834         ZERO_STRUCTP(ctr);
835
836         return;
837 }
838
839 /***********************************************************************
840  **********************************************************************/
841
842 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
843 {
844         if ( !ctr )
845                 return NULL;
846
847         return ctr->ctx;
848 }
849
850 /***********************************************************************
851  **********************************************************************/
852
853 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
854 {
855         if ( !ctr || !ctr->msg_groups )
856                 return NULL;
857
858         if ( idx >= ctr->num_groups )
859                 return NULL;
860
861         return &ctr->msg_groups[idx];
862
863 }
864
865 /***********************************************************************
866  How many groups of change messages do we have ?
867  **********************************************************************/
868
869 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
870 {
871         if ( !ctr )
872                 return 0;
873
874         return ctr->num_groups;
875 }
876
877 /***********************************************************************
878  Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
879  **********************************************************************/
880
881 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
882 {
883         SPOOLSS_NOTIFY_MSG_GROUP        *groups = NULL;
884         SPOOLSS_NOTIFY_MSG_GROUP        *msg_grp = NULL;
885         SPOOLSS_NOTIFY_MSG              *msg_list = NULL;
886         int                             i, new_slot;
887
888         if ( !ctr || !msg )
889                 return 0;
890
891         /* loop over all groups looking for a matching printer name */
892
893         for ( i=0; i<ctr->num_groups; i++ ) {
894                 if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
895                         break;
896         }
897
898         /* add a new group? */
899
900         if ( i == ctr->num_groups ) {
901                 ctr->num_groups++;
902
903                 if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
904                         DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
905                         return 0;
906                 }
907                 ctr->msg_groups = groups;
908
909                 /* clear the new entry and set the printer name */
910
911                 ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
912                 fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
913         }
914
915         /* add the change messages; 'i' is the correct index now regardless */
916
917         msg_grp = &ctr->msg_groups[i];
918
919         msg_grp->num_msgs++;
920
921         if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
922                 DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
923                 return 0;
924         }
925         msg_grp->msgs = msg_list;
926
927         new_slot = msg_grp->num_msgs-1;
928         memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
929
930         /* need to allocate own copy of data */
931
932         if ( msg->len != 0 )
933                 msg_grp->msgs[new_slot].notify.data = (char *)
934                         TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
935
936         return ctr->num_groups;
937 }
938
939 /***********************************************************************
940  Send a change notication message on all handles which have a call
941  back registered
942  **********************************************************************/
943
944 static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32_t idx )
945 {
946         Printer_entry            *p;
947         TALLOC_CTX               *mem_ctx = notify_ctr_getctx( ctr );
948         SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
949         SPOOLSS_NOTIFY_MSG       *messages;
950         int                      sending_msg_count;
951
952         if ( !msg_group ) {
953                 DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
954                 return;
955         }
956
957         messages = msg_group->msgs;
958
959         if ( !messages ) {
960                 DEBUG(5,("send_notify2_changes() called with no messages!\n"));
961                 return;
962         }
963
964         DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
965
966         /* loop over all printers */
967
968         for (p = printers_list; p; p = p->next) {
969                 struct spoolss_Notify *notifies;
970                 uint32_t count = 0;
971                 uint32_t id;
972                 int     i;
973
974                 /* Is there notification on this handle? */
975
976                 if ( !p->notify.client_connected )
977                         continue;
978
979                 DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
980
981                 /* For this printer?  Print servers always receive
982                    notifications. */
983
984                 if ( ( p->printer_type == SPLHND_PRINTER )  &&
985                     ( !strequal(msg_group->printername, p->sharename) ) )
986                         continue;
987
988                 DEBUG(10,("Our printer\n"));
989
990                 /* allocate the max entries possible */
991
992                 notifies = TALLOC_ZERO_ARRAY(mem_ctx, struct spoolss_Notify, msg_group->num_msgs);
993                 if (!notifies) {
994                         return;
995                 }
996
997                 /* build the array of change notifications */
998
999                 sending_msg_count = 0;
1000
1001                 for ( i=0; i<msg_group->num_msgs; i++ ) {
1002                         SPOOLSS_NOTIFY_MSG      *msg = &messages[i];
1003
1004                         /* Are we monitoring this event? */
1005
1006                         if (!is_monitoring_event(p, msg->type, msg->field))
1007                                 continue;
1008
1009                         sending_msg_count++;
1010
1011
1012                         DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
1013                                 msg->type, msg->field, p->sharename));
1014
1015                         /*
1016                          * if the is a printer notification handle and not a job notification
1017                          * type, then set the id to 0.  Other wise just use what was specified
1018                          * in the message.
1019                          *
1020                          * When registering change notification on a print server handle
1021                          * we always need to send back the id (snum) matching the printer
1022                          * for which the change took place.  For change notify registered
1023                          * on a printer handle, this does not matter and the id should be 0.
1024                          *
1025                          * --jerry
1026                          */
1027
1028                         if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
1029                                 id = 0;
1030                         else
1031                                 id = msg->id;
1032
1033
1034                         /* Convert unix jobid to smb jobid */
1035
1036                         if (msg->flags & SPOOLSS_NOTIFY_MSG_UNIX_JOBID) {
1037                                 id = sysjob_to_jobid(msg->id);
1038
1039                                 if (id == -1) {
1040                                         DEBUG(3, ("no such unix jobid %d\n", msg->id));
1041                                         goto done;
1042                                 }
1043                         }
1044
1045                         construct_info_data( &notifies[count], msg->type, msg->field, id );
1046
1047                         switch(msg->type) {
1048                         case PRINTER_NOTIFY_TYPE:
1049                                 if ( printer_notify_table[msg->field].fn )
1050                                         printer_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1051                                 break;
1052
1053                         case JOB_NOTIFY_TYPE:
1054                                 if ( job_notify_table[msg->field].fn )
1055                                         job_notify_table[msg->field].fn(msg, &notifies[count], mem_ctx);
1056                                 break;
1057
1058                         default:
1059                                 DEBUG(5, ("Unknown notification type %d\n", msg->type));
1060                                 goto done;
1061                         }
1062
1063                         count++;
1064                 }
1065
1066                 if ( sending_msg_count ) {
1067                         NTSTATUS status;
1068                         WERROR werr;
1069                         union spoolss_ReplyPrinterInfo info;
1070                         struct spoolss_NotifyInfo info0;
1071                         uint32_t reply_result;
1072
1073                         info0.version   = 0x2;
1074                         info0.flags     = count ? 0x00020000 /* ??? */ : PRINTER_NOTIFY_INFO_DISCARDED;
1075                         info0.count     = count;
1076                         info0.notifies  = notifies;
1077
1078                         info.info0 = &info0;
1079
1080                         status = rpccli_spoolss_RouterReplyPrinterEx(notify_cli_pipe, mem_ctx,
1081                                                                      &p->notify.client_hnd,
1082                                                                      p->notify.change, /* color */
1083                                                                      p->notify.flags,
1084                                                                      &reply_result,
1085                                                                      0, /* reply_type, must be 0 */
1086                                                                      info,
1087                                                                      &werr);
1088                         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
1089                                 DEBUG(1,("RouterReplyPrinterEx to client: %s failed: %s\n",
1090                                         notify_cli_pipe->srv_name_slash,
1091                                         win_errstr(werr)));
1092                         }
1093                         switch (reply_result) {
1094                                 case 0:
1095                                         break;
1096                                 case PRINTER_NOTIFY_INFO_DISCARDED:
1097                                 case PRINTER_NOTIFY_INFO_DISCARDNOTED:
1098                                 case PRINTER_NOTIFY_INFO_COLOR_MISMATCH:
1099                                         break;
1100                                 default:
1101                                         break;
1102                         }
1103                 }
1104         }
1105
1106 done:
1107         DEBUG(8,("send_notify2_changes: Exit...\n"));
1108         return;
1109 }
1110
1111 /***********************************************************************
1112  **********************************************************************/
1113
1114 static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
1115 {
1116
1117         uint32_t tv_sec, tv_usec;
1118         size_t offset = 0;
1119
1120         /* Unpack message */
1121
1122         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "f",
1123                              msg->printer);
1124
1125         offset += tdb_unpack((uint8_t *)buf + offset, len - offset, "ddddddd",
1126                                 &tv_sec, &tv_usec,
1127                                 &msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
1128
1129         if (msg->len == 0)
1130                 tdb_unpack((uint8_t *)buf + offset, len - offset, "dd",
1131                            &msg->notify.value[0], &msg->notify.value[1]);
1132         else
1133                 tdb_unpack((uint8_t *)buf + offset, len - offset, "B",
1134                            &msg->len, &msg->notify.data);
1135
1136         DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
1137                   msg->printer, (unsigned int)msg->id, msg->type, msg->field, msg->flags));
1138
1139         tv->tv_sec = tv_sec;
1140         tv->tv_usec = tv_usec;
1141
1142         if (msg->len == 0)
1143                 DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
1144                           msg->notify.value[1]));
1145         else
1146                 dump_data(3, (uint8_t *)msg->notify.data, msg->len);
1147
1148         return true;
1149 }
1150
1151 /********************************************************************
1152  Receive a notify2 message list
1153  ********************************************************************/
1154
1155 static void receive_notify2_message_list(struct messaging_context *msg,
1156                                          void *private_data,
1157                                          uint32_t msg_type,
1158                                          struct server_id server_id,
1159                                          DATA_BLOB *data)
1160 {
1161         size_t                  msg_count, i;
1162         char                    *buf = (char *)data->data;
1163         char                    *msg_ptr;
1164         size_t                  msg_len;
1165         SPOOLSS_NOTIFY_MSG      notify;
1166         SPOOLSS_NOTIFY_MSG_CTR  messages;
1167         int                     num_groups;
1168
1169         if (data->length < 4) {
1170                 DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
1171                 return;
1172         }
1173
1174         msg_count = IVAL(buf, 0);
1175         msg_ptr = buf + 4;
1176
1177         DEBUG(5, ("receive_notify2_message_list: got %lu messages in list\n", (unsigned long)msg_count));
1178
1179         if (msg_count == 0) {
1180                 DEBUG(0,("receive_notify2_message_list: bad message format (msg_count == 0) !\n"));
1181                 return;
1182         }
1183
1184         /* initialize the container */
1185
1186         ZERO_STRUCT( messages );
1187         notify_msg_ctr_init( &messages );
1188
1189         /*
1190          * build message groups for each printer identified
1191          * in a change_notify msg.  Remember that a PCN message
1192          * includes the handle returned for the srv_spoolss_replyopenprinter()
1193          * call.  Therefore messages are grouped according to printer handle.
1194          */
1195
1196         for ( i=0; i<msg_count; i++ ) {
1197                 struct timeval msg_tv;
1198
1199                 if (msg_ptr + 4 - buf > data->length) {
1200                         DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
1201                         return;
1202                 }
1203
1204                 msg_len = IVAL(msg_ptr,0);
1205                 msg_ptr += 4;
1206
1207                 if (msg_ptr + msg_len - buf > data->length) {
1208                         DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
1209                         return;
1210                 }
1211
1212                 /* unpack messages */
1213
1214                 ZERO_STRUCT( notify );
1215                 notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
1216                 msg_ptr += msg_len;
1217
1218                 /* add to correct list in container */
1219
1220                 notify_msg_ctr_addmsg( &messages, &notify );
1221
1222                 /* free memory that might have been allocated by notify2_unpack_msg() */
1223
1224                 if ( notify.len != 0 )
1225                         SAFE_FREE( notify.notify.data );
1226         }
1227
1228         /* process each group of messages */
1229
1230         num_groups = notify_msg_ctr_numgroups( &messages );
1231         for ( i=0; i<num_groups; i++ )
1232                 send_notify2_changes( &messages, i );
1233
1234
1235         /* cleanup */
1236
1237         DEBUG(10,("receive_notify2_message_list: processed %u messages\n",
1238                 (uint32_t)msg_count ));
1239
1240         notify_msg_ctr_destroy( &messages );
1241
1242         return;
1243 }
1244
1245 /********************************************************************
1246  Send a message to ourself about new driver being installed
1247  so we can upgrade the information for each printer bound to this
1248  driver
1249  ********************************************************************/
1250
1251 static bool srv_spoolss_drv_upgrade_printer(const char *drivername)
1252 {
1253         int len = strlen(drivername);
1254
1255         if (!len)
1256                 return false;
1257
1258         DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
1259                 drivername));
1260
1261         messaging_send_buf(smbd_messaging_context(), procid_self(),
1262                            MSG_PRINTER_DRVUPGRADE,
1263                            (uint8_t *)drivername, len+1);
1264
1265         return true;
1266 }
1267
1268 /**********************************************************************
1269  callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
1270  over all printers, upgrading ones as necessary
1271  **********************************************************************/
1272
1273 void do_drv_upgrade_printer(struct messaging_context *msg,
1274                             void *private_data,
1275                             uint32_t msg_type,
1276                             struct server_id server_id,
1277                             DATA_BLOB *data)
1278 {
1279         fstring drivername;
1280         int snum;
1281         int n_services = lp_numservices();
1282         size_t len;
1283
1284         len = MIN(data->length,sizeof(drivername)-1);
1285         strncpy(drivername, (const char *)data->data, len);
1286
1287         DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
1288
1289         /* Iterate the printer list */
1290
1291         for (snum=0; snum<n_services; snum++)
1292         {
1293                 if (lp_snum_ok(snum) && lp_print_ok(snum) )
1294                 {
1295                         WERROR result;
1296                         NT_PRINTER_INFO_LEVEL *printer = NULL;
1297
1298                         result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
1299                         if (!W_ERROR_IS_OK(result))
1300                                 continue;
1301
1302                         if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
1303                         {
1304                                 DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
1305
1306                                 /* all we care about currently is the change_id */
1307
1308                                 result = mod_a_printer(printer, 2);
1309                                 if (!W_ERROR_IS_OK(result)) {
1310                                         DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
1311                                                 win_errstr(result)));
1312                                 }
1313                         }
1314
1315                         free_a_printer(&printer, 2);
1316                 }
1317         }
1318
1319         /* all done */
1320 }
1321
1322 /********************************************************************
1323  Update the cache for all printq's with a registered client
1324  connection
1325  ********************************************************************/
1326
1327 void update_monitored_printq_cache( void )
1328 {
1329         Printer_entry *printer = printers_list;
1330         int snum;
1331
1332         /* loop through all printers and update the cache where
1333            client_connected == true */
1334         while ( printer )
1335         {
1336                 if ( (printer->printer_type == SPLHND_PRINTER)
1337                         && printer->notify.client_connected )
1338                 {
1339                         snum = print_queue_snum(printer->sharename);
1340                         print_queue_status( snum, NULL, NULL );
1341                 }
1342
1343                 printer = printer->next;
1344         }
1345
1346         return;
1347 }
1348 /********************************************************************
1349  Send a message to ourself about new driver being installed
1350  so we can upgrade the information for each printer bound to this
1351  driver
1352  ********************************************************************/
1353
1354 static bool srv_spoolss_reset_printerdata(char* drivername)
1355 {
1356         int len = strlen(drivername);
1357
1358         if (!len)
1359                 return false;
1360
1361         DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
1362                 drivername));
1363
1364         messaging_send_buf(smbd_messaging_context(), procid_self(),
1365                            MSG_PRINTERDATA_INIT_RESET,
1366                            (uint8_t *)drivername, len+1);
1367
1368         return true;
1369 }
1370
1371 /**********************************************************************
1372  callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
1373  over all printers, resetting printer data as neessary
1374  **********************************************************************/
1375
1376 void reset_all_printerdata(struct messaging_context *msg,
1377                            void *private_data,
1378                            uint32_t msg_type,
1379                            struct server_id server_id,
1380                            DATA_BLOB *data)
1381 {
1382         fstring drivername;
1383         int snum;
1384         int n_services = lp_numservices();
1385         size_t len;
1386
1387         len = MIN( data->length, sizeof(drivername)-1 );
1388         strncpy( drivername, (const char *)data->data, len );
1389
1390         DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
1391
1392         /* Iterate the printer list */
1393
1394         for ( snum=0; snum<n_services; snum++ )
1395         {
1396                 if ( lp_snum_ok(snum) && lp_print_ok(snum) )
1397                 {
1398                         WERROR result;
1399                         NT_PRINTER_INFO_LEVEL *printer = NULL;
1400
1401                         result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
1402                         if ( !W_ERROR_IS_OK(result) )
1403                                 continue;
1404
1405                         /*
1406                          * if the printer is bound to the driver,
1407                          * then reset to the new driver initdata
1408                          */
1409
1410                         if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
1411                         {
1412                                 DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
1413
1414                                 if ( !set_driver_init(printer, 2) ) {
1415                                         DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
1416                                                 printer->info_2->printername, printer->info_2->drivername));
1417                                 }
1418
1419                                 result = mod_a_printer( printer, 2 );
1420                                 if ( !W_ERROR_IS_OK(result) ) {
1421                                         DEBUG(3,("reset_all_printerdata: mod_a_printer() failed!  (%s)\n",
1422                                                 get_dos_error_msg(result)));
1423                                 }
1424                         }
1425
1426                         free_a_printer( &printer, 2 );
1427                 }
1428         }
1429
1430         /* all done */
1431
1432         return;
1433 }
1434
1435 /****************************************************************
1436  _spoolss_OpenPrinter
1437 ****************************************************************/
1438
1439 WERROR _spoolss_OpenPrinter(pipes_struct *p,
1440                             struct spoolss_OpenPrinter *r)
1441 {
1442         struct spoolss_OpenPrinterEx e;
1443         WERROR werr;
1444
1445         ZERO_STRUCT(e.in.userlevel);
1446
1447         e.in.printername        = r->in.printername;
1448         e.in.datatype           = r->in.datatype;
1449         e.in.devmode_ctr        = r->in.devmode_ctr;
1450         e.in.access_mask        = r->in.access_mask;
1451         e.in.level              = 0;
1452
1453         e.out.handle            = r->out.handle;
1454
1455         werr = _spoolss_OpenPrinterEx(p, &e);
1456
1457         if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
1458                 /* OpenPrinterEx returns this for a bad
1459                  * printer name. We must return WERR_INVALID_PRINTER_NAME
1460                  * instead.
1461                  */
1462                 werr = WERR_INVALID_PRINTER_NAME;
1463         }
1464
1465         return werr;
1466 }
1467
1468 /********************************************************************
1469  ********************************************************************/
1470
1471 bool convert_devicemode(const char *printername,
1472                         const struct spoolss_DeviceMode *devmode,
1473                         NT_DEVICEMODE **pp_nt_devmode)
1474 {
1475         NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
1476
1477         /*
1478          * Ensure nt_devmode is a valid pointer
1479          * as we will be overwriting it.
1480          */
1481
1482         if (nt_devmode == NULL) {
1483                 DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
1484                 if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
1485                         return false;
1486         }
1487
1488         rpcstr_push(nt_devmode->devicename, devmode->devicename, 31, 0);
1489         rpcstr_push(nt_devmode->formname, devmode->formname, 31, 0);
1490
1491         nt_devmode->specversion         = devmode->specversion;
1492         nt_devmode->driverversion       = devmode->driverversion;
1493         nt_devmode->size                = devmode->size;
1494         nt_devmode->fields              = devmode->fields;
1495         nt_devmode->orientation         = devmode->orientation;
1496         nt_devmode->papersize           = devmode->papersize;
1497         nt_devmode->paperlength         = devmode->paperlength;
1498         nt_devmode->paperwidth          = devmode->paperwidth;
1499         nt_devmode->scale               = devmode->scale;
1500         nt_devmode->copies              = devmode->copies;
1501         nt_devmode->defaultsource       = devmode->defaultsource;
1502         nt_devmode->printquality        = devmode->printquality;
1503         nt_devmode->color               = devmode->color;
1504         nt_devmode->duplex              = devmode->duplex;
1505         nt_devmode->yresolution         = devmode->yresolution;
1506         nt_devmode->ttoption            = devmode->ttoption;
1507         nt_devmode->collate             = devmode->collate;
1508
1509         nt_devmode->logpixels           = devmode->logpixels;
1510         nt_devmode->bitsperpel          = devmode->bitsperpel;
1511         nt_devmode->pelswidth           = devmode->pelswidth;
1512         nt_devmode->pelsheight          = devmode->pelsheight;
1513         nt_devmode->displayflags        = devmode->displayflags;
1514         nt_devmode->displayfrequency    = devmode->displayfrequency;
1515         nt_devmode->icmmethod           = devmode->icmmethod;
1516         nt_devmode->icmintent           = devmode->icmintent;
1517         nt_devmode->mediatype           = devmode->mediatype;
1518         nt_devmode->dithertype          = devmode->dithertype;
1519         nt_devmode->reserved1           = devmode->reserved1;
1520         nt_devmode->reserved2           = devmode->reserved2;
1521         nt_devmode->panningwidth        = devmode->panningwidth;
1522         nt_devmode->panningheight       = devmode->panningheight;
1523
1524         /*
1525          * Only change private and driverextra if the incoming devmode
1526          * has a new one. JRA.
1527          */
1528
1529         if ((devmode->__driverextra_length != 0) && (devmode->driverextra_data.data != NULL)) {
1530                 SAFE_FREE(nt_devmode->nt_dev_private);
1531                 nt_devmode->driverextra = devmode->__driverextra_length;
1532                 if((nt_devmode->nt_dev_private = SMB_MALLOC_ARRAY(uint8_t, nt_devmode->driverextra)) == NULL)
1533                         return false;
1534                 memcpy(nt_devmode->nt_dev_private, devmode->driverextra_data.data, nt_devmode->driverextra);
1535         }
1536
1537         *pp_nt_devmode = nt_devmode;
1538
1539         return true;
1540 }
1541
1542 /****************************************************************
1543  _spoolss_OpenPrinterEx
1544 ****************************************************************/
1545
1546 WERROR _spoolss_OpenPrinterEx(pipes_struct *p,
1547                               struct spoolss_OpenPrinterEx *r)
1548 {
1549         int snum;
1550         Printer_entry *Printer=NULL;
1551
1552         if (!r->in.printername) {
1553                 return WERR_INVALID_PARAM;
1554         }
1555
1556         /* some sanity check because you can open a printer or a print server */
1557         /* aka: \\server\printer or \\server */
1558
1559         DEBUGADD(3,("checking name: %s\n", r->in.printername));
1560
1561         if (!open_printer_hnd(p, r->out.handle, r->in.printername, 0)) {
1562                 ZERO_STRUCTP(r->out.handle);
1563                 return WERR_INVALID_PARAM;
1564         }
1565
1566         Printer = find_printer_index_by_hnd(p, r->out.handle);
1567         if ( !Printer ) {
1568                 DEBUG(0,("_spoolss_OpenPrinterEx: logic error.  Can't find printer "
1569                         "handle we created for printer %s\n", r->in.printername));
1570                 close_printer_handle(p, r->out.handle);
1571                 ZERO_STRUCTP(r->out.handle);
1572                 return WERR_INVALID_PARAM;
1573         }
1574
1575         /*
1576          * First case: the user is opening the print server:
1577          *
1578          * Disallow MS AddPrinterWizard if parameter disables it. A Win2k
1579          * client 1st tries an OpenPrinterEx with access==0, MUST be allowed.
1580          *
1581          * Then both Win2k and WinNT clients try an OpenPrinterEx with
1582          * SERVER_ALL_ACCESS, which we allow only if the user is root (uid=0)
1583          * or if the user is listed in the smb.conf printer admin parameter.
1584          *
1585          * Then they try OpenPrinterEx with SERVER_READ which we allow. This lets the
1586          * client view printer folder, but does not show the MSAPW.
1587          *
1588          * Note: this test needs code to check access rights here too. Jeremy
1589          * could you look at this?
1590          *
1591          * Second case: the user is opening a printer:
1592          * NT doesn't let us connect to a printer if the connecting user
1593          * doesn't have print permission.
1594          *
1595          * Third case: user is opening a Port Monitor
1596          * access checks same as opening a handle to the print server.
1597          */
1598
1599         switch (Printer->printer_type )
1600         {
1601         case SPLHND_SERVER:
1602         case SPLHND_PORTMON_TCP:
1603         case SPLHND_PORTMON_LOCAL:
1604                 /* Printserver handles use global struct... */
1605
1606                 snum = -1;
1607
1608                 /* Map standard access rights to object specific access rights */
1609
1610                 se_map_standard(&r->in.access_mask,
1611                                 &printserver_std_mapping);
1612
1613                 /* Deny any object specific bits that don't apply to print
1614                    servers (i.e printer and job specific bits) */
1615
1616                 r->in.access_mask &= SPECIFIC_RIGHTS_MASK;
1617
1618                 if (r->in.access_mask &
1619                     ~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
1620                         DEBUG(3, ("access DENIED for non-printserver bits\n"));
1621                         close_printer_handle(p, r->out.handle);
1622                         ZERO_STRUCTP(r->out.handle);
1623                         return WERR_ACCESS_DENIED;
1624                 }
1625
1626                 /* Allow admin access */
1627
1628                 if ( r->in.access_mask & SERVER_ACCESS_ADMINISTER )
1629                 {
1630                         SE_PRIV se_printop = SE_PRINT_OPERATOR;
1631
1632                         if (!lp_ms_add_printer_wizard()) {
1633                                 close_printer_handle(p, r->out.handle);
1634                                 ZERO_STRUCTP(r->out.handle);
1635                                 return WERR_ACCESS_DENIED;
1636                         }
1637
1638                         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
1639                            and not a printer admin, then fail */
1640
1641                         if ((p->server_info->utok.uid != 0) &&
1642                             !user_has_privileges(p->server_info->ptok,
1643                                                  &se_printop ) &&
1644                             !token_contains_name_in_list(
1645                                     uidtoname(p->server_info->utok.uid),
1646                                     NULL, NULL,
1647                                     p->server_info->ptok,
1648                                     lp_printer_admin(snum))) {
1649                                 close_printer_handle(p, r->out.handle);
1650                                 ZERO_STRUCTP(r->out.handle);
1651                                 return WERR_ACCESS_DENIED;
1652                         }
1653
1654                         r->in.access_mask = SERVER_ACCESS_ADMINISTER;
1655                 }
1656                 else
1657                 {
1658                         r->in.access_mask = SERVER_ACCESS_ENUMERATE;
1659                 }
1660
1661                 DEBUG(4,("Setting print server access = %s\n", (r->in.access_mask == SERVER_ACCESS_ADMINISTER)
1662                         ? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
1663
1664                 /* We fall through to return WERR_OK */
1665                 break;
1666
1667         case SPLHND_PRINTER:
1668                 /* NT doesn't let us connect to a printer if the connecting user
1669                    doesn't have print permission.  */
1670
1671                 if (!get_printer_snum(p, r->out.handle, &snum, NULL)) {
1672                         close_printer_handle(p, r->out.handle);
1673                         ZERO_STRUCTP(r->out.handle);
1674                         return WERR_BADFID;
1675                 }
1676
1677                 se_map_standard(&r->in.access_mask, &printer_std_mapping);
1678
1679                 /* map an empty access mask to the minimum access mask */
1680                 if (r->in.access_mask == 0x0)
1681                         r->in.access_mask = PRINTER_ACCESS_USE;
1682
1683                 /*
1684                  * If we are not serving the printer driver for this printer,
1685                  * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE.  This
1686                  * will keep NT clients happy  --jerry
1687                  */
1688
1689                 if (lp_use_client_driver(snum)
1690                         && (r->in.access_mask & PRINTER_ACCESS_ADMINISTER))
1691                 {
1692                         r->in.access_mask = PRINTER_ACCESS_USE;
1693                 }
1694
1695                 /* check smb.conf parameters and the the sec_desc */
1696
1697                 if ( !check_access(get_client_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
1698                         DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
1699                         ZERO_STRUCTP(r->out.handle);
1700                         return WERR_ACCESS_DENIED;
1701                 }
1702
1703                 if (!user_ok_token(uidtoname(p->server_info->utok.uid), NULL,
1704                                    p->server_info->ptok, snum) ||
1705                     !print_access_check(p->server_info, snum,
1706                                         r->in.access_mask)) {
1707                         DEBUG(3, ("access DENIED for printer open\n"));
1708                         close_printer_handle(p, r->out.handle);
1709                         ZERO_STRUCTP(r->out.handle);
1710                         return WERR_ACCESS_DENIED;
1711                 }
1712
1713                 if ((r->in.access_mask & SPECIFIC_RIGHTS_MASK)& ~(PRINTER_ACCESS_ADMINISTER|PRINTER_ACCESS_USE)) {
1714                         DEBUG(3, ("access DENIED for printer open - unknown bits\n"));
1715                         close_printer_handle(p, r->out.handle);
1716                         ZERO_STRUCTP(r->out.handle);
1717                         return WERR_ACCESS_DENIED;
1718                 }
1719
1720                 if (r->in.access_mask & PRINTER_ACCESS_ADMINISTER)
1721                         r->in.access_mask = PRINTER_ACCESS_ADMINISTER;
1722                 else
1723                         r->in.access_mask = PRINTER_ACCESS_USE;
1724
1725                 DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1726                         ? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
1727
1728                 break;
1729
1730         default:
1731                 /* sanity check to prevent programmer error */
1732                 ZERO_STRUCTP(r->out.handle);
1733                 return WERR_BADFID;
1734         }
1735
1736         Printer->access_granted = r->in.access_mask;
1737
1738         /*
1739          * If the client sent a devmode in the OpenPrinter() call, then
1740          * save it here in case we get a job submission on this handle
1741          */
1742
1743          if ((Printer->printer_type != SPLHND_SERVER) &&
1744              r->in.devmode_ctr.devmode) {
1745                 convert_devicemode(Printer->sharename,
1746                                    r->in.devmode_ctr.devmode,
1747                                    &Printer->nt_devmode);
1748          }
1749
1750 #if 0   /* JERRY -- I'm doubtful this is really effective */
1751         /* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
1752            optimization in Windows 2000 clients  --jerry */
1753
1754         if ( (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
1755                 && (RA_WIN2K == get_remote_arch()) )
1756         {
1757                 DEBUG(10,("_spoolss_OpenPrinterEx: Enabling LAN/WAN hack for Win2k clients.\n"));
1758                 sys_usleep( 500000 );
1759         }
1760 #endif
1761
1762         return WERR_OK;
1763 }
1764
1765 /****************************************************************************
1766 ****************************************************************************/
1767
1768 static bool printer_info2_to_nt_printer_info2(struct spoolss_SetPrinterInfo2 *r,
1769                                               NT_PRINTER_INFO_LEVEL_2 *d)
1770 {
1771         DEBUG(7,("printer_info2_to_nt_printer_info2\n"));
1772
1773         if (!r || !d) {
1774                 return false;
1775         }
1776
1777         d->attributes           = r->attributes;
1778         d->priority             = r->priority;
1779         d->default_priority     = r->defaultpriority;
1780         d->starttime            = r->starttime;
1781         d->untiltime            = r->untiltime;
1782         d->status               = r->status;
1783         d->cjobs                = r->cjobs;
1784
1785         fstrcpy(d->servername,  r->servername);
1786         fstrcpy(d->printername, r->printername);
1787         fstrcpy(d->sharename,   r->sharename);
1788         fstrcpy(d->portname,    r->portname);
1789         fstrcpy(d->drivername,  r->drivername);
1790         slprintf(d->comment, sizeof(d->comment)-1, "%s", r->comment);
1791         fstrcpy(d->location,    r->location);
1792         fstrcpy(d->sepfile,     r->sepfile);
1793         fstrcpy(d->printprocessor, r->printprocessor);
1794         fstrcpy(d->datatype,    r->datatype);
1795         fstrcpy(d->parameters,  r->parameters);
1796
1797         return true;
1798 }
1799
1800 /****************************************************************************
1801 ****************************************************************************/
1802
1803 static bool convert_printer_info(struct spoolss_SetPrinterInfoCtr *info_ctr,
1804                                  NT_PRINTER_INFO_LEVEL *printer)
1805 {
1806         bool ret;
1807
1808         switch (info_ctr->level) {
1809         case 2:
1810                 /* allocate memory if needed.  Messy because
1811                    convert_printer_info is used to update an existing
1812                    printer or build a new one */
1813
1814                 if (!printer->info_2) {
1815                         printer->info_2 = TALLOC_ZERO_P(printer, NT_PRINTER_INFO_LEVEL_2);
1816                         if (!printer->info_2) {
1817                                 DEBUG(0,("convert_printer_info: "
1818                                         "talloc() failed!\n"));
1819                                 return false;
1820                         }
1821                 }
1822
1823                 ret = printer_info2_to_nt_printer_info2(info_ctr->info.info2,
1824                                                         printer->info_2);
1825                 printer->info_2->setuptime = time(NULL);
1826                 return ret;
1827         }
1828
1829         return false;
1830 }
1831
1832 /*******************************************************************
1833 ********************************************************************/
1834
1835 static bool string_array_to_fstring_array(const char **sarray, fstring **farray)
1836 {
1837         int i;
1838
1839         if (!sarray) {
1840                 *farray = NULL;
1841                 return true;
1842         }
1843
1844         *farray = SMB_MALLOC_ARRAY(fstring, 1);
1845         if (!*farray) {
1846                 return false;
1847         }
1848
1849         for (i=0; sarray[i] != NULL; i++) {
1850                 *farray = SMB_REALLOC_ARRAY(*farray, fstring, i+2);
1851                 if (!*farray) {
1852                         return false;
1853                 }
1854                 fstrcpy((*farray)[i], sarray[i]);
1855         }
1856
1857         fstrcpy((*farray)[i], "");
1858
1859         return true;
1860 }
1861
1862 /*******************************************************************
1863 ********************************************************************/
1864
1865 static bool driver_info3_to_nt_driver_info3(struct spoolss_AddDriverInfo3 *r,
1866                                             NT_PRINTER_DRIVER_INFO_LEVEL_3 **p)
1867 {
1868         NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
1869
1870         DEBUG(7,("driver_info3_to_nt_driver_info3: Converting from UNICODE to ASCII\n"));
1871
1872         if (*p == NULL) {
1873                 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
1874                 if (*p == NULL) {
1875                         return false;
1876                 }
1877                 ZERO_STRUCTP(*p);
1878         }
1879
1880         d = *p;
1881
1882         d->cversion =                   r->version;
1883
1884         fstrcpy(d->name,                r->driver_name);
1885         fstrcpy(d->environment,         r->architecture);
1886         fstrcpy(d->driverpath,          r->driver_path);
1887         fstrcpy(d->datafile,            r->data_file);
1888         fstrcpy(d->configfile,          r->config_file);
1889         fstrcpy(d->helpfile,            r->help_file);
1890         fstrcpy(d->monitorname,         r->monitor_name);
1891         fstrcpy(d->defaultdatatype,     r->default_datatype);
1892
1893         DEBUGADD(8,( "version:         %d\n", d->cversion));
1894         DEBUGADD(8,( "name:            %s\n", d->name));
1895         DEBUGADD(8,( "environment:     %s\n", d->environment));
1896         DEBUGADD(8,( "driverpath:      %s\n", d->driverpath));
1897         DEBUGADD(8,( "datafile:        %s\n", d->datafile));
1898         DEBUGADD(8,( "configfile:      %s\n", d->configfile));
1899         DEBUGADD(8,( "helpfile:        %s\n", d->helpfile));
1900         DEBUGADD(8,( "monitorname:     %s\n", d->monitorname));
1901         DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1902
1903         if (r->dependent_files) {
1904                 if (!string_array_to_fstring_array(r->dependent_files->string,
1905                                                    &d->dependentfiles)) {
1906                         SAFE_FREE(*p);
1907                         return false;
1908                 }
1909         }
1910
1911         return true;
1912 }
1913
1914 /*******************************************************************
1915 ********************************************************************/
1916
1917 static bool driver_info6_to_nt_driver_info6(struct spoolss_AddDriverInfo6 *r,
1918                                             NT_PRINTER_DRIVER_INFO_LEVEL_6 **p)
1919 {
1920         NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
1921
1922         DEBUG(7,("driver_info6_to_nt_driver_info6: Converting from UNICODE to ASCII\n"));
1923
1924         if (*p == NULL) {
1925                 *p = SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
1926                 if (*p == NULL) {
1927                         return false;
1928                 }
1929                 ZERO_STRUCTP(*p);
1930         }
1931
1932         d = *p;
1933
1934         d->version =                    r->version;
1935
1936         fstrcpy(d->name,                r->driver_name);
1937         fstrcpy(d->environment,         r->architecture);
1938         fstrcpy(d->driverpath,          r->driver_path);
1939         fstrcpy(d->datafile,            r->data_file);
1940         fstrcpy(d->configfile,          r->config_file);
1941         fstrcpy(d->helpfile,            r->help_file);
1942         fstrcpy(d->monitorname,         r->monitor_name);
1943         fstrcpy(d->defaultdatatype,     r->default_datatype);
1944
1945         DEBUGADD(8,( "version:         %d\n", d->version));
1946         DEBUGADD(8,( "name:            %s\n", d->name));
1947         DEBUGADD(8,( "environment:     %s\n", d->environment));
1948         DEBUGADD(8,( "driverpath:      %s\n", d->driverpath));
1949         DEBUGADD(8,( "datafile:        %s\n", d->datafile));
1950         DEBUGADD(8,( "configfile:      %s\n", d->configfile));
1951         DEBUGADD(8,( "helpfile:        %s\n", d->helpfile));
1952         DEBUGADD(8,( "monitorname:     %s\n", d->monitorname));
1953         DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
1954
1955         if (r->dependent_files) {
1956                 if (!string_array_to_fstring_array(r->dependent_files->string,
1957                                                    &d->dependentfiles)) {
1958                         goto error;
1959                 }
1960         }
1961
1962         if (r->previous_names) {
1963                 if (!string_array_to_fstring_array(r->previous_names->string,
1964                                                    &d->previousnames)) {
1965                         goto error;
1966                 }
1967         }
1968
1969         return true;
1970
1971  error:
1972         SAFE_FREE(*p);
1973         return false;
1974 }
1975
1976 /********************************************************************
1977  ********************************************************************/
1978
1979 static bool convert_printer_driver_info(const struct spoolss_AddDriverInfoCtr *r,
1980                                         NT_PRINTER_DRIVER_INFO_LEVEL *printer,
1981                                         uint32_t level)
1982 {
1983         switch (level) {
1984         case 3:
1985                 printer->info_3 = NULL;
1986                 if (!driver_info3_to_nt_driver_info3(r->info.info3, &printer->info_3)) {
1987                         return false;
1988                 }
1989                 break;
1990         case 6:
1991                 printer->info_6 = NULL;
1992                 if (!driver_info6_to_nt_driver_info6(r->info.info6, &printer->info_6)) {
1993                         return false;
1994                 }
1995                 break;
1996         default:
1997                 return false;
1998         }
1999
2000         return true;
2001 }
2002
2003 /********************************************************************
2004  * _spoolss_enddocprinter_internal.
2005  ********************************************************************/
2006
2007 static WERROR _spoolss_enddocprinter_internal(pipes_struct *p,
2008                                               struct policy_handle *handle)
2009 {
2010         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
2011         int snum;
2012
2013         if (!Printer) {
2014                 DEBUG(2,("_spoolss_enddocprinter_internal: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
2015                 return WERR_BADFID;
2016         }
2017
2018         if (!get_printer_snum(p, handle, &snum, NULL))
2019                 return WERR_BADFID;
2020
2021         Printer->document_started = false;
2022         print_job_end(snum, Printer->jobid,NORMAL_CLOSE);
2023         /* error codes unhandled so far ... */
2024
2025         return WERR_OK;
2026 }
2027
2028 /****************************************************************
2029  _spoolss_ClosePrinter
2030 ****************************************************************/
2031
2032 WERROR _spoolss_ClosePrinter(pipes_struct *p,
2033                              struct spoolss_ClosePrinter *r)
2034 {
2035         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2036
2037         if (Printer && Printer->document_started)
2038                 _spoolss_enddocprinter_internal(p, r->in.handle);          /* print job was not closed */
2039
2040         if (!close_printer_handle(p, r->in.handle))
2041                 return WERR_BADFID;
2042
2043         /* clear the returned printer handle.  Observed behavior
2044            from Win2k server.  Don't think this really matters.
2045            Previous code just copied the value of the closed
2046            handle.    --jerry */
2047
2048         ZERO_STRUCTP(r->out.handle);
2049
2050         return WERR_OK;
2051 }
2052
2053 /****************************************************************
2054  _spoolss_DeletePrinter
2055 ****************************************************************/
2056
2057 WERROR _spoolss_DeletePrinter(pipes_struct *p,
2058                               struct spoolss_DeletePrinter *r)
2059 {
2060         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2061         WERROR result;
2062
2063         if (Printer && Printer->document_started)
2064                 _spoolss_enddocprinter_internal(p, r->in.handle);  /* print job was not closed */
2065
2066         result = delete_printer_handle(p, r->in.handle);
2067
2068         update_c_setprinter(false);
2069
2070         return result;
2071 }
2072
2073 /*******************************************************************
2074  * static function to lookup the version id corresponding to an
2075  * long architecture string
2076  ******************************************************************/
2077
2078 static int get_version_id(const char *arch)
2079 {
2080         int i;
2081         struct table_node archi_table[]= {
2082
2083                 {"Windows 4.0",          "WIN40",       0 },
2084                 {"Windows NT x86",       "W32X86",      2 },
2085                 {"Windows NT R4000",     "W32MIPS",     2 },
2086                 {"Windows NT Alpha_AXP", "W32ALPHA",    2 },
2087                 {"Windows NT PowerPC",   "W32PPC",      2 },
2088                 {"Windows IA64",         "IA64",        3 },
2089                 {"Windows x64",          "x64",         3 },
2090                 {NULL,                   "",            -1 }
2091         };
2092
2093         for (i=0; archi_table[i].long_archi != NULL; i++)
2094         {
2095                 if (strcmp(arch, archi_table[i].long_archi) == 0)
2096                         return (archi_table[i].version);
2097         }
2098
2099         return -1;
2100 }
2101
2102 /****************************************************************
2103  _spoolss_DeletePrinterDriver
2104 ****************************************************************/
2105
2106 WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
2107                                     struct spoolss_DeletePrinterDriver *r)
2108 {
2109         NT_PRINTER_DRIVER_INFO_LEVEL    info;
2110         NT_PRINTER_DRIVER_INFO_LEVEL    info_win2k;
2111         int                             version;
2112         WERROR                          status;
2113         WERROR                          status_win2k = WERR_ACCESS_DENIED;
2114         SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
2115
2116         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2117            and not a printer admin, then fail */
2118
2119         if ( (p->server_info->utok.uid != 0)
2120                 && !user_has_privileges(p->server_info->ptok, &se_printop )
2121                 && !token_contains_name_in_list(
2122                         uidtoname(p->server_info->utok.uid), NULL,
2123                         NULL, p->server_info->ptok,
2124                         lp_printer_admin(-1)) )
2125         {
2126                 return WERR_ACCESS_DENIED;
2127         }
2128
2129         /* check that we have a valid driver name first */
2130
2131         if ((version = get_version_id(r->in.architecture)) == -1)
2132                 return WERR_INVALID_ENVIRONMENT;
2133
2134         ZERO_STRUCT(info);
2135         ZERO_STRUCT(info_win2k);
2136
2137         if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2138                                                 r->in.architecture,
2139                                                 version)))
2140         {
2141                 /* try for Win2k driver if "Windows NT x86" */
2142
2143                 if ( version == 2 ) {
2144                         version = 3;
2145                         if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3,
2146                                                                 r->in.driver,
2147                                                                 r->in.architecture,
2148                                                                 version))) {
2149                                 status = WERR_UNKNOWN_PRINTER_DRIVER;
2150                                 goto done;
2151                         }
2152                 }
2153                 /* otherwise it was a failure */
2154                 else {
2155                         status = WERR_UNKNOWN_PRINTER_DRIVER;
2156                         goto done;
2157                 }
2158
2159         }
2160
2161         if (printer_driver_in_use(info.info_3)) {
2162                 status = WERR_PRINTER_DRIVER_IN_USE;
2163                 goto done;
2164         }
2165
2166         if ( version == 2 )
2167         {
2168                 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2169                                                        r->in.driver,
2170                                                        r->in.architecture, 3)))
2171                 {
2172                         /* if we get to here, we now have 2 driver info structures to remove */
2173                         /* remove the Win2k driver first*/
2174
2175                         status_win2k = delete_printer_driver(
2176                                 p, info_win2k.info_3, 3, false);
2177                         free_a_printer_driver( info_win2k, 3 );
2178
2179                         /* this should not have failed---if it did, report to client */
2180                         if ( !W_ERROR_IS_OK(status_win2k) )
2181                         {
2182                                 status = status_win2k;
2183                                 goto done;
2184                         }
2185                 }
2186         }
2187
2188         status = delete_printer_driver(p, info.info_3, version, false);
2189
2190         /* if at least one of the deletes succeeded return OK */
2191
2192         if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2193                 status = WERR_OK;
2194
2195 done:
2196         free_a_printer_driver( info, 3 );
2197
2198         return status;
2199 }
2200
2201 /****************************************************************
2202  _spoolss_DeletePrinterDriverEx
2203 ****************************************************************/
2204
2205 WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
2206                                       struct spoolss_DeletePrinterDriverEx *r)
2207 {
2208         NT_PRINTER_DRIVER_INFO_LEVEL    info;
2209         NT_PRINTER_DRIVER_INFO_LEVEL    info_win2k;
2210         int                             version;
2211         bool                            delete_files;
2212         WERROR                          status;
2213         WERROR                          status_win2k = WERR_ACCESS_DENIED;
2214         SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
2215
2216         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
2217            and not a printer admin, then fail */
2218
2219         if ( (p->server_info->utok.uid != 0)
2220                 && !user_has_privileges(p->server_info->ptok, &se_printop )
2221                 && !token_contains_name_in_list(
2222                         uidtoname(p->server_info->utok.uid), NULL, NULL,
2223                         p->server_info->ptok, lp_printer_admin(-1)) )
2224         {
2225                 return WERR_ACCESS_DENIED;
2226         }
2227
2228         /* check that we have a valid driver name first */
2229         if ((version = get_version_id(r->in.architecture)) == -1) {
2230                 /* this is what NT returns */
2231                 return WERR_INVALID_ENVIRONMENT;
2232         }
2233
2234         if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
2235                 version = r->in.version;
2236
2237         ZERO_STRUCT(info);
2238         ZERO_STRUCT(info_win2k);
2239
2240         status = get_a_printer_driver(&info, 3, r->in.driver,
2241                                       r->in.architecture, version);
2242
2243         if ( !W_ERROR_IS_OK(status) )
2244         {
2245                 /*
2246                  * if the client asked for a specific version,
2247                  * or this is something other than Windows NT x86,
2248                  * then we've failed
2249                  */
2250
2251                 if ( (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
2252                         goto done;
2253
2254                 /* try for Win2k driver if "Windows NT x86" */
2255
2256                 version = 3;
2257                 if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
2258                                                         r->in.architecture,
2259                                                         version))) {
2260                         status = WERR_UNKNOWN_PRINTER_DRIVER;
2261                         goto done;
2262                 }
2263         }
2264
2265         if ( printer_driver_in_use(info.info_3) ) {
2266                 status = WERR_PRINTER_DRIVER_IN_USE;
2267                 goto done;
2268         }
2269
2270         /*
2271          * we have a couple of cases to consider.
2272          * (1) Are any files in use?  If so and DPD_DELTE_ALL_FILE is set,
2273          *     then the delete should fail if **any** files overlap with
2274          *     other drivers
2275          * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
2276          *     non-overlapping files
2277          * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
2278          *     is set, the do not delete any files
2279          * Refer to MSDN docs on DeletePrinterDriverEx() for details.
2280          */
2281
2282         delete_files = r->in.delete_flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
2283
2284         /* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
2285
2286         if ( delete_files && printer_driver_files_in_use(info.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2287                 /* no idea of the correct error here */
2288                 status = WERR_ACCESS_DENIED;
2289                 goto done;
2290         }
2291
2292
2293         /* also check for W32X86/3 if necessary; maybe we already have? */
2294
2295         if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION)  ) {
2296                 if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
2297                                                        r->in.driver,
2298                                                        r->in.architecture, 3)))
2299                 {
2300
2301                         if ( delete_files && printer_driver_files_in_use(info_win2k.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
2302                                 /* no idea of the correct error here */
2303                                 free_a_printer_driver( info_win2k, 3 );
2304                                 status = WERR_ACCESS_DENIED;
2305                                 goto done;
2306                         }
2307
2308                         /* if we get to here, we now have 2 driver info structures to remove */
2309                         /* remove the Win2k driver first*/
2310
2311                         status_win2k = delete_printer_driver(
2312                                 p, info_win2k.info_3, 3, delete_files);
2313                         free_a_printer_driver( info_win2k, 3 );
2314
2315                         /* this should not have failed---if it did, report to client */
2316
2317                         if ( !W_ERROR_IS_OK(status_win2k) )
2318                                 goto done;
2319                 }
2320         }
2321
2322         status = delete_printer_driver(p, info.info_3, version, delete_files);
2323
2324         if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
2325                 status = WERR_OK;
2326 done:
2327         free_a_printer_driver( info, 3 );
2328
2329         return status;
2330 }
2331
2332
2333 /****************************************************************************
2334  Internal routine for removing printerdata
2335  ***************************************************************************/
2336
2337 static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value )
2338 {
2339         return delete_printer_data( printer->info_2, key, value );
2340 }
2341
2342 /****************************************************************************
2343  Internal routine for storing printerdata
2344  ***************************************************************************/
2345
2346 WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
2347                           const char *key, const char *value,
2348                           uint32_t type, uint8_t *data, int real_len)
2349 {
2350         /* the registry objects enforce uniqueness based on value name */
2351
2352         return add_printer_data( printer->info_2, key, value, type, data, real_len );
2353 }
2354
2355 /********************************************************************
2356  GetPrinterData on a printer server Handle.
2357 ********************************************************************/
2358
2359 static WERROR getprinterdata_printer_server(TALLOC_CTX *mem_ctx,
2360                                             const char *value,
2361                                             enum winreg_Type *type,
2362                                             union spoolss_PrinterData *data)
2363 {
2364         DEBUG(8,("getprinterdata_printer_server:%s\n", value));
2365
2366         if (!StrCaseCmp(value, "W3SvcInstalled")) {
2367                 *type = REG_DWORD;
2368                 data->value = 0x00;
2369                 return WERR_OK;
2370         }
2371
2372         if (!StrCaseCmp(value, "BeepEnabled")) {
2373                 *type = REG_DWORD;
2374                 data->value = 0x00;
2375                 return WERR_OK;
2376         }
2377
2378         if (!StrCaseCmp(value, "EventLog")) {
2379                 *type = REG_DWORD;
2380                 /* formally was 0x1b */
2381                 data->value = 0x00;
2382                 return WERR_OK;
2383         }
2384
2385         if (!StrCaseCmp(value, "NetPopup")) {
2386                 *type = REG_DWORD;
2387                 data->value = 0x00;
2388                 return WERR_OK;
2389         }
2390
2391         if (!StrCaseCmp(value, "MajorVersion")) {
2392                 *type = REG_DWORD;
2393
2394                 /* Windows NT 4.0 seems to not allow uploading of drivers
2395                    to a server that reports 0x3 as the MajorVersion.
2396                    need to investigate more how Win2k gets around this .
2397                    -- jerry */
2398
2399                 if (RA_WINNT == get_remote_arch()) {
2400                         data->value = 0x02;
2401                 } else {
2402                         data->value = 0x03;
2403                 }
2404
2405                 return WERR_OK;
2406         }
2407
2408         if (!StrCaseCmp(value, "MinorVersion")) {
2409                 *type = REG_DWORD;
2410                 data->value = 0x00;
2411                 return WERR_OK;
2412         }
2413
2414         /* REG_BINARY
2415          *  uint32_t size        = 0x114
2416          *  uint32_t major       = 5
2417          *  uint32_t minor       = [0|1]
2418          *  uint32_t build       = [2195|2600]
2419          *  extra unicode string = e.g. "Service Pack 3"
2420          */
2421         if (!StrCaseCmp(value, "OSVersion")) {
2422                 DATA_BLOB blob;
2423                 enum ndr_err_code ndr_err;
2424                 struct spoolss_OSVersion os;
2425
2426                 os.major                = 5;    /* Windows 2000 == 5.0 */
2427                 os.minor                = 0;
2428                 os.build                = 2195; /* build */
2429                 os.extra_string         = "";   /* leave extra string empty */
2430
2431                 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &os,
2432                         (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
2433                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2434                         return WERR_GENERAL_FAILURE;
2435                 }
2436
2437                 *type = REG_BINARY;
2438                 data->binary = blob;
2439
2440                 return WERR_OK;
2441         }
2442
2443
2444         if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
2445                 *type = REG_SZ;
2446
2447                 data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
2448                 W_ERROR_HAVE_NO_MEMORY(data->string);
2449
2450                 return WERR_OK;
2451         }
2452
2453         if (!StrCaseCmp(value, "Architecture")) {
2454                 *type = REG_SZ;
2455
2456                 data->string = talloc_strdup(mem_ctx, "Windows NT x86");
2457                 W_ERROR_HAVE_NO_MEMORY(data->string);
2458
2459                 return WERR_OK;
2460         }
2461
2462         if (!StrCaseCmp(value, "DsPresent")) {
2463                 *type = REG_DWORD;
2464
2465                 /* only show the publish check box if we are a
2466                    member of a AD domain */
2467
2468                 if (lp_security() == SEC_ADS) {
2469                         data->value = 0x01;
2470                 } else {
2471                         data->value = 0x00;
2472                 }
2473                 return WERR_OK;
2474         }
2475
2476         if (!StrCaseCmp(value, "DNSMachineName")) {
2477                 const char *hostname = get_mydnsfullname();
2478
2479                 if (!hostname) {
2480                         return WERR_BADFILE;
2481                 }
2482
2483                 *type = REG_SZ;
2484                 data->string = talloc_strdup(mem_ctx, hostname);
2485                 W_ERROR_HAVE_NO_MEMORY(data->string);
2486
2487                 return WERR_OK;
2488         }
2489
2490         return WERR_INVALID_PARAM;
2491 }
2492
2493 /****************************************************************
2494  _spoolss_GetPrinterData
2495 ****************************************************************/
2496
2497 WERROR _spoolss_GetPrinterData(pipes_struct *p,
2498                                struct spoolss_GetPrinterData *r)
2499 {
2500         WERROR result;
2501         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2502         NT_PRINTER_INFO_LEVEL *printer = NULL;
2503         int snum = 0;
2504
2505         /*
2506          * Reminder: when it's a string, the length is in BYTES
2507          * even if UNICODE is negociated.
2508          *
2509          * JFM, 4/19/1999
2510          */
2511
2512         /* in case of problem, return some default values */
2513
2514         *r->out.needed  = 0;
2515         *r->out.type    = 0;
2516
2517         DEBUG(4,("_spoolss_GetPrinterData\n"));
2518
2519         if (!Printer) {
2520                 DEBUG(2,("_spoolss_GetPrinterData: Invalid handle (%s:%u:%u).\n",
2521                         OUR_HANDLE(r->in.handle)));
2522                 result = WERR_BADFID;
2523                 goto done;
2524         }
2525
2526         if (Printer->printer_type == SPLHND_SERVER) {
2527                 result = getprinterdata_printer_server(p->mem_ctx,
2528                                                        r->in.value_name,
2529                                                        r->out.type,
2530                                                        r->out.data);
2531         } else {
2532                 if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
2533                         result = WERR_BADFID;
2534                         goto done;
2535                 }
2536
2537                 result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
2538                 if (!W_ERROR_IS_OK(result)) {
2539                         goto done;
2540                 }
2541
2542                 /* XP sends this and wants to change id value from the PRINTER_INFO_0 */
2543
2544                 if (strequal(r->in.value_name, "ChangeId")) {
2545                         *r->out.type = REG_DWORD;
2546                         r->out.data->value = printer->info_2->changeid;
2547                         result = WERR_OK;
2548                 } else {
2549                         REGISTRY_VALUE *v;
2550                         DATA_BLOB blob;
2551
2552                         v = get_printer_data(printer->info_2,
2553                                              SPOOL_PRINTERDATA_KEY,
2554                                              r->in.value_name);
2555                         if (!v) {
2556                                 result = WERR_BADFILE;
2557                                 goto done;
2558                         }
2559
2560                         *r->out.type = v->type;
2561
2562                         blob = data_blob_const(v->data_p, v->size);
2563
2564                         result = pull_spoolss_PrinterData(p->mem_ctx, &blob,
2565                                                           r->out.data,
2566                                                           *r->out.type);
2567                 }
2568         }
2569
2570  done:
2571         /* cleanup & exit */
2572
2573         if (printer) {
2574                 free_a_printer(&printer, 2);
2575         }
2576
2577         if (!W_ERROR_IS_OK(result)) {
2578                 return result;
2579         }
2580
2581         *r->out.needed  = ndr_size_spoolss_PrinterData(r->out.data, *r->out.type, NULL, 0);
2582         *r->out.type    = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
2583         r->out.data     = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
2584
2585         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
2586 }
2587
2588 /*********************************************************
2589  Connect to the client machine.
2590 **********************************************************/
2591
2592 static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
2593                         struct sockaddr_storage *client_ss, const char *remote_machine)
2594 {
2595         NTSTATUS ret;
2596         struct cli_state *the_cli;
2597         struct sockaddr_storage rm_addr;
2598
2599         if ( is_zero_addr((struct sockaddr *)client_ss) ) {
2600                 if ( !resolve_name( remote_machine, &rm_addr, 0x20) ) {
2601                         DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
2602                         return false;
2603                 }
2604
2605                 if (ismyaddr((struct sockaddr *)&rm_addr)) {
2606                         DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
2607                         return false;
2608                 }
2609         } else {
2610                 char addr[INET6_ADDRSTRLEN];
2611                 rm_addr = *client_ss;
2612                 print_sockaddr(addr, sizeof(addr), &rm_addr);
2613                 DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
2614                         addr));
2615         }
2616
2617         /* setup the connection */
2618
2619         ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
2620                 &rm_addr, 0, "IPC$", "IPC",
2621                 "", /* username */
2622                 "", /* domain */
2623                 "", /* password */
2624                 0, lp_client_signing(), NULL );
2625
2626         if ( !NT_STATUS_IS_OK( ret ) ) {
2627                 DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
2628                         remote_machine ));
2629                 return false;
2630         }
2631
2632         if ( the_cli->protocol != PROTOCOL_NT1 ) {
2633                 DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
2634                 cli_shutdown(the_cli);
2635                 return false;
2636         }
2637
2638         /*
2639          * Ok - we have an anonymous connection to the IPC$ share.
2640          * Now start the NT Domain stuff :-).
2641          */
2642
2643         ret = cli_rpc_pipe_open_noauth(the_cli, &ndr_table_spoolss.syntax_id, pp_pipe);
2644         if (!NT_STATUS_IS_OK(ret)) {
2645                 DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
2646                         remote_machine, nt_errstr(ret)));
2647                 cli_shutdown(the_cli);
2648                 return false;
2649         }
2650
2651         return true;
2652 }
2653
2654 /***************************************************************************
2655  Connect to the client.
2656 ****************************************************************************/
2657
2658 static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
2659                                         uint32_t localprinter, uint32_t type,
2660                                         struct policy_handle *handle,
2661                                         struct sockaddr_storage *client_ss)
2662 {
2663         WERROR result;
2664         NTSTATUS status;
2665
2666         /*
2667          * If it's the first connection, contact the client
2668          * and connect to the IPC$ share anonymously
2669          */
2670         if (smb_connections==0) {
2671                 fstring unix_printer;
2672
2673                 fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
2674
2675                 if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
2676                         return false;
2677
2678                 messaging_register(smbd_messaging_context(), NULL,
2679                                    MSG_PRINTER_NOTIFY2,
2680                                    receive_notify2_message_list);
2681                 /* Tell the connections db we're now interested in printer
2682                  * notify messages. */
2683                 register_message_flags(true, FLAG_MSG_PRINT_NOTIFY);
2684         }
2685
2686         /*
2687          * Tell the specific printing tdb we want messages for this printer
2688          * by registering our PID.
2689          */
2690
2691         if (!print_notify_register_pid(snum))
2692                 DEBUG(0,("print_notify_register_pid: Failed to register our pid for printer %s\n", printer ));
2693
2694         smb_connections++;
2695
2696         status = rpccli_spoolss_ReplyOpenPrinter(notify_cli_pipe, talloc_tos(),
2697                                                  printer,
2698                                                  localprinter,
2699                                                  type,
2700                                                  0,
2701                                                  NULL,
2702                                                  handle,
2703                                                  &result);
2704         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result))
2705                 DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
2706                         win_errstr(result)));
2707
2708         return (W_ERROR_IS_OK(result));
2709 }
2710
2711 /****************************************************************
2712  ****************************************************************/
2713
2714 static struct spoolss_NotifyOption *dup_spoolss_NotifyOption(TALLOC_CTX *mem_ctx,
2715                                                              const struct spoolss_NotifyOption *r)
2716 {
2717         struct spoolss_NotifyOption *option;
2718         uint32_t i,k;
2719
2720         if (!r) {
2721                 return NULL;
2722         }
2723
2724         option = talloc_zero(mem_ctx, struct spoolss_NotifyOption);
2725         if (!option) {
2726                 return NULL;
2727         }
2728
2729         *option = *r;
2730
2731         if (!option->count) {
2732                 return option;
2733         }
2734
2735         option->types = talloc_zero_array(option,
2736                 struct spoolss_NotifyOptionType, option->count);
2737         if (!option->types) {
2738                 talloc_free(option);
2739                 return NULL;
2740         }
2741
2742         for (i=0; i < option->count; i++) {
2743                 option->types[i] = r->types[i];
2744
2745                 if (option->types[i].count) {
2746                         option->types[i].fields = talloc_zero_array(option,
2747                                 union spoolss_Field, option->types[i].count);
2748                         if (!option->types[i].fields) {
2749                                 talloc_free(option);
2750                                 return NULL;
2751                         }
2752                         for (k=0; k<option->types[i].count; k++) {
2753                                 option->types[i].fields[k] =
2754                                         r->types[i].fields[k];
2755                         }
2756                 }
2757         }
2758
2759         return option;
2760 }
2761
2762 /****************************************************************
2763  * _spoolss_RemoteFindFirstPrinterChangeNotifyEx
2764  *
2765  * before replying OK: status=0 a rpc call is made to the workstation
2766  * asking ReplyOpenPrinter
2767  *
2768  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
2769  * called from api_spoolss_rffpcnex
2770 ****************************************************************/
2771
2772 WERROR _spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p,
2773                                                      struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
2774 {
2775         int snum = -1;
2776         struct spoolss_NotifyOption *option = r->in.notify_options;
2777         struct sockaddr_storage client_ss;
2778
2779         /* store the notify value in the printer struct */
2780
2781         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
2782
2783         if (!Printer) {
2784                 DEBUG(2,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
2785                         "Invalid handle (%s:%u:%u).\n",
2786                         OUR_HANDLE(r->in.handle)));
2787                 return WERR_BADFID;
2788         }
2789
2790         Printer->notify.flags           = r->in.flags;
2791         Printer->notify.options         = r->in.options;
2792         Printer->notify.printerlocal    = r->in.printer_local;
2793
2794         TALLOC_FREE(Printer->notify.option);
2795         Printer->notify.option = dup_spoolss_NotifyOption(Printer, option);
2796
2797         fstrcpy(Printer->notify.localmachine, r->in.local_machine);
2798
2799         /* Connect to the client machine and send a ReplyOpenPrinter */
2800
2801         if ( Printer->printer_type == SPLHND_SERVER)
2802                 snum = -1;
2803         else if ( (Printer->printer_type == SPLHND_PRINTER) &&
2804                         !get_printer_snum(p, r->in.handle, &snum, NULL) )
2805                 return WERR_BADFID;
2806
2807         if (!interpret_string_addr(&client_ss, p->client_address,
2808                                    AI_NUMERICHOST)) {
2809                 return WERR_SERVER_UNAVAILABLE;
2810         }
2811
2812         if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
2813                                         Printer->notify.printerlocal, 1,
2814                                         &Printer->notify.client_hnd, &client_ss))
2815                 return WERR_SERVER_UNAVAILABLE;
2816
2817         Printer->notify.client_connected = true;
2818
2819         return WERR_OK;
2820 }
2821
2822 /*******************************************************************
2823  * fill a notify_info_data with the servername
2824  ********************************************************************/
2825
2826 void spoolss_notify_server_name(int snum,
2827                                        struct spoolss_Notify *data,
2828                                        print_queue_struct *queue,
2829                                        NT_PRINTER_INFO_LEVEL *printer,
2830                                        TALLOC_CTX *mem_ctx)
2831 {
2832         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->servername);
2833 }
2834
2835 /*******************************************************************
2836  * fill a notify_info_data with the printername (not including the servername).
2837  ********************************************************************/
2838
2839 void spoolss_notify_printer_name(int snum,
2840                                         struct spoolss_Notify *data,
2841                                         print_queue_struct *queue,
2842                                         NT_PRINTER_INFO_LEVEL *printer,
2843                                         TALLOC_CTX *mem_ctx)
2844 {
2845         /* the notify name should not contain the \\server\ part */
2846         char *p = strrchr(printer->info_2->printername, '\\');
2847
2848         if (!p) {
2849                 p = printer->info_2->printername;
2850         } else {
2851                 p++;
2852         }
2853
2854         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
2855 }
2856
2857 /*******************************************************************
2858  * fill a notify_info_data with the servicename
2859  ********************************************************************/
2860
2861 void spoolss_notify_share_name(int snum,
2862                                       struct spoolss_Notify *data,
2863                                       print_queue_struct *queue,
2864                                       NT_PRINTER_INFO_LEVEL *printer,
2865                                       TALLOC_CTX *mem_ctx)
2866 {
2867         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(snum));
2868 }
2869
2870 /*******************************************************************
2871  * fill a notify_info_data with the port name
2872  ********************************************************************/
2873
2874 void spoolss_notify_port_name(int snum,
2875                                      struct spoolss_Notify *data,
2876                                      print_queue_struct *queue,
2877                                      NT_PRINTER_INFO_LEVEL *printer,
2878                                      TALLOC_CTX *mem_ctx)
2879 {
2880         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->portname);
2881 }
2882
2883 /*******************************************************************
2884  * fill a notify_info_data with the printername
2885  * but it doesn't exist, have to see what to do
2886  ********************************************************************/
2887
2888 void spoolss_notify_driver_name(int snum,
2889                                        struct spoolss_Notify *data,
2890                                        print_queue_struct *queue,
2891                                        NT_PRINTER_INFO_LEVEL *printer,
2892                                        TALLOC_CTX *mem_ctx)
2893 {
2894         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->drivername);
2895 }
2896
2897 /*******************************************************************
2898  * fill a notify_info_data with the comment
2899  ********************************************************************/
2900
2901 void spoolss_notify_comment(int snum,
2902                                    struct spoolss_Notify *data,
2903                                    print_queue_struct *queue,
2904                                    NT_PRINTER_INFO_LEVEL *printer,
2905                                    TALLOC_CTX *mem_ctx)
2906 {
2907         char *p;
2908
2909         if (*printer->info_2->comment == '\0') {
2910                 p = lp_comment(snum);
2911         } else {
2912                 p = printer->info_2->comment;
2913         }
2914
2915         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->comment);
2916 }
2917
2918 /*******************************************************************
2919  * fill a notify_info_data with the comment
2920  * location = "Room 1, floor 2, building 3"
2921  ********************************************************************/
2922
2923 void spoolss_notify_location(int snum,
2924                                     struct spoolss_Notify *data,
2925                                     print_queue_struct *queue,
2926                                     NT_PRINTER_INFO_LEVEL *printer,
2927                                     TALLOC_CTX *mem_ctx)
2928 {
2929         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->location);
2930 }
2931
2932 /*******************************************************************
2933  * fill a notify_info_data with the device mode
2934  * jfm:xxxx don't to it for know but that's a real problem !!!
2935  ********************************************************************/
2936
2937 static void spoolss_notify_devmode(int snum,
2938                                    struct spoolss_Notify *data,
2939                                    print_queue_struct *queue,
2940                                    NT_PRINTER_INFO_LEVEL *printer,
2941                                    TALLOC_CTX *mem_ctx)
2942 {
2943         /* for a dummy implementation we have to zero the fields */
2944         SETUP_SPOOLSS_NOTIFY_DATA_DEVMODE(data, NULL);
2945 }
2946
2947 /*******************************************************************
2948  * fill a notify_info_data with the separator file name
2949  ********************************************************************/
2950
2951 void spoolss_notify_sepfile(int snum,
2952                                    struct spoolss_Notify *data,
2953                                    print_queue_struct *queue,
2954                                    NT_PRINTER_INFO_LEVEL *printer,
2955                                    TALLOC_CTX *mem_ctx)
2956 {
2957         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->sepfile);
2958 }
2959
2960 /*******************************************************************
2961  * fill a notify_info_data with the print processor
2962  * jfm:xxxx return always winprint to indicate we don't do anything to it
2963  ********************************************************************/
2964
2965 void spoolss_notify_print_processor(int snum,
2966                                            struct spoolss_Notify *data,
2967                                            print_queue_struct *queue,
2968                                            NT_PRINTER_INFO_LEVEL *printer,
2969                                            TALLOC_CTX *mem_ctx)
2970 {
2971         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->printprocessor);
2972 }
2973
2974 /*******************************************************************
2975  * fill a notify_info_data with the print processor options
2976  * jfm:xxxx send an empty string
2977  ********************************************************************/
2978
2979 void spoolss_notify_parameters(int snum,
2980                                       struct spoolss_Notify *data,
2981                                       print_queue_struct *queue,
2982                                       NT_PRINTER_INFO_LEVEL *printer,
2983                                       TALLOC_CTX *mem_ctx)
2984 {
2985         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->parameters);
2986 }
2987
2988 /*******************************************************************
2989  * fill a notify_info_data with the data type
2990  * jfm:xxxx always send RAW as data type
2991  ********************************************************************/
2992
2993 void spoolss_notify_datatype(int snum,
2994                                     struct spoolss_Notify *data,
2995                                     print_queue_struct *queue,
2996                                     NT_PRINTER_INFO_LEVEL *printer,
2997                                     TALLOC_CTX *mem_ctx)
2998 {
2999         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, printer->info_2->datatype);
3000 }
3001
3002 /*******************************************************************
3003  * fill a notify_info_data with the security descriptor
3004  * jfm:xxxx send an null pointer to say no security desc
3005  * have to implement security before !
3006  ********************************************************************/
3007
3008 static void spoolss_notify_security_desc(int snum,
3009                                          struct spoolss_Notify *data,
3010                                          print_queue_struct *queue,
3011                                          NT_PRINTER_INFO_LEVEL *printer,
3012                                          TALLOC_CTX *mem_ctx)
3013 {
3014         SETUP_SPOOLSS_NOTIFY_DATA_SECDESC(data,
3015                                           printer->info_2->secdesc_buf->sd_size,
3016                                           printer->info_2->secdesc_buf->sd);
3017 }
3018
3019 /*******************************************************************
3020  * fill a notify_info_data with the attributes
3021  * jfm:xxxx a samba printer is always shared
3022  ********************************************************************/
3023
3024 void spoolss_notify_attributes(int snum,
3025                                       struct spoolss_Notify *data,
3026                                       print_queue_struct *queue,
3027                                       NT_PRINTER_INFO_LEVEL *printer,
3028                                       TALLOC_CTX *mem_ctx)
3029 {
3030         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->attributes);
3031 }
3032
3033 /*******************************************************************
3034  * fill a notify_info_data with the priority
3035  ********************************************************************/
3036
3037 static void spoolss_notify_priority(int snum,
3038                                     struct spoolss_Notify *data,
3039                                     print_queue_struct *queue,
3040                                     NT_PRINTER_INFO_LEVEL *printer,
3041                                     TALLOC_CTX *mem_ctx)
3042 {
3043         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->priority);
3044 }
3045
3046 /*******************************************************************
3047  * fill a notify_info_data with the default priority
3048  ********************************************************************/
3049
3050 static void spoolss_notify_default_priority(int snum,
3051                                             struct spoolss_Notify *data,
3052                                             print_queue_struct *queue,
3053                                             NT_PRINTER_INFO_LEVEL *printer,
3054                                             TALLOC_CTX *mem_ctx)
3055 {
3056         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->default_priority);
3057 }
3058
3059 /*******************************************************************
3060  * fill a notify_info_data with the start time
3061  ********************************************************************/
3062
3063 static void spoolss_notify_start_time(int snum,
3064                                       struct spoolss_Notify *data,
3065                                       print_queue_struct *queue,
3066                                       NT_PRINTER_INFO_LEVEL *printer,
3067                                       TALLOC_CTX *mem_ctx)
3068 {
3069         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->starttime);
3070 }
3071
3072 /*******************************************************************
3073  * fill a notify_info_data with the until time
3074  ********************************************************************/
3075
3076 static void spoolss_notify_until_time(int snum,
3077                                       struct spoolss_Notify *data,
3078                                       print_queue_struct *queue,
3079                                       NT_PRINTER_INFO_LEVEL *printer,
3080                                       TALLOC_CTX *mem_ctx)
3081 {
3082         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->untiltime);
3083 }
3084
3085 /*******************************************************************
3086  * fill a notify_info_data with the status
3087  ********************************************************************/
3088
3089 static void spoolss_notify_status(int snum,
3090                                   struct spoolss_Notify *data,
3091                                   print_queue_struct *queue,
3092                                   NT_PRINTER_INFO_LEVEL *printer,
3093                                   TALLOC_CTX *mem_ctx)
3094 {
3095         print_status_struct status;
3096
3097         print_queue_length(snum, &status);
3098         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, status.status);
3099 }
3100
3101 /*******************************************************************
3102  * fill a notify_info_data with the number of jobs queued
3103  ********************************************************************/
3104
3105 void spoolss_notify_cjobs(int snum,
3106                                  struct spoolss_Notify *data,
3107                                  print_queue_struct *queue,
3108                                  NT_PRINTER_INFO_LEVEL *printer,
3109                                  TALLOC_CTX *mem_ctx)
3110 {
3111         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, print_queue_length(snum, NULL));
3112 }
3113
3114 /*******************************************************************
3115  * fill a notify_info_data with the average ppm
3116  ********************************************************************/
3117
3118 static void spoolss_notify_average_ppm(int snum,
3119                                        struct spoolss_Notify *data,
3120                                        print_queue_struct *queue,
3121                                        NT_PRINTER_INFO_LEVEL *printer,
3122                                        TALLOC_CTX *mem_ctx)
3123 {
3124         /* always respond 8 pages per minutes */
3125         /* a little hard ! */
3126         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, printer->info_2->averageppm);
3127 }
3128
3129 /*******************************************************************
3130  * fill a notify_info_data with username
3131  ********************************************************************/
3132
3133 static void spoolss_notify_username(int snum,
3134                                     struct spoolss_Notify *data,
3135                                     print_queue_struct *queue,
3136                                     NT_PRINTER_INFO_LEVEL *printer,
3137                                     TALLOC_CTX *mem_ctx)
3138 {
3139         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_user);
3140 }
3141
3142 /*******************************************************************
3143  * fill a notify_info_data with job status
3144  ********************************************************************/
3145
3146 static void spoolss_notify_job_status(int snum,
3147                                       struct spoolss_Notify *data,
3148                                       print_queue_struct *queue,
3149                                       NT_PRINTER_INFO_LEVEL *printer,
3150                                       TALLOC_CTX *mem_ctx)
3151 {
3152         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, nt_printj_status(queue->status));
3153 }
3154
3155 /*******************************************************************
3156  * fill a notify_info_data with job name
3157  ********************************************************************/
3158
3159 static void spoolss_notify_job_name(int snum,
3160                                     struct spoolss_Notify *data,
3161                                     print_queue_struct *queue,
3162                                     NT_PRINTER_INFO_LEVEL *printer,
3163                                     TALLOC_CTX *mem_ctx)
3164 {
3165         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, queue->fs_file);
3166 }
3167
3168 /*******************************************************************
3169  * fill a notify_info_data with job status
3170  ********************************************************************/
3171
3172 static void spoolss_notify_job_status_string(int snum,
3173                                              struct spoolss_Notify *data,
3174                                              print_queue_struct *queue,
3175                                              NT_PRINTER_INFO_LEVEL *printer,
3176                                              TALLOC_CTX *mem_ctx)
3177 {
3178         /*
3179          * Now we're returning job status codes we just return a "" here. JRA.
3180          */
3181
3182         const char *p = "";
3183
3184 #if 0 /* NO LONGER NEEDED - JRA. 02/22/2001 */
3185         p = "unknown";
3186
3187         switch (queue->status) {
3188         case LPQ_QUEUED:
3189                 p = "Queued";
3190                 break;
3191         case LPQ_PAUSED:
3192                 p = "";    /* NT provides the paused string */
3193                 break;
3194         case LPQ_SPOOLING:
3195                 p = "Spooling";
3196                 break;
3197         case LPQ_PRINTING:
3198                 p = "Printing";
3199                 break;
3200         }
3201 #endif /* NO LONGER NEEDED. */
3202
3203         SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, p);
3204 }
3205
3206 /*******************************************************************
3207  * fill a notify_info_data with job time
3208  ********************************************************************/
3209
3210 static void spoolss_notify_job_time(int snum,
3211                                     struct spoolss_Notify *data,
3212                                     print_queue_struct *queue,
3213                                     NT_PRINTER_INFO_LEVEL *printer,
3214                                     TALLOC_CTX *mem_ctx)
3215 {
3216         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3217 }
3218
3219 /*******************************************************************
3220  * fill a notify_info_data with job size
3221  ********************************************************************/
3222
3223 static void spoolss_notify_job_size(int snum,
3224                                     struct spoolss_Notify *data,
3225                                     print_queue_struct *queue,
3226                                     NT_PRINTER_INFO_LEVEL *printer,
3227                                     TALLOC_CTX *mem_ctx)
3228 {
3229         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->size);
3230 }
3231
3232 /*******************************************************************
3233  * fill a notify_info_data with page info
3234  ********************************************************************/
3235 static void spoolss_notify_total_pages(int snum,
3236                                 struct spoolss_Notify *data,
3237                                 print_queue_struct *queue,
3238                                 NT_PRINTER_INFO_LEVEL *printer,
3239                                 TALLOC_CTX *mem_ctx)
3240 {
3241         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->page_count);
3242 }
3243
3244 /*******************************************************************
3245  * fill a notify_info_data with pages printed info.
3246  ********************************************************************/
3247 static void spoolss_notify_pages_printed(int snum,
3248                                 struct spoolss_Notify *data,
3249                                 print_queue_struct *queue,
3250                                 NT_PRINTER_INFO_LEVEL *printer,
3251                                 TALLOC_CTX *mem_ctx)
3252 {
3253         /* Add code when back-end tracks this */
3254         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, 0);
3255 }
3256
3257 /*******************************************************************
3258  Fill a notify_info_data with job position.
3259  ********************************************************************/
3260
3261 static void spoolss_notify_job_position(int snum,
3262                                         struct spoolss_Notify *data,
3263                                         print_queue_struct *queue,
3264                                         NT_PRINTER_INFO_LEVEL *printer,
3265                                         TALLOC_CTX *mem_ctx)
3266 {
3267         SETUP_SPOOLSS_NOTIFY_DATA_INTEGER(data, queue->job);
3268 }
3269
3270 /*******************************************************************
3271  Fill a notify_info_data with submitted time.
3272  ********************************************************************/
3273
3274 static void spoolss_notify_submitted_time(int snum,
3275                                           struct spoolss_Notify *data,
3276                                           print_queue_struct *queue,
3277                                           NT_PRINTER_INFO_LEVEL *printer,
3278                                           TALLOC_CTX *mem_ctx)
3279 {
3280         data->data.string.string = NULL;
3281         data->data.string.size = 0;
3282
3283         init_systemtime_buffer(mem_ctx, gmtime(&queue->time),
3284                                &data->data.string.string,
3285                                &data->data.string.size);
3286
3287 }
3288
3289 struct s_notify_info_data_table
3290 {
3291         enum spoolss_NotifyType type;
3292         uint16_t field;
3293         const char *name;
3294         enum spoolss_NotifyTable variable_type;
3295         void (*fn) (int snum, struct spoolss_Notify *data,
3296                     print_queue_struct *queue,
3297                     NT_PRINTER_INFO_LEVEL *printer, TALLOC_CTX *mem_ctx);
3298 };
3299
3300 /* A table describing the various print notification constants and
3301    whether the notification data is a pointer to a variable sized
3302    buffer, a one value uint32_t or a two value uint32_t. */
3303
3304 static const struct s_notify_info_data_table notify_info_data_table[] =
3305 {
3306 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SERVER_NAME,         "PRINTER_NOTIFY_FIELD_SERVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3307 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME,        "PRINTER_NOTIFY_FIELD_PRINTER_NAME",        NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3308 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME,          "PRINTER_NOTIFY_FIELD_SHARE_NAME",          NOTIFY_TABLE_STRING,   spoolss_notify_share_name },
3309 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME,           "PRINTER_NOTIFY_FIELD_PORT_NAME",           NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3310 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME,         "PRINTER_NOTIFY_FIELD_DRIVER_NAME",         NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3311 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT,             "PRINTER_NOTIFY_FIELD_COMMENT",             NOTIFY_TABLE_STRING,   spoolss_notify_comment },
3312 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION,            "PRINTER_NOTIFY_FIELD_LOCATION",            NOTIFY_TABLE_STRING,   spoolss_notify_location },
3313 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEVMODE,             "PRINTER_NOTIFY_FIELD_DEVMODE",             NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3314 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE,             "PRINTER_NOTIFY_FIELD_SEPFILE",             NOTIFY_TABLE_STRING,   spoolss_notify_sepfile },
3315 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR,     "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR",     NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3316 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PARAMETERS,          "PRINTER_NOTIFY_FIELD_PARAMETERS",          NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3317 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DATATYPE,            "PRINTER_NOTIFY_FIELD_DATATYPE",            NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3318 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR, "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR", NOTIFY_TABLE_SECURITYDESCRIPTOR,   spoolss_notify_security_desc },
3319 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_ATTRIBUTES,          "PRINTER_NOTIFY_FIELD_ATTRIBUTES",          NOTIFY_TABLE_DWORD,    spoolss_notify_attributes },
3320 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRIORITY,            "PRINTER_NOTIFY_FIELD_PRIORITY",            NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3321 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY,    "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY",    NOTIFY_TABLE_DWORD,    spoolss_notify_default_priority },
3322 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_START_TIME,          "PRINTER_NOTIFY_FIELD_START_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3323 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_UNTIL_TIME,          "PRINTER_NOTIFY_FIELD_UNTIL_TIME",          NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3324 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS,              "PRINTER_NOTIFY_FIELD_STATUS",              NOTIFY_TABLE_DWORD,    spoolss_notify_status },
3325 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_STATUS_STRING,       "PRINTER_NOTIFY_FIELD_STATUS_STRING",       NOTIFY_TABLE_STRING,   NULL },
3326 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_CJOBS,               "PRINTER_NOTIFY_FIELD_CJOBS",               NOTIFY_TABLE_DWORD,    spoolss_notify_cjobs },
3327 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_AVERAGE_PPM,         "PRINTER_NOTIFY_FIELD_AVERAGE_PPM",         NOTIFY_TABLE_DWORD,    spoolss_notify_average_ppm },
3328 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_PAGES,         "PRINTER_NOTIFY_FIELD_TOTAL_PAGES",         NOTIFY_TABLE_DWORD,    NULL },
3329 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PAGES_PRINTED,       "PRINTER_NOTIFY_FIELD_PAGES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3330 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_TOTAL_BYTES,         "PRINTER_NOTIFY_FIELD_TOTAL_BYTES",         NOTIFY_TABLE_DWORD,    NULL },
3331 { PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_BYTES_PRINTED,       "PRINTER_NOTIFY_FIELD_BYTES_PRINTED",       NOTIFY_TABLE_DWORD,    NULL },
3332 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINTER_NAME,            "JOB_NOTIFY_FIELD_PRINTER_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_printer_name },
3333 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_MACHINE_NAME,            "JOB_NOTIFY_FIELD_MACHINE_NAME",            NOTIFY_TABLE_STRING,   spoolss_notify_server_name },
3334 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PORT_NAME,               "JOB_NOTIFY_FIELD_PORT_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_port_name },
3335 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_USER_NAME,               "JOB_NOTIFY_FIELD_USER_NAME",               NOTIFY_TABLE_STRING,   spoolss_notify_username },
3336 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_NOTIFY_NAME,             "JOB_NOTIFY_FIELD_NOTIFY_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_username },
3337 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DATATYPE,                "JOB_NOTIFY_FIELD_DATATYPE",                NOTIFY_TABLE_STRING,   spoolss_notify_datatype },
3338 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRINT_PROCESSOR,         "JOB_NOTIFY_FIELD_PRINT_PROCESSOR",         NOTIFY_TABLE_STRING,   spoolss_notify_print_processor },
3339 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PARAMETERS,              "JOB_NOTIFY_FIELD_PARAMETERS",              NOTIFY_TABLE_STRING,   spoolss_notify_parameters },
3340 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DRIVER_NAME,             "JOB_NOTIFY_FIELD_DRIVER_NAME",             NOTIFY_TABLE_STRING,   spoolss_notify_driver_name },
3341 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DEVMODE,                 "JOB_NOTIFY_FIELD_DEVMODE",                 NOTIFY_TABLE_DEVMODE,  spoolss_notify_devmode },
3342 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS,                  "JOB_NOTIFY_FIELD_STATUS",                  NOTIFY_TABLE_DWORD,    spoolss_notify_job_status },
3343 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_STATUS_STRING,           "JOB_NOTIFY_FIELD_STATUS_STRING",           NOTIFY_TABLE_STRING,   spoolss_notify_job_status_string },
3344 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR,     "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR",     NOTIFY_TABLE_SECURITYDESCRIPTOR,   NULL },
3345 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_DOCUMENT,                "JOB_NOTIFY_FIELD_DOCUMENT",                NOTIFY_TABLE_STRING,   spoolss_notify_job_name },
3346 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PRIORITY,                "JOB_NOTIFY_FIELD_PRIORITY",                NOTIFY_TABLE_DWORD,    spoolss_notify_priority },
3347 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_POSITION,                "JOB_NOTIFY_FIELD_POSITION",                NOTIFY_TABLE_DWORD,    spoolss_notify_job_position },
3348 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_SUBMITTED,               "JOB_NOTIFY_FIELD_SUBMITTED",               NOTIFY_TABLE_TIME,     spoolss_notify_submitted_time },
3349 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_START_TIME,              "JOB_NOTIFY_FIELD_START_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_start_time },
3350 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_UNTIL_TIME,              "JOB_NOTIFY_FIELD_UNTIL_TIME",              NOTIFY_TABLE_DWORD,    spoolss_notify_until_time },
3351 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TIME,                    "JOB_NOTIFY_FIELD_TIME",                    NOTIFY_TABLE_DWORD,    spoolss_notify_job_time },
3352 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_PAGES,             "JOB_NOTIFY_FIELD_TOTAL_PAGES",             NOTIFY_TABLE_DWORD,    spoolss_notify_total_pages },
3353 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_PAGES_PRINTED,           "JOB_NOTIFY_FIELD_PAGES_PRINTED",           NOTIFY_TABLE_DWORD,    spoolss_notify_pages_printed },
3354 { JOB_NOTIFY_TYPE,     JOB_NOTIFY_FIELD_TOTAL_BYTES,             "JOB_NOTIFY_FIELD_TOTAL_BYTES",             NOTIFY_TABLE_DWORD,    spoolss_notify_job_size },
3355 };
3356
3357 /*******************************************************************
3358  Return the variable_type of info_data structure.
3359 ********************************************************************/
3360
3361 static uint32_t variable_type_of_notify_info_data(enum spoolss_NotifyType type,
3362                                                   uint16_t field)
3363 {
3364         int i=0;
3365
3366         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3367                 if ( (notify_info_data_table[i].type == type) &&
3368                      (notify_info_data_table[i].field == field) ) {
3369                         return notify_info_data_table[i].variable_type;
3370                 }
3371         }
3372
3373         DEBUG(5, ("invalid notify data type %d/%d\n", type, field));
3374
3375         return 0;
3376 }
3377
3378 /****************************************************************************
3379 ****************************************************************************/
3380
3381 static bool search_notify(enum spoolss_NotifyType type,
3382                           uint16_t field,
3383                           int *value)
3384 {
3385         int i;
3386
3387         for (i = 0; i < ARRAY_SIZE(notify_info_data_table); i++) {
3388                 if (notify_info_data_table[i].type == type &&
3389                     notify_info_data_table[i].field == field &&
3390                     notify_info_data_table[i].fn != NULL) {
3391                         *value = i;
3392                         return true;
3393                 }
3394         }
3395
3396         return false;
3397 }
3398
3399 /****************************************************************************
3400 ****************************************************************************/
3401
3402 void construct_info_data(struct spoolss_Notify *info_data,
3403                          enum spoolss_NotifyType type,
3404                          uint16_t field,
3405                          int id)
3406 {
3407         info_data->type                 = type;
3408         info_data->field.field          = field;
3409         info_data->variable_type        = variable_type_of_notify_info_data(type, field);
3410         info_data->job_id               = id;
3411 }
3412
3413 /*******************************************************************
3414  *
3415  * fill a notify_info struct with info asked
3416  *
3417  ********************************************************************/
3418
3419 static bool construct_notify_printer_info(Printer_entry *print_hnd,
3420                                           struct spoolss_NotifyInfo *info,
3421                                           int snum,
3422                                           const struct spoolss_NotifyOptionType *option_type,
3423                                           uint32_t id,
3424                                           TALLOC_CTX *mem_ctx)
3425 {
3426         int field_num,j;
3427         enum spoolss_NotifyType type;
3428         uint16_t field;
3429
3430         struct spoolss_Notify *current_data;
3431         NT_PRINTER_INFO_LEVEL *printer = NULL;
3432         print_queue_struct *queue=NULL;
3433
3434         type = option_type->type;
3435
3436         DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
3437                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3438                 option_type->count, lp_servicename(snum)));
3439
3440         if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
3441                 return false;
3442
3443         for(field_num=0; field_num < option_type->count; field_num++) {
3444                 field = option_type->fields[field_num].field;
3445
3446                 DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
3447
3448                 if (!search_notify(type, field, &j) )
3449                         continue;
3450
3451                 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3452                                                       struct spoolss_Notify,
3453                                                       info->count + 1);
3454                 if (info->notifies == NULL) {
3455                         DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
3456                         free_a_printer(&printer, 2);
3457                         return false;
3458                 }
3459
3460                 current_data = &info->notifies[info->count];
3461
3462                 construct_info_data(current_data, type, field, id);
3463
3464                 DEBUG(10,("construct_notify_printer_info: calling [%s]  snum=%d  printername=[%s])\n",
3465                                 notify_info_data_table[j].name, snum, printer->info_2->printername ));
3466
3467                 notify_info_data_table[j].fn(snum, current_data, queue,
3468                                              printer, mem_ctx);
3469
3470                 info->count++;
3471         }
3472
3473         free_a_printer(&printer, 2);
3474         return true;
3475 }
3476
3477 /*******************************************************************
3478  *
3479  * fill a notify_info struct with info asked
3480  *
3481  ********************************************************************/
3482
3483 static bool construct_notify_jobs_info(print_queue_struct *queue,
3484                                        struct spoolss_NotifyInfo *info,
3485                                        NT_PRINTER_INFO_LEVEL *printer,
3486                                        int snum,
3487                                        const struct spoolss_NotifyOptionType *option_type,
3488                                        uint32_t id,
3489                                        TALLOC_CTX *mem_ctx)
3490 {
3491         int field_num,j;
3492         enum spoolss_NotifyType type;
3493         uint16_t field;
3494         struct spoolss_Notify *current_data;
3495
3496         DEBUG(4,("construct_notify_jobs_info\n"));
3497
3498         type = option_type->type;
3499
3500         DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
3501                 (type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
3502                 option_type->count));
3503
3504         for(field_num=0; field_num<option_type->count; field_num++) {
3505                 field = option_type->fields[field_num].field;
3506
3507                 if (!search_notify(type, field, &j) )
3508                         continue;
3509
3510                 info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
3511                                                       struct spoolss_Notify,
3512                                                       info->count + 1);
3513                 if (info->notifies == NULL) {
3514                         DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
3515                         return false;
3516                 }
3517
3518                 current_data=&(info->notifies[info->count]);
3519
3520                 construct_info_data(current_data, type, field, id);
3521                 notify_info_data_table[j].fn(snum, current_data, queue,
3522                                              printer, mem_ctx);
3523                 info->count++;
3524         }
3525
3526         return true;
3527 }
3528
3529 /*
3530  * JFM: The enumeration is not that simple, it's even non obvious.
3531  *
3532  * let's take an example: I want to monitor the PRINTER SERVER for
3533  * the printer's name and the number of jobs currently queued.
3534  * So in the NOTIFY_OPTION, I have one NOTIFY_OPTION_TYPE structure.
3535  * Its type is PRINTER_NOTIFY_TYPE and it has 2 fields NAME and CJOBS.
3536  *
3537  * I have 3 printers on the back of my server.
3538  *
3539  * Now the response is a NOTIFY_INFO structure, with 6 NOTIFY_INFO_DATA
3540  * structures.
3541  *   Number     Data                    Id
3542  *      1       printer 1 name          1
3543  *      2       printer 1 cjob          1
3544  *      3       printer 2 name          2
3545  *      4       printer 2 cjob          2
3546  *      5       printer 3 name          3
3547  *      6       printer 3 name          3
3548  *
3549  * that's the print server case, the printer case is even worse.
3550  */
3551
3552 /*******************************************************************
3553  *
3554  * enumerate all printers on the printserver
3555  * fill a notify_info struct with info asked
3556  *
3557  ********************************************************************/
3558
3559 static WERROR printserver_notify_info(pipes_struct *p,
3560                                       struct policy_handle *hnd,
3561                                       struct spoolss_NotifyInfo *info,
3562                                       TALLOC_CTX *mem_ctx)
3563 {
3564         int snum;
3565         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3566         int n_services=lp_numservices();
3567         int i;
3568         struct spoolss_NotifyOption *option;
3569         struct spoolss_NotifyOptionType option_type;
3570
3571         DEBUG(4,("printserver_notify_info\n"));
3572
3573         if (!Printer)
3574                 return WERR_BADFID;
3575
3576         option = Printer->notify.option;
3577
3578         info->version   = 2;
3579         info->notifies  = NULL;
3580         info->count     = 0;
3581
3582         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3583            sending a ffpcn() request first */
3584
3585         if ( !option )
3586                 return WERR_BADFID;
3587
3588         for (i=0; i<option->count; i++) {
3589                 option_type = option->types[i];
3590
3591                 if (option_type.type != PRINTER_NOTIFY_TYPE)
3592                         continue;
3593
3594                 for (snum=0; snum<n_services; snum++)
3595                 {
3596                         if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
3597                                 construct_notify_printer_info ( Printer, info, snum, &option_type, snum, mem_ctx );
3598                 }
3599         }
3600
3601 #if 0
3602         /*
3603          * Debugging information, don't delete.
3604          */
3605
3606         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3607         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3608         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3609
3610         for (i=0; i<info->count; i++) {
3611                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3612                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3613                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3614         }
3615 #endif
3616
3617         return WERR_OK;
3618 }
3619
3620 /*******************************************************************
3621  *
3622  * fill a notify_info struct with info asked
3623  *
3624  ********************************************************************/
3625
3626 static WERROR printer_notify_info(pipes_struct *p, struct policy_handle *hnd,
3627                                   struct spoolss_NotifyInfo *info,
3628                                   TALLOC_CTX *mem_ctx)
3629 {
3630         int snum;
3631         Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
3632         int i;
3633         uint32_t id;
3634         struct spoolss_NotifyOption *option;
3635         struct spoolss_NotifyOptionType option_type;
3636         int count,j;
3637         print_queue_struct *queue=NULL;
3638         print_status_struct status;
3639
3640         DEBUG(4,("printer_notify_info\n"));
3641
3642         if (!Printer)
3643                 return WERR_BADFID;
3644
3645         option = Printer->notify.option;
3646         id = 0x0;
3647
3648         info->version   = 2;
3649         info->notifies  = NULL;
3650         info->count     = 0;
3651
3652         /* a bug in xp sp2 rc2 causes it to send a fnpcn request without
3653            sending a ffpcn() request first */
3654
3655         if ( !option )
3656                 return WERR_BADFID;
3657
3658         get_printer_snum(p, hnd, &snum, NULL);
3659
3660         for (i=0; i<option->count; i++) {
3661                 option_type = option->types[i];
3662
3663                 switch (option_type.type) {
3664                 case PRINTER_NOTIFY_TYPE:
3665                         if(construct_notify_printer_info(Printer, info, snum,
3666                                                          &option_type, id,
3667                                                          mem_ctx))
3668                                 id--;
3669                         break;
3670
3671                 case JOB_NOTIFY_TYPE: {
3672                         NT_PRINTER_INFO_LEVEL *printer = NULL;
3673
3674                         count = print_queue_status(snum, &queue, &status);
3675
3676                         if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))))
3677                                 goto done;
3678
3679                         for (j=0; j<count; j++) {
3680                                 construct_notify_jobs_info(&queue[j], info,
3681                                                            printer, snum,
3682                                                            &option_type,
3683                                                            queue[j].job,
3684                                                            mem_ctx);
3685                         }
3686
3687                         free_a_printer(&printer, 2);
3688
3689                 done:
3690                         SAFE_FREE(queue);
3691                         break;
3692                 }
3693                 }
3694         }
3695
3696         /*
3697          * Debugging information, don't delete.
3698          */
3699         /*
3700         DEBUG(1,("dumping the NOTIFY_INFO\n"));
3701         DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
3702         DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
3703
3704         for (i=0; i<info->count; i++) {
3705                 DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
3706                 i, info->data[i].type, info->data[i].field, info->data[i].reserved,
3707                 info->data[i].id, info->data[i].size, info->data[i].enc_type));
3708         }
3709         */
3710         return WERR_OK;
3711 }
3712
3713 /****************************************************************
3714  _spoolss_RouterRefreshPrinterChangeNotify
3715 ****************************************************************/
3716
3717 WERROR _spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p,
3718                                                  struct spoolss_RouterRefreshPrinterChangeNotify *r)
3719 {
3720         struct spoolss_NotifyInfo *info;
3721
3722         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
3723         WERROR result = WERR_BADFID;
3724
3725         /* we always have a spoolss_NotifyInfo struct */
3726         info = talloc_zero(p->mem_ctx, struct spoolss_NotifyInfo);
3727         if (!info) {
3728                 result = WERR_NOMEM;
3729                 goto done;
3730         }
3731
3732         *r->out.info = info;
3733
3734         if (!Printer) {
3735                 DEBUG(2,("_spoolss_RouterRefreshPrinterChangeNotify: "
3736                         "Invalid handle (%s:%u:%u).\n",
3737                         OUR_HANDLE(r->in.handle)));
3738                 goto done;
3739         }
3740
3741         DEBUG(4,("Printer type %x\n",Printer->printer_type));
3742
3743         /*
3744          *      We are now using the change value, and
3745          *      I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
3746          *      I don't have a global notification system, I'm sending back all the
3747          *      informations even when _NOTHING_ has changed.
3748          */
3749
3750         /* We need to keep track of the change value to send back in
3751            RRPCN replies otherwise our updates are ignored. */
3752
3753         Printer->notify.fnpcn = true;
3754
3755         if (Printer->notify.client_connected) {
3756                 DEBUG(10,("_spoolss_RouterRefreshPrinterChangeNotify: "
3757                         "Saving change value in request [%x]\n",
3758                         r->in.change_low));
3759                 Printer->notify.change = r->in.change_low;
3760         }
3761
3762         /* just ignore the spoolss_NotifyOption */
3763
3764         switch (Printer->printer_type) {
3765                 case SPLHND_SERVER:
3766                         result = printserver_notify_info(p, r->in.handle,
3767                                                          info, p->mem_ctx);
3768                         break;
3769
3770                 case SPLHND_PRINTER:
3771                         result = printer_notify_info(p, r->in.handle,
3772                                                      info, p->mem_ctx);
3773                         break;
3774         }
3775
3776         Printer->notify.fnpcn = false;
3777
3778 done:
3779         return result;
3780 }
3781
3782 /********************************************************************
3783  * construct_printer_info_0
3784  * fill a printer_info_0 struct
3785  ********************************************************************/
3786
3787 static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
3788                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3789                                       struct spoolss_PrinterInfo0 *r,
3790                                       int snum)
3791 {
3792         int count;
3793         counter_printer_0 *session_counter;
3794         time_t setuptime;
3795         print_status_struct status;
3796
3797         r->printername          = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
3798         W_ERROR_HAVE_NO_MEMORY(r->printername);
3799
3800         r->servername           = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
3801         W_ERROR_HAVE_NO_MEMORY(r->servername);
3802
3803         count = print_queue_length(snum, &status);
3804
3805         /* check if we already have a counter for this printer */
3806         for (session_counter = counter_list; session_counter; session_counter = session_counter->next) {
3807                 if (session_counter->snum == snum)
3808                         break;
3809         }
3810
3811         /* it's the first time, add it to the list */
3812         if (session_counter == NULL) {
3813                 session_counter = SMB_MALLOC_P(counter_printer_0);
3814                 W_ERROR_HAVE_NO_MEMORY(session_counter);
3815                 ZERO_STRUCTP(session_counter);
3816                 session_counter->snum           = snum;
3817                 session_counter->counter        = 0;
3818                 DLIST_ADD(counter_list, session_counter);
3819         }
3820
3821         /* increment it */
3822         session_counter->counter++;
3823
3824         r->cjobs                        = count;
3825         r->total_jobs                   = 0;
3826         r->total_bytes                  = 0;
3827
3828         setuptime = (time_t)ntprinter->info_2->setuptime;
3829
3830         init_systemtime(&r->time, gmtime(&setuptime));
3831
3832         /* JFM:
3833          * the global_counter should be stored in a TDB as it's common to all the clients
3834          * and should be zeroed on samba startup
3835          */
3836         r->global_counter               = session_counter->counter;
3837         r->total_pages                  = 0;
3838         /* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
3839         r->version                      = 0x0005;       /* NT 5 */
3840         r->free_build                   = 0x0893;       /* build 2195 */
3841         r->spooling                     = 0;
3842         r->max_spooling                 = 0;
3843         r->session_counter              = session_counter->counter;
3844         r->num_error_out_of_paper       = 0x0;
3845         r->num_error_not_ready          = 0x0;          /* number of print failure */
3846         r->job_error                    = 0x0;
3847         r->number_of_processors         = 0x1;
3848         r->processor_type               = PROCESSOR_INTEL_PENTIUM; /* 586 Pentium ? */
3849         r->high_part_total_bytes        = 0x0;
3850         r->change_id                    = ntprinter->info_2->changeid; /* ChangeID in milliseconds*/
3851         r->last_error                   = WERR_OK;
3852         r->status                       = nt_printq_status(status.status);
3853         r->enumerate_network_printers   = 0x0;
3854         r->c_setprinter                 = get_c_setprinter(); /* monotonically increasing sum of delta printer counts */
3855         r->processor_architecture       = 0x0;
3856         r->processor_level              = 0x6;          /* 6  ???*/
3857         r->ref_ic                       = 0;
3858         r->reserved2                    = 0;
3859         r->reserved3                    = 0;
3860
3861         return WERR_OK;
3862 }
3863
3864 /****************************************************************************
3865  Convert an NT_DEVICEMODE to a spoolss_DeviceMode structure.  Both pointers
3866  should be valid upon entry
3867 ****************************************************************************/
3868
3869 static WERROR convert_nt_devicemode(TALLOC_CTX *mem_ctx,
3870                                     struct spoolss_DeviceMode *r,
3871                                     const NT_DEVICEMODE *ntdevmode)
3872 {
3873         if (!r || !ntdevmode) {
3874                 return WERR_INVALID_PARAM;
3875         }
3876
3877         r->devicename           = talloc_strdup(mem_ctx, ntdevmode->devicename);
3878         W_ERROR_HAVE_NO_MEMORY(r->devicename);
3879
3880         r->specversion          = ntdevmode->specversion;
3881         r->driverversion        = ntdevmode->driverversion;
3882         r->size                 = ntdevmode->size;
3883         r->__driverextra_length = ntdevmode->driverextra;
3884         r->fields               = ntdevmode->fields;
3885
3886         r->orientation          = ntdevmode->orientation;
3887         r->papersize            = ntdevmode->papersize;
3888         r->paperlength          = ntdevmode->paperlength;
3889         r->paperwidth           = ntdevmode->paperwidth;
3890         r->scale                = ntdevmode->scale;
3891         r->copies               = ntdevmode->copies;
3892         r->defaultsource        = ntdevmode->defaultsource;
3893         r->printquality         = ntdevmode->printquality;
3894         r->color                = ntdevmode->color;
3895         r->duplex               = ntdevmode->duplex;
3896         r->yresolution          = ntdevmode->yresolution;
3897         r->ttoption             = ntdevmode->ttoption;
3898         r->collate              = ntdevmode->collate;
3899
3900         r->formname             = talloc_strdup(mem_ctx, ntdevmode->formname);
3901         W_ERROR_HAVE_NO_MEMORY(r->formname);
3902
3903         /* all 0 below are values that have not been set in the old parsing/copy
3904          * function, maybe they should... - gd */
3905
3906         r->logpixels            = 0;
3907         r->bitsperpel           = 0;
3908         r->pelswidth            = 0;
3909         r->pelsheight           = 0;
3910         r->displayflags         = 0;
3911         r->displayfrequency     = 0;
3912         r->icmmethod            = ntdevmode->icmmethod;
3913         r->icmintent            = ntdevmode->icmintent;
3914         r->mediatype            = ntdevmode->mediatype;
3915         r->dithertype           = ntdevmode->dithertype;
3916         r->reserved1            = 0;
3917         r->reserved2            = 0;
3918         r->panningwidth         = 0;
3919         r->panningheight        = 0;
3920
3921         if (ntdevmode->nt_dev_private != NULL) {
3922                 r->driverextra_data = data_blob_talloc(mem_ctx,
3923                         ntdevmode->nt_dev_private,
3924                         ntdevmode->driverextra);
3925                 W_ERROR_HAVE_NO_MEMORY(r->driverextra_data.data);
3926         }
3927
3928         return WERR_OK;
3929 }
3930
3931
3932 /****************************************************************************
3933  Create a spoolss_DeviceMode struct. Returns talloced memory.
3934 ****************************************************************************/
3935
3936 struct spoolss_DeviceMode *construct_dev_mode(TALLOC_CTX *mem_ctx,
3937                                               const char *servicename)
3938 {
3939         WERROR result;
3940         NT_PRINTER_INFO_LEVEL   *printer = NULL;
3941         struct spoolss_DeviceMode *devmode = NULL;
3942
3943         DEBUG(7,("construct_dev_mode\n"));
3944
3945         DEBUGADD(8,("getting printer characteristics\n"));
3946
3947         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
3948                 return NULL;
3949
3950         if (!printer->info_2->devmode) {
3951                 DEBUG(5, ("BONG! There was no device mode!\n"));
3952                 goto done;
3953         }
3954
3955         devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
3956         if (!devmode) {
3957                 DEBUG(2,("construct_dev_mode: talloc fail.\n"));
3958                 goto done;
3959         }
3960
3961         DEBUGADD(8,("loading DEVICEMODE\n"));
3962
3963         result = convert_nt_devicemode(mem_ctx, devmode, printer->info_2->devmode);
3964         if (!W_ERROR_IS_OK(result)) {
3965                 TALLOC_FREE(devmode);
3966         }
3967
3968 done:
3969         free_a_printer(&printer,2);
3970
3971         return devmode;
3972 }
3973
3974 /********************************************************************
3975  * construct_printer_info3
3976  * fill a spoolss_PrinterInfo3 struct
3977  ********************************************************************/
3978
3979 static WERROR construct_printer_info3(TALLOC_CTX *mem_ctx,
3980                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
3981                                       struct spoolss_PrinterInfo3 *r,
3982                                       int snum)
3983 {
3984         /* These are the components of the SD we are returning. */
3985
3986         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
3987                 /* don't use talloc_steal() here unless you do a deep steal of all
3988                    the SEC_DESC members */
3989
3990                 r->secdesc = dup_sec_desc(mem_ctx,
3991                                           ntprinter->info_2->secdesc_buf->sd);
3992                 W_ERROR_HAVE_NO_MEMORY(r->secdesc);
3993         }
3994
3995         return WERR_OK;
3996 }
3997
3998 /********************************************************************
3999  * construct_printer_info4
4000  * fill a spoolss_PrinterInfo4 struct
4001  ********************************************************************/
4002
4003 static WERROR construct_printer_info4(TALLOC_CTX *mem_ctx,
4004                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4005                                       struct spoolss_PrinterInfo4 *r,
4006                                       int snum)
4007 {
4008         r->printername  = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4009         W_ERROR_HAVE_NO_MEMORY(r->printername);
4010         r->servername   = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
4011         W_ERROR_HAVE_NO_MEMORY(r->servername);
4012
4013         r->attributes   = ntprinter->info_2->attributes;
4014
4015         return WERR_OK;
4016 }
4017
4018 /********************************************************************
4019  * construct_printer_info5
4020  * fill a spoolss_PrinterInfo5 struct
4021  ********************************************************************/
4022
4023 static WERROR construct_printer_info5(TALLOC_CTX *mem_ctx,
4024                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4025                                       struct spoolss_PrinterInfo5 *r,
4026                                       int snum)
4027 {
4028         r->printername  = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4029         W_ERROR_HAVE_NO_MEMORY(r->printername);
4030         r->portname     = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4031         W_ERROR_HAVE_NO_MEMORY(r->portname);
4032
4033         r->attributes   = ntprinter->info_2->attributes;
4034
4035         /* these two are not used by NT+ according to MSDN */
4036
4037         r->device_not_selected_timeout          = 0x0;  /* have seen 0x3a98 */
4038         r->transmission_retry_timeout           = 0x0;  /* have seen 0xafc8 */
4039
4040         return WERR_OK;
4041 }
4042
4043 /********************************************************************
4044  * construct_printer_info_6
4045  * fill a spoolss_PrinterInfo6 struct
4046  ********************************************************************/
4047
4048 static WERROR construct_printer_info6(TALLOC_CTX *mem_ctx,
4049                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4050                                       struct spoolss_PrinterInfo6 *r,
4051                                       int snum)
4052 {
4053         int count;
4054         print_status_struct status;
4055
4056         count = print_queue_length(snum, &status);
4057
4058         r->status = nt_printq_status(status.status);
4059
4060         return WERR_OK;
4061 }
4062
4063 /********************************************************************
4064  * construct_printer_info7
4065  * fill a spoolss_PrinterInfo7 struct
4066  ********************************************************************/
4067
4068 static WERROR construct_printer_info7(TALLOC_CTX *mem_ctx,
4069                                       Printer_entry *print_hnd,
4070                                       struct spoolss_PrinterInfo7 *r,
4071                                       int snum)
4072 {
4073         struct GUID guid;
4074
4075         if (is_printer_published(print_hnd, snum, &guid)) {
4076                 r->guid = talloc_strdup_upper(mem_ctx, GUID_string2(mem_ctx, &guid));
4077                 r->action = DSPRINT_PUBLISH;
4078         } else {
4079                 r->guid = talloc_strdup(mem_ctx, "");
4080                 r->action = DSPRINT_UNPUBLISH;
4081         }
4082         W_ERROR_HAVE_NO_MEMORY(r->guid);
4083
4084         return WERR_OK;
4085 }
4086
4087 /********************************************************************
4088  * construct_printer_info8
4089  * fill a spoolss_PrinterInfo8 struct
4090  ********************************************************************/
4091
4092 static WERROR construct_printer_info8(TALLOC_CTX *mem_ctx,
4093                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4094                                       struct spoolss_DeviceModeInfo *r,
4095                                       int snum)
4096 {
4097         struct spoolss_DeviceMode *devmode;
4098         WERROR result;
4099
4100         if (!ntprinter->info_2->devmode) {
4101                 r->devmode = NULL;
4102                 return WERR_OK;
4103         }
4104
4105         devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
4106         W_ERROR_HAVE_NO_MEMORY(devmode);
4107
4108         result = convert_nt_devicemode(mem_ctx, devmode, ntprinter->info_2->devmode);
4109         if (!W_ERROR_IS_OK(result)) {
4110                 TALLOC_FREE(devmode);
4111                 return result;
4112         }
4113
4114         r->devmode      = devmode;
4115
4116         return WERR_OK;
4117 }
4118
4119
4120 /********************************************************************
4121  * construct_printer_info1
4122  * fill a spoolss_PrinterInfo1 struct
4123 ********************************************************************/
4124
4125 static WERROR construct_printer_info1(TALLOC_CTX *mem_ctx,
4126                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4127                                       uint32_t flags,
4128                                       struct spoolss_PrinterInfo1 *r,
4129                                       int snum)
4130 {
4131         r->flags                = flags;
4132
4133         r->description          = talloc_asprintf(mem_ctx, "%s,%s,%s",
4134                                                   ntprinter->info_2->printername,
4135                                                   ntprinter->info_2->drivername,
4136                                                   ntprinter->info_2->location);
4137         W_ERROR_HAVE_NO_MEMORY(r->description);
4138
4139         if (*ntprinter->info_2->comment == '\0') {
4140                 r->comment      = talloc_strdup(mem_ctx, lp_comment(snum));
4141         } else {
4142                 r->comment      = talloc_strdup(mem_ctx, ntprinter->info_2->comment); /* saved comment */
4143         }
4144         W_ERROR_HAVE_NO_MEMORY(r->comment);
4145
4146         r->name                 = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4147         W_ERROR_HAVE_NO_MEMORY(r->name);
4148
4149         return WERR_OK;
4150 }
4151
4152 /********************************************************************
4153  * construct_printer_info2
4154  * fill a spoolss_PrinterInfo2 struct
4155 ********************************************************************/
4156
4157 static WERROR construct_printer_info2(TALLOC_CTX *mem_ctx,
4158                                       const NT_PRINTER_INFO_LEVEL *ntprinter,
4159                                       struct spoolss_PrinterInfo2 *r,
4160                                       int snum)
4161 {
4162         int count;
4163
4164         print_status_struct status;
4165
4166         count = print_queue_length(snum, &status);
4167
4168         r->servername           = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
4169         W_ERROR_HAVE_NO_MEMORY(r->servername);
4170         r->printername          = talloc_strdup(mem_ctx, ntprinter->info_2->printername);
4171         W_ERROR_HAVE_NO_MEMORY(r->printername);
4172         r->sharename            = talloc_strdup(mem_ctx, lp_servicename(snum));
4173         W_ERROR_HAVE_NO_MEMORY(r->sharename);
4174         r->portname             = talloc_strdup(mem_ctx, ntprinter->info_2->portname);
4175         W_ERROR_HAVE_NO_MEMORY(r->portname);
4176         r->drivername           = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
4177         W_ERROR_HAVE_NO_MEMORY(r->drivername);
4178
4179         if (*ntprinter->info_2->comment == '\0') {
4180                 r->comment      = talloc_strdup(mem_ctx, lp_comment(snum));
4181         } else {
4182                 r->comment      = talloc_strdup(mem_ctx, ntprinter->info_2->comment);
4183         }
4184         W_ERROR_HAVE_NO_MEMORY(r->comment);
4185
4186         r->location             = talloc_strdup(mem_ctx, ntprinter->info_2->location);
4187         W_ERROR_HAVE_NO_MEMORY(r->location);
4188         r->sepfile              = talloc_strdup(mem_ctx, ntprinter->info_2->sepfile);
4189         W_ERROR_HAVE_NO_MEMORY(r->sepfile);
4190         r->printprocessor       = talloc_strdup(mem_ctx, ntprinter->info_2->printprocessor);
4191         W_ERROR_HAVE_NO_MEMORY(r->printprocessor);
4192         r->datatype             = talloc_strdup(mem_ctx, ntprinter->info_2->datatype);
4193         W_ERROR_HAVE_NO_MEMORY(r->datatype);
4194         r->parameters           = talloc_strdup(mem_ctx, ntprinter->info_2->parameters);
4195         W_ERROR_HAVE_NO_MEMORY(r->parameters);
4196
4197         r->attributes           = ntprinter->info_2->attributes;
4198
4199         r->priority             = ntprinter->info_2->priority;
4200         r->defaultpriority      = ntprinter->info_2->default_priority;
4201         r->starttime            = ntprinter->info_2->starttime;
4202         r->untiltime            = ntprinter->info_2->untiltime;
4203         r->status               = nt_printq_status(status.status);
4204         r->cjobs                = count;
4205         r->averageppm           = ntprinter->info_2->averageppm;
4206
4207         r->devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
4208         if (!r->devmode) {
4209                 DEBUG(8,("Returning NULL Devicemode!\n"));
4210         }
4211
4212         r->secdesc              = NULL;
4213
4214         if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
4215                 /* don't use talloc_steal() here unless you do a deep steal of all
4216                    the SEC_DESC members */
4217
4218                 r->secdesc      = dup_sec_desc(mem_ctx, ntprinter->info_2->secdesc_buf->sd);
4219         }
4220
4221         return WERR_OK;
4222 }
4223
4224 /********************************************************************
4225 ********************************************************************/
4226
4227 static bool snum_is_shared_printer(int snum)
4228 {
4229         return (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum));
4230 }
4231
4232 /********************************************************************
4233  Spoolss_enumprinters.
4234 ********************************************************************/
4235
4236 static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
4237                                            uint32_t level,
4238                                            uint32_t flags,
4239                                            union spoolss_PrinterInfo **info_p,
4240                                            uint32_t *count_p)
4241 {
4242         int snum;
4243         int n_services = lp_numservices();
4244         union spoolss_PrinterInfo *info = NULL;
4245         uint32_t count = 0;
4246         WERROR result = WERR_OK;
4247
4248         *count_p = 0;
4249         *info_p = NULL;
4250
4251         for (snum = 0; snum < n_services; snum++) {
4252
4253                 NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4254
4255                 if (!snum_is_shared_printer(snum)) {
4256                         continue;
4257                 }
4258
4259                 DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
4260                         lp_servicename(snum), snum));
4261
4262                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
4263                                             union spoolss_PrinterInfo,
4264                                             count + 1);
4265                 if (!info) {
4266                         result = WERR_NOMEM;
4267                         goto out;
4268                 }
4269
4270                 result = get_a_printer(NULL, &ntprinter, 2,
4271                                        lp_const_servicename(snum));
4272                 if (!W_ERROR_IS_OK(result)) {
4273                         goto out;
4274                 }
4275
4276                 switch (level) {
4277                 case 0:
4278                         result = construct_printer_info0(info, ntprinter,
4279                                                          &info[count].info0, snum);
4280                         break;
4281                 case 1:
4282                         result = construct_printer_info1(info, ntprinter, flags,
4283                                                          &info[count].info1, snum);
4284                         break;
4285                 case 2:
4286                         result = construct_printer_info2(info, ntprinter,
4287                                                          &info[count].info2, snum);
4288                         break;
4289                 case 4:
4290                         result = construct_printer_info4(info, ntprinter,
4291                                                          &info[count].info4, snum);
4292                         break;
4293                 case 5:
4294                         result = construct_printer_info5(info, ntprinter,
4295                                                          &info[count].info5, snum);
4296                         break;
4297
4298                 default:
4299                         result = WERR_UNKNOWN_LEVEL;
4300                         free_a_printer(&ntprinter, 2);
4301                         goto out;
4302                 }
4303
4304                 free_a_printer(&ntprinter, 2);
4305                 if (!W_ERROR_IS_OK(result)) {
4306                         goto out;
4307                 }
4308
4309                 count++;
4310         }
4311
4312         *count_p = count;
4313         *info_p = info;
4314
4315  out:
4316         if (!W_ERROR_IS_OK(result)) {
4317                 TALLOC_FREE(info);
4318                 return result;
4319         }
4320
4321         *info_p = info;
4322
4323         return WERR_OK;
4324 }
4325
4326 /********************************************************************
4327  * handle enumeration of printers at level 0
4328  ********************************************************************/
4329
4330 static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
4331                                   uint32_t flags,
4332                                   const char *servername,
4333                                   union spoolss_PrinterInfo **info,
4334                                   uint32_t *count)
4335 {
4336         DEBUG(4,("enum_all_printers_info_0\n"));
4337
4338         return enum_all_printers_info_level(mem_ctx, 0, flags, info, count);
4339 }
4340
4341
4342 /********************************************************************
4343 ********************************************************************/
4344
4345 static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
4346                                        uint32_t flags,
4347                                        union spoolss_PrinterInfo **info,
4348                                        uint32_t *count)
4349 {
4350         DEBUG(4,("enum_all_printers_info_1\n"));
4351
4352         return enum_all_printers_info_level(mem_ctx, 1, flags, info, count);
4353 }
4354
4355 /********************************************************************
4356  enum_all_printers_info_1_local.
4357 *********************************************************************/
4358
4359 static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
4360                                              union spoolss_PrinterInfo **info,
4361                                              uint32_t *count)
4362 {
4363         DEBUG(4,("enum_all_printers_info_1_local\n"));
4364
4365         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4366 }
4367
4368 /********************************************************************
4369  enum_all_printers_info_1_name.
4370 *********************************************************************/
4371
4372 static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
4373                                             const char *name,
4374                                             union spoolss_PrinterInfo **info,
4375                                             uint32_t *count)
4376 {
4377         const char *s = name;
4378
4379         DEBUG(4,("enum_all_printers_info_1_name\n"));
4380
4381         if ((name[0] == '\\') && (name[1] == '\\')) {
4382                 s = name + 2;
4383         }
4384
4385         if (!is_myname_or_ipaddr(s)) {
4386                 return WERR_INVALID_NAME;
4387         }
4388
4389         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_ICON8, info, count);
4390 }
4391
4392 /********************************************************************
4393  enum_all_printers_info_1_network.
4394 *********************************************************************/
4395
4396 static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
4397                                                const char *name,
4398                                                union spoolss_PrinterInfo **info,
4399                                                uint32_t *count)
4400 {
4401         const char *s = name;
4402
4403         DEBUG(4,("enum_all_printers_info_1_network\n"));
4404
4405         /* If we respond to a enum_printers level 1 on our name with flags
4406            set to PRINTER_ENUM_REMOTE with a list of printers then these
4407            printers incorrectly appear in the APW browse list.
4408            Specifically the printers for the server appear at the workgroup
4409            level where all the other servers in the domain are
4410            listed. Windows responds to this call with a
4411            WERR_CAN_NOT_COMPLETE so we should do the same. */
4412
4413         if (name[0] == '\\' && name[1] == '\\') {
4414                  s = name + 2;
4415         }
4416
4417         if (is_myname_or_ipaddr(s)) {
4418                  return WERR_CAN_NOT_COMPLETE;
4419         }
4420
4421         return enum_all_printers_info_1(mem_ctx, PRINTER_ENUM_NAME, info, count);
4422 }
4423
4424 /********************************************************************
4425  * api_spoolss_enumprinters
4426  *
4427  * called from api_spoolss_enumprinters (see this to understand)
4428  ********************************************************************/
4429
4430 static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
4431                                        union spoolss_PrinterInfo **info,
4432                                        uint32_t *count)
4433 {
4434         DEBUG(4,("enum_all_printers_info_2\n"));
4435
4436         return enum_all_printers_info_level(mem_ctx, 2, 0, info, count);
4437 }
4438
4439 /********************************************************************
4440  * handle enumeration of printers at level 1
4441  ********************************************************************/
4442
4443 static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
4444                                   uint32_t flags,
4445                                   const char *name,
4446                                   union spoolss_PrinterInfo **info,
4447                                   uint32_t *count)
4448 {
4449         /* Not all the flags are equals */
4450
4451         if (flags & PRINTER_ENUM_LOCAL) {
4452                 return enum_all_printers_info_1_local(mem_ctx, info, count);
4453         }
4454
4455         if (flags & PRINTER_ENUM_NAME) {
4456                 return enum_all_printers_info_1_name(mem_ctx, name, info, count);
4457         }
4458
4459         if (flags & PRINTER_ENUM_NETWORK) {
4460                 return enum_all_printers_info_1_network(mem_ctx, name, info, count);
4461         }
4462
4463         return WERR_OK; /* NT4sp5 does that */
4464 }
4465
4466 /********************************************************************
4467  * handle enumeration of printers at level 2
4468  ********************************************************************/
4469
4470 static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
4471                                   uint32_t flags,
4472                                   const char *servername,
4473                                   union spoolss_PrinterInfo **info,
4474                                   uint32_t *count)
4475 {
4476         if (flags & PRINTER_ENUM_LOCAL) {
4477                 return enum_all_printers_info_2(mem_ctx, info, count);
4478         }
4479
4480         if (flags & PRINTER_ENUM_NAME) {
4481                 if (!is_myname_or_ipaddr(canon_servername(servername))) {
4482                         return WERR_INVALID_NAME;
4483                 }
4484
4485                 return enum_all_printers_info_2(mem_ctx, info, count);
4486         }
4487
4488         if (flags & PRINTER_ENUM_REMOTE) {
4489                 return WERR_UNKNOWN_LEVEL;
4490         }
4491
4492         return WERR_OK;
4493 }
4494
4495 /********************************************************************
4496  * handle enumeration of printers at level 4
4497  ********************************************************************/
4498
4499 static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
4500                                   uint32_t flags,
4501                                   const char *servername,
4502                                   union spoolss_PrinterInfo **info,
4503                                   uint32_t *count)
4504 {
4505         DEBUG(4,("enum_all_printers_info_4\n"));
4506
4507         return enum_all_printers_info_level(mem_ctx, 4, flags, info, count);
4508 }
4509
4510
4511 /********************************************************************
4512  * handle enumeration of printers at level 5
4513  ********************************************************************/
4514
4515 static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
4516                                   uint32_t flags,
4517                                   const char *servername,
4518                                   union spoolss_PrinterInfo **info,
4519                                   uint32_t *count)
4520 {
4521         DEBUG(4,("enum_all_printers_info_5\n"));
4522
4523         return enum_all_printers_info_level(mem_ctx, 5, flags, info, count);
4524 }
4525
4526 /****************************************************************
4527  _spoolss_EnumPrinters
4528 ****************************************************************/
4529
4530 WERROR _spoolss_EnumPrinters(pipes_struct *p,
4531                              struct spoolss_EnumPrinters *r)
4532 {
4533         const char *name;
4534         WERROR result;
4535
4536         /* that's an [in out] buffer */
4537
4538         if (!r->in.buffer && (r->in.offered != 0)) {
4539                 return WERR_INVALID_PARAM;
4540         }
4541
4542         DEBUG(4,("_spoolss_EnumPrinters\n"));
4543
4544         *r->out.needed = 0;
4545         *r->out.count = 0;
4546         *r->out.info = NULL;
4547
4548         /*
4549          * Level 1:
4550          *          flags==PRINTER_ENUM_NAME
4551          *           if name=="" then enumerates all printers
4552          *           if name!="" then enumerate the printer
4553          *          flags==PRINTER_ENUM_REMOTE
4554          *          name is NULL, enumerate printers
4555          * Level 2: name!="" enumerates printers, name can't be NULL
4556          * Level 3: doesn't exist
4557          * Level 4: does a local registry lookup
4558          * Level 5: same as Level 2
4559          */
4560
4561         name = talloc_strdup_upper(p->mem_ctx, r->in.server);
4562         W_ERROR_HAVE_NO_MEMORY(name);
4563
4564         switch (r->in.level) {
4565         case 0:
4566                 result = enumprinters_level0(p->mem_ctx, r->in.flags, name,
4567                                              r->out.info, r->out.count);
4568                 break;
4569         case 1:
4570                 result = enumprinters_level1(p->mem_ctx, r->in.flags, name,
4571                                              r->out.info, r->out.count);
4572                 break;
4573         case 2:
4574                 result = enumprinters_level2(p->mem_ctx, r->in.flags, name,
4575                                              r->out.info, r->out.count);
4576                 break;
4577         case 4:
4578                 result = enumprinters_level4(p->mem_ctx, r->in.flags, name,
4579                                              r->out.info, r->out.count);
4580                 break;
4581         case 5:
4582                 result = enumprinters_level5(p->mem_ctx, r->in.flags, name,
4583                                              r->out.info, r->out.count);
4584                 break;
4585         default:
4586                 return WERR_UNKNOWN_LEVEL;
4587         }
4588
4589         if (!W_ERROR_IS_OK(result)) {
4590                 return result;
4591         }
4592
4593         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
4594                                                      spoolss_EnumPrinters, NULL,
4595                                                      *r->out.info, r->in.level,
4596                                                      *r->out.count);
4597         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
4598         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
4599
4600         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4601 }
4602
4603 /****************************************************************
4604  _spoolss_GetPrinter
4605 ****************************************************************/
4606
4607 WERROR _spoolss_GetPrinter(pipes_struct *p,
4608                            struct spoolss_GetPrinter *r)
4609 {
4610         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
4611         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
4612         WERROR result = WERR_OK;
4613
4614         int snum;
4615
4616         /* that's an [in out] buffer */
4617
4618         if (!r->in.buffer && (r->in.offered != 0)) {
4619                 return WERR_INVALID_PARAM;
4620         }
4621
4622         *r->out.needed = 0;
4623
4624         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
4625                 return WERR_BADFID;
4626         }
4627
4628         result = get_a_printer(Printer, &ntprinter, 2,
4629                                lp_const_servicename(snum));
4630         if (!W_ERROR_IS_OK(result)) {
4631                 return result;
4632         }
4633
4634         switch (r->in.level) {
4635         case 0:
4636                 result = construct_printer_info0(p->mem_ctx, ntprinter,
4637                                                  &r->out.info->info0, snum);
4638                 break;
4639         case 1:
4640                 result = construct_printer_info1(p->mem_ctx, ntprinter,
4641                                                  PRINTER_ENUM_ICON8,
4642                                                  &r->out.info->info1, snum);
4643                 break;
4644         case 2:
4645                 result = construct_printer_info2(p->mem_ctx, ntprinter,
4646                                                  &r->out.info->info2, snum);
4647                 break;
4648         case 3:
4649                 result = construct_printer_info3(p->mem_ctx, ntprinter,
4650                                                  &r->out.info->info3, snum);
4651                 break;
4652         case 4:
4653                 result = construct_printer_info4(p->mem_ctx, ntprinter,
4654                                                  &r->out.info->info4, snum);
4655                 break;
4656         case 5:
4657                 result = construct_printer_info5(p->mem_ctx, ntprinter,
4658                                                  &r->out.info->info5, snum);
4659                 break;
4660         case 6:
4661                 result = construct_printer_info6(p->mem_ctx, ntprinter,
4662                                                  &r->out.info->info6, snum);
4663                 break;
4664         case 7:
4665                 result = construct_printer_info7(p->mem_ctx, Printer,
4666                                                  &r->out.info->info7, snum);
4667                 break;
4668         case 8:
4669                 result = construct_printer_info8(p->mem_ctx, ntprinter,
4670                                                  &r->out.info->info8, snum);
4671                 break;
4672         default:
4673                 result = WERR_UNKNOWN_LEVEL;
4674                 break;
4675         }
4676
4677         free_a_printer(&ntprinter, 2);
4678
4679         if (!W_ERROR_IS_OK(result)) {
4680                 TALLOC_FREE(r->out.info);
4681                 return result;
4682         }
4683
4684         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrinterInfo, NULL,
4685                                                r->out.info, r->in.level);
4686         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
4687
4688         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
4689 }
4690
4691 /********************************************************************
4692  ********************************************************************/
4693
4694 static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
4695                                                   fstring *fstring_array,
4696                                                   const char *cservername)
4697 {
4698         int i, num_strings = 0;
4699         const char **array = NULL;
4700
4701         for (i=0; fstring_array && fstring_array[i][0] != '\0'; i++) {
4702
4703                 const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
4704                                                   cservername, fstring_array[i]);
4705                 if (!str) {
4706                         TALLOC_FREE(array);
4707                         return NULL;
4708                 }
4709
4710
4711                 if (!add_string_to_array(mem_ctx, str, &array, &num_strings)) {
4712                         TALLOC_FREE(array);
4713                         return NULL;
4714                 }
4715         }
4716
4717         if (i > 0) {
4718                 ADD_TO_ARRAY(mem_ctx, const char *, NULL,
4719                              &array, &num_strings);
4720         }
4721
4722         return array;
4723 }
4724
4725 /********************************************************************
4726  * fill a spoolss_DriverInfo1 struct
4727  ********************************************************************/
4728
4729 static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
4730                                         struct spoolss_DriverInfo1 *r,
4731                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4732                                         const char *servername,
4733                                         const char *architecture)
4734 {
4735         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4736         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4737
4738         return WERR_OK;
4739 }
4740
4741 /********************************************************************
4742  * fill a spoolss_DriverInfo2 struct
4743  ********************************************************************/
4744
4745 static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
4746                                         struct spoolss_DriverInfo2 *r,
4747                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4748                                         const char *servername)
4749
4750 {
4751         const char *cservername = canon_servername(servername);
4752
4753         r->version              = driver->info_3->cversion;
4754
4755         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4756         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4757         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4758         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4759
4760         if (strlen(driver->info_3->driverpath)) {
4761                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4762                                 cservername, driver->info_3->driverpath);
4763         } else {
4764                 r->driver_path  = talloc_strdup(mem_ctx, "");
4765         }
4766         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4767
4768         if (strlen(driver->info_3->datafile)) {
4769                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4770                                 cservername, driver->info_3->datafile);
4771         } else {
4772                 r->data_file    = talloc_strdup(mem_ctx, "");
4773         }
4774         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4775
4776         if (strlen(driver->info_3->configfile)) {
4777                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4778                                 cservername, driver->info_3->configfile);
4779         } else {
4780                 r->config_file  = talloc_strdup(mem_ctx, "");
4781         }
4782         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4783
4784         return WERR_OK;
4785 }
4786
4787 /********************************************************************
4788  * fill a spoolss_DriverInfo3 struct
4789  ********************************************************************/
4790
4791 static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
4792                                         struct spoolss_DriverInfo3 *r,
4793                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4794                                         const char *servername)
4795 {
4796         const char *cservername = canon_servername(servername);
4797
4798         r->version              = driver->info_3->cversion;
4799
4800         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4801         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4802         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4803         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4804
4805         if (strlen(driver->info_3->driverpath)) {
4806                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4807                                 cservername, driver->info_3->driverpath);
4808         } else {
4809                 r->driver_path  = talloc_strdup(mem_ctx, "");
4810         }
4811         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4812
4813         if (strlen(driver->info_3->datafile)) {
4814                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4815                                 cservername, driver->info_3->datafile);
4816         } else {
4817                 r->data_file    = talloc_strdup(mem_ctx, "");
4818         }
4819         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4820
4821         if (strlen(driver->info_3->configfile)) {
4822                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4823                                 cservername, driver->info_3->configfile);
4824         } else {
4825                 r->config_file  = talloc_strdup(mem_ctx, "");
4826         }
4827         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4828
4829         if (strlen(driver->info_3->helpfile)) {
4830                 r->help_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4831                                 cservername, driver->info_3->helpfile);
4832         } else {
4833                 r->help_file    = talloc_strdup(mem_ctx, "");
4834         }
4835         W_ERROR_HAVE_NO_MEMORY(r->help_file);
4836
4837         r->monitor_name         = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4838         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4839         r->default_datatype     = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4840         W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4841
4842         r->dependent_files = string_array_from_driver_info(mem_ctx,
4843                                                            driver->info_3->dependentfiles,
4844                                                            cservername);
4845         return WERR_OK;
4846 }
4847
4848 /********************************************************************
4849  * fill a spoolss_DriverInfo4 struct
4850  ********************************************************************/
4851
4852 static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
4853                                         struct spoolss_DriverInfo4 *r,
4854                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4855                                         const char *servername)
4856 {
4857         const char *cservername = canon_servername(servername);
4858
4859         r->version              = driver->info_3->cversion;
4860
4861         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4862         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4863         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4864         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4865
4866         if (strlen(driver->info_3->driverpath)) {
4867                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4868                                 cservername, driver->info_3->driverpath);
4869         } else {
4870                 r->driver_path  = talloc_strdup(mem_ctx, "");
4871         }
4872         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4873
4874         if (strlen(driver->info_3->datafile)) {
4875                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4876                                 cservername, driver->info_3->datafile);
4877         } else {
4878                 r->data_file    = talloc_strdup(mem_ctx, "");
4879         }
4880         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4881
4882         if (strlen(driver->info_3->configfile)) {
4883                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4884                                 cservername, driver->info_3->configfile);
4885         } else {
4886                 r->config_file  = talloc_strdup(mem_ctx, "");
4887         }
4888         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4889
4890         if (strlen(driver->info_3->helpfile)) {
4891                 r->help_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4892                                 cservername, driver->info_3->helpfile);
4893         } else {
4894                 r->help_file    = talloc_strdup(mem_ctx, "");
4895         }
4896         W_ERROR_HAVE_NO_MEMORY(r->help_file);
4897
4898         r->dependent_files = string_array_from_driver_info(mem_ctx,
4899                                                            driver->info_3->dependentfiles,
4900                                                            cservername);
4901
4902
4903         r->monitor_name         = talloc_strdup(mem_ctx, driver->info_3->monitorname);
4904         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
4905         r->default_datatype     = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
4906         W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
4907
4908         r->previous_names = string_array_from_driver_info(mem_ctx,
4909                                                           NULL,
4910                                                           cservername);
4911
4912         return WERR_OK;
4913 }
4914
4915 /********************************************************************
4916  * fill a spoolss_DriverInfo5 struct
4917  ********************************************************************/
4918
4919 static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
4920                                         struct spoolss_DriverInfo5 *r,
4921                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4922                                         const char *servername)
4923 {
4924         const char *cservername = canon_servername(servername);
4925
4926         r->version              = driver->info_3->cversion;
4927
4928         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4929         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4930         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4931         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4932
4933         if (strlen(driver->info_3->driverpath)) {
4934                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4935                                 cservername, driver->info_3->driverpath);
4936         } else {
4937                 r->driver_path  = talloc_strdup(mem_ctx, "");
4938         }
4939         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4940
4941         if (strlen(driver->info_3->datafile)) {
4942                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4943                                 cservername, driver->info_3->datafile);
4944         } else {
4945                 r->data_file    = talloc_strdup(mem_ctx, "");
4946         }
4947         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4948
4949         if (strlen(driver->info_3->configfile)) {
4950                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4951                                 cservername, driver->info_3->configfile);
4952         } else {
4953                 r->config_file  = talloc_strdup(mem_ctx, "");
4954         }
4955         W_ERROR_HAVE_NO_MEMORY(r->config_file);
4956
4957         r->driver_attributes    = 0;
4958         r->config_version       = 0;
4959         r->driver_version       = 0;
4960
4961         return WERR_OK;
4962 }
4963 /********************************************************************
4964  * fill a spoolss_DriverInfo6 struct
4965  ********************************************************************/
4966
4967 static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
4968                                         struct spoolss_DriverInfo6 *r,
4969                                         const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
4970                                         const char *servername)
4971 {
4972         const char *cservername = canon_servername(servername);
4973
4974         r->version              = driver->info_3->cversion;
4975
4976         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
4977         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
4978         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
4979         W_ERROR_HAVE_NO_MEMORY(r->architecture);
4980
4981         if (strlen(driver->info_3->driverpath)) {
4982                 r->driver_path  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4983                                 cservername, driver->info_3->driverpath);
4984         } else {
4985                 r->driver_path  = talloc_strdup(mem_ctx, "");
4986         }
4987         W_ERROR_HAVE_NO_MEMORY(r->driver_path);
4988
4989         if (strlen(driver->info_3->datafile)) {
4990                 r->data_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
4991                                 cservername, driver->info_3->datafile);
4992         } else {
4993                 r->data_file    = talloc_strdup(mem_ctx, "");
4994         }
4995         W_ERROR_HAVE_NO_MEMORY(r->data_file);
4996
4997         if (strlen(driver->info_3->configfile)) {
4998                 r->config_file  = talloc_asprintf(mem_ctx, "\\\\%s%s",
4999                                 cservername, driver->info_3->configfile);
5000         } else {
5001                 r->config_file  = talloc_strdup(mem_ctx, "");
5002         }
5003         W_ERROR_HAVE_NO_MEMORY(r->config_file);
5004
5005         if (strlen(driver->info_3->helpfile)) {
5006                 r->help_file    = talloc_asprintf(mem_ctx, "\\\\%s%s",
5007                                 cservername, driver->info_3->helpfile);
5008         } else {
5009                 r->help_file    = talloc_strdup(mem_ctx, "");
5010         }
5011         W_ERROR_HAVE_NO_MEMORY(r->help_file);
5012
5013         r->monitor_name         = talloc_strdup(mem_ctx, driver->info_3->monitorname);
5014         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
5015         r->default_datatype     = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
5016         W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
5017
5018         r->dependent_files = string_array_from_driver_info(mem_ctx,
5019                                                            driver->info_3->dependentfiles,
5020                                                            cservername);
5021         r->previous_names = string_array_from_driver_info(mem_ctx,
5022                                                           NULL,
5023                                                           cservername);
5024
5025         r->driver_date          = 0;
5026         r->driver_version       = 0;
5027
5028         r->manufacturer_name    = talloc_strdup(mem_ctx, "");
5029         W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5030         r->manufacturer_url     = talloc_strdup(mem_ctx, "");
5031         W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5032         r->hardware_id          = talloc_strdup(mem_ctx, "");
5033         W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5034         r->provider             = talloc_strdup(mem_ctx, "");
5035         W_ERROR_HAVE_NO_MEMORY(r->provider);
5036
5037         return WERR_OK;
5038 }
5039
5040 /********************************************************************
5041  ********************************************************************/
5042
5043 static WERROR fill_spoolss_DriverFileInfo(TALLOC_CTX *mem_ctx,
5044                                           struct spoolss_DriverFileInfo *r,
5045                                           const char *cservername,
5046                                           const char *file_name,
5047                                           enum spoolss_DriverFileType file_type,
5048                                           uint32_t file_version)
5049 {
5050         r->file_name    = talloc_asprintf(mem_ctx, "\\\\%s%s",
5051                                           cservername, file_name);
5052         W_ERROR_HAVE_NO_MEMORY(r->file_name);
5053         r->file_type    = file_type;
5054         r->file_version = file_version;
5055
5056         return WERR_OK;
5057 }
5058
5059 /********************************************************************
5060  ********************************************************************/
5061
5062 static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
5063                                                  const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5064                                                  const char *cservername,
5065                                                  struct spoolss_DriverFileInfo **info_p,
5066                                                  uint32_t *count_p)
5067 {
5068         struct spoolss_DriverFileInfo *info = NULL;
5069         uint32_t count = 0;
5070         WERROR result;
5071         uint32_t i;
5072
5073         *info_p = NULL;
5074         *count_p = 0;
5075
5076         if (strlen(driver->info_3->driverpath)) {
5077                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5078                                             struct spoolss_DriverFileInfo,
5079                                             count + 1);
5080                 W_ERROR_HAVE_NO_MEMORY(info);
5081                 result = fill_spoolss_DriverFileInfo(info,
5082                                                      &info[count],
5083                                                      cservername,
5084                                                      driver->info_3->driverpath,
5085                                                      SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
5086                                                      0);
5087                 W_ERROR_NOT_OK_RETURN(result);
5088                 count++;
5089         }
5090
5091         if (strlen(driver->info_3->configfile)) {
5092                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5093                                             struct spoolss_DriverFileInfo,
5094                                             count + 1);
5095                 W_ERROR_HAVE_NO_MEMORY(info);
5096                 result = fill_spoolss_DriverFileInfo(info,
5097                                                      &info[count],
5098                                                      cservername,
5099                                                      driver->info_3->configfile,
5100                                                      SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
5101                                                      0);
5102                 W_ERROR_NOT_OK_RETURN(result);
5103                 count++;
5104         }
5105
5106         if (strlen(driver->info_3->datafile)) {
5107                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5108                                             struct spoolss_DriverFileInfo,
5109                                             count + 1);
5110                 W_ERROR_HAVE_NO_MEMORY(info);
5111                 result = fill_spoolss_DriverFileInfo(info,
5112                                                      &info[count],
5113                                                      cservername,
5114                                                      driver->info_3->datafile,
5115                                                      SPOOLSS_DRIVER_FILE_TYPE_DATA,
5116                                                      0);
5117                 W_ERROR_NOT_OK_RETURN(result);
5118                 count++;
5119         }
5120
5121         if (strlen(driver->info_3->helpfile)) {
5122                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5123                                             struct spoolss_DriverFileInfo,
5124                                             count + 1);
5125                 W_ERROR_HAVE_NO_MEMORY(info);
5126                 result = fill_spoolss_DriverFileInfo(info,
5127                                                      &info[count],
5128                                                      cservername,
5129                                                      driver->info_3->helpfile,
5130                                                      SPOOLSS_DRIVER_FILE_TYPE_HELP,
5131                                                      0);
5132                 W_ERROR_NOT_OK_RETURN(result);
5133                 count++;
5134         }
5135
5136         for (i=0; driver->info_3->dependentfiles[i][0] != '\0'; i++) {
5137                 info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
5138                                             struct spoolss_DriverFileInfo,
5139                                             count + 1);
5140                 W_ERROR_HAVE_NO_MEMORY(info);
5141                 result = fill_spoolss_DriverFileInfo(info,
5142                                                      &info[count],
5143                                                      cservername,
5144                                                      driver->info_3->dependentfiles[i],
5145                                                      SPOOLSS_DRIVER_FILE_TYPE_OTHER,
5146                                                      0);
5147                 W_ERROR_NOT_OK_RETURN(result);
5148                 count++;
5149         }
5150
5151         *info_p = info;
5152         *count_p = count;
5153
5154         return WERR_OK;
5155 }
5156
5157 /********************************************************************
5158  * fill a spoolss_DriverInfo101 sttruct
5159  ********************************************************************/
5160
5161 static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
5162                                           struct spoolss_DriverInfo101 *r,
5163                                           const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
5164                                           const char *servername)
5165 {
5166         const char *cservername = canon_servername(servername);
5167         WERROR result;
5168
5169         r->version              = driver->info_3->cversion;
5170
5171         r->driver_name          = talloc_strdup(mem_ctx, driver->info_3->name);
5172         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
5173         r->architecture         = talloc_strdup(mem_ctx, driver->info_3->environment);
5174         W_ERROR_HAVE_NO_MEMORY(r->architecture);
5175
5176         result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
5177                                                     cservername,
5178                                                     &r->file_info,
5179                                                     &r->file_count);
5180         if (!W_ERROR_IS_OK(result)) {
5181                 return result;
5182         }
5183
5184         r->monitor_name         = talloc_strdup(mem_ctx, driver->info_3->monitorname);
5185         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
5186
5187         r->default_datatype     = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
5188         W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
5189
5190         r->previous_names = string_array_from_driver_info(mem_ctx,
5191                                                           NULL,
5192                                                           cservername);
5193         r->driver_date          = 0;
5194         r->driver_version       = 0;
5195
5196         r->manufacturer_name    = talloc_strdup(mem_ctx, "");
5197         W_ERROR_HAVE_NO_MEMORY(r->manufacturer_name);
5198         r->manufacturer_url     = talloc_strdup(mem_ctx, "");
5199         W_ERROR_HAVE_NO_MEMORY(r->manufacturer_url);
5200         r->hardware_id          = talloc_strdup(mem_ctx, "");
5201         W_ERROR_HAVE_NO_MEMORY(r->hardware_id);
5202         r->provider             = talloc_strdup(mem_ctx, "");
5203         W_ERROR_HAVE_NO_MEMORY(r->provider);
5204
5205         return WERR_OK;
5206 }
5207
5208 /********************************************************************
5209  * construct_printer_driver_info_1
5210  ********************************************************************/
5211
5212 static WERROR construct_printer_driver_info_1(TALLOC_CTX *mem_ctx,
5213                                               struct spoolss_DriverInfo1 *r,
5214                                               int snum,
5215                                               const char *servername,
5216                                               const char *architecture,
5217                                               uint32_t version)
5218 {
5219         NT_PRINTER_INFO_LEVEL *printer = NULL;
5220         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5221         WERROR result;
5222
5223         ZERO_STRUCT(driver);
5224
5225         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5226                 return WERR_INVALID_PRINTER_NAME;
5227
5228         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5229                 free_a_printer(&printer, 2);
5230                 return WERR_UNKNOWN_PRINTER_DRIVER;
5231         }
5232
5233         result = fill_printer_driver_info1(mem_ctx, r, &driver, servername, architecture);
5234
5235         free_a_printer(&printer,2);
5236
5237         return result;
5238 }
5239
5240 /********************************************************************
5241  * construct_printer_driver_info_2
5242  * fill a printer_info_2 struct
5243  ********************************************************************/
5244
5245 static WERROR construct_printer_driver_info_2(TALLOC_CTX *mem_ctx,
5246                                               struct spoolss_DriverInfo2 *r,
5247                                               int snum,
5248                                               const char *servername,
5249                                               const char *architecture,
5250                                               uint32_t version)
5251 {
5252         NT_PRINTER_INFO_LEVEL *printer = NULL;
5253         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5254         WERROR result;
5255
5256         ZERO_STRUCT(printer);
5257         ZERO_STRUCT(driver);
5258
5259         if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
5260                 return WERR_INVALID_PRINTER_NAME;
5261
5262         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
5263                 free_a_printer(&printer, 2);
5264                 return WERR_UNKNOWN_PRINTER_DRIVER;
5265         }
5266
5267         result = fill_printer_driver_info2(mem_ctx, r, &driver, servername);
5268
5269         free_a_printer(&printer,2);
5270
5271         return result;
5272 }
5273
5274 /********************************************************************
5275  * construct_printer_info_3
5276  * fill a printer_info_3 struct
5277  ********************************************************************/
5278
5279 static WERROR construct_printer_driver_info_3(TALLOC_CTX *mem_ctx,
5280                                               struct spoolss_DriverInfo3 *r,
5281                                               int snum,
5282                                               const char *servername,
5283                                               const char *architecture,
5284                                               uint32_t version)
5285 {
5286         NT_PRINTER_INFO_LEVEL *printer = NULL;
5287         NT_PRINTER_DRIVER_INFO_LEVEL driver;
5288         WERROR status;
5289         ZERO_STRUCT(driver);
5290
5291         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5292         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5293         if (!W_ERROR_IS_OK(status))
5294                 return WERR_INVALID_PRINTER_NAME;
5295
5296         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5297         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5298
5299 #if 0   /* JERRY */
5300
5301         /*
5302          * I put this code in during testing.  Helpful when commenting out the
5303          * support for DRIVER_INFO_6 in regards to win2k.  Not needed in general
5304          * as win2k always queries the driver using an infor level of 6.
5305          * I've left it in (but ifdef'd out) because I'll probably
5306          * use it in experimentation again in the future.   --jerry 22/01/2002
5307          */
5308
5309         if (!W_ERROR_IS_OK(status)) {
5310                 /*
5311                  * Is this a W2k client ?
5312                  */
5313                 if (version == 3) {
5314                         /* Yes - try again with a WinNT driver. */
5315                         version = 2;
5316                         status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5317                         DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
5318                 }
5319 #endif
5320
5321                 if (!W_ERROR_IS_OK(status)) {
5322                         free_a_printer(&printer,2);
5323                         return WERR_UNKNOWN_PRINTER_DRIVER;
5324                 }
5325
5326 #if 0   /* JERRY */
5327         }
5328 #endif
5329
5330
5331         status = fill_printer_driver_info3(mem_ctx, r, &driver, servername);
5332
5333         free_a_printer(&printer,2);
5334
5335         return status;
5336 }
5337
5338 /********************************************************************
5339  * construct_printer_info_6
5340  * fill a printer_info_6 struct
5341  ********************************************************************/
5342
5343 static WERROR construct_printer_driver_info_6(TALLOC_CTX *mem_ctx,
5344                                               struct spoolss_DriverInfo6 *r,
5345                                               int snum,
5346                                               const char *servername,
5347                                               const char *architecture,
5348                                               uint32_t version)
5349 {
5350         NT_PRINTER_INFO_LEVEL           *printer = NULL;
5351         NT_PRINTER_DRIVER_INFO_LEVEL    driver;
5352         WERROR                          status;
5353
5354         ZERO_STRUCT(driver);
5355
5356         status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
5357
5358         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5359
5360         if (!W_ERROR_IS_OK(status))
5361                 return WERR_INVALID_PRINTER_NAME;
5362
5363         status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5364
5365         DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5366
5367         if (!W_ERROR_IS_OK(status))
5368         {
5369                 /*
5370                  * Is this a W2k client ?
5371                  */
5372
5373                 if (version < 3) {
5374                         free_a_printer(&printer,2);
5375                         return WERR_UNKNOWN_PRINTER_DRIVER;
5376                 }
5377
5378                 /* Yes - try again with a WinNT driver. */
5379                 version = 2;
5380                 status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
5381                 DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
5382                 if (!W_ERROR_IS_OK(status)) {
5383                         free_a_printer(&printer,2);
5384                         return WERR_UNKNOWN_PRINTER_DRIVER;
5385                 }
5386         }
5387
5388         status = fill_printer_driver_info6(mem_ctx, r, &driver, servername);
5389
5390         free_a_printer(&printer,2);
5391         free_a_printer_driver(driver, 3);
5392
5393         return status;
5394 }
5395
5396 /********************************************************************
5397  * construct_printer_info_101
5398  * fill a printer_info_101 struct
5399  ********************************************************************/
5400
5401 static WERROR construct_printer_driver_info_101(TALLOC_CTX *mem_ctx,
5402                                                 struct spoolss_DriverInfo101 *r,
5403                                                 int snum,
5404                                                 const char *servername,
5405                                                 const char *architecture,
5406                                                 uint32_t version)
5407 {
5408         NT_PRINTER_INFO_LEVEL           *printer = NULL;
5409         NT_PRINTER_DRIVER_INFO_LEVEL    driver;
5410         WERROR                          result;
5411
5412         ZERO_STRUCT(driver);
5413
5414         result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
5415
5416         DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5417                 win_errstr(result)));
5418
5419         if (!W_ERROR_IS_OK(result)) {
5420                 return WERR_INVALID_PRINTER_NAME;
5421         }
5422
5423         result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5424                                       architecture, version);
5425
5426         DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
5427                 win_errstr(result)));
5428
5429         if (!W_ERROR_IS_OK(result)) {
5430                 /*
5431                  * Is this a W2k client ?
5432                  */
5433
5434                 if (version < 3) {
5435                         free_a_printer(&printer, 2);
5436                         return WERR_UNKNOWN_PRINTER_DRIVER;
5437                 }
5438
5439                 /* Yes - try again with a WinNT driver. */
5440                 version = 2;
5441                 result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
5442                                               architecture, version);
5443                 DEBUG(8,("construct_printer_driver_info_6: status: %s\n",
5444                         win_errstr(result)));
5445                 if (!W_ERROR_IS_OK(result)) {
5446                         free_a_printer(&printer, 2);
5447                         return WERR_UNKNOWN_PRINTER_DRIVER;
5448                 }
5449         }
5450
5451         result = fill_printer_driver_info101(mem_ctx, r, &driver, servername);
5452
5453         free_a_printer(&printer, 2);
5454         free_a_printer_driver(driver, 3);
5455
5456         return result;
5457 }
5458
5459 /****************************************************************
5460  _spoolss_GetPrinterDriver2
5461 ****************************************************************/
5462
5463 WERROR _spoolss_GetPrinterDriver2(pipes_struct *p,
5464                                   struct spoolss_GetPrinterDriver2 *r)
5465 {
5466         Printer_entry *printer;
5467         WERROR result;
5468
5469         const char *servername;
5470         int snum;
5471
5472         /* that's an [in out] buffer */
5473
5474         if (!r->in.buffer && (r->in.offered != 0)) {
5475                 return WERR_INVALID_PARAM;
5476         }
5477
5478         DEBUG(4,("_spoolss_GetPrinterDriver2\n"));
5479
5480         if (!(printer = find_printer_index_by_hnd(p, r->in.handle))) {
5481                 DEBUG(0,("_spoolss_GetPrinterDriver2: invalid printer handle!\n"));
5482                 return WERR_INVALID_PRINTER_NAME;
5483         }
5484
5485         *r->out.needed = 0;
5486         *r->out.server_major_version = 0;
5487         *r->out.server_minor_version = 0;
5488
5489         servername = get_server_name(printer);
5490
5491         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5492                 return WERR_BADFID;
5493         }
5494
5495         switch (r->in.level) {
5496         case 1:
5497                 result = construct_printer_driver_info_1(p->mem_ctx,
5498                                                          &r->out.info->info1,
5499                                                          snum,
5500                                                          servername,
5501                                                          r->in.architecture,
5502                                                          r->in.client_major_version);
5503                 break;
5504         case 2:
5505                 result = construct_printer_driver_info_2(p->mem_ctx,
5506                                                          &r->out.info->info2,
5507                                                          snum,
5508                                                          servername,
5509                                                          r->in.architecture,
5510                                                          r->in.client_major_version);
5511                 break;
5512         case 3:
5513                 result = construct_printer_driver_info_3(p->mem_ctx,
5514                                                          &r->out.info->info3,
5515                                                          snum,
5516                                                          servername,
5517                                                          r->in.architecture,
5518                                                          r->in.client_major_version);
5519                 break;
5520         case 6:
5521                 result = construct_printer_driver_info_6(p->mem_ctx,
5522                                                          &r->out.info->info6,
5523                                                          snum,
5524                                                          servername,
5525                                                          r->in.architecture,
5526                                                          r->in.client_major_version);
5527                 break;
5528         case 101:
5529                 result = construct_printer_driver_info_101(p->mem_ctx,
5530                                                            &r->out.info->info101,
5531                                                            snum,
5532                                                            servername,
5533                                                            r->in.architecture,
5534                                                            r->in.client_major_version);
5535                 break;
5536         default:
5537                 result = WERR_UNKNOWN_LEVEL;
5538                 break;
5539         }
5540
5541         if (!W_ERROR_IS_OK(result)) {
5542                 TALLOC_FREE(r->out.info);
5543                 return result;
5544         }
5545
5546         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverInfo, NULL,
5547                                                r->out.info, r->in.level);
5548         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
5549
5550         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
5551 }
5552
5553
5554 /****************************************************************
5555  _spoolss_StartPagePrinter
5556 ****************************************************************/
5557
5558 WERROR _spoolss_StartPagePrinter(pipes_struct *p,
5559                                  struct spoolss_StartPagePrinter *r)
5560 {
5561         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5562
5563         if (!Printer) {
5564                 DEBUG(3,("_spoolss_StartPagePrinter: "
5565                         "Error in startpageprinter printer handle\n"));
5566                 return WERR_BADFID;
5567         }
5568
5569         Printer->page_started = true;
5570         return WERR_OK;
5571 }
5572
5573 /****************************************************************
5574  _spoolss_EndPagePrinter
5575 ****************************************************************/
5576
5577 WERROR _spoolss_EndPagePrinter(pipes_struct *p,
5578                                struct spoolss_EndPagePrinter *r)
5579 {
5580         int snum;
5581
5582         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5583
5584         if (!Printer) {
5585                 DEBUG(2,("_spoolss_EndPagePrinter: Invalid handle (%s:%u:%u).\n",
5586                         OUR_HANDLE(r->in.handle)));
5587                 return WERR_BADFID;
5588         }
5589
5590         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5591                 return WERR_BADFID;
5592
5593         Printer->page_started = false;
5594         print_job_endpage(snum, Printer->jobid);
5595
5596         return WERR_OK;
5597 }
5598
5599 /****************************************************************
5600  _spoolss_StartDocPrinter
5601 ****************************************************************/
5602
5603 WERROR _spoolss_StartDocPrinter(pipes_struct *p,
5604                                 struct spoolss_StartDocPrinter *r)
5605 {
5606         struct spoolss_DocumentInfo1 *info_1;
5607         int snum;
5608         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5609
5610         if (!Printer) {
5611                 DEBUG(2,("_spoolss_StartDocPrinter: "
5612                         "Invalid handle (%s:%u:%u)\n",
5613                         OUR_HANDLE(r->in.handle)));
5614                 return WERR_BADFID;
5615         }
5616
5617         if (r->in.level != 1) {
5618                 return WERR_UNKNOWN_LEVEL;
5619         }
5620
5621         info_1 = r->in.info.info1;
5622
5623         /*
5624          * a nice thing with NT is it doesn't listen to what you tell it.
5625          * when asked to send _only_ RAW datas, it tries to send datas
5626          * in EMF format.
5627          *
5628          * So I add checks like in NT Server ...
5629          */
5630
5631         if (info_1->datatype) {
5632                 if (strcmp(info_1->datatype, "RAW") != 0) {
5633                         *r->out.job_id = 0;
5634                         return WERR_INVALID_DATATYPE;
5635                 }
5636         }
5637
5638         /* get the share number of the printer */
5639         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
5640                 return WERR_BADFID;
5641         }
5642
5643         Printer->jobid = print_job_start(p->server_info, snum,
5644                                          info_1->document_name,
5645                                          Printer->nt_devmode);
5646
5647         /* An error occured in print_job_start() so return an appropriate
5648            NT error code. */
5649
5650         if (Printer->jobid == -1) {
5651                 return map_werror_from_unix(errno);
5652         }
5653
5654         Printer->document_started = true;
5655         *r->out.job_id = Printer->jobid;
5656
5657         return WERR_OK;
5658 }
5659
5660 /****************************************************************
5661  _spoolss_EndDocPrinter
5662 ****************************************************************/
5663
5664 WERROR _spoolss_EndDocPrinter(pipes_struct *p,
5665                               struct spoolss_EndDocPrinter *r)
5666 {
5667         return _spoolss_enddocprinter_internal(p, r->in.handle);
5668 }
5669
5670 /****************************************************************
5671  _spoolss_WritePrinter
5672 ****************************************************************/
5673
5674 WERROR _spoolss_WritePrinter(pipes_struct *p,
5675                              struct spoolss_WritePrinter *r)
5676 {
5677         uint32_t buffer_written;
5678         int snum;
5679         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
5680
5681         if (!Printer) {
5682                 DEBUG(2,("_spoolss_WritePrinter: Invalid handle (%s:%u:%u)\n",
5683                         OUR_HANDLE(r->in.handle)));
5684                 *r->out.num_written = r->in._data_size;
5685                 return WERR_BADFID;
5686         }
5687
5688         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5689                 return WERR_BADFID;
5690
5691         buffer_written = (uint32_t)print_job_write(snum, Printer->jobid,
5692                                                    (const char *)r->in.data.data,
5693                                                    (SMB_OFF_T)-1,
5694                                                    (size_t)r->in._data_size);
5695         if (buffer_written == (uint32_t)-1) {
5696                 *r->out.num_written = 0;
5697                 if (errno == ENOSPC)
5698                         return WERR_NO_SPOOL_SPACE;
5699                 else
5700                         return WERR_ACCESS_DENIED;
5701         }
5702
5703         *r->out.num_written = r->in._data_size;
5704
5705         return WERR_OK;
5706 }
5707
5708 /********************************************************************
5709  * api_spoolss_getprinter
5710  * called from the spoolss dispatcher
5711  *
5712  ********************************************************************/
5713
5714 static WERROR control_printer(struct policy_handle *handle, uint32_t command,
5715                               pipes_struct *p)
5716 {
5717         int snum;
5718         WERROR errcode = WERR_BADFUNC;
5719         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5720
5721         if (!Printer) {
5722                 DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n",
5723                         OUR_HANDLE(handle)));
5724                 return WERR_BADFID;
5725         }
5726
5727         if (!get_printer_snum(p, handle, &snum, NULL))
5728                 return WERR_BADFID;
5729
5730         switch (command) {
5731         case SPOOLSS_PRINTER_CONTROL_PAUSE:
5732                 if (print_queue_pause(p->server_info, snum, &errcode)) {
5733                         errcode = WERR_OK;
5734                 }
5735                 break;
5736         case SPOOLSS_PRINTER_CONTROL_RESUME:
5737         case SPOOLSS_PRINTER_CONTROL_UNPAUSE:
5738                 if (print_queue_resume(p->server_info, snum, &errcode)) {
5739                         errcode = WERR_OK;
5740                 }
5741                 break;
5742         case SPOOLSS_PRINTER_CONTROL_PURGE:
5743                 if (print_queue_purge(p->server_info, snum, &errcode)) {
5744                         errcode = WERR_OK;
5745                 }
5746                 break;
5747         default:
5748                 return WERR_UNKNOWN_LEVEL;
5749         }
5750
5751         return errcode;
5752 }
5753
5754
5755 /****************************************************************
5756  _spoolss_AbortPrinter
5757  * From MSDN: "Deletes printer's spool file if printer is configured
5758  * for spooling"
5759 ****************************************************************/
5760
5761 WERROR _spoolss_AbortPrinter(pipes_struct *p,
5762                              struct spoolss_AbortPrinter *r)
5763 {
5764         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
5765         int             snum;
5766         WERROR          errcode = WERR_OK;
5767
5768         if (!Printer) {
5769                 DEBUG(2,("_spoolss_AbortPrinter: Invalid handle (%s:%u:%u)\n",
5770                         OUR_HANDLE(r->in.handle)));
5771                 return WERR_BADFID;
5772         }
5773
5774         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
5775                 return WERR_BADFID;
5776
5777         print_job_delete(p->server_info, snum, Printer->jobid, &errcode );
5778
5779         return errcode;
5780 }
5781
5782 /********************************************************************
5783  * called by spoolss_api_setprinter
5784  * when updating a printer description
5785  ********************************************************************/
5786
5787 static WERROR update_printer_sec(struct policy_handle *handle,
5788                                  pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
5789 {
5790         SEC_DESC_BUF *new_secdesc_ctr = NULL, *old_secdesc_ctr = NULL;
5791         WERROR result;
5792         int snum;
5793
5794         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
5795
5796         if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
5797                 DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
5798                          OUR_HANDLE(handle)));
5799
5800                 result = WERR_BADFID;
5801                 goto done;
5802         }
5803
5804         if (!secdesc_ctr) {
5805                 DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
5806                 result = WERR_INVALID_PARAM;
5807                 goto done;
5808         }
5809
5810         /* Check the user has permissions to change the security
5811            descriptor.  By experimentation with two NT machines, the user
5812            requires Full Access to the printer to change security
5813            information. */
5814
5815         if ( Printer->access_granted != PRINTER_ACCESS_ADMINISTER ) {
5816                 DEBUG(4,("update_printer_sec: updated denied by printer permissions\n"));
5817                 result = WERR_ACCESS_DENIED;
5818                 goto done;
5819         }
5820
5821         /* NT seems to like setting the security descriptor even though
5822            nothing may have actually changed. */
5823
5824         if ( !nt_printing_getsec(p->mem_ctx, Printer->sharename, &old_secdesc_ctr)) {
5825                 DEBUG(2,("update_printer_sec: nt_printing_getsec() failed\n"));
5826                 result = WERR_BADFID;
5827                 goto done;
5828         }
5829
5830         if (DEBUGLEVEL >= 10) {
5831                 SEC_ACL *the_acl;
5832                 int i;
5833
5834                 the_acl = old_secdesc_ctr->sd->dacl;
5835                 DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
5836                            PRINTERNAME(snum), the_acl->num_aces));
5837
5838                 for (i = 0; i < the_acl->num_aces; i++) {
5839                         DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5840                                            &the_acl->aces[i].trustee),
5841                                   the_acl->aces[i].access_mask));
5842                 }
5843
5844                 the_acl = secdesc_ctr->sd->dacl;
5845
5846                 if (the_acl) {
5847                         DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5848                                    PRINTERNAME(snum), the_acl->num_aces));
5849
5850                         for (i = 0; i < the_acl->num_aces; i++) {
5851                                 DEBUG(10, ("%s 0x%08x\n", sid_string_dbg(
5852                                                    &the_acl->aces[i].trustee),
5853                                            the_acl->aces[i].access_mask));
5854                         }
5855                 } else {
5856                         DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
5857                 }
5858         }
5859
5860         new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
5861         if (!new_secdesc_ctr) {
5862                 result = WERR_NOMEM;
5863                 goto done;
5864         }
5865
5866         if (sec_desc_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
5867                 result = WERR_OK;
5868                 goto done;
5869         }
5870
5871         result = nt_printing_setsec(Printer->sharename, new_secdesc_ctr);
5872
5873  done:
5874
5875         return result;
5876 }
5877
5878 /********************************************************************
5879  Canonicalize printer info from a client
5880
5881  ATTN: It does not matter what we set the servername to hear
5882  since we do the necessary work in get_a_printer() to set it to
5883  the correct value based on what the client sent in the
5884  _spoolss_open_printer_ex().
5885  ********************************************************************/
5886
5887 static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
5888 {
5889         fstring printername;
5890         const char *p;
5891
5892         DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
5893                 "portname=%s drivername=%s comment=%s location=%s\n",
5894                 info->servername, info->printername, info->sharename,
5895                 info->portname, info->drivername, info->comment, info->location));
5896
5897         /* we force some elements to "correct" values */
5898         slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
5899         fstrcpy(info->sharename, lp_servicename(snum));
5900
5901         /* check to see if we allow printername != sharename */
5902
5903         if ( lp_force_printername(snum) ) {
5904                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5905                         global_myname(), info->sharename );
5906         } else {
5907
5908                 /* make sure printername is in \\server\printername format */
5909
5910                 fstrcpy( printername, info->printername );
5911                 p = printername;
5912                 if ( printername[0] == '\\' && printername[1] == '\\' ) {
5913                         if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
5914                                 p++;
5915                 }
5916
5917                 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
5918                          global_myname(), p );
5919         }
5920
5921         info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
5922         info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
5923
5924
5925
5926         return true;
5927 }
5928
5929 /****************************************************************************
5930 ****************************************************************************/
5931
5932 WERROR add_port_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, const char *portname, const char *uri )
5933 {
5934         char *cmd = lp_addport_cmd();
5935         char *command = NULL;
5936         int ret;
5937         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5938         bool is_print_op = false;
5939
5940         if ( !*cmd ) {
5941                 return WERR_ACCESS_DENIED;
5942         }
5943
5944         command = talloc_asprintf(ctx,
5945                         "%s \"%s\" \"%s\"", cmd, portname, uri );
5946         if (!command) {
5947                 return WERR_NOMEM;
5948         }
5949
5950         if ( token )
5951                 is_print_op = user_has_privileges( token, &se_printop );
5952
5953         DEBUG(10,("Running [%s]\n", command));
5954
5955         /********* BEGIN SePrintOperatorPrivilege **********/
5956
5957         if ( is_print_op )
5958                 become_root();
5959
5960         ret = smbrun(command, NULL);
5961
5962         if ( is_print_op )
5963                 unbecome_root();
5964
5965         /********* END SePrintOperatorPrivilege **********/
5966
5967         DEBUGADD(10,("returned [%d]\n", ret));
5968
5969         TALLOC_FREE(command);
5970
5971         if ( ret != 0 ) {
5972                 return WERR_ACCESS_DENIED;
5973         }
5974
5975         return WERR_OK;
5976 }
5977
5978 /****************************************************************************
5979 ****************************************************************************/
5980
5981 bool add_printer_hook(TALLOC_CTX *ctx, NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
5982 {
5983         char *cmd = lp_addprinter_cmd();
5984         char **qlines;
5985         char *command = NULL;
5986         int numlines;
5987         int ret;
5988         int fd;
5989         SE_PRIV se_printop = SE_PRINT_OPERATOR;
5990         bool is_print_op = false;
5991         char *remote_machine = talloc_strdup(ctx, "%m");
5992
5993         if (!remote_machine) {
5994                 return false;
5995         }
5996         remote_machine = talloc_sub_basic(ctx,
5997                                 current_user_info.smb_name,
5998                                 current_user_info.domain,
5999                                 remote_machine);
6000         if (!remote_machine) {
6001                 return false;
6002         }
6003
6004         command = talloc_asprintf(ctx,
6005                         "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
6006                         cmd, printer->info_2->printername, printer->info_2->sharename,
6007                         printer->info_2->portname, printer->info_2->drivername,
6008                         printer->info_2->location, printer->info_2->comment, remote_machine);
6009         if (!command) {
6010                 return false;
6011         }
6012
6013         if ( token )
6014                 is_print_op = user_has_privileges( token, &se_printop );
6015
6016         DEBUG(10,("Running [%s]\n", command));
6017
6018         /********* BEGIN SePrintOperatorPrivilege **********/
6019
6020         if ( is_print_op )
6021                 become_root();
6022
6023         if ( (ret = smbrun(command, &fd)) == 0 ) {
6024                 /* Tell everyone we updated smb.conf. */
6025                 message_send_all(smbd_messaging_context(),
6026                                  MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
6027         }
6028
6029         if ( is_print_op )
6030                 unbecome_root();
6031
6032         /********* END SePrintOperatorPrivilege **********/
6033
6034         DEBUGADD(10,("returned [%d]\n", ret));
6035
6036         TALLOC_FREE(command);
6037         TALLOC_FREE(remote_machine);
6038
6039         if ( ret != 0 ) {
6040                 if (fd != -1)
6041                         close(fd);
6042                 return false;
6043         }
6044
6045         /* reload our services immediately */
6046         reload_services(false);
6047
6048         numlines = 0;
6049         /* Get lines and convert them back to dos-codepage */
6050         qlines = fd_lines_load(fd, &numlines, 0, NULL);
6051         DEBUGADD(10,("Lines returned = [%d]\n", numlines));
6052         close(fd);
6053
6054         /* Set the portname to what the script says the portname should be. */
6055         /* but don't require anything to be return from the script exit a good error code */
6056
6057         if (numlines) {
6058                 /* Set the portname to what the script says the portname should be. */
6059                 strncpy(printer->info_2->portname, qlines[0], sizeof(printer->info_2->portname));
6060                 DEBUGADD(6,("Line[0] = [%s]\n", qlines[0]));
6061         }
6062
6063         TALLOC_FREE(qlines);
6064         return true;
6065 }
6066
6067
6068 /********************************************************************
6069  * Called by spoolss_api_setprinter
6070  * when updating a printer description.
6071  ********************************************************************/
6072
6073 static WERROR update_printer(pipes_struct *p, struct policy_handle *handle,
6074                              struct spoolss_SetPrinterInfoCtr *info_ctr,
6075                              struct spoolss_DeviceMode *devmode)
6076 {
6077         int snum;
6078         NT_PRINTER_INFO_LEVEL *printer = NULL, *old_printer = NULL;
6079         Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
6080         WERROR result;
6081         UNISTR2 buffer;
6082         fstring asc_buffer;
6083
6084         DEBUG(8,("update_printer\n"));
6085
6086         result = WERR_OK;
6087
6088         if (!Printer) {
6089                 result = WERR_BADFID;
6090                 goto done;
6091         }
6092
6093         if (!get_printer_snum(p, handle, &snum, NULL)) {
6094                 result = WERR_BADFID;
6095                 goto done;
6096         }
6097
6098         if (!W_ERROR_IS_OK(get_a_printer(Printer, &printer, 2, lp_const_servicename(snum))) ||
6099             (!W_ERROR_IS_OK(get_a_printer(Printer, &old_printer, 2, lp_const_servicename(snum))))) {
6100                 result = WERR_BADFID;
6101                 goto done;
6102         }
6103
6104         DEBUGADD(8,("Converting info_2 struct\n"));
6105
6106         /*
6107          * convert_printer_info converts the incoming
6108          * info from the client and overwrites the info
6109          * just read from the tdb in the pointer 'printer'.
6110          */
6111
6112         if (!convert_printer_info(info_ctr, printer)) {
6113                 result =  WERR_NOMEM;
6114                 goto done;
6115         }
6116
6117         if (devmode) {
6118                 /* we have a valid devmode
6119                    convert it and link it*/
6120
6121                 DEBUGADD(8,("update_printer: Converting the devicemode struct\n"));
6122                 if (!convert_devicemode(printer->info_2->printername, devmode,
6123                                         &printer->info_2->devmode)) {
6124                         result =  WERR_NOMEM;
6125                         goto done;
6126                 }
6127         }
6128
6129         /* Do sanity check on the requested changes for Samba */
6130
6131         if (!check_printer_ok(printer->info_2, snum)) {
6132                 result = WERR_INVALID_PARAM;
6133                 goto done;
6134         }
6135
6136         /* FIXME!!! If the driver has changed we really should verify that
6137            it is installed before doing much else   --jerry */
6138
6139         /* Check calling user has permission to update printer description */
6140
6141         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
6142                 DEBUG(3, ("update_printer: printer property change denied by handle\n"));
6143                 result = WERR_ACCESS_DENIED;
6144                 goto done;
6145         }
6146
6147         /* Call addprinter hook */
6148         /* Check changes to see if this is really needed */
6149
6150         if ( *lp_addprinter_cmd()
6151                 && (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
6152                         || !strequal(printer->info_2->comment, old_printer->info_2->comment)
6153                         || !strequal(printer->info_2->portname, old_printer->info_2->portname)
6154                         || !strequal(printer->info_2->location, old_printer->info_2->location)) )
6155         {
6156                 /* add_printer_hook() will call reload_services() */
6157
6158                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
6159                                        printer) ) {
6160                         result = WERR_ACCESS_DENIED;
6161                         goto done;
6162                 }
6163         }
6164
6165         /*
6166          * When a *new* driver is bound to a printer, the drivername is used to
6167          * lookup previously saved driver initialization info, which is then
6168          * bound to the printer, simulating what happens in the Windows arch.
6169          */
6170         if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
6171         {
6172                 if (!set_driver_init(printer, 2))
6173                 {
6174                         DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
6175                                 printer->info_2->drivername));
6176                 }
6177
6178                 DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
6179                         printer->info_2->drivername));
6180
6181                 notify_printer_driver(snum, printer->info_2->drivername);
6182         }
6183
6184         /*
6185          * flag which changes actually occured.  This is a small subset of
6186          * all the possible changes.  We also have to update things in the
6187          * DsSpooler key.
6188          */
6189
6190         if (!strequal(printer->info_2->comment, old_printer->info_2->comment)) {
6191                 init_unistr2( &buffer, printer->info_2->comment, UNI_STR_TERMINATE);
6192                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "description",
6193                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6194
6195                 notify_printer_comment(snum, printer->info_2->comment);
6196         }
6197
6198         if (!strequal(printer->info_2->sharename, old_printer->info_2->sharename)) {
6199                 init_unistr2( &buffer, printer->info_2->sharename, UNI_STR_TERMINATE);
6200                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shareName",
6201                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6202
6203                 notify_printer_sharename(snum, printer->info_2->sharename);
6204         }
6205
6206         if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
6207                 char *pname;
6208
6209                 if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
6210                         pname++;
6211                 else
6212                         pname = printer->info_2->printername;
6213
6214
6215                 init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
6216                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
6217                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6218
6219                 notify_printer_printername( snum, pname );
6220         }
6221
6222         if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
6223                 init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
6224                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
6225                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6226
6227                 notify_printer_port(snum, printer->info_2->portname);
6228         }
6229
6230         if (!strequal(printer->info_2->location, old_printer->info_2->location)) {
6231                 init_unistr2( &buffer, printer->info_2->location, UNI_STR_TERMINATE);
6232                 set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "location",
6233                         REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6234
6235                 notify_printer_location(snum, printer->info_2->location);
6236         }
6237
6238         /* here we need to update some more DsSpooler keys */
6239         /* uNCName, serverName, shortServerName */
6240
6241         init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
6242         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
6243                 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6244         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "shortServerName",
6245                 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6246
6247         slprintf( asc_buffer, sizeof(asc_buffer)-1, "\\\\%s\\%s",
6248                  global_myname(), printer->info_2->sharename );
6249         init_unistr2( &buffer, asc_buffer, UNI_STR_TERMINATE);
6250         set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "uNCName",
6251                 REG_SZ, (uint8_t *)buffer.buffer, buffer.uni_str_len*2 );
6252
6253         /* Update printer info */
6254         result = mod_a_printer(printer, 2);
6255
6256 done:
6257         free_a_printer(&printer, 2);
6258         free_a_printer(&old_printer, 2);
6259
6260
6261         return result;
6262 }
6263
6264 /****************************************************************************
6265 ****************************************************************************/
6266 static WERROR publish_or_unpublish_printer(pipes_struct *p,
6267                                            struct policy_handle *handle,
6268                                            struct spoolss_SetPrinterInfo7 *info7)
6269 {
6270 #ifdef HAVE_ADS
6271         int snum;
6272         Printer_entry *Printer;
6273
6274         if ( lp_security() != SEC_ADS ) {
6275                 return WERR_UNKNOWN_LEVEL;
6276         }
6277
6278         Printer = find_printer_index_by_hnd(p, handle);
6279
6280         DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
6281
6282         if (!Printer)
6283                 return WERR_BADFID;
6284
6285         if (!get_printer_snum(p, handle, &snum, NULL))
6286                 return WERR_BADFID;
6287
6288         nt_printer_publish(Printer, snum, info7->action);
6289
6290         return WERR_OK;
6291 #else
6292         return WERR_UNKNOWN_LEVEL;
6293 #endif
6294 }
6295
6296 /****************************************************************
6297  _spoolss_SetPrinter
6298 ****************************************************************/
6299
6300 WERROR _spoolss_SetPrinter(pipes_struct *p,
6301                            struct spoolss_SetPrinter *r)
6302 {
6303         WERROR result;
6304
6305         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6306
6307         if (!Printer) {
6308                 DEBUG(2,("_spoolss_SetPrinter: Invalid handle (%s:%u:%u)\n",
6309                         OUR_HANDLE(r->in.handle)));
6310                 return WERR_BADFID;
6311         }
6312
6313         /* check the level */
6314         switch (r->in.info_ctr->level) {
6315                 case 0:
6316                         return control_printer(r->in.handle, r->in.command, p);
6317                 case 2:
6318                         result = update_printer(p, r->in.handle,
6319                                                 r->in.info_ctr,
6320                                                 r->in.devmode_ctr->devmode);
6321                         if (!W_ERROR_IS_OK(result))
6322                                 return result;
6323                         if (r->in.secdesc_ctr->sd)
6324                                 result = update_printer_sec(r->in.handle, p,
6325                                                             r->in.secdesc_ctr);
6326                         return result;
6327                 case 3:
6328                         return update_printer_sec(r->in.handle, p,
6329                                                   r->in.secdesc_ctr);
6330                 case 7:
6331                         return publish_or_unpublish_printer(p, r->in.handle,
6332                                                             r->in.info_ctr->info.info7);
6333                 default:
6334                         return WERR_UNKNOWN_LEVEL;
6335         }
6336 }
6337
6338 /****************************************************************
6339  _spoolss_FindClosePrinterNotify
6340 ****************************************************************/
6341
6342 WERROR _spoolss_FindClosePrinterNotify(pipes_struct *p,
6343                                        struct spoolss_FindClosePrinterNotify *r)
6344 {
6345         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
6346
6347         if (!Printer) {
6348                 DEBUG(2,("_spoolss_FindClosePrinterNotify: "
6349                         "Invalid handle (%s:%u:%u)\n", OUR_HANDLE(r->in.handle)));
6350                 return WERR_BADFID;
6351         }
6352
6353         if (Printer->notify.client_connected == true) {
6354                 int snum = -1;
6355
6356                 if ( Printer->printer_type == SPLHND_SERVER)
6357                         snum = -1;
6358                 else if ( (Printer->printer_type == SPLHND_PRINTER) &&
6359                                 !get_printer_snum(p, r->in.handle, &snum, NULL) )
6360                         return WERR_BADFID;
6361
6362                 srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
6363         }
6364
6365         Printer->notify.flags=0;
6366         Printer->notify.options=0;
6367         Printer->notify.localmachine[0]='\0';
6368         Printer->notify.printerlocal=0;
6369         TALLOC_FREE(Printer->notify.option);
6370         Printer->notify.client_connected = false;
6371
6372         return WERR_OK;
6373 }
6374
6375 /****************************************************************
6376  _spoolss_AddJob
6377 ****************************************************************/
6378
6379 WERROR _spoolss_AddJob(pipes_struct *p,
6380                        struct spoolss_AddJob *r)
6381 {
6382         if (!r->in.buffer && (r->in.offered != 0)) {
6383                 return WERR_INVALID_PARAM;
6384         }
6385
6386         /* this is what a NT server returns for AddJob. AddJob must fail on
6387          * non-local printers */
6388
6389         if (r->in.level != 1) {
6390                 return WERR_UNKNOWN_LEVEL;
6391         }
6392
6393         return WERR_INVALID_PARAM;
6394 }
6395
6396 /****************************************************************************
6397 fill_job_info1
6398 ****************************************************************************/
6399
6400 static WERROR fill_job_info1(TALLOC_CTX *mem_ctx,
6401                              struct spoolss_JobInfo1 *r,
6402                              const print_queue_struct *queue,
6403                              int position, int snum,
6404                              const NT_PRINTER_INFO_LEVEL *ntprinter)
6405 {
6406         struct tm *t;
6407
6408         t = gmtime(&queue->time);
6409
6410         r->job_id               = queue->job;
6411
6412         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6413         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6414         r->server_name          = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6415         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6416         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6417         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6418         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6419         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6420         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6421         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6422         r->text_status          = talloc_strdup(mem_ctx, "");
6423         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6424
6425         r->status               = nt_printj_status(queue->status);
6426         r->priority             = queue->priority;
6427         r->position             = position;
6428         r->total_pages          = queue->page_count;
6429         r->pages_printed        = 0; /* ??? */
6430
6431         init_systemtime(&r->submitted, t);
6432
6433         return WERR_OK;
6434 }
6435
6436 /****************************************************************************
6437 fill_job_info2
6438 ****************************************************************************/
6439
6440 static WERROR fill_job_info2(TALLOC_CTX *mem_ctx,
6441                              struct spoolss_JobInfo2 *r,
6442                              const print_queue_struct *queue,
6443                              int position, int snum,
6444                              const NT_PRINTER_INFO_LEVEL *ntprinter,
6445                              struct spoolss_DeviceMode *devmode)
6446 {
6447         struct tm *t;
6448
6449         t = gmtime(&queue->time);
6450
6451         r->job_id               = queue->job;
6452
6453         r->printer_name         = talloc_strdup(mem_ctx, lp_servicename(snum));
6454         W_ERROR_HAVE_NO_MEMORY(r->printer_name);
6455         r->server_name          = talloc_strdup(mem_ctx, ntprinter->info_2->servername);
6456         W_ERROR_HAVE_NO_MEMORY(r->server_name);
6457         r->user_name            = talloc_strdup(mem_ctx, queue->fs_user);
6458         W_ERROR_HAVE_NO_MEMORY(r->user_name);
6459         r->document_name        = talloc_strdup(mem_ctx, queue->fs_file);
6460         W_ERROR_HAVE_NO_MEMORY(r->document_name);
6461         r->notify_name          = talloc_strdup(mem_ctx, queue->fs_user);
6462         W_ERROR_HAVE_NO_MEMORY(r->notify_name);
6463         r->data_type            = talloc_strdup(mem_ctx, "RAW");
6464         W_ERROR_HAVE_NO_MEMORY(r->data_type);
6465         r->print_processor      = talloc_strdup(mem_ctx, "winprint");
6466         W_ERROR_HAVE_NO_MEMORY(r->print_processor);
6467         r->parameters           = talloc_strdup(mem_ctx, "");
6468         W_ERROR_HAVE_NO_MEMORY(r->parameters);
6469         r->driver_name          = talloc_strdup(mem_ctx, ntprinter->info_2->drivername);
6470         W_ERROR_HAVE_NO_MEMORY(r->driver_name);
6471
6472         r->devmode              = devmode;
6473
6474         r->text_status          = talloc_strdup(mem_ctx, "");
6475         W_ERROR_HAVE_NO_MEMORY(r->text_status);
6476
6477         r->secdesc              = NULL;
6478
6479         r->status               = nt_printj_status(queue->status);
6480         r->priority             = queue->priority;
6481         r->position             = position;
6482         r->start_time           = 0;
6483         r->until_time           = 0;
6484         r->total_pages          = queue->page_count;
6485         r->size                 = queue->size;
6486         init_systemtime(&r->submitted, t);
6487         r->time                 = 0;
6488         r->pages_printed        = 0; /* ??? */
6489
6490         return WERR_OK;
6491 }
6492
6493 /****************************************************************************
6494  Enumjobs at level 1.
6495 ****************************************************************************/
6496
6497 static WERROR enumjobs_level1(TALLOC_CTX *mem_ctx,
6498                               const print_queue_struct *queue,
6499                               uint32_t num_queues, int snum,
6500                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6501                               union spoolss_JobInfo **info_p,
6502                               uint32_t *count)
6503 {
6504         union spoolss_JobInfo *info;
6505         int i;
6506         WERROR result = WERR_OK;
6507
6508         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6509         W_ERROR_HAVE_NO_MEMORY(info);
6510
6511         *count = num_queues;
6512
6513         for (i=0; i<*count; i++) {
6514                 result = fill_job_info1(info,
6515                                         &info[i].info1,
6516                                         &queue[i],
6517                                         i,
6518                                         snum,
6519                                         ntprinter);
6520                 if (!W_ERROR_IS_OK(result)) {
6521                         goto out;
6522                 }
6523         }
6524
6525  out:
6526         if (!W_ERROR_IS_OK(result)) {
6527                 TALLOC_FREE(info);
6528                 *count = 0;
6529                 return result;
6530         }
6531
6532         *info_p = info;
6533
6534         return WERR_OK;
6535 }
6536
6537 /****************************************************************************
6538  Enumjobs at level 2.
6539 ****************************************************************************/
6540
6541 static WERROR enumjobs_level2(TALLOC_CTX *mem_ctx,
6542                               const print_queue_struct *queue,
6543                               uint32_t num_queues, int snum,
6544                               const NT_PRINTER_INFO_LEVEL *ntprinter,
6545                               union spoolss_JobInfo **info_p,
6546                               uint32_t *count)
6547 {
6548         union spoolss_JobInfo *info;
6549         int i;
6550         WERROR result = WERR_OK;
6551
6552         info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
6553         W_ERROR_HAVE_NO_MEMORY(info);
6554
6555         *count = num_queues;
6556
6557         for (i=0; i<*count; i++) {
6558
6559                 struct spoolss_DeviceMode *devmode;
6560
6561                 devmode = construct_dev_mode(info, lp_const_servicename(snum));
6562                 if (!devmode) {
6563                         result = WERR_NOMEM;
6564                         goto out;
6565                 }
6566
6567                 result = fill_job_info2(info,
6568                                         &info[i].info2,
6569                                         &queue[i],
6570                                         i,
6571                                         snum,
6572                                         ntprinter,
6573                                         devmode);
6574                 if (!W_ERROR_IS_OK(result)) {
6575                         goto out;
6576                 }
6577         }
6578
6579  out:
6580         if (!W_ERROR_IS_OK(result)) {
6581                 TALLOC_FREE(info);
6582                 *count = 0;
6583                 return result;
6584         }
6585
6586         *info_p = info;
6587
6588         return WERR_OK;
6589 }
6590
6591 /****************************************************************
6592  _spoolss_EnumJobs
6593 ****************************************************************/
6594
6595 WERROR _spoolss_EnumJobs(pipes_struct *p,
6596                          struct spoolss_EnumJobs *r)
6597 {
6598         WERROR result;
6599         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
6600         int snum;
6601         print_status_struct prt_status;
6602         print_queue_struct *queue = NULL;
6603         uint32_t count;
6604
6605         /* that's an [in out] buffer */
6606
6607         if (!r->in.buffer && (r->in.offered != 0)) {
6608                 return WERR_INVALID_PARAM;
6609         }
6610
6611         DEBUG(4,("_spoolss_EnumJobs\n"));
6612
6613         *r->out.needed = 0;
6614         *r->out.count = 0;
6615         *r->out.info = NULL;
6616
6617         /* lookup the printer snum and tdb entry */
6618
6619         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6620                 return WERR_BADFID;
6621         }
6622
6623         result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
6624         if (!W_ERROR_IS_OK(result)) {
6625                 return result;
6626         }
6627
6628         count = print_queue_status(snum, &queue, &prt_status);
6629         DEBUGADD(4,("count:[%d], status:[%d], [%s]\n",
6630                 count, prt_status.status, prt_status.message));
6631
6632         if (count == 0) {
6633                 SAFE_FREE(queue);
6634                 free_a_printer(&ntprinter, 2);
6635                 return WERR_OK;
6636         }
6637
6638         switch (r->in.level) {
6639         case 1:
6640                 result = enumjobs_level1(p->mem_ctx, queue, count, snum,
6641                                          ntprinter, r->out.info, r->out.count);
6642                 break;
6643         case 2:
6644                 result = enumjobs_level2(p->mem_ctx, queue, count, snum,
6645                                          ntprinter, r->out.info, r->out.count);
6646                 break;
6647         default:
6648                 result = WERR_UNKNOWN_LEVEL;
6649                 break;
6650         }
6651
6652         SAFE_FREE(queue);
6653         free_a_printer(&ntprinter, 2);
6654
6655         if (!W_ERROR_IS_OK(result)) {
6656                 return result;
6657         }
6658
6659         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6660                                                      spoolss_EnumJobs, NULL,
6661                                                      *r->out.info, r->in.level,
6662                                                      *r->out.count);
6663         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6664         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6665
6666         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6667 }
6668
6669 /****************************************************************
6670  _spoolss_ScheduleJob
6671 ****************************************************************/
6672
6673 WERROR _spoolss_ScheduleJob(pipes_struct *p,
6674                             struct spoolss_ScheduleJob *r)
6675 {
6676         return WERR_OK;
6677 }
6678
6679 /****************************************************************
6680  _spoolss_SetJob
6681 ****************************************************************/
6682
6683 WERROR _spoolss_SetJob(pipes_struct *p,
6684                        struct spoolss_SetJob *r)
6685 {
6686         int snum;
6687         WERROR errcode = WERR_BADFUNC;
6688
6689         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
6690                 return WERR_BADFID;
6691         }
6692
6693         if (!print_job_exists(lp_const_servicename(snum), r->in.job_id)) {
6694                 return WERR_INVALID_PRINTER_NAME;
6695         }
6696
6697         switch (r->in.command) {
6698         case SPOOLSS_JOB_CONTROL_CANCEL:
6699         case SPOOLSS_JOB_CONTROL_DELETE:
6700                 if (print_job_delete(p->server_info, snum, r->in.job_id, &errcode)) {
6701                         errcode = WERR_OK;
6702                 }
6703                 break;
6704         case SPOOLSS_JOB_CONTROL_PAUSE:
6705                 if (print_job_pause(p->server_info, snum, r->in.job_id, &errcode)) {
6706                         errcode = WERR_OK;
6707                 }
6708                 break;
6709         case SPOOLSS_JOB_CONTROL_RESTART:
6710         case SPOOLSS_JOB_CONTROL_RESUME:
6711                 if (print_job_resume(p->server_info, snum, r->in.job_id, &errcode)) {
6712                         errcode = WERR_OK;
6713                 }
6714                 break;
6715         default:
6716                 return WERR_UNKNOWN_LEVEL;
6717         }
6718
6719         return errcode;
6720 }
6721
6722 /****************************************************************************
6723  Enumerates all printer drivers by level.
6724 ****************************************************************************/
6725
6726 static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
6727                                        const char *servername,
6728                                        const char *architecture,
6729                                        uint32_t level,
6730                                        union spoolss_DriverInfo **info_p,
6731                                        uint32_t *count_p)
6732 {
6733         int i;
6734         int ndrivers;
6735         uint32_t version;
6736         fstring *list = NULL;
6737         NT_PRINTER_DRIVER_INFO_LEVEL driver;
6738         union spoolss_DriverInfo *info = NULL;
6739         uint32_t count = 0;
6740         WERROR result = WERR_OK;
6741
6742         *count_p = 0;
6743         *info_p = NULL;
6744
6745         for (version=0; version<DRIVER_MAX_VERSION; version++) {
6746                 list = NULL;
6747                 ndrivers = get_ntdrivers(&list, architecture, version);
6748                 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
6749                         ndrivers, architecture, version));
6750
6751                 if (ndrivers == -1) {
6752                         result = WERR_NOMEM;
6753                         goto out;
6754                 }
6755
6756                 if (ndrivers != 0) {
6757                         info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
6758                                                     union spoolss_DriverInfo,
6759                                                     count + ndrivers);
6760                         if (!info) {
6761                                 DEBUG(0,("enumprinterdrivers_level1: "
6762                                         "failed to enlarge driver info buffer!\n"));
6763                                 result = WERR_NOMEM;
6764                                 goto out;
6765                         }
6766                 }
6767
6768                 for (i=0; i<ndrivers; i++) {
6769                         DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
6770                         ZERO_STRUCT(driver);
6771                         result = get_a_printer_driver(&driver, 3, list[i],
6772                                                       architecture, version);
6773                         if (!W_ERROR_IS_OK(result)) {
6774                                 goto out;
6775                         }
6776
6777                         switch (level) {
6778                         case 1:
6779                                 result = fill_printer_driver_info1(info, &info[count+i].info1,
6780                                                                    &driver, servername,
6781                                                                    architecture);
6782                                 break;
6783                         case 2:
6784                                 result = fill_printer_driver_info2(info, &info[count+i].info2,
6785                                                                    &driver, servername);
6786                                 break;
6787                         case 3:
6788                                 result = fill_printer_driver_info3(info, &info[count+i].info3,
6789                                                                    &driver, servername);
6790                                 break;
6791                         case 4:
6792                                 result = fill_printer_driver_info4(info, &info[count+i].info4,
6793                                                                    &driver, servername);
6794                                 break;
6795                         case 5:
6796                                 result = fill_printer_driver_info5(info, &info[count+i].info5,
6797                                                                    &driver, servername);
6798                                 break;
6799                         case 6:
6800                                 result = fill_printer_driver_info6(info, &info[count+i].info6,
6801                                                                    &driver, servername);
6802                                 break;
6803                         default:
6804                                 result = WERR_UNKNOWN_LEVEL;
6805                                 break;
6806                         }
6807
6808                         if (!W_ERROR_IS_OK(result)) {
6809                                 free_a_printer_driver(driver, 3);
6810                                 goto out;
6811                         }
6812                         free_a_printer_driver(driver, 3);
6813                 }
6814
6815                 count += ndrivers;
6816                 SAFE_FREE(list);
6817         }
6818
6819  out:
6820         SAFE_FREE(list);
6821
6822         if (!W_ERROR_IS_OK(result)) {
6823                 TALLOC_FREE(info);
6824                 return result;
6825         }
6826
6827         *info_p = info;
6828         *count_p = count;
6829
6830         return WERR_OK;
6831 }
6832
6833 /****************************************************************************
6834  Enumerates all printer drivers at level 1.
6835 ****************************************************************************/
6836
6837 static WERROR enumprinterdrivers_level1(TALLOC_CTX *mem_ctx,
6838                                         const char *servername,
6839                                         const char *architecture,
6840                                         union spoolss_DriverInfo **info_p,
6841                                         uint32_t *count)
6842 {
6843         return enumprinterdrivers_level(mem_ctx, servername, architecture, 1,
6844                                         info_p, count);
6845 }
6846
6847 /****************************************************************************
6848  Enumerates all printer drivers at level 2.
6849 ****************************************************************************/
6850
6851 static WERROR enumprinterdrivers_level2(TALLOC_CTX *mem_ctx,
6852                                         const char *servername,
6853                                         const char *architecture,
6854                                         union spoolss_DriverInfo **info_p,
6855                                         uint32_t *count)
6856 {
6857         return enumprinterdrivers_level(mem_ctx, servername, architecture, 2,
6858                                         info_p, count);
6859 }
6860
6861 /****************************************************************************
6862  Enumerates all printer drivers at level 3.
6863 ****************************************************************************/
6864
6865 static WERROR enumprinterdrivers_level3(TALLOC_CTX *mem_ctx,
6866                                         const char *servername,
6867                                         const char *architecture,
6868                                         union spoolss_DriverInfo **info_p,
6869                                         uint32_t *count)
6870 {
6871         return enumprinterdrivers_level(mem_ctx, servername, architecture, 3,
6872                                         info_p, count);
6873 }
6874
6875 /****************************************************************************
6876  Enumerates all printer drivers at level 4.
6877 ****************************************************************************/
6878
6879 static WERROR enumprinterdrivers_level4(TALLOC_CTX *mem_ctx,
6880                                         const char *servername,
6881                                         const char *architecture,
6882                                         union spoolss_DriverInfo **info_p,
6883                                         uint32_t *count)
6884 {
6885         return enumprinterdrivers_level(mem_ctx, servername, architecture, 4,
6886                                         info_p, count);
6887 }
6888
6889 /****************************************************************************
6890  Enumerates all printer drivers at level 5.
6891 ****************************************************************************/
6892
6893 static WERROR enumprinterdrivers_level5(TALLOC_CTX *mem_ctx,
6894                                         const char *servername,
6895                                         const char *architecture,
6896                                         union spoolss_DriverInfo **info_p,
6897                                         uint32_t *count)
6898 {
6899         return enumprinterdrivers_level(mem_ctx, servername, architecture, 5,
6900                                         info_p, count);
6901 }
6902
6903 /****************************************************************************
6904  Enumerates all printer drivers at level 6.
6905 ****************************************************************************/
6906
6907 static WERROR enumprinterdrivers_level6(TALLOC_CTX *mem_ctx,
6908                                         const char *servername,
6909                                         const char *architecture,
6910                                         union spoolss_DriverInfo **info_p,
6911                                         uint32_t *count)
6912 {
6913         return enumprinterdrivers_level(mem_ctx, servername, architecture, 6,
6914                                         info_p, count);
6915 }
6916
6917
6918 /****************************************************************
6919  _spoolss_EnumPrinterDrivers
6920 ****************************************************************/
6921
6922 WERROR _spoolss_EnumPrinterDrivers(pipes_struct *p,
6923                                    struct spoolss_EnumPrinterDrivers *r)
6924 {
6925         const char *cservername;
6926         WERROR result;
6927
6928         /* that's an [in out] buffer */
6929
6930         if (!r->in.buffer && (r->in.offered != 0)) {
6931                 return WERR_INVALID_PARAM;
6932         }
6933
6934         DEBUG(4,("_spoolss_EnumPrinterDrivers\n"));
6935
6936         *r->out.needed = 0;
6937         *r->out.count = 0;
6938         *r->out.info = NULL;
6939
6940         cservername = canon_servername(r->in.server);
6941
6942         if (!is_myname_or_ipaddr(cservername)) {
6943                 return WERR_UNKNOWN_PRINTER_DRIVER;
6944         }
6945
6946         switch (r->in.level) {
6947         case 1:
6948                 result = enumprinterdrivers_level1(p->mem_ctx, cservername,
6949                                                    r->in.environment,
6950                                                    r->out.info, r->out.count);
6951                 break;
6952         case 2:
6953                 result = enumprinterdrivers_level2(p->mem_ctx, cservername,
6954                                                    r->in.environment,
6955                                                    r->out.info, r->out.count);
6956                 break;
6957         case 3:
6958                 result = enumprinterdrivers_level3(p->mem_ctx, cservername,
6959                                                    r->in.environment,
6960                                                    r->out.info, r->out.count);
6961                 break;
6962         case 4:
6963                 result = enumprinterdrivers_level4(p->mem_ctx, cservername,
6964                                                    r->in.environment,
6965                                                    r->out.info, r->out.count);
6966                 break;
6967         case 5:
6968                 result = enumprinterdrivers_level5(p->mem_ctx, cservername,
6969                                                    r->in.environment,
6970                                                    r->out.info, r->out.count);
6971                 break;
6972         case 6:
6973                 result = enumprinterdrivers_level6(p->mem_ctx, cservername,
6974                                                    r->in.environment,
6975                                                    r->out.info, r->out.count);
6976                 break;
6977         default:
6978                 return WERR_UNKNOWN_LEVEL;
6979         }
6980
6981         if (!W_ERROR_IS_OK(result)) {
6982                 return result;
6983         }
6984
6985         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
6986                                                      spoolss_EnumPrinterDrivers, NULL,
6987                                                      *r->out.info, r->in.level,
6988                                                      *r->out.count);
6989         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
6990         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
6991
6992         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
6993 }
6994
6995 /****************************************************************************
6996 ****************************************************************************/
6997
6998 static WERROR fill_form_info_1(TALLOC_CTX *mem_ctx,
6999                                struct spoolss_FormInfo1 *r,
7000                                const nt_forms_struct *form)
7001 {
7002         r->form_name    = talloc_strdup(mem_ctx, form->name);
7003         W_ERROR_HAVE_NO_MEMORY(r->form_name);
7004
7005         r->flags        = form->flag;
7006         r->size.width   = form->width;
7007         r->size.height  = form->length;
7008         r->area.left    = form->left;
7009         r->area.top     = form->top;
7010         r->area.right   = form->right;
7011         r->area.bottom  = form->bottom;
7012
7013         return WERR_OK;
7014 }
7015
7016 /****************************************************************
7017  spoolss_enumforms_level1
7018 ****************************************************************/
7019
7020 static WERROR spoolss_enumforms_level1(TALLOC_CTX *mem_ctx,
7021                                        const nt_forms_struct *builtin_forms,
7022                                        uint32_t num_builtin_forms,
7023                                        const nt_forms_struct *user_forms,
7024                                        uint32_t num_user_forms,
7025                                        union spoolss_FormInfo **info_p,
7026                                        uint32_t *count)
7027 {
7028         union spoolss_FormInfo *info;
7029         WERROR result = WERR_OK;
7030         int i;
7031
7032         *count = num_builtin_forms + num_user_forms;
7033
7034         info = TALLOC_ARRAY(mem_ctx, union spoolss_FormInfo, *count);
7035         W_ERROR_HAVE_NO_MEMORY(info);
7036
7037         /* construct the list of form structures */
7038         for (i=0; i<num_builtin_forms; i++) {
7039                 DEBUGADD(6,("Filling form number [%d]\n",i));
7040                 result = fill_form_info_1(info, &info[i].info1,
7041                                           &builtin_forms[i]);
7042                 if (!W_ERROR_IS_OK(result)) {
7043                         goto out;
7044                 }
7045         }
7046
7047         for (; i<num_user_forms; i++) {
7048                 DEBUGADD(6,("Filling form number [%d]\n",i));
7049                 result = fill_form_info_1(info, &info[i].info1,
7050                                           &user_forms[i-num_builtin_forms]);
7051                 if (!W_ERROR_IS_OK(result)) {
7052                         goto out;
7053                 }
7054         }
7055
7056  out:
7057         if (!W_ERROR_IS_OK(result)) {
7058                 TALLOC_FREE(info);
7059                 *count = 0;
7060                 return result;
7061         }
7062
7063         *info_p = info;
7064
7065         return WERR_OK;
7066 }
7067
7068 /****************************************************************
7069  _spoolss_EnumForms
7070 ****************************************************************/
7071
7072 WERROR _spoolss_EnumForms(pipes_struct *p,
7073                           struct spoolss_EnumForms *r)
7074 {
7075         WERROR result;
7076         nt_forms_struct *user_forms = NULL;
7077         nt_forms_struct *builtin_forms = NULL;
7078         uint32_t num_user_forms;
7079         uint32_t num_builtin_forms;
7080
7081         *r->out.count = 0;
7082         *r->out.needed = 0;
7083         *r->out.info = NULL;
7084
7085         /* that's an [in out] buffer */
7086
7087         if (!r->in.buffer && (r->in.offered != 0) ) {
7088                 return WERR_INVALID_PARAM;
7089         }
7090
7091         DEBUG(4,("_spoolss_EnumForms\n"));
7092         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7093         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
7094
7095         num_builtin_forms = get_builtin_ntforms(&builtin_forms);
7096         DEBUGADD(5,("Number of builtin forms [%d]\n", num_builtin_forms));
7097         num_user_forms = get_ntforms(&user_forms);
7098         DEBUGADD(5,("Number of user forms [%d]\n", num_user_forms));
7099
7100         if (num_user_forms + num_builtin_forms == 0) {
7101                 SAFE_FREE(builtin_forms);
7102                 SAFE_FREE(user_forms);
7103                 return WERR_NO_MORE_ITEMS;
7104         }
7105
7106         switch (r->in.level) {
7107         case 1:
7108                 result = spoolss_enumforms_level1(p->mem_ctx,
7109                                                   builtin_forms,
7110                                                   num_builtin_forms,
7111                                                   user_forms,
7112                                                   num_user_forms,
7113                                                   r->out.info,
7114                                                   r->out.count);
7115                 break;
7116         default:
7117                 result = WERR_UNKNOWN_LEVEL;
7118                 break;
7119         }
7120
7121         SAFE_FREE(user_forms);
7122         SAFE_FREE(builtin_forms);
7123
7124         if (!W_ERROR_IS_OK(result)) {
7125                 return result;
7126         }
7127
7128         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7129                                                      spoolss_EnumForms, NULL,
7130                                                      *r->out.info, r->in.level,
7131                                                      *r->out.count);
7132         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7133         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7134
7135         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7136 }
7137
7138 /****************************************************************
7139 ****************************************************************/
7140
7141 static WERROR find_form_byname(const char *name,
7142                                nt_forms_struct *form)
7143 {
7144         nt_forms_struct *list = NULL;
7145         int num_forms = 0, i = 0;
7146
7147         if (get_a_builtin_ntform_by_string(name, form)) {
7148                 return WERR_OK;
7149         }
7150
7151         num_forms = get_ntforms(&list);
7152         DEBUGADD(5,("Number of forms [%d]\n", num_forms));
7153
7154         if (num_forms == 0) {
7155                 return WERR_BADFID;
7156         }
7157
7158         /* Check if the requested name is in the list of form structures */
7159         for (i = 0; i < num_forms; i++) {
7160
7161                 DEBUG(4,("checking form %s (want %s)\n", list[i].name, name));
7162
7163                 if (strequal(name, list[i].name)) {
7164                         DEBUGADD(6,("Found form %s number [%d]\n", name, i));
7165                         *form = list[i];
7166                         SAFE_FREE(list);
7167                         return WERR_OK;
7168                 }
7169         }
7170
7171         SAFE_FREE(list);
7172
7173         return WERR_BADFID;
7174 }
7175
7176 /****************************************************************
7177  _spoolss_GetForm
7178 ****************************************************************/
7179
7180 WERROR _spoolss_GetForm(pipes_struct *p,
7181                         struct spoolss_GetForm *r)
7182 {
7183         WERROR result;
7184         nt_forms_struct form;
7185
7186         /* that's an [in out] buffer */
7187
7188         if (!r->in.buffer && (r->in.offered != 0)) {
7189                 return WERR_INVALID_PARAM;
7190         }
7191
7192         DEBUG(4,("_spoolss_GetForm\n"));
7193         DEBUGADD(5,("Offered buffer size [%d]\n", r->in.offered));
7194         DEBUGADD(5,("Info level [%d]\n",          r->in.level));
7195
7196         result = find_form_byname(r->in.form_name, &form);
7197         if (!W_ERROR_IS_OK(result)) {
7198                 TALLOC_FREE(r->out.info);
7199                 return result;
7200         }
7201
7202         switch (r->in.level) {
7203         case 1:
7204                 result = fill_form_info_1(p->mem_ctx,
7205                                           &r->out.info->info1,
7206                                           &form);
7207                 break;
7208
7209         default:
7210                 result = WERR_UNKNOWN_LEVEL;
7211                 break;
7212         }
7213
7214         if (!W_ERROR_IS_OK(result)) {
7215                 TALLOC_FREE(r->out.info);
7216                 return result;
7217         }
7218
7219         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, NULL,
7220                                                r->out.info, r->in.level);
7221         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7222
7223         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7224 }
7225
7226 /****************************************************************************
7227 ****************************************************************************/
7228
7229 static WERROR fill_port_1(TALLOC_CTX *mem_ctx,
7230                           struct spoolss_PortInfo1 *r,
7231                           const char *name)
7232 {
7233         r->port_name = talloc_strdup(mem_ctx, name);
7234         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7235
7236         return WERR_OK;
7237 }
7238
7239 /****************************************************************************
7240  TODO: This probably needs distinguish between TCP/IP and Local ports
7241  somehow.
7242 ****************************************************************************/
7243
7244 static WERROR fill_port_2(TALLOC_CTX *mem_ctx,
7245                           struct spoolss_PortInfo2 *r,
7246                           const char *name)
7247 {
7248         r->port_name = talloc_strdup(mem_ctx, name);
7249         W_ERROR_HAVE_NO_MEMORY(r->port_name);
7250
7251         r->monitor_name = talloc_strdup(mem_ctx, "Local Monitor");
7252         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
7253
7254         r->description = talloc_strdup(mem_ctx, SPL_LOCAL_PORT);
7255         W_ERROR_HAVE_NO_MEMORY(r->description);
7256
7257         r->port_type = SPOOLSS_PORT_TYPE_WRITE;
7258         r->reserved = 0;
7259
7260         return WERR_OK;
7261 }
7262
7263
7264 /****************************************************************************
7265  wrapper around the enumer ports command
7266 ****************************************************************************/
7267
7268 WERROR enumports_hook(TALLOC_CTX *ctx, int *count, char ***lines )
7269 {
7270         char *cmd = lp_enumports_cmd();
7271         char **qlines = NULL;
7272         char *command = NULL;
7273         int numlines;
7274         int ret;
7275         int fd;
7276
7277         *count = 0;
7278         *lines = NULL;
7279
7280         /* if no hook then just fill in the default port */
7281
7282         if ( !*cmd ) {
7283                 if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
7284                         return WERR_NOMEM;
7285                 }
7286                 if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
7287                         TALLOC_FREE(qlines);
7288                         return WERR_NOMEM;
7289                 }
7290                 qlines[1] = NULL;
7291                 numlines = 1;
7292         }
7293         else {
7294                 /* we have a valid enumport command */
7295
7296                 command = talloc_asprintf(ctx, "%s \"%d\"", cmd, 1);
7297                 if (!command) {
7298                         return WERR_NOMEM;
7299                 }
7300
7301                 DEBUG(10,("Running [%s]\n", command));
7302                 ret = smbrun(command, &fd);
7303                 DEBUG(10,("Returned [%d]\n", ret));
7304                 TALLOC_FREE(command);
7305                 if (ret != 0) {
7306                         if (fd != -1) {
7307                                 close(fd);
7308                         }
7309                         return WERR_ACCESS_DENIED;
7310                 }
7311
7312                 numlines = 0;
7313                 qlines = fd_lines_load(fd, &numlines, 0, NULL);
7314                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
7315                 close(fd);
7316         }
7317
7318         *count = numlines;
7319         *lines = qlines;
7320
7321         return WERR_OK;
7322 }
7323
7324 /****************************************************************************
7325  enumports level 1.
7326 ****************************************************************************/
7327
7328 static WERROR enumports_level_1(TALLOC_CTX *mem_ctx,
7329                                 union spoolss_PortInfo **info_p,
7330                                 uint32_t *count)
7331 {
7332         union spoolss_PortInfo *info = NULL;
7333         int i=0;
7334         WERROR result = WERR_OK;
7335         char **qlines = NULL;
7336         int numlines = 0;
7337
7338         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7339         if (!W_ERROR_IS_OK(result)) {
7340                 goto out;
7341         }
7342
7343         if (numlines) {
7344                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7345                 if (!info) {
7346                         DEBUG(10,("Returning WERR_NOMEM\n"));
7347                         result = WERR_NOMEM;
7348                         goto out;
7349                 }
7350
7351                 for (i=0; i<numlines; i++) {
7352                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7353                         result = fill_port_1(info, &info[i].info1, qlines[i]);
7354                         if (!W_ERROR_IS_OK(result)) {
7355                                 goto out;
7356                         }
7357                 }
7358         }
7359         TALLOC_FREE(qlines);
7360
7361 out:
7362         if (!W_ERROR_IS_OK(result)) {
7363                 TALLOC_FREE(info);
7364                 TALLOC_FREE(qlines);
7365                 *count = 0;
7366                 *info_p = NULL;
7367                 return result;
7368         }
7369
7370         *info_p = info;
7371         *count = numlines;
7372
7373         return WERR_OK;
7374 }
7375
7376 /****************************************************************************
7377  enumports level 2.
7378 ****************************************************************************/
7379
7380 static WERROR enumports_level_2(TALLOC_CTX *mem_ctx,
7381                                 union spoolss_PortInfo **info_p,
7382                                 uint32_t *count)
7383 {
7384         union spoolss_PortInfo *info = NULL;
7385         int i=0;
7386         WERROR result = WERR_OK;
7387         char **qlines = NULL;
7388         int numlines = 0;
7389
7390         result = enumports_hook(talloc_tos(), &numlines, &qlines );
7391         if (!W_ERROR_IS_OK(result)) {
7392                 goto out;
7393         }
7394
7395         if (numlines) {
7396                 info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
7397                 if (!info) {
7398                         DEBUG(10,("Returning WERR_NOMEM\n"));
7399                         result = WERR_NOMEM;
7400                         goto out;
7401                 }
7402
7403                 for (i=0; i<numlines; i++) {
7404                         DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
7405                         result = fill_port_2(info, &info[i].info2, qlines[i]);
7406                         if (!W_ERROR_IS_OK(result)) {
7407                                 goto out;
7408                         }
7409                 }
7410         }
7411         TALLOC_FREE(qlines);
7412
7413 out:
7414         if (!W_ERROR_IS_OK(result)) {
7415                 TALLOC_FREE(info);
7416                 TALLOC_FREE(qlines);
7417                 *count = 0;
7418                 *info_p = NULL;
7419                 return result;
7420         }
7421
7422         *info_p = info;
7423         *count = numlines;
7424
7425         return WERR_OK;
7426 }
7427
7428 /****************************************************************
7429  _spoolss_EnumPorts
7430 ****************************************************************/
7431
7432 WERROR _spoolss_EnumPorts(pipes_struct *p,
7433                           struct spoolss_EnumPorts *r)
7434 {
7435         WERROR result;
7436
7437         /* that's an [in out] buffer */
7438
7439         if (!r->in.buffer && (r->in.offered != 0)) {
7440                 return WERR_INVALID_PARAM;
7441         }
7442
7443         DEBUG(4,("_spoolss_EnumPorts\n"));
7444
7445         *r->out.count = 0;
7446         *r->out.needed = 0;
7447         *r->out.info = NULL;
7448
7449         switch (r->in.level) {
7450         case 1:
7451                 result = enumports_level_1(p->mem_ctx, r->out.info,
7452                                            r->out.count);
7453                 break;
7454         case 2:
7455                 result = enumports_level_2(p->mem_ctx, r->out.info,
7456                                            r->out.count);
7457                 break;
7458         default:
7459                 return WERR_UNKNOWN_LEVEL;
7460         }
7461
7462         if (!W_ERROR_IS_OK(result)) {
7463                 return result;
7464         }
7465
7466         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
7467                                                      spoolss_EnumPorts, NULL,
7468                                                      *r->out.info, r->in.level,
7469                                                      *r->out.count);
7470         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
7471         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
7472
7473         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7474 }
7475
7476 /****************************************************************************
7477 ****************************************************************************/
7478
7479 static WERROR spoolss_addprinterex_level_2(pipes_struct *p,
7480                                            const char *server,
7481                                            struct spoolss_SetPrinterInfoCtr *info_ctr,
7482                                            struct spoolss_DeviceMode *devmode,
7483                                            struct security_descriptor *sec_desc,
7484                                            struct spoolss_UserLevelCtr *user_ctr,
7485                                            struct policy_handle *handle)
7486 {
7487         NT_PRINTER_INFO_LEVEL *printer = NULL;
7488         fstring name;
7489         int     snum;
7490         WERROR err = WERR_OK;
7491
7492         if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
7493                 DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
7494                 return WERR_NOMEM;
7495         }
7496
7497         /* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
7498         if (!convert_printer_info(info_ctr, printer)) {
7499                 free_a_printer(&printer, 2);
7500                 return WERR_NOMEM;
7501         }
7502
7503         /* check to see if the printer already exists */
7504
7505         if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
7506                 DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
7507                         printer->info_2->sharename));
7508                 free_a_printer(&printer, 2);
7509                 return WERR_PRINTER_ALREADY_EXISTS;
7510         }
7511
7512         /* FIXME!!!  smbd should check to see if the driver is installed before
7513            trying to add a printer like this  --jerry */
7514
7515         if (*lp_addprinter_cmd() ) {
7516                 if ( !add_printer_hook(p->mem_ctx, p->server_info->ptok,
7517                                        printer) ) {
7518                         free_a_printer(&printer,2);
7519                         return WERR_ACCESS_DENIED;
7520                 }
7521         } else {
7522                 DEBUG(0,("spoolss_addprinterex_level_2: add printer for printer %s called and no"
7523                         "smb.conf parameter \"addprinter command\" is defined. This"
7524                         "parameter must exist for this call to succeed\n",
7525                         printer->info_2->sharename ));
7526         }
7527
7528         /* use our primary netbios name since get_a_printer() will convert
7529            it to what the client expects on a case by case basis */
7530
7531         slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
7532              printer->info_2->sharename);
7533
7534
7535         if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
7536                 free_a_printer(&printer,2);
7537                 return WERR_ACCESS_DENIED;
7538         }
7539
7540         /* you must be a printer admin to add a new printer */
7541         if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
7542                 free_a_printer(&printer,2);
7543                 return WERR_ACCESS_DENIED;
7544         }
7545
7546         /*
7547          * Do sanity check on the requested changes for Samba.
7548          */
7549
7550         if (!check_printer_ok(printer->info_2, snum)) {
7551                 free_a_printer(&printer,2);
7552                 return WERR_INVALID_PARAM;
7553         }
7554
7555         /*
7556          * When a printer is created, the drivername bound to the printer is used
7557          * to lookup previously saved driver initialization info, which is then
7558          * bound to the new printer, simulating what happens in the Windows arch.
7559          */
7560
7561         if (!devmode)
7562         {
7563                 set_driver_init(printer, 2);
7564         }
7565         else
7566         {
7567                 /* A valid devmode was included, convert and link it
7568                 */
7569                 DEBUGADD(10, ("spoolss_addprinterex_level_2: devmode included, converting\n"));
7570
7571                 if (!convert_devicemode(printer->info_2->printername, devmode,
7572                                         &printer->info_2->devmode)) {
7573                         return  WERR_NOMEM;
7574                 }
7575         }
7576
7577         /* write the ASCII on disk */
7578         err = mod_a_printer(printer, 2);
7579         if (!W_ERROR_IS_OK(err)) {
7580                 free_a_printer(&printer,2);
7581                 return err;
7582         }
7583
7584         if (!open_printer_hnd(p, handle, name, PRINTER_ACCESS_ADMINISTER)) {
7585                 /* Handle open failed - remove addition. */
7586                 del_a_printer(printer->info_2->sharename);
7587                 free_a_printer(&printer,2);
7588                 ZERO_STRUCTP(handle);
7589                 return WERR_ACCESS_DENIED;
7590         }
7591
7592         update_c_setprinter(false);
7593         free_a_printer(&printer,2);
7594
7595         return WERR_OK;
7596 }
7597
7598 /****************************************************************
7599  _spoolss_AddPrinterEx
7600 ****************************************************************/
7601
7602 WERROR _spoolss_AddPrinterEx(pipes_struct *p,
7603                              struct spoolss_AddPrinterEx *r)
7604 {
7605         switch (r->in.info_ctr->level) {
7606         case 1:
7607                 /* we don't handle yet */
7608                 /* but I know what to do ... */
7609                 return WERR_UNKNOWN_LEVEL;
7610         case 2:
7611                 return spoolss_addprinterex_level_2(p, r->in.server,
7612                                                     r->in.info_ctr,
7613                                                     r->in.devmode_ctr->devmode,
7614                                                     r->in.secdesc_ctr->sd,
7615                                                     r->in.userlevel_ctr,
7616                                                     r->out.handle);
7617         default:
7618                 return WERR_UNKNOWN_LEVEL;
7619         }
7620 }
7621
7622 /****************************************************************
7623  _spoolss_AddPrinterDriver
7624 ****************************************************************/
7625
7626 WERROR _spoolss_AddPrinterDriver(pipes_struct *p,
7627                                  struct spoolss_AddPrinterDriver *r)
7628 {
7629         uint32_t level = r->in.info_ctr->level;
7630         struct spoolss_AddDriverInfoCtr *info = r->in.info_ctr;
7631         WERROR err = WERR_OK;
7632         NT_PRINTER_DRIVER_INFO_LEVEL driver;
7633         const char *driver_name = NULL;
7634         uint32_t version;
7635         const char *fn;
7636
7637         switch (p->hdr_req.opnum) {
7638                 case NDR_SPOOLSS_ADDPRINTERDRIVER:
7639                         fn = "_spoolss_AddPrinterDriver";
7640                         break;
7641                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX:
7642                         fn = "_spoolss_AddPrinterDriverEx";
7643                         break;
7644                 default:
7645                         return WERR_INVALID_PARAM;
7646         }
7647
7648
7649         /* FIXME */
7650         if (level != 3 && level != 6) {
7651                 /* Clever hack from Martin Zielinski <mz@seh.de>
7652                  * to allow downgrade from level 8 (Vista).
7653                  */
7654                 DEBUG(0,("%s: level %d not yet implemented\n", fn, level));
7655                 return WERR_UNKNOWN_LEVEL;
7656         }
7657
7658         ZERO_STRUCT(driver);
7659
7660         if (!convert_printer_driver_info(info, &driver, level)) {
7661                 err = WERR_NOMEM;
7662                 goto done;
7663         }
7664
7665         DEBUG(5,("Cleaning driver's information\n"));
7666         err = clean_up_driver_struct(p, driver, level);
7667         if (!W_ERROR_IS_OK(err))
7668                 goto done;
7669
7670         DEBUG(5,("Moving driver to final destination\n"));
7671         if( !W_ERROR_IS_OK(err = move_driver_to_download_area(p, driver, level,
7672                                                               &err)) ) {
7673                 goto done;
7674         }
7675
7676         if (add_a_printer_driver(driver, level)!=0) {
7677                 err = WERR_ACCESS_DENIED;
7678                 goto done;
7679         }
7680
7681         switch(level) {
7682         case 3:
7683                 driver_name = driver.info_3->name ? driver.info_3->name : "";
7684                 break;
7685         case 6:
7686                 driver_name = driver.info_6->name ? driver.info_6->name : "";
7687                 break;
7688         }
7689
7690         /*
7691          * I think this is where he DrvUpgradePrinter() hook would be
7692          * be called in a driver's interface DLL on a Windows NT 4.0/2k
7693          * server.  Right now, we just need to send ourselves a message
7694          * to update each printer bound to this driver.   --jerry
7695          */
7696
7697         if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
7698                 DEBUG(0,("%s: Failed to send message about upgrading driver [%s]!\n",
7699                         fn, driver_name));
7700         }
7701
7702         /*
7703          * Based on the version (e.g. driver destination dir: 0=9x,2=Nt/2k,3=2k/Xp),
7704          * decide if the driver init data should be deleted. The rules are:
7705          *  1) never delete init data if it is a 9x driver, they don't use it anyway
7706          *  2) delete init data only if there is no 2k/Xp driver
7707          *  3) always delete init data
7708          * The generalized rule is always use init data from the highest order driver.
7709          * It is necessary to follow the driver install by an initialization step to
7710          * finish off this process.
7711         */
7712         if (level == 3)
7713                 version = driver.info_3->cversion;
7714         else if (level == 6)
7715                 version = driver.info_6->version;
7716         else
7717                 version = -1;
7718         switch (version) {
7719                 /*
7720                  * 9x printer driver - never delete init data
7721                 */
7722                 case 0:
7723                         DEBUG(10,("%s: init data not deleted for 9x driver [%s]\n",
7724                                 fn, driver_name));
7725                         break;
7726
7727                 /*
7728                  * Nt or 2k (compatiblity mode) printer driver - only delete init data if
7729                  * there is no 2k/Xp driver init data for this driver name.
7730                 */
7731                 case 2:
7732                 {
7733                         NT_PRINTER_DRIVER_INFO_LEVEL driver1;
7734
7735                         if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
7736                                 /*
7737                                  * No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
7738                                 */
7739                                 if (!del_driver_init(driver_name))
7740                                         DEBUG(6,("%s: del_driver_init(%s) Nt failed!\n",
7741                                                 fn, driver_name));
7742                         } else {
7743                                 /*
7744                                  * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
7745                                 */
7746                                 free_a_printer_driver(driver1,3);
7747                                 DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
7748                                         fn, driver_name));
7749                         }
7750                 }
7751                 break;
7752
7753                 /*
7754                  * 2k or Xp printer driver - always delete init data
7755                 */
7756                 case 3:
7757                         if (!del_driver_init(driver_name))
7758                                 DEBUG(6,("%s: del_driver_init(%s) 2k/Xp failed!\n",
7759                                         fn, driver_name));
7760                         break;
7761
7762                 default:
7763                         DEBUG(0,("%s: invalid level=%d\n", fn, level));
7764                         break;
7765         }
7766
7767
7768 done:
7769         free_a_printer_driver(driver, level);
7770         return err;
7771 }
7772
7773 /****************************************************************
7774  _spoolss_AddPrinterDriverEx
7775 ****************************************************************/
7776
7777 WERROR _spoolss_AddPrinterDriverEx(pipes_struct *p,
7778                                    struct spoolss_AddPrinterDriverEx *r)
7779 {
7780         struct spoolss_AddPrinterDriver a;
7781
7782         /*
7783          * we only support the semantics of AddPrinterDriver()
7784          * i.e. only copy files that are newer than existing ones
7785          */
7786
7787         if (r->in.flags != APD_COPY_NEW_FILES) {
7788                 return WERR_ACCESS_DENIED;
7789         }
7790
7791         a.in.servername         = r->in.servername;
7792         a.in.info_ctr           = r->in.info_ctr;
7793
7794         return _spoolss_AddPrinterDriver(p, &a);
7795 }
7796
7797 /****************************************************************************
7798 ****************************************************************************/
7799
7800 struct _spoolss_paths {
7801         int type;
7802         const char *share;
7803         const char *dir;
7804 };
7805
7806 enum { SPOOLSS_DRIVER_PATH, SPOOLSS_PRTPROCS_PATH };
7807
7808 static const struct _spoolss_paths spoolss_paths[]= {
7809         { SPOOLSS_DRIVER_PATH,          "print$",       "DRIVERS" },
7810         { SPOOLSS_PRTPROCS_PATH,        "prnproc$",     "PRTPROCS" }
7811 };
7812
7813 static WERROR compose_spoolss_server_path(TALLOC_CTX *mem_ctx,
7814                                           const char *servername,
7815                                           const char *environment,
7816                                           int component,
7817                                           char **path)
7818 {
7819         const char *pservername = NULL;
7820         const char *long_archi = SPOOLSS_ARCHITECTURE_NT_X86;
7821         const char *short_archi;
7822
7823         *path = NULL;
7824
7825         /* environment may be empty */
7826         if (environment && strlen(environment)) {
7827                 long_archi = environment;
7828         }
7829
7830         /* servername may be empty */
7831         if (servername && strlen(servername)) {
7832                 pservername = canon_servername(servername);
7833
7834                 if (!is_myname_or_ipaddr(pservername)) {
7835                         return WERR_INVALID_PARAM;
7836                 }
7837         }
7838
7839         if (!(short_archi = get_short_archi(long_archi))) {
7840                 return WERR_INVALID_ENVIRONMENT;
7841         }
7842
7843         switch (component) {
7844         case SPOOLSS_PRTPROCS_PATH:
7845         case SPOOLSS_DRIVER_PATH:
7846                 if (pservername) {
7847                         *path = talloc_asprintf(mem_ctx,
7848                                         "\\\\%s\\%s\\%s",
7849                                         pservername,
7850                                         spoolss_paths[component].share,
7851                                         short_archi);
7852                 } else {
7853                         *path = talloc_asprintf(mem_ctx, "%s\\%s\\%s",
7854                                         SPOOLSS_DEFAULT_SERVER_PATH,
7855                                         spoolss_paths[component].dir,
7856                                         short_archi);
7857                 }
7858                 break;
7859         default:
7860                 return WERR_INVALID_PARAM;
7861         }
7862
7863         if (!*path) {
7864                 return WERR_NOMEM;
7865         }
7866
7867         return WERR_OK;
7868 }
7869
7870 /****************************************************************************
7871 ****************************************************************************/
7872
7873 static WERROR getprinterdriverdir_level_1(TALLOC_CTX *mem_ctx,
7874                                           const char *servername,
7875                                           const char *environment,
7876                                           struct spoolss_DriverDirectoryInfo1 *r)
7877 {
7878         WERROR werr;
7879         char *path = NULL;
7880
7881         werr = compose_spoolss_server_path(mem_ctx,
7882                                            servername,
7883                                            environment,
7884                                            SPOOLSS_DRIVER_PATH,
7885                                            &path);
7886         if (!W_ERROR_IS_OK(werr)) {
7887                 return werr;
7888         }
7889
7890         DEBUG(4,("printer driver directory: [%s]\n", path));
7891
7892         r->directory_name = path;
7893
7894         return WERR_OK;
7895 }
7896
7897 /****************************************************************
7898  _spoolss_GetPrinterDriverDirectory
7899 ****************************************************************/
7900
7901 WERROR _spoolss_GetPrinterDriverDirectory(pipes_struct *p,
7902                                           struct spoolss_GetPrinterDriverDirectory *r)
7903 {
7904         WERROR werror;
7905
7906         /* that's an [in out] buffer */
7907
7908         if (!r->in.buffer && (r->in.offered != 0)) {
7909                 return WERR_INVALID_PARAM;
7910         }
7911
7912         DEBUG(5,("_spoolss_GetPrinterDriverDirectory: level %d\n",
7913                 r->in.level));
7914
7915         *r->out.needed = 0;
7916
7917         /* r->in.level is ignored */
7918
7919         werror = getprinterdriverdir_level_1(p->mem_ctx,
7920                                              r->in.server,
7921                                              r->in.environment,
7922                                              &r->out.info->info1);
7923         if (!W_ERROR_IS_OK(werror)) {
7924                 TALLOC_FREE(r->out.info);
7925                 return werror;
7926         }
7927
7928         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, NULL,
7929                                                r->out.info, r->in.level);
7930         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
7931
7932         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
7933 }
7934
7935 /****************************************************************
7936  _spoolss_EnumPrinterData
7937 ****************************************************************/
7938
7939 WERROR _spoolss_EnumPrinterData(pipes_struct *p,
7940                                 struct spoolss_EnumPrinterData *r)
7941 {
7942         NT_PRINTER_INFO_LEVEL *printer = NULL;
7943         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
7944         int             snum;
7945         WERROR          result;
7946         REGISTRY_VALUE  *val = NULL;
7947         NT_PRINTER_DATA *p_data;
7948         int             i, key_index, num_values;
7949         int             name_length;
7950
7951         *r->out.value_needed    = 0;
7952         *r->out.type            = REG_NONE;
7953         *r->out.data_needed     = 0;
7954
7955         DEBUG(5,("_spoolss_EnumPrinterData\n"));
7956
7957         if (!Printer) {
7958                 DEBUG(2,("_spoolss_EnumPrinterData: Invalid handle (%s:%u:%u).\n",
7959                         OUR_HANDLE(r->in.handle)));
7960                 return WERR_BADFID;
7961         }
7962
7963         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
7964                 return WERR_BADFID;
7965         }
7966
7967         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
7968         if (!W_ERROR_IS_OK(result)) {
7969                 return result;
7970         }
7971
7972         p_data = printer->info_2->data;
7973         key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
7974
7975         result = WERR_OK;
7976
7977         /*
7978          * The NT machine wants to know the biggest size of value and data
7979          *
7980          * cf: MSDN EnumPrinterData remark section
7981          */
7982
7983         if (!r->in.value_offered && !r->in.data_offered && (key_index != -1)) {
7984
7985                 uint32_t biggest_valuesize = 0;
7986                 uint32_t biggest_datasize = 0;
7987
7988                 DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
7989
7990                 num_values = regval_ctr_numvals( p_data->keys[key_index].values );
7991
7992                 for ( i=0; i<num_values; i++ )
7993                 {
7994                         val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
7995
7996                         name_length = strlen(val->valuename);
7997                         if ( strlen(val->valuename) > biggest_valuesize )
7998                                 biggest_valuesize = name_length;
7999
8000                         if ( val->size > biggest_datasize )
8001                                 biggest_datasize = val->size;
8002
8003                         DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
8004                                 biggest_datasize));
8005                 }
8006
8007                 /* the value is an UNICODE string but real_value_size is the length
8008                    in bytes including the trailing 0 */
8009
8010                 *r->out.value_needed = 2 * (1 + biggest_valuesize);
8011                 *r->out.data_needed  = biggest_datasize;
8012
8013                 DEBUG(6,("final values: [%d], [%d]\n",
8014                         *r->out.value_needed, *r->out.data_needed));
8015
8016                 goto done;
8017         }
8018
8019         /*
8020          * the value len is wrong in NT sp3
8021          * that's the number of bytes not the number of unicode chars
8022          */
8023
8024         if (key_index != -1) {
8025                 val = regval_ctr_specific_value(p_data->keys[key_index].values,
8026                                                 r->in.enum_index);
8027         }
8028
8029         if (!val) {
8030
8031                 /* out_value should default to "" or else NT4 has
8032                    problems unmarshalling the response */
8033
8034                 if (r->in.value_offered) {
8035                         *r->out.value_needed = 1;
8036                         r->out.value_name = talloc_strdup(r, "");
8037                         if (!r->out.value_name) {
8038                                 result = WERR_NOMEM;
8039                                 goto done;
8040                         }
8041                 } else {
8042                         r->out.value_name = NULL;
8043                         *r->out.value_needed = 0;
8044                 }
8045
8046                 /* the data is counted in bytes */
8047
8048                 *r->out.data_needed = r->in.data_offered;
8049
8050                 result = WERR_NO_MORE_ITEMS;
8051         } else {
8052                 /*
8053                  * the value is:
8054                  * - counted in bytes in the request
8055                  * - counted in UNICODE chars in the max reply
8056                  * - counted in bytes in the real size
8057                  *
8058                  * take a pause *before* coding not *during* coding
8059                  */
8060
8061                 /* name */
8062                 if (r->in.value_offered) {
8063                         r->out.value_name = talloc_strdup(r, regval_name(val));
8064                         if (!r->out.value_name) {
8065                                 result = WERR_NOMEM;
8066                                 goto done;
8067                         }
8068                         *r->out.value_needed = strlen_m(regval_name(val));
8069                 } else {
8070                         r->out.value_name = NULL;
8071                         *r->out.value_needed = 0;
8072                 }
8073
8074                 /* type */
8075
8076                 *r->out.type = regval_type(val);
8077
8078                 /* data - counted in bytes */
8079
8080                 if (r->out.data && regval_size(val)) {
8081                         memcpy(r->out.data, regval_data_p(val), regval_size(val));
8082                 }
8083
8084                 *r->out.data_needed = regval_size(val);
8085         }
8086
8087 done:
8088         free_a_printer(&printer, 2);
8089         return result;
8090 }
8091
8092 /****************************************************************
8093  _spoolss_SetPrinterData
8094 ****************************************************************/
8095
8096 WERROR _spoolss_SetPrinterData(pipes_struct *p,
8097                                struct spoolss_SetPrinterData *r)
8098 {
8099         NT_PRINTER_INFO_LEVEL *printer = NULL;
8100         int snum=0;
8101         WERROR result = WERR_OK;
8102         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8103         DATA_BLOB blob;
8104
8105         DEBUG(5,("_spoolss_SetPrinterData\n"));
8106
8107         if (!Printer) {
8108                 DEBUG(2,("_spoolss_SetPrinterData: Invalid handle (%s:%u:%u).\n",
8109                         OUR_HANDLE(r->in.handle)));
8110                 return WERR_BADFID;
8111         }
8112
8113         if (Printer->printer_type == SPLHND_SERVER) {
8114                 DEBUG(10,("_spoolss_SetPrinterData: "
8115                         "Not implemented for server handles yet\n"));
8116                 return WERR_INVALID_PARAM;
8117         }
8118
8119         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8120                 return WERR_BADFID;
8121         }
8122
8123         /*
8124          * Access check : NT returns "access denied" if you make a
8125          * SetPrinterData call without the necessary privildge.
8126          * we were originally returning OK if nothing changed
8127          * which made Win2k issue **a lot** of SetPrinterData
8128          * when connecting to a printer  --jerry
8129          */
8130
8131         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8132                 DEBUG(3,("_spoolss_SetPrinterData: "
8133                         "change denied by handle access permissions\n"));
8134                 result = WERR_ACCESS_DENIED;
8135                 goto done;
8136         }
8137
8138         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8139         if (!W_ERROR_IS_OK(result)) {
8140                 return result;
8141         }
8142
8143         result = push_spoolss_PrinterData(p->mem_ctx, &blob,
8144                                           r->in.type, &r->in.data);
8145         if (!W_ERROR_IS_OK(result)) {
8146                 goto done;
8147         }
8148
8149         /*
8150          * When client side code sets a magic printer data key, detect it and save
8151          * the current printer data and the magic key's data (its the DEVMODE) for
8152          * future printer/driver initializations.
8153          */
8154         if ((r->in.type == REG_BINARY) && strequal(r->in.value_name, PHANTOM_DEVMODE_KEY)) {
8155                 /* Set devmode and printer initialization info */
8156                 result = save_driver_init(printer, 2, blob.data, blob.length);
8157
8158                 srv_spoolss_reset_printerdata(printer->info_2->drivername);
8159
8160                 goto done;
8161         }
8162
8163         result = set_printer_dataex(printer, SPOOL_PRINTERDATA_KEY,
8164                                     r->in.value_name, r->in.type,
8165                                     blob.data, blob.length);
8166         if (W_ERROR_IS_OK(result)) {
8167                 result = mod_a_printer(printer, 2);
8168         }
8169
8170 done:
8171         free_a_printer(&printer, 2);
8172
8173         return result;
8174 }
8175
8176 /****************************************************************
8177  _spoolss_ResetPrinter
8178 ****************************************************************/
8179
8180 WERROR _spoolss_ResetPrinter(pipes_struct *p,
8181                              struct spoolss_ResetPrinter *r)
8182 {
8183         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8184         int             snum;
8185
8186         DEBUG(5,("_spoolss_ResetPrinter\n"));
8187
8188         /*
8189          * All we do is to check to see if the handle and queue is valid.
8190          * This call really doesn't mean anything to us because we only
8191          * support RAW printing.   --jerry
8192          */
8193
8194         if (!Printer) {
8195                 DEBUG(2,("_spoolss_ResetPrinter: Invalid handle (%s:%u:%u).\n",
8196                         OUR_HANDLE(r->in.handle)));
8197                 return WERR_BADFID;
8198         }
8199
8200         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8201                 return WERR_BADFID;
8202
8203
8204         /* blindly return success */
8205         return WERR_OK;
8206 }
8207
8208 /****************************************************************
8209  _spoolss_DeletePrinterData
8210 ****************************************************************/
8211
8212 WERROR _spoolss_DeletePrinterData(pipes_struct *p,
8213                                   struct spoolss_DeletePrinterData *r)
8214 {
8215         NT_PRINTER_INFO_LEVEL   *printer = NULL;
8216         int             snum=0;
8217         WERROR          status = WERR_OK;
8218         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
8219
8220         DEBUG(5,("_spoolss_DeletePrinterData\n"));
8221
8222         if (!Printer) {
8223                 DEBUG(2,("_spoolss_DeletePrinterData: Invalid handle (%s:%u:%u).\n",
8224                         OUR_HANDLE(r->in.handle)));
8225                 return WERR_BADFID;
8226         }
8227
8228         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8229                 return WERR_BADFID;
8230
8231         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
8232                 DEBUG(3, ("_spoolss_DeletePrinterData: "
8233                         "printer properties change denied by handle\n"));
8234                 return WERR_ACCESS_DENIED;
8235         }
8236
8237         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8238         if (!W_ERROR_IS_OK(status))
8239                 return status;
8240
8241         if (!r->in.value_name) {
8242                 free_a_printer(&printer, 2);
8243                 return WERR_NOMEM;
8244         }
8245
8246         status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY,
8247                                         r->in.value_name );
8248
8249         if ( W_ERROR_IS_OK(status) )
8250                 mod_a_printer( printer, 2 );
8251
8252         free_a_printer(&printer, 2);
8253
8254         return status;
8255 }
8256
8257 /****************************************************************
8258  _spoolss_AddForm
8259 ****************************************************************/
8260
8261 WERROR _spoolss_AddForm(pipes_struct *p,
8262                         struct spoolss_AddForm *r)
8263 {
8264         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8265         nt_forms_struct tmpForm;
8266         int snum;
8267         WERROR status = WERR_OK;
8268         NT_PRINTER_INFO_LEVEL *printer = NULL;
8269         SE_PRIV se_printop = SE_PRINT_OPERATOR;
8270
8271         int count=0;
8272         nt_forms_struct *list=NULL;
8273         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8274
8275         DEBUG(5,("_spoolss_AddForm\n"));
8276
8277         if (!Printer) {
8278                 DEBUG(2,("_spoolss_AddForm: Invalid handle (%s:%u:%u).\n",
8279                         OUR_HANDLE(r->in.handle)));
8280                 return WERR_BADFID;
8281         }
8282
8283
8284         /* forms can be added on printer of on the print server handle */
8285
8286         if ( Printer->printer_type == SPLHND_PRINTER )
8287         {
8288                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8289                         return WERR_BADFID;
8290
8291                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8292                 if (!W_ERROR_IS_OK(status))
8293                         goto done;
8294         }
8295
8296         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8297            and not a printer admin, then fail */
8298
8299         if ((p->server_info->utok.uid != 0) &&
8300              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8301              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8302                                           NULL, NULL,
8303                                           p->server_info->ptok,
8304                                           lp_printer_admin(snum))) {
8305                 DEBUG(2,("_spoolss_Addform: denied by insufficient permissions.\n"));
8306                 return WERR_ACCESS_DENIED;
8307         }
8308
8309         /* can't add if builtin */
8310
8311         if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8312                 status = WERR_FILE_EXISTS;
8313                 goto done;
8314         }
8315
8316         count = get_ntforms(&list);
8317
8318         if(!add_a_form(&list, form, &count)) {
8319                 status =  WERR_NOMEM;
8320                 goto done;
8321         }
8322
8323         write_ntforms(&list, count);
8324
8325         /*
8326          * ChangeID must always be set if this is a printer
8327          */
8328
8329         if ( Printer->printer_type == SPLHND_PRINTER )
8330                 status = mod_a_printer(printer, 2);
8331
8332 done:
8333         if ( printer )
8334                 free_a_printer(&printer, 2);
8335         SAFE_FREE(list);
8336
8337         return status;
8338 }
8339
8340 /****************************************************************
8341  _spoolss_DeleteForm
8342 ****************************************************************/
8343
8344 WERROR _spoolss_DeleteForm(pipes_struct *p,
8345                            struct spoolss_DeleteForm *r)
8346 {
8347         const char *form_name = r->in.form_name;
8348         nt_forms_struct tmpForm;
8349         int count=0;
8350         nt_forms_struct *list=NULL;
8351         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8352         int snum;
8353         WERROR status = WERR_OK;
8354         NT_PRINTER_INFO_LEVEL *printer = NULL;
8355         SE_PRIV se_printop = SE_PRINT_OPERATOR;
8356
8357         DEBUG(5,("_spoolss_DeleteForm\n"));
8358
8359         if (!Printer) {
8360                 DEBUG(2,("_spoolss_DeleteForm: Invalid handle (%s:%u:%u).\n",
8361                         OUR_HANDLE(r->in.handle)));
8362                 return WERR_BADFID;
8363         }
8364
8365         /* forms can be deleted on printer of on the print server handle */
8366
8367         if ( Printer->printer_type == SPLHND_PRINTER )
8368         {
8369                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8370                         return WERR_BADFID;
8371
8372                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8373                 if (!W_ERROR_IS_OK(status))
8374                         goto done;
8375         }
8376
8377         if ((p->server_info->utok.uid != 0) &&
8378              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8379              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8380                                           NULL, NULL,
8381                                           p->server_info->ptok,
8382                                           lp_printer_admin(snum))) {
8383                 DEBUG(2,("_spoolss_DeleteForm: denied by insufficient permissions.\n"));
8384                 return WERR_ACCESS_DENIED;
8385         }
8386
8387
8388         /* can't delete if builtin */
8389
8390         if (get_a_builtin_ntform_by_string(form_name,&tmpForm)) {
8391                 status = WERR_INVALID_PARAM;
8392                 goto done;
8393         }
8394
8395         count = get_ntforms(&list);
8396
8397         if ( !delete_a_form(&list, form_name, &count, &status ))
8398                 goto done;
8399
8400         /*
8401          * ChangeID must always be set if this is a printer
8402          */
8403
8404         if ( Printer->printer_type == SPLHND_PRINTER )
8405                 status = mod_a_printer(printer, 2);
8406
8407 done:
8408         if ( printer )
8409                 free_a_printer(&printer, 2);
8410         SAFE_FREE(list);
8411
8412         return status;
8413 }
8414
8415 /****************************************************************
8416  _spoolss_SetForm
8417 ****************************************************************/
8418
8419 WERROR _spoolss_SetForm(pipes_struct *p,
8420                         struct spoolss_SetForm *r)
8421 {
8422         struct spoolss_AddFormInfo1 *form = r->in.info.info1;
8423         nt_forms_struct tmpForm;
8424         int snum;
8425         WERROR status = WERR_OK;
8426         NT_PRINTER_INFO_LEVEL *printer = NULL;
8427         SE_PRIV se_printop = SE_PRINT_OPERATOR;
8428
8429         int count=0;
8430         nt_forms_struct *list=NULL;
8431         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
8432
8433         DEBUG(5,("_spoolss_SetForm\n"));
8434
8435         if (!Printer) {
8436                 DEBUG(2,("_spoolss_SetForm: Invalid handle (%s:%u:%u).\n",
8437                         OUR_HANDLE(r->in.handle)));
8438                 return WERR_BADFID;
8439         }
8440
8441         /* forms can be modified on printer of on the print server handle */
8442
8443         if ( Printer->printer_type == SPLHND_PRINTER )
8444         {
8445                 if (!get_printer_snum(p, r->in.handle, &snum, NULL))
8446                         return WERR_BADFID;
8447
8448                 status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
8449                 if (!W_ERROR_IS_OK(status))
8450                         goto done;
8451         }
8452
8453         /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
8454            and not a printer admin, then fail */
8455
8456         if ((p->server_info->utok.uid != 0) &&
8457              !user_has_privileges(p->server_info->ptok, &se_printop) &&
8458              !token_contains_name_in_list(uidtoname(p->server_info->utok.uid),
8459                                           NULL, NULL,
8460                                           p->server_info->ptok,
8461                                           lp_printer_admin(snum))) {
8462                 DEBUG(2,("_spoolss_Setform: denied by insufficient permissions.\n"));
8463                 return WERR_ACCESS_DENIED;
8464         }
8465
8466         /* can't set if builtin */
8467         if (get_a_builtin_ntform_by_string(form->form_name, &tmpForm)) {
8468                 status = WERR_INVALID_PARAM;
8469                 goto done;
8470         }
8471
8472         count = get_ntforms(&list);
8473         update_a_form(&list, form, count);
8474         write_ntforms(&list, count);
8475
8476         /*
8477          * ChangeID must always be set if this is a printer
8478          */
8479
8480         if ( Printer->printer_type == SPLHND_PRINTER )
8481                 status = mod_a_printer(printer, 2);
8482
8483
8484 done:
8485         if ( printer )
8486                 free_a_printer(&printer, 2);
8487         SAFE_FREE(list);
8488
8489         return status;
8490 }
8491
8492 /****************************************************************************
8493  fill_print_processor1
8494 ****************************************************************************/
8495
8496 static WERROR fill_print_processor1(TALLOC_CTX *mem_ctx,
8497                                     struct spoolss_PrintProcessorInfo1 *r,
8498                                     const char *print_processor_name)
8499 {
8500         r->print_processor_name = talloc_strdup(mem_ctx, print_processor_name);
8501         W_ERROR_HAVE_NO_MEMORY(r->print_processor_name);
8502
8503         return WERR_OK;
8504 }
8505
8506 /****************************************************************************
8507  enumprintprocessors level 1.
8508 ****************************************************************************/
8509
8510 static WERROR enumprintprocessors_level_1(TALLOC_CTX *mem_ctx,
8511                                           union spoolss_PrintProcessorInfo **info_p,
8512                                           uint32_t *count)
8513 {
8514         union spoolss_PrintProcessorInfo *info;
8515         WERROR result;
8516
8517         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
8518         W_ERROR_HAVE_NO_MEMORY(info);
8519
8520         *count = 1;
8521
8522         result = fill_print_processor1(info, &info[0].info1, "winprint");
8523         if (!W_ERROR_IS_OK(result)) {
8524                 goto out;
8525         }
8526
8527  out:
8528         if (!W_ERROR_IS_OK(result)) {
8529                 TALLOC_FREE(info);
8530                 *count = 0;
8531                 return result;
8532         }
8533
8534         *info_p = info;
8535
8536         return WERR_OK;
8537 }
8538
8539 /****************************************************************
8540  _spoolss_EnumPrintProcessors
8541 ****************************************************************/
8542
8543 WERROR _spoolss_EnumPrintProcessors(pipes_struct *p,
8544                                     struct spoolss_EnumPrintProcessors *r)
8545 {
8546         WERROR result;
8547
8548         /* that's an [in out] buffer */
8549
8550         if (!r->in.buffer && (r->in.offered != 0)) {
8551                 return WERR_INVALID_PARAM;
8552         }
8553
8554         DEBUG(5,("_spoolss_EnumPrintProcessors\n"));
8555
8556         /*
8557          * Enumerate the print processors ...
8558          *
8559          * Just reply with "winprint", to keep NT happy
8560          * and I can use my nice printer checker.
8561          */
8562
8563         *r->out.count = 0;
8564         *r->out.needed = 0;
8565         *r->out.info = NULL;
8566
8567         switch (r->in.level) {
8568         case 1:
8569                 result = enumprintprocessors_level_1(p->mem_ctx, r->out.info,
8570                                                      r->out.count);
8571                 break;
8572         default:
8573                 return WERR_UNKNOWN_LEVEL;
8574         }
8575
8576         if (!W_ERROR_IS_OK(result)) {
8577                 return result;
8578         }
8579
8580         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8581                                                      spoolss_EnumPrintProcessors, NULL,
8582                                                      *r->out.info, r->in.level,
8583                                                      *r->out.count);
8584         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8585         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8586
8587         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8588 }
8589
8590 /****************************************************************************
8591  fill_printprocdatatype1
8592 ****************************************************************************/
8593
8594 static WERROR fill_printprocdatatype1(TALLOC_CTX *mem_ctx,
8595                                       struct spoolss_PrintProcDataTypesInfo1 *r,
8596                                       const char *name_array)
8597 {
8598         r->name_array = talloc_strdup(mem_ctx, name_array);
8599         W_ERROR_HAVE_NO_MEMORY(r->name_array);
8600
8601         return WERR_OK;
8602 }
8603
8604 /****************************************************************************
8605  enumprintprocdatatypes level 1.
8606 ****************************************************************************/
8607
8608 static WERROR enumprintprocdatatypes_level_1(TALLOC_CTX *mem_ctx,
8609                                              union spoolss_PrintProcDataTypesInfo **info_p,
8610                                              uint32_t *count)
8611 {
8612         WERROR result;
8613         union spoolss_PrintProcDataTypesInfo *info;
8614
8615         info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
8616         W_ERROR_HAVE_NO_MEMORY(info);
8617
8618         *count = 1;
8619
8620         result = fill_printprocdatatype1(info, &info[0].info1, "RAW");
8621         if (!W_ERROR_IS_OK(result)) {
8622                 goto out;
8623         }
8624
8625  out:
8626         if (!W_ERROR_IS_OK(result)) {
8627                 TALLOC_FREE(info);
8628                 *count = 0;
8629                 return result;
8630         }
8631
8632         *info_p = info;
8633
8634         return WERR_OK;
8635 }
8636
8637 /****************************************************************
8638  _spoolss_EnumPrintProcDataTypes
8639 ****************************************************************/
8640
8641 WERROR _spoolss_EnumPrintProcDataTypes(pipes_struct *p,
8642                                        struct spoolss_EnumPrintProcDataTypes *r)
8643 {
8644         WERROR result;
8645
8646         /* that's an [in out] buffer */
8647
8648         if (!r->in.buffer && (r->in.offered != 0)) {
8649                 return WERR_INVALID_PARAM;
8650         }
8651
8652         DEBUG(5,("_spoolss_EnumPrintProcDataTypes\n"));
8653
8654         *r->out.count = 0;
8655         *r->out.needed = 0;
8656         *r->out.info = NULL;
8657
8658         switch (r->in.level) {
8659         case 1:
8660                 result = enumprintprocdatatypes_level_1(p->mem_ctx, r->out.info,
8661                                                         r->out.count);
8662                 break;
8663         default:
8664                 return WERR_UNKNOWN_LEVEL;
8665         }
8666
8667         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8668                                                      spoolss_EnumPrintProcDataTypes, NULL,
8669                                                      *r->out.info, r->in.level,
8670                                                      *r->out.count);
8671         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8672         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8673
8674         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8675 }
8676
8677 /****************************************************************************
8678  fill_monitor_1
8679 ****************************************************************************/
8680
8681 static WERROR fill_monitor_1(TALLOC_CTX *mem_ctx,
8682                              struct spoolss_MonitorInfo1 *r,
8683                              const char *monitor_name)
8684 {
8685         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8686         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8687
8688         return WERR_OK;
8689 }
8690
8691 /****************************************************************************
8692  fill_monitor_2
8693 ****************************************************************************/
8694
8695 static WERROR fill_monitor_2(TALLOC_CTX *mem_ctx,
8696                              struct spoolss_MonitorInfo2 *r,
8697                              const char *monitor_name,
8698                              const char *environment,
8699                              const char *dll_name)
8700 {
8701         r->monitor_name                 = talloc_strdup(mem_ctx, monitor_name);
8702         W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
8703         r->environment                  = talloc_strdup(mem_ctx, environment);
8704         W_ERROR_HAVE_NO_MEMORY(r->environment);
8705         r->dll_name                     = talloc_strdup(mem_ctx, dll_name);
8706         W_ERROR_HAVE_NO_MEMORY(r->dll_name);
8707
8708         return WERR_OK;
8709 }
8710
8711 /****************************************************************************
8712  enumprintmonitors level 1.
8713 ****************************************************************************/
8714
8715 static WERROR enumprintmonitors_level_1(TALLOC_CTX *mem_ctx,
8716                                         union spoolss_MonitorInfo **info_p,
8717                                         uint32_t *count)
8718 {
8719         union spoolss_MonitorInfo *info;
8720         WERROR result = WERR_OK;
8721
8722         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8723         W_ERROR_HAVE_NO_MEMORY(info);
8724
8725         *count = 2;
8726
8727         result = fill_monitor_1(info, &info[0].info1,
8728                                 SPL_LOCAL_PORT);
8729         if (!W_ERROR_IS_OK(result)) {
8730                 goto out;
8731         }
8732
8733         result = fill_monitor_1(info, &info[1].info1,
8734                                 SPL_TCPIP_PORT);
8735         if (!W_ERROR_IS_OK(result)) {
8736                 goto out;
8737         }
8738
8739 out:
8740         if (!W_ERROR_IS_OK(result)) {
8741                 TALLOC_FREE(info);
8742                 *count = 0;
8743                 return result;
8744         }
8745
8746         *info_p = info;
8747
8748         return WERR_OK;
8749 }
8750
8751 /****************************************************************************
8752  enumprintmonitors level 2.
8753 ****************************************************************************/
8754
8755 static WERROR enumprintmonitors_level_2(TALLOC_CTX *mem_ctx,
8756                                         union spoolss_MonitorInfo **info_p,
8757                                         uint32_t *count)
8758 {
8759         union spoolss_MonitorInfo *info;
8760         WERROR result = WERR_OK;
8761
8762         info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
8763         W_ERROR_HAVE_NO_MEMORY(info);
8764
8765         *count = 2;
8766
8767         result = fill_monitor_2(info, &info[0].info2,
8768                                 SPL_LOCAL_PORT,
8769                                 "Windows NT X86", /* FIXME */
8770                                 "localmon.dll");
8771         if (!W_ERROR_IS_OK(result)) {
8772                 goto out;
8773         }
8774
8775         result = fill_monitor_2(info, &info[1].info2,
8776                                 SPL_TCPIP_PORT,
8777                                 "Windows NT X86", /* FIXME */
8778                                 "tcpmon.dll");
8779         if (!W_ERROR_IS_OK(result)) {
8780                 goto out;
8781         }
8782
8783 out:
8784         if (!W_ERROR_IS_OK(result)) {
8785                 TALLOC_FREE(info);
8786                 *count = 0;
8787                 return result;
8788         }
8789
8790         *info_p = info;
8791
8792         return WERR_OK;
8793 }
8794
8795 /****************************************************************
8796  _spoolss_EnumMonitors
8797 ****************************************************************/
8798
8799 WERROR _spoolss_EnumMonitors(pipes_struct *p,
8800                              struct spoolss_EnumMonitors *r)
8801 {
8802         WERROR result;
8803
8804         /* that's an [in out] buffer */
8805
8806         if (!r->in.buffer && (r->in.offered != 0)) {
8807                 return WERR_INVALID_PARAM;
8808         }
8809
8810         DEBUG(5,("_spoolss_EnumMonitors\n"));
8811
8812         /*
8813          * Enumerate the print monitors ...
8814          *
8815          * Just reply with "Local Port", to keep NT happy
8816          * and I can use my nice printer checker.
8817          */
8818
8819         *r->out.count = 0;
8820         *r->out.needed = 0;
8821         *r->out.info = NULL;
8822
8823         switch (r->in.level) {
8824         case 1:
8825                 result = enumprintmonitors_level_1(p->mem_ctx, r->out.info,
8826                                                    r->out.count);
8827                 break;
8828         case 2:
8829                 result = enumprintmonitors_level_2(p->mem_ctx, r->out.info,
8830                                                    r->out.count);
8831                 break;
8832         default:
8833                 return WERR_UNKNOWN_LEVEL;
8834         }
8835
8836         if (!W_ERROR_IS_OK(result)) {
8837                 return result;
8838         }
8839
8840         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
8841                                                      spoolss_EnumMonitors, NULL,
8842                                                      *r->out.info, r->in.level,
8843                                                      *r->out.count);
8844         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
8845         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
8846
8847         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
8848 }
8849
8850 /****************************************************************************
8851 ****************************************************************************/
8852
8853 static WERROR getjob_level_1(TALLOC_CTX *mem_ctx,
8854                              const print_queue_struct *queue,
8855                              int count, int snum,
8856                              const NT_PRINTER_INFO_LEVEL *ntprinter,
8857                              uint32_t jobid,
8858                              struct spoolss_JobInfo1 *r)
8859 {
8860         int i = 0;
8861         bool found = false;
8862
8863         for (i=0; i<count && found == false; i++) {
8864                 if (queue[i].job == (int)jobid) {
8865                         found = true;
8866                 }
8867         }
8868
8869         if (found == false) {
8870                 /* NT treats not found as bad param... yet another bad choice */
8871                 return WERR_INVALID_PARAM;
8872         }
8873
8874         return fill_job_info1(mem_ctx,
8875                               r,
8876                               &queue[i-1],
8877                               i,
8878                               snum,
8879                               ntprinter);
8880 }
8881
8882 /****************************************************************************
8883 ****************************************************************************/
8884
8885 static WERROR getjob_level_2(TALLOC_CTX *mem_ctx,
8886                              const print_queue_struct *queue,
8887                              int count, int snum,
8888                              const NT_PRINTER_INFO_LEVEL *ntprinter,
8889                              uint32_t jobid,
8890                              struct spoolss_JobInfo2 *r)
8891 {
8892         int i = 0;
8893         bool found = false;
8894         struct spoolss_DeviceMode *devmode;
8895         NT_DEVICEMODE *nt_devmode;
8896         WERROR result;
8897
8898         for (i=0; i<count && found == false; i++) {
8899                 if (queue[i].job == (int)jobid) {
8900                         found = true;
8901                 }
8902         }
8903
8904         if (found == false) {
8905                 /* NT treats not found as bad param... yet another bad
8906                    choice */
8907                 return WERR_INVALID_PARAM;
8908         }
8909
8910         /*
8911          * if the print job does not have a DEVMODE associated with it,
8912          * just use the one for the printer. A NULL devicemode is not
8913          *  a failure condition
8914          */
8915
8916         nt_devmode = print_job_devmode(lp_const_servicename(snum), jobid);
8917         if (nt_devmode) {
8918                 devmode = TALLOC_ZERO_P(mem_ctx, struct spoolss_DeviceMode);
8919                 W_ERROR_HAVE_NO_MEMORY(devmode);
8920                 result = convert_nt_devicemode(devmode, devmode, nt_devmode);
8921                 if (!W_ERROR_IS_OK(result)) {
8922                         return result;
8923                 }
8924         } else {
8925                 devmode = construct_dev_mode(mem_ctx, lp_const_servicename(snum));
8926                 W_ERROR_HAVE_NO_MEMORY(devmode);
8927         }
8928
8929         return fill_job_info2(mem_ctx,
8930                               r,
8931                               &queue[i-1],
8932                               i,
8933                               snum,
8934                               ntprinter,
8935                               devmode);
8936 }
8937
8938 /****************************************************************
8939  _spoolss_GetJob
8940 ****************************************************************/
8941
8942 WERROR _spoolss_GetJob(pipes_struct *p,
8943                        struct spoolss_GetJob *r)
8944 {
8945         WERROR result = WERR_OK;
8946         NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
8947         int snum;
8948         int count;
8949         print_queue_struct      *queue = NULL;
8950         print_status_struct prt_status;
8951
8952         /* that's an [in out] buffer */
8953
8954         if (!r->in.buffer && (r->in.offered != 0)) {
8955                 return WERR_INVALID_PARAM;
8956         }
8957
8958         DEBUG(5,("_spoolss_GetJob\n"));
8959
8960         *r->out.needed = 0;
8961
8962         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
8963                 return WERR_BADFID;
8964         }
8965
8966         result = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
8967         if (!W_ERROR_IS_OK(result)) {
8968                 return result;
8969         }
8970
8971         count = print_queue_status(snum, &queue, &prt_status);
8972
8973         DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
8974                      count, prt_status.status, prt_status.message));
8975
8976         switch (r->in.level) {
8977         case 1:
8978                 result = getjob_level_1(p->mem_ctx,
8979                                         queue, count, snum, ntprinter,
8980                                         r->in.job_id, &r->out.info->info1);
8981                 break;
8982         case 2:
8983                 result = getjob_level_2(p->mem_ctx,
8984                                         queue, count, snum, ntprinter,
8985                                         r->in.job_id, &r->out.info->info2);
8986                 break;
8987         default:
8988                 result = WERR_UNKNOWN_LEVEL;
8989                 break;
8990         }
8991
8992         SAFE_FREE(queue);
8993         free_a_printer(&ntprinter, 2);
8994
8995         if (!W_ERROR_IS_OK(result)) {
8996                 TALLOC_FREE(r->out.info);
8997                 return result;
8998         }
8999
9000         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_JobInfo, NULL,
9001                                                r->out.info, r->in.level);
9002         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9003
9004         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9005 }
9006
9007 /****************************************************************
9008  _spoolss_GetPrinterDataEx
9009
9010  From MSDN documentation of GetPrinterDataEx: pass request
9011  to GetPrinterData if key is "PrinterDriverData".
9012 ****************************************************************/
9013
9014 WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
9015                                  struct spoolss_GetPrinterDataEx *r)
9016 {
9017
9018         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9019         REGISTRY_VALUE          *val = NULL;
9020         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9021         int                     snum = 0;
9022         WERROR result = WERR_OK;
9023
9024         DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
9025
9026         DEBUG(10, ("_spoolss_GetPrinterDataEx: key => [%s], value => [%s]\n",
9027                 r->in.key_name, r->in.value_name));
9028
9029         /* in case of problem, return some default values */
9030
9031         *r->out.needed  = 0;
9032         *r->out.type    = REG_NONE;
9033
9034         if (!Printer) {
9035                 DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9036                         OUR_HANDLE(r->in.handle)));
9037                 result = WERR_BADFID;
9038                 goto done;
9039         }
9040
9041         /* Is the handle to a printer or to the server? */
9042
9043         if (Printer->printer_type == SPLHND_SERVER) {
9044                 DEBUG(10,("_spoolss_GetPrinterDataEx: "
9045                         "Not implemented for server handles yet\n"));
9046                 result = WERR_INVALID_PARAM;
9047                 goto done;
9048         }
9049
9050         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9051                 return WERR_BADFID;
9052         }
9053
9054         result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9055         if (!W_ERROR_IS_OK(result)) {
9056                 goto done;
9057         }
9058
9059         /* check to see if the keyname is valid */
9060         if (!strlen(r->in.key_name)) {
9061                 result = WERR_INVALID_PARAM;
9062                 goto done;
9063         }
9064
9065         if (lookup_printerkey(printer->info_2->data, r->in.key_name) == -1) {
9066                 DEBUG(4,("_spoolss_GetPrinterDataEx: "
9067                         "Invalid keyname [%s]\n", r->in.key_name ));
9068                 result = WERR_BADFILE;
9069                 goto done;
9070         }
9071
9072         /* When given a new keyname, we should just create it */
9073
9074         val = get_printer_data(printer->info_2,
9075                                r->in.key_name, r->in.value_name);
9076         if (!val) {
9077                 result = WERR_BADFILE;
9078                 goto done;
9079         }
9080
9081         *r->out.needed = regval_size(val);
9082
9083         if (*r->out.needed > r->in.offered) {
9084                 result = WERR_MORE_DATA;
9085                 goto done;
9086         }
9087
9088         *r->out.type = regval_type(val);
9089
9090         memcpy(r->out.buffer, regval_data_p(val), regval_size(val));
9091
9092  done:
9093         if (printer) {
9094                 free_a_printer(&printer, 2);
9095         }
9096
9097         return result;
9098 }
9099
9100 /****************************************************************
9101  _spoolss_SetPrinterDataEx
9102 ****************************************************************/
9103
9104 WERROR _spoolss_SetPrinterDataEx(pipes_struct *p,
9105                                  struct spoolss_SetPrinterDataEx *r)
9106 {
9107         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9108         int                     snum = 0;
9109         WERROR                  result = WERR_OK;
9110         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
9111         char                    *oid_string;
9112
9113         DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
9114
9115         /* From MSDN documentation of SetPrinterDataEx: pass request to
9116            SetPrinterData if key is "PrinterDriverData" */
9117
9118         if (!Printer) {
9119                 DEBUG(2,("_spoolss_SetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
9120                         OUR_HANDLE(r->in.handle)));
9121                 return WERR_BADFID;
9122         }
9123
9124         if (Printer->printer_type == SPLHND_SERVER) {
9125                 DEBUG(10,("_spoolss_SetPrinterDataEx: "
9126                         "Not implemented for server handles yet\n"));
9127                 return WERR_INVALID_PARAM;
9128         }
9129
9130         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9131                 return WERR_BADFID;
9132         }
9133
9134         /*
9135          * Access check : NT returns "access denied" if you make a
9136          * SetPrinterData call without the necessary privildge.
9137          * we were originally returning OK if nothing changed
9138          * which made Win2k issue **a lot** of SetPrinterData
9139          * when connecting to a printer  --jerry
9140          */
9141
9142         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9143                 DEBUG(3, ("_spoolss_SetPrinterDataEx: "
9144                         "change denied by handle access permissions\n"));
9145                 return WERR_ACCESS_DENIED;
9146         }
9147
9148         result = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
9149         if (!W_ERROR_IS_OK(result)) {
9150                 return result;
9151         }
9152
9153         /* check for OID in valuename */
9154
9155         oid_string = strchr(r->in.value_name, ',');
9156         if (oid_string) {
9157                 *oid_string = '\0';
9158                 oid_string++;
9159         }
9160
9161         /* save the registry data */
9162
9163         result = set_printer_dataex(printer, r->in.key_name, r->in.value_name,
9164                                     r->in.type, r->in.buffer, r->in.offered);
9165
9166         if (W_ERROR_IS_OK(result)) {
9167                 /* save the OID if one was specified */
9168                 if (oid_string) {
9169                         char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
9170                                 r->in.key_name, SPOOL_OID_KEY);
9171                         if (!str) {
9172                                 result = WERR_NOMEM;
9173                                 goto done;
9174                         }
9175
9176                         /*
9177                          * I'm not checking the status here on purpose.  Don't know
9178                          * if this is right, but I'm returning the status from the
9179                          * previous set_printer_dataex() call.  I have no idea if
9180                          * this is right.    --jerry
9181                          */
9182
9183                         set_printer_dataex(printer, str, r->in.value_name,
9184                                            REG_SZ, (uint8_t *)oid_string,
9185                                            strlen(oid_string)+1);
9186                 }
9187
9188                 result = mod_a_printer(printer, 2);
9189         }
9190
9191  done:
9192         free_a_printer(&printer, 2);
9193
9194         return result;
9195 }
9196
9197 /****************************************************************
9198  _spoolss_DeletePrinterDataEx
9199 ****************************************************************/
9200
9201 WERROR _spoolss_DeletePrinterDataEx(pipes_struct *p,
9202                                     struct spoolss_DeletePrinterDataEx *r)
9203 {
9204         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9205         int             snum=0;
9206         WERROR          status = WERR_OK;
9207         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9208
9209         DEBUG(5,("_spoolss_DeletePrinterDataEx\n"));
9210
9211         if (!Printer) {
9212                 DEBUG(2,("_spoolss_DeletePrinterDataEx: "
9213                         "Invalid handle (%s:%u:%u).\n",
9214                         OUR_HANDLE(r->in.handle)));
9215                 return WERR_BADFID;
9216         }
9217
9218         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9219                 return WERR_BADFID;
9220
9221         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9222                 DEBUG(3, ("_spoolss_DeletePrinterDataEx: "
9223                         "printer properties change denied by handle\n"));
9224                 return WERR_ACCESS_DENIED;
9225         }
9226
9227         if (!r->in.value_name || !r->in.key_name) {
9228                 return WERR_NOMEM;
9229         }
9230
9231         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9232         if (!W_ERROR_IS_OK(status))
9233                 return status;
9234
9235         status = delete_printer_dataex( printer, r->in.key_name, r->in.value_name );
9236
9237         if ( W_ERROR_IS_OK(status) )
9238                 mod_a_printer( printer, 2 );
9239
9240         free_a_printer(&printer, 2);
9241
9242         return status;
9243 }
9244
9245 /****************************************************************
9246  _spoolss_EnumPrinterKey
9247 ****************************************************************/
9248
9249 WERROR _spoolss_EnumPrinterKey(pipes_struct *p,
9250                                struct spoolss_EnumPrinterKey *r)
9251 {
9252         fstring         *keynames = NULL;
9253         int             num_keys;
9254         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9255         NT_PRINTER_DATA *data;
9256         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9257         int             snum = 0;
9258         WERROR          result = WERR_BADFILE;
9259         int i;
9260         const char **array = NULL;
9261
9262
9263         DEBUG(4,("_spoolss_EnumPrinterKey\n"));
9264
9265         if (!Printer) {
9266                 DEBUG(2,("_spoolss_EnumPrinterKey: Invalid handle (%s:%u:%u).\n",
9267                         OUR_HANDLE(r->in.handle)));
9268                 return WERR_BADFID;
9269         }
9270
9271         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9272                 return WERR_BADFID;
9273         }
9274
9275         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9276         if (!W_ERROR_IS_OK(result)) {
9277                 return result;
9278         }
9279
9280         /* get the list of subkey names */
9281
9282         data = printer->info_2->data;
9283
9284         num_keys = get_printer_subkeys(data, r->in.key_name, &keynames);
9285         if (num_keys == -1) {
9286                 result = WERR_BADFILE;
9287                 goto done;
9288         }
9289
9290         *r->out.needed = 4;
9291
9292         array = talloc_zero_array(r->out.key_buffer, const char *, num_keys + 1);
9293         if (!array) {
9294                 result = WERR_NOMEM;
9295                 goto done;
9296         }
9297
9298         for (i=0; i < num_keys; i++) {
9299                 array[i] = talloc_strdup(array, keynames[i]);
9300                 if (!array[i]) {
9301                         result = WERR_NOMEM;
9302                         goto done;
9303                 }
9304
9305                 *r->out.needed += strlen_m_term(keynames[i]) * 2;
9306         }
9307
9308         if (r->in.offered < *r->out.needed) {
9309                 result = WERR_MORE_DATA;
9310                 goto done;
9311         }
9312
9313         result = WERR_OK;
9314
9315         *r->out.key_buffer = array;
9316
9317  done:
9318         if (!W_ERROR_IS_OK(result)) {
9319                 TALLOC_FREE(array);
9320                 ZERO_STRUCTP(r->out.key_buffer);
9321         }
9322
9323         free_a_printer(&printer, 2);
9324         SAFE_FREE(keynames);
9325
9326         return result;
9327 }
9328
9329 /****************************************************************
9330  _spoolss_DeletePrinterKey
9331 ****************************************************************/
9332
9333 WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
9334                                  struct spoolss_DeletePrinterKey *r)
9335 {
9336         Printer_entry           *Printer = find_printer_index_by_hnd(p, r->in.handle);
9337         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9338         int                     snum=0;
9339         WERROR                  status;
9340
9341         DEBUG(5,("_spoolss_DeletePrinterKey\n"));
9342
9343         if (!Printer) {
9344                 DEBUG(2,("_spoolss_DeletePrinterKey: Invalid handle (%s:%u:%u).\n",
9345                         OUR_HANDLE(r->in.handle)));
9346                 return WERR_BADFID;
9347         }
9348
9349         /* if keyname == NULL, return error */
9350
9351         if ( !r->in.key_name )
9352                 return WERR_INVALID_PARAM;
9353
9354         if (!get_printer_snum(p, r->in.handle, &snum, NULL))
9355                 return WERR_BADFID;
9356
9357         if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
9358                 DEBUG(3, ("_spoolss_DeletePrinterKey: "
9359                         "printer properties change denied by handle\n"));
9360                 return WERR_ACCESS_DENIED;
9361         }
9362
9363         status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9364         if (!W_ERROR_IS_OK(status))
9365                 return status;
9366
9367         /* delete the key and all subneys */
9368
9369         status = delete_all_printer_data( printer->info_2, r->in.key_name );
9370
9371         if ( W_ERROR_IS_OK(status) )
9372                 status = mod_a_printer(printer, 2);
9373
9374         free_a_printer( &printer, 2 );
9375
9376         return status;
9377 }
9378
9379 /****************************************************************
9380 ****************************************************************/
9381
9382 static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
9383                                                    REGISTRY_VALUE *v,
9384                                                    struct spoolss_PrinterEnumValues *r)
9385 {
9386         WERROR result;
9387
9388         r->data = TALLOC_ZERO_P(mem_ctx, union spoolss_PrinterData);
9389         W_ERROR_HAVE_NO_MEMORY(r->data);
9390
9391         r->value_name   = talloc_strdup(mem_ctx, regval_name(v));
9392         W_ERROR_HAVE_NO_MEMORY(r->value_name);
9393
9394         r->type         = regval_type(v);
9395         r->data_length  = regval_size(v);
9396
9397         if (r->data_length) {
9398                 DATA_BLOB blob = data_blob_const(regval_data_p(v),
9399                                                  regval_size(v));
9400                 result = pull_spoolss_PrinterData(mem_ctx, &blob,
9401                                                   r->data,
9402                                                   r->type);
9403                 if (!W_ERROR_IS_OK(result)) {
9404                         return result;
9405                 }
9406         }
9407
9408         return WERR_OK;
9409 }
9410
9411 /****************************************************************
9412  _spoolss_EnumPrinterDataEx
9413 ****************************************************************/
9414
9415 WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
9416                                   struct spoolss_EnumPrinterDataEx *r)
9417 {
9418         uint32_t        count = 0;
9419         NT_PRINTER_INFO_LEVEL   *printer = NULL;
9420         struct spoolss_PrinterEnumValues *info = NULL;
9421         NT_PRINTER_DATA         *p_data;
9422         Printer_entry   *Printer = find_printer_index_by_hnd(p, r->in.handle);
9423         int             snum;
9424         WERROR          result;
9425         int             key_index;
9426         int             i;
9427
9428         DEBUG(4,("_spoolss_EnumPrinterDataEx\n"));
9429
9430         *r->out.count = 0;
9431         *r->out.needed = 0;
9432         *r->out.info = NULL;
9433
9434         if (!Printer) {
9435                 DEBUG(2,("_spoolss_EnumPrinterDataEx: Invalid handle (%s:%u:%u1<).\n",
9436                         OUR_HANDLE(r->in.handle)));
9437                 return WERR_BADFID;
9438         }
9439
9440         /*
9441          * first check for a keyname of NULL or "".  Win2k seems to send
9442          * this a lot and we should send back WERR_INVALID_PARAM
9443          * no need to spend time looking up the printer in this case.
9444          * --jerry
9445          */
9446
9447         if (!strlen(r->in.key_name)) {
9448                 result = WERR_INVALID_PARAM;
9449                 goto done;
9450         }
9451
9452         /* get the printer off of disk */
9453
9454         if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
9455                 return WERR_BADFID;
9456         }
9457
9458         ZERO_STRUCT(printer);
9459         result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
9460         if (!W_ERROR_IS_OK(result)) {
9461                 return result;
9462         }
9463
9464         /* now look for a match on the key name */
9465
9466         p_data = printer->info_2->data;
9467
9468         key_index = lookup_printerkey(p_data, r->in.key_name);
9469         if (key_index == -1) {
9470                 DEBUG(10,("_spoolss_EnumPrinterDataEx: Unknown keyname [%s]\n",
9471                         r->in.key_name));
9472                 result = WERR_INVALID_PARAM;
9473                 goto done;
9474         }
9475
9476         /* allocate the memory for the array of pointers -- if necessary */
9477
9478         count = regval_ctr_numvals(p_data->keys[key_index].values);
9479         if (!count) {
9480                 result = WERR_OK; /* ??? */
9481                 goto done;
9482         }
9483
9484         info = TALLOC_ZERO_ARRAY(p->mem_ctx,
9485                                  struct spoolss_PrinterEnumValues,
9486                                  count);
9487         if (!info) {
9488                 DEBUG(0,("_spoolss_EnumPrinterDataEx: talloc() failed\n"));
9489                 result = WERR_NOMEM;
9490                 goto done;
9491         }
9492
9493         /*
9494          * loop through all params and build the array to pass
9495          * back to the  client
9496          */
9497
9498         for (i=0; i < count; i++) {
9499
9500                 REGISTRY_VALUE  *val;
9501
9502                 /* lookup the registry value */
9503
9504                 val = regval_ctr_specific_value(p_data->keys[key_index].values, i);
9505
9506                 DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val)));
9507
9508                 /* copy the data */
9509
9510                 result = registry_value_to_printer_enum_value(info, val, &info[i]);
9511                 if (!W_ERROR_IS_OK(result)) {
9512                         goto done;
9513                 }
9514         }
9515
9516 #if 0 /* FIXME - gd */
9517         /* housekeeping information in the reply */
9518
9519         /* Fix from Martin Zielinski <mz@seh.de> - ensure
9520          * the hand marshalled container size is a multiple
9521          * of 4 bytes for RPC alignment.
9522          */
9523
9524         if (needed % 4) {
9525                 needed += 4-(needed % 4);
9526         }
9527 #endif
9528         *r->out.count   = count;
9529         *r->out.info    = info;
9530
9531  done:
9532
9533         if (printer) {
9534                 free_a_printer(&printer, 2);
9535         }
9536
9537         if (!W_ERROR_IS_OK(result)) {
9538                 return result;
9539         }
9540
9541         *r->out.needed  = SPOOLSS_BUFFER_ARRAY(p->mem_ctx,
9542                                                spoolss_EnumPrinterDataEx, NULL,
9543                                                *r->out.info,
9544                                                *r->out.count);
9545         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
9546         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, *r->out.count);
9547
9548         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
9549 }
9550
9551 /****************************************************************************
9552 ****************************************************************************/
9553
9554 static WERROR getprintprocessordirectory_level_1(TALLOC_CTX *mem_ctx,
9555                                                  const char *servername,
9556                                                  const char *environment,
9557                                                  struct spoolss_PrintProcessorDirectoryInfo1 *r)
9558 {
9559         WERROR werr;
9560         char *path = NULL;
9561
9562         werr = compose_spoolss_server_path(mem_ctx,
9563                                            servername,
9564                                            environment,
9565                                            SPOOLSS_PRTPROCS_PATH,
9566                                            &path);
9567         if (!W_ERROR_IS_OK(werr)) {
9568                 return werr;
9569         }
9570
9571         DEBUG(4,("print processor directory: [%s]\n", path));
9572
9573         r->directory_name = path;
9574
9575         return WERR_OK;
9576 }
9577
9578 /****************************************************************
9579  _spoolss_GetPrintProcessorDirectory
9580 ****************************************************************/
9581
9582 WERROR _spoolss_GetPrintProcessorDirectory(pipes_struct *p,
9583                                            struct spoolss_GetPrintProcessorDirectory *r)
9584 {
9585         WERROR result;
9586
9587         /* that's an [in out] buffer */
9588
9589         if (!r->in.buffer && (r->in.offered != 0)) {
9590                 return WERR_INVALID_PARAM;
9591         }
9592
9593         DEBUG(5,("_spoolss_GetPrintProcessorDirectory: level %d\n",
9594                 r->in.level));
9595
9596         *r->out.needed = 0;
9597
9598         /* r->in.level is ignored */
9599
9600         result = getprintprocessordirectory_level_1(p->mem_ctx,
9601                                                     r->in.server,
9602                                                     r->in.environment,
9603                                                     &r->out.info->info1);
9604         if (!W_ERROR_IS_OK(result)) {
9605                 TALLOC_FREE(r->out.info);
9606                 return result;
9607         }
9608
9609         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, NULL,
9610                                                r->out.info, r->in.level);
9611         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
9612
9613         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
9614 }
9615
9616 /*******************************************************************
9617  ********************************************************************/
9618
9619 static bool push_monitorui_buf(TALLOC_CTX *mem_ctx, DATA_BLOB *buf,
9620                                const char *dllname)
9621 {
9622         enum ndr_err_code ndr_err;
9623         struct spoolss_MonitorUi ui;
9624
9625         ui.dll_name = dllname;
9626
9627         ndr_err = ndr_push_struct_blob(buf, mem_ctx, NULL, &ui,
9628                        (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorUi);
9629         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9630                 NDR_PRINT_DEBUG(spoolss_MonitorUi, &ui);
9631         }
9632         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9633 }
9634
9635 /*******************************************************************
9636  Streams the monitor UI DLL name in UNICODE
9637 *******************************************************************/
9638
9639 static WERROR xcvtcp_monitorui(TALLOC_CTX *mem_ctx,
9640                                NT_USER_TOKEN *token, DATA_BLOB *in,
9641                                DATA_BLOB *out, uint32_t *needed)
9642 {
9643         const char *dllname = "tcpmonui.dll";
9644
9645         *needed = (strlen(dllname)+1) * 2;
9646
9647         if (out->length < *needed) {
9648                 return WERR_INSUFFICIENT_BUFFER;
9649         }
9650
9651         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9652                 return WERR_NOMEM;
9653         }
9654
9655         return WERR_OK;
9656 }
9657
9658 /*******************************************************************
9659  ********************************************************************/
9660
9661 static bool pull_port_data_1(TALLOC_CTX *mem_ctx,
9662                              struct spoolss_PortData1 *port1,
9663                              const DATA_BLOB *buf)
9664 {
9665         enum ndr_err_code ndr_err;
9666         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port1,
9667                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData1);
9668         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9669                 NDR_PRINT_DEBUG(spoolss_PortData1, port1);
9670         }
9671         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9672 }
9673
9674 /*******************************************************************
9675  ********************************************************************/
9676
9677 static bool pull_port_data_2(TALLOC_CTX *mem_ctx,
9678                              struct spoolss_PortData2 *port2,
9679                              const DATA_BLOB *buf)
9680 {
9681         enum ndr_err_code ndr_err;
9682         ndr_err = ndr_pull_struct_blob(buf, mem_ctx, NULL, port2,
9683                        (ndr_pull_flags_fn_t)ndr_pull_spoolss_PortData2);
9684         if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && (DEBUGLEVEL >= 10)) {
9685                 NDR_PRINT_DEBUG(spoolss_PortData2, port2);
9686         }
9687         return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
9688 }
9689
9690 /*******************************************************************
9691  Create a new TCP/IP port
9692 *******************************************************************/
9693
9694 static WERROR xcvtcp_addport(TALLOC_CTX *mem_ctx,
9695                              NT_USER_TOKEN *token, DATA_BLOB *in,
9696                              DATA_BLOB *out, uint32_t *needed)
9697 {
9698         struct spoolss_PortData1 port1;
9699         struct spoolss_PortData2 port2;
9700         char *device_uri = NULL;
9701         uint32_t version;
9702
9703         const char *portname;
9704         const char *hostaddress;
9705         const char *queue;
9706         uint32_t port_number;
9707         uint32_t protocol;
9708
9709         /* peek for spoolss_PortData version */
9710
9711         if (!in || (in->length < (128 + 4))) {
9712                 return WERR_GENERAL_FAILURE;
9713         }
9714
9715         version = IVAL(in->data, 128);
9716
9717         switch (version) {
9718                 case 1:
9719                         ZERO_STRUCT(port1);
9720
9721                         if (!pull_port_data_1(mem_ctx, &port1, in)) {
9722                                 return WERR_NOMEM;
9723                         }
9724
9725                         portname        = port1.portname;
9726                         hostaddress     = port1.hostaddress;
9727                         queue           = port1.queue;
9728                         protocol        = port1.protocol;
9729                         port_number     = port1.port_number;
9730
9731                         break;
9732                 case 2:
9733                         ZERO_STRUCT(port2);
9734
9735                         if (!pull_port_data_2(mem_ctx, &port2, in)) {
9736                                 return WERR_NOMEM;
9737                         }
9738
9739                         portname        = port2.portname;
9740                         hostaddress     = port2.hostaddress;
9741                         queue           = port2.queue;
9742                         protocol        = port2.protocol;
9743                         port_number     = port2.port_number;
9744
9745                         break;
9746                 default:
9747                         DEBUG(1,("xcvtcp_addport: "
9748                                 "unknown version of port_data: %d\n", version));
9749                         return WERR_UNKNOWN_PORT;
9750         }
9751
9752         /* create the device URI and call the add_port_hook() */
9753
9754         switch (protocol) {
9755         case PROTOCOL_RAWTCP_TYPE:
9756                 device_uri = talloc_asprintf(mem_ctx,
9757                                 "socket://%s:%d/", hostaddress,
9758                                 port_number);
9759                 break;
9760
9761         case PROTOCOL_LPR_TYPE:
9762                 device_uri = talloc_asprintf(mem_ctx,
9763                         "lpr://%s/%s", hostaddress, queue );
9764                 break;
9765
9766         default:
9767                 return WERR_UNKNOWN_PORT;
9768         }
9769
9770         if (!device_uri) {
9771                 return WERR_NOMEM;
9772         }
9773
9774         return add_port_hook(mem_ctx, token, portname, device_uri);
9775 }
9776
9777 /*******************************************************************
9778 *******************************************************************/
9779
9780 struct xcv_api_table xcvtcp_cmds[] = {
9781         { "MonitorUI",  xcvtcp_monitorui },
9782         { "AddPort",    xcvtcp_addport},
9783         { NULL,         NULL }
9784 };
9785
9786 static WERROR process_xcvtcp_command(TALLOC_CTX *mem_ctx,
9787                                      NT_USER_TOKEN *token, const char *command,
9788                                      DATA_BLOB *inbuf,
9789                                      DATA_BLOB *outbuf,
9790                                      uint32_t *needed )
9791 {
9792         int i;
9793
9794         DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
9795
9796         for ( i=0; xcvtcp_cmds[i].name; i++ ) {
9797                 if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
9798                         return xcvtcp_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9799         }
9800
9801         return WERR_BADFUNC;
9802 }
9803
9804 /*******************************************************************
9805 *******************************************************************/
9806 #if 0   /* don't support management using the "Local Port" monitor */
9807
9808 static WERROR xcvlocal_monitorui(TALLOC_CTX *mem_ctx,
9809                                  NT_USER_TOKEN *token, DATA_BLOB *in,
9810                                  DATA_BLOB *out, uint32_t *needed)
9811 {
9812         const char *dllname = "localui.dll";
9813
9814         *needed = (strlen(dllname)+1) * 2;
9815
9816         if (out->length < *needed) {
9817                 return WERR_INSUFFICIENT_BUFFER;
9818         }
9819
9820         if (!push_monitorui_buf(mem_ctx, out, dllname)) {
9821                 return WERR_NOMEM;
9822         }
9823
9824         return WERR_OK;
9825 }
9826
9827 /*******************************************************************
9828 *******************************************************************/
9829
9830 struct xcv_api_table xcvlocal_cmds[] = {
9831         { "MonitorUI",  xcvlocal_monitorui },
9832         { NULL,         NULL }
9833 };
9834 #else
9835 struct xcv_api_table xcvlocal_cmds[] = {
9836         { NULL,         NULL }
9837 };
9838 #endif
9839
9840
9841
9842 /*******************************************************************
9843 *******************************************************************/
9844
9845 static WERROR process_xcvlocal_command(TALLOC_CTX *mem_ctx,
9846                                        NT_USER_TOKEN *token, const char *command,
9847                                        DATA_BLOB *inbuf, DATA_BLOB *outbuf,
9848                                        uint32_t *needed)
9849 {
9850         int i;
9851
9852         DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
9853
9854         for ( i=0; xcvlocal_cmds[i].name; i++ ) {
9855                 if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
9856                         return xcvlocal_cmds[i].fn(mem_ctx, token, inbuf, outbuf, needed);
9857         }
9858         return WERR_BADFUNC;
9859 }
9860
9861 /****************************************************************
9862  _spoolss_XcvData
9863 ****************************************************************/
9864
9865 WERROR _spoolss_XcvData(pipes_struct *p,
9866                         struct spoolss_XcvData *r)
9867 {
9868         Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
9869         DATA_BLOB out_data = data_blob_null;
9870         WERROR werror;
9871
9872         if (!Printer) {
9873                 DEBUG(2,("_spoolss_XcvData: Invalid handle (%s:%u:%u).\n",
9874                         OUR_HANDLE(r->in.handle)));
9875                 return WERR_BADFID;
9876         }
9877
9878         /* Has to be a handle to the TCP/IP port monitor */
9879
9880         if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
9881                 DEBUG(2,("_spoolss_XcvData: Call only valid for Port Monitors\n"));
9882                 return WERR_BADFID;
9883         }
9884
9885         /* requires administrative access to the server */
9886
9887         if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
9888                 DEBUG(2,("_spoolss_XcvData: denied by handle permissions.\n"));
9889                 return WERR_ACCESS_DENIED;
9890         }
9891
9892         /* Allocate the outgoing buffer */
9893
9894         if (r->in.out_data_size) {
9895                 out_data = data_blob_talloc_zero(p->mem_ctx, r->in.out_data_size);
9896                 if (out_data.data == NULL) {
9897                         return WERR_NOMEM;
9898                 }
9899         }
9900
9901         switch ( Printer->printer_type ) {
9902         case SPLHND_PORTMON_TCP:
9903                 werror = process_xcvtcp_command(p->mem_ctx,
9904                                                 p->server_info->ptok,
9905                                                 r->in.function_name,
9906                                                 &r->in.in_data, &out_data,
9907                                                 r->out.needed);
9908                 break;
9909         case SPLHND_PORTMON_LOCAL:
9910                 werror = process_xcvlocal_command(p->mem_ctx,
9911                                                   p->server_info->ptok,
9912                                                   r->in.function_name,
9913                                                   &r->in.in_data, &out_data,
9914                                                   r->out.needed);
9915                 break;
9916         default:
9917                 werror = WERR_INVALID_PRINT_MONITOR;
9918         }
9919
9920         if (!W_ERROR_IS_OK(werror)) {
9921                 return werror;
9922         }
9923
9924         *r->out.status_code = 0;
9925
9926         memcpy(r->out.out_data, out_data.data, out_data.length);
9927
9928         return WERR_OK;
9929 }
9930
9931 /****************************************************************
9932  _spoolss_AddPrintProcessor
9933 ****************************************************************/
9934
9935 WERROR _spoolss_AddPrintProcessor(pipes_struct *p,
9936                                   struct spoolss_AddPrintProcessor *r)
9937 {
9938         /* for now, just indicate success and ignore the add.  We'll
9939            automatically set the winprint processor for printer
9940            entries later.  Used to debug the LexMark Optra S 1855 PCL
9941            driver --jerry */
9942
9943         return WERR_OK;
9944 }
9945
9946 /****************************************************************
9947  _spoolss_AddPort
9948 ****************************************************************/
9949
9950 WERROR _spoolss_AddPort(pipes_struct *p,
9951                         struct spoolss_AddPort *r)
9952 {
9953         /* do what w2k3 does */
9954
9955         return WERR_NOT_SUPPORTED;
9956 }
9957
9958 /****************************************************************
9959  _spoolss_AddPrinter
9960 ****************************************************************/
9961
9962 WERROR _spoolss_AddPrinter(pipes_struct *p,
9963                            struct spoolss_AddPrinter *r)
9964 {
9965         p->rng_fault_state = true;
9966         return WERR_NOT_SUPPORTED;
9967 }
9968
9969 /****************************************************************
9970  _spoolss_GetPrinterDriver
9971 ****************************************************************/
9972
9973 WERROR _spoolss_GetPrinterDriver(pipes_struct *p,
9974                                  struct spoolss_GetPrinterDriver *r)
9975 {
9976         p->rng_fault_state = true;
9977         return WERR_NOT_SUPPORTED;
9978 }
9979
9980 /****************************************************************
9981  _spoolss_ReadPrinter
9982 ****************************************************************/
9983
9984 WERROR _spoolss_ReadPrinter(pipes_struct *p,
9985                             struct spoolss_ReadPrinter *r)
9986 {
9987         p->rng_fault_state = true;
9988         return WERR_NOT_SUPPORTED;
9989 }
9990
9991 /****************************************************************
9992  _spoolss_WaitForPrinterChange
9993 ****************************************************************/
9994
9995 WERROR _spoolss_WaitForPrinterChange(pipes_struct *p,
9996                                      struct spoolss_WaitForPrinterChange *r)
9997 {
9998         p->rng_fault_state = true;
9999         return WERR_NOT_SUPPORTED;
10000 }
10001
10002 /****************************************************************
10003  _spoolss_ConfigurePort
10004 ****************************************************************/
10005
10006 WERROR _spoolss_ConfigurePort(pipes_struct *p,
10007                               struct spoolss_ConfigurePort *r)
10008 {
10009         p->rng_fault_state = true;
10010         return WERR_NOT_SUPPORTED;
10011 }
10012
10013 /****************************************************************
10014  _spoolss_DeletePort
10015 ****************************************************************/
10016
10017 WERROR _spoolss_DeletePort(pipes_struct *p,
10018                            struct spoolss_DeletePort *r)
10019 {
10020         p->rng_fault_state = true;
10021         return WERR_NOT_SUPPORTED;
10022 }
10023
10024 /****************************************************************
10025  _spoolss_CreatePrinterIC
10026 ****************************************************************/
10027
10028 WERROR _spoolss_CreatePrinterIC(pipes_struct *p,
10029                                 struct spoolss_CreatePrinterIC *r)
10030 {
10031         p->rng_fault_state = true;
10032         return WERR_NOT_SUPPORTED;
10033 }
10034
10035 /****************************************************************
10036  _spoolss_PlayGDIScriptOnPrinterIC
10037 ****************************************************************/
10038
10039 WERROR _spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p,
10040                                          struct spoolss_PlayGDIScriptOnPrinterIC *r)
10041 {
10042         p->rng_fault_state = true;
10043         return WERR_NOT_SUPPORTED;
10044 }
10045
10046 /****************************************************************
10047  _spoolss_DeletePrinterIC
10048 ****************************************************************/
10049
10050 WERROR _spoolss_DeletePrinterIC(pipes_struct *p,
10051                                 struct spoolss_DeletePrinterIC *r)
10052 {
10053         p->rng_fault_state = true;
10054         return WERR_NOT_SUPPORTED;
10055 }
10056
10057 /****************************************************************
10058  _spoolss_AddPrinterConnection
10059 ****************************************************************/
10060
10061 WERROR _spoolss_AddPrinterConnection(pipes_struct *p,
10062                                      struct spoolss_AddPrinterConnection *r)
10063 {
10064         p->rng_fault_state = true;
10065         return WERR_NOT_SUPPORTED;
10066 }
10067
10068 /****************************************************************
10069  _spoolss_DeletePrinterConnection
10070 ****************************************************************/
10071
10072 WERROR _spoolss_DeletePrinterConnection(pipes_struct *p,
10073                                         struct spoolss_DeletePrinterConnection *r)
10074 {
10075         p->rng_fault_state = true;
10076         return WERR_NOT_SUPPORTED;
10077 }
10078
10079 /****************************************************************
10080  _spoolss_PrinterMessageBox
10081 ****************************************************************/
10082
10083 WERROR _spoolss_PrinterMessageBox(pipes_struct *p,
10084                                   struct spoolss_PrinterMessageBox *r)
10085 {
10086         p->rng_fault_state = true;
10087         return WERR_NOT_SUPPORTED;
10088 }
10089
10090 /****************************************************************
10091  _spoolss_AddMonitor
10092 ****************************************************************/
10093
10094 WERROR _spoolss_AddMonitor(pipes_struct *p,
10095                            struct spoolss_AddMonitor *r)
10096 {
10097         p->rng_fault_state = true;
10098         return WERR_NOT_SUPPORTED;
10099 }
10100
10101 /****************************************************************
10102  _spoolss_DeleteMonitor
10103 ****************************************************************/
10104
10105 WERROR _spoolss_DeleteMonitor(pipes_struct *p,
10106                               struct spoolss_DeleteMonitor *r)
10107 {
10108         p->rng_fault_state = true;
10109         return WERR_NOT_SUPPORTED;
10110 }
10111
10112 /****************************************************************
10113  _spoolss_DeletePrintProcessor
10114 ****************************************************************/
10115
10116 WERROR _spoolss_DeletePrintProcessor(pipes_struct *p,
10117                                      struct spoolss_DeletePrintProcessor *r)
10118 {
10119         p->rng_fault_state = true;
10120         return WERR_NOT_SUPPORTED;
10121 }
10122
10123 /****************************************************************
10124  _spoolss_AddPrintProvidor
10125 ****************************************************************/
10126
10127 WERROR _spoolss_AddPrintProvidor(pipes_struct *p,
10128                                  struct spoolss_AddPrintProvidor *r)
10129 {
10130         p->rng_fault_state = true;
10131         return WERR_NOT_SUPPORTED;
10132 }
10133
10134 /****************************************************************
10135  _spoolss_DeletePrintProvidor
10136 ****************************************************************/
10137
10138 WERROR _spoolss_DeletePrintProvidor(pipes_struct *p,
10139                                     struct spoolss_DeletePrintProvidor *r)
10140 {
10141         p->rng_fault_state = true;
10142         return WERR_NOT_SUPPORTED;
10143 }
10144
10145 /****************************************************************
10146  _spoolss_FindFirstPrinterChangeNotification
10147 ****************************************************************/
10148
10149 WERROR _spoolss_FindFirstPrinterChangeNotification(pipes_struct *p,
10150                                                    struct spoolss_FindFirstPrinterChangeNotification *r)
10151 {
10152         p->rng_fault_state = true;
10153         return WERR_NOT_SUPPORTED;
10154 }
10155
10156 /****************************************************************
10157  _spoolss_FindNextPrinterChangeNotification
10158 ****************************************************************/
10159
10160 WERROR _spoolss_FindNextPrinterChangeNotification(pipes_struct *p,
10161                                                   struct spoolss_FindNextPrinterChangeNotification *r)
10162 {
10163         p->rng_fault_state = true;
10164         return WERR_NOT_SUPPORTED;
10165 }
10166
10167 /****************************************************************
10168  _spoolss_RouterFindFirstPrinterChangeNotificationOld
10169 ****************************************************************/
10170
10171 WERROR _spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p,
10172                                                             struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
10173 {
10174         p->rng_fault_state = true;
10175         return WERR_NOT_SUPPORTED;
10176 }
10177
10178 /****************************************************************
10179  _spoolss_ReplyOpenPrinter
10180 ****************************************************************/
10181
10182 WERROR _spoolss_ReplyOpenPrinter(pipes_struct *p,
10183                                  struct spoolss_ReplyOpenPrinter *r)
10184 {
10185         p->rng_fault_state = true;
10186         return WERR_NOT_SUPPORTED;
10187 }
10188
10189 /****************************************************************
10190  _spoolss_RouterReplyPrinter
10191 ****************************************************************/
10192
10193 WERROR _spoolss_RouterReplyPrinter(pipes_struct *p,
10194                                    struct spoolss_RouterReplyPrinter *r)
10195 {
10196         p->rng_fault_state = true;
10197         return WERR_NOT_SUPPORTED;
10198 }
10199
10200 /****************************************************************
10201  _spoolss_ReplyClosePrinter
10202 ****************************************************************/
10203
10204 WERROR _spoolss_ReplyClosePrinter(pipes_struct *p,
10205                                   struct spoolss_ReplyClosePrinter *r)
10206 {
10207         p->rng_fault_state = true;
10208         return WERR_NOT_SUPPORTED;
10209 }
10210
10211 /****************************************************************
10212  _spoolss_AddPortEx
10213 ****************************************************************/
10214
10215 WERROR _spoolss_AddPortEx(pipes_struct *p,
10216                           struct spoolss_AddPortEx *r)
10217 {
10218         p->rng_fault_state = true;
10219         return WERR_NOT_SUPPORTED;
10220 }
10221
10222 /****************************************************************
10223  _spoolss_RouterFindFirstPrinterChangeNotification
10224 ****************************************************************/
10225
10226 WERROR _spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p,
10227                                                          struct spoolss_RouterFindFirstPrinterChangeNotification *r)
10228 {
10229         p->rng_fault_state = true;
10230         return WERR_NOT_SUPPORTED;
10231 }
10232
10233 /****************************************************************
10234  _spoolss_SpoolerInit
10235 ****************************************************************/
10236
10237 WERROR _spoolss_SpoolerInit(pipes_struct *p,
10238                             struct spoolss_SpoolerInit *r)
10239 {
10240         p->rng_fault_state = true;
10241         return WERR_NOT_SUPPORTED;
10242 }
10243
10244 /****************************************************************
10245  _spoolss_ResetPrinterEx
10246 ****************************************************************/
10247
10248 WERROR _spoolss_ResetPrinterEx(pipes_struct *p,
10249                                struct spoolss_ResetPrinterEx *r)
10250 {
10251         p->rng_fault_state = true;
10252         return WERR_NOT_SUPPORTED;
10253 }
10254
10255 /****************************************************************
10256  _spoolss_RouterReplyPrinterEx
10257 ****************************************************************/
10258
10259 WERROR _spoolss_RouterReplyPrinterEx(pipes_struct *p,
10260                                      struct spoolss_RouterReplyPrinterEx *r)
10261 {
10262         p->rng_fault_state = true;
10263         return WERR_NOT_SUPPORTED;
10264 }
10265
10266 /****************************************************************
10267  _spoolss_44
10268 ****************************************************************/
10269
10270 WERROR _spoolss_44(pipes_struct *p,
10271                    struct spoolss_44 *r)
10272 {
10273         p->rng_fault_state = true;
10274         return WERR_NOT_SUPPORTED;
10275 }
10276
10277 /****************************************************************
10278  _spoolss_47
10279 ****************************************************************/
10280
10281 WERROR _spoolss_47(pipes_struct *p,
10282                    struct spoolss_47 *r)
10283 {
10284         p->rng_fault_state = true;
10285         return WERR_NOT_SUPPORTED;
10286 }
10287
10288 /****************************************************************
10289  _spoolss_4a
10290 ****************************************************************/
10291
10292 WERROR _spoolss_4a(pipes_struct *p,
10293                    struct spoolss_4a *r)
10294 {
10295         p->rng_fault_state = true;
10296         return WERR_NOT_SUPPORTED;
10297 }
10298
10299 /****************************************************************
10300  _spoolss_4b
10301 ****************************************************************/
10302
10303 WERROR _spoolss_4b(pipes_struct *p,
10304                    struct spoolss_4b *r)
10305 {
10306         p->rng_fault_state = true;
10307         return WERR_NOT_SUPPORTED;
10308 }
10309
10310 /****************************************************************
10311  _spoolss_4c
10312 ****************************************************************/
10313
10314 WERROR _spoolss_4c(pipes_struct *p,
10315                    struct spoolss_4c *r)
10316 {
10317         p->rng_fault_state = true;
10318         return WERR_NOT_SUPPORTED;
10319 }
10320
10321 /****************************************************************
10322  _spoolss_53
10323 ****************************************************************/
10324
10325 WERROR _spoolss_53(pipes_struct *p,
10326                    struct spoolss_53 *r)
10327 {
10328         p->rng_fault_state = true;
10329         return WERR_NOT_SUPPORTED;
10330 }
10331
10332 /****************************************************************
10333  _spoolss_55
10334 ****************************************************************/
10335
10336 WERROR _spoolss_55(pipes_struct *p,
10337                    struct spoolss_55 *r)
10338 {
10339         p->rng_fault_state = true;
10340         return WERR_NOT_SUPPORTED;
10341 }
10342
10343 /****************************************************************
10344  _spoolss_56
10345 ****************************************************************/
10346
10347 WERROR _spoolss_56(pipes_struct *p,
10348                    struct spoolss_56 *r)
10349 {
10350         p->rng_fault_state = true;
10351         return WERR_NOT_SUPPORTED;
10352 }
10353
10354 /****************************************************************
10355  _spoolss_57
10356 ****************************************************************/
10357
10358 WERROR _spoolss_57(pipes_struct *p,
10359                    struct spoolss_57 *r)
10360 {
10361         p->rng_fault_state = true;
10362         return WERR_NOT_SUPPORTED;
10363 }
10364
10365 /****************************************************************
10366  _spoolss_5a
10367 ****************************************************************/
10368
10369 WERROR _spoolss_5a(pipes_struct *p,
10370                    struct spoolss_5a *r)
10371 {
10372         p->rng_fault_state = true;
10373         return WERR_NOT_SUPPORTED;
10374 }
10375
10376 /****************************************************************
10377  _spoolss_5b
10378 ****************************************************************/
10379
10380 WERROR _spoolss_5b(pipes_struct *p,
10381                    struct spoolss_5b *r)
10382 {
10383         p->rng_fault_state = true;
10384         return WERR_NOT_SUPPORTED;
10385 }
10386
10387 /****************************************************************
10388  _spoolss_5c
10389 ****************************************************************/
10390
10391 WERROR _spoolss_5c(pipes_struct *p,
10392                    struct spoolss_5c *r)
10393 {
10394         p->rng_fault_state = true;
10395         return WERR_NOT_SUPPORTED;
10396 }
10397
10398 /****************************************************************
10399  _spoolss_5d
10400 ****************************************************************/
10401
10402 WERROR _spoolss_5d(pipes_struct *p,
10403                    struct spoolss_5d *r)
10404 {
10405         p->rng_fault_state = true;
10406         return WERR_NOT_SUPPORTED;
10407 }
10408
10409 /****************************************************************
10410  _spoolss_5e
10411 ****************************************************************/
10412
10413 WERROR _spoolss_5e(pipes_struct *p,
10414                    struct spoolss_5e *r)
10415 {
10416         p->rng_fault_state = true;
10417         return WERR_NOT_SUPPORTED;
10418 }
10419
10420 /****************************************************************
10421  _spoolss_5f
10422 ****************************************************************/
10423
10424 WERROR _spoolss_5f(pipes_struct *p,
10425                    struct spoolss_5f *r)
10426 {
10427         p->rng_fault_state = true;
10428         return WERR_NOT_SUPPORTED;
10429 }
10430