s3-spoolss: use PRINTER_ENUM_NAME and remove double enum define.
[samba.git] / librpc / idl / spoolss.idl
1 #include "idl_types.h"
2
3 /*
4   spoolss interface definitions
5 */
6 import "misc.idl", "security.idl", "winreg.idl";
7
8 [ uuid("12345678-1234-abcd-ef00-0123456789ab"),
9   version(1.0),
10   endpoint("ncacn_np:[\\pipe\\spoolss]"),
11   pointer_default(unique),
12   helpstring("Spooler SubSystem"),
13   helper("../librpc/ndr/ndr_spoolss_buf.h")
14 ] interface spoolss
15 {
16         typedef [v1_enum] enum winreg_Type winreg_Type;
17         typedef struct {
18                 uint16 year;
19                 uint16 month;
20                 uint16 day_of_week;
21                 uint16 day;
22                 uint16 hour;
23                 uint16 minute;
24                 uint16 second;
25                 uint16 millisecond;
26         } spoolss_Time;
27
28         typedef struct {
29                 [relative] nstring *printername;
30                 [relative] nstring *servername;
31                 uint32 cjobs;
32                 uint32 total_jobs;
33                 uint32 total_bytes;
34                 spoolss_Time time;              
35                 uint32 global_counter;
36                 uint32 total_pages;
37                 uint32 version;
38                 uint32 unknown10;
39                 uint32 unknown11;
40                 uint32 unknown12;
41                 uint32 session_counter;
42                 uint32 unknown14;
43                 uint32 printer_errors;
44                 uint32 unknown16;
45                 uint32 unknown17;
46                 uint32 unknown18;
47                 uint32 unknown19;
48                 uint32 change_id;
49                 uint32 unknown21;
50                 uint32 status;
51                 uint32 unknown23;
52                 uint32 c_setprinter;
53                 uint16 unknown25;
54                 uint16 unknown26;
55                 uint32 unknown27;
56                 uint32 unknown28;
57                 uint32 unknown29;
58         } spoolss_PrinterInfo0;
59
60         typedef [public,gensize] struct {
61                 [charset(UTF16)] uint16 devicename[32];
62                 uint16 specversion;
63                 uint16 driverversion;
64                 uint16 size;
65                 [value(r->driverextra_data.length)] uint16 __driverextra_length;
66                 uint32 fields;
67                 uint16 orientation;
68                 uint16 papersize;
69                 uint16 paperlength;
70                 uint16 paperwidth;
71                 uint16 scale;
72                 uint16 copies;
73                 uint16 defaultsource;
74                 uint16 printquality;
75                 uint16 color;
76                 uint16 duplex;
77                 uint16 yresolution;
78                 uint16 ttoption;
79                 uint16 collate;
80                 [charset(UTF16)] uint16 formname[32];
81                 uint16 logpixels;
82                 uint32 bitsperpel;
83                 uint32 pelswidth;
84                 uint32 pelsheight;
85                 uint32 displayflags;
86                 uint32 displayfrequency;
87                 uint32 icmmethod;
88                 uint32 icmintent;
89                 uint32 mediatype;
90                 uint32 dithertype;
91                 uint32 reserved1;
92                 uint32 reserved2;
93                 uint32 panningwidth;
94                 uint32 panningheight;
95                 [subcontext_size(__driverextra_length),subcontext(0),flag(NDR_REMAINING)] DATA_BLOB driverextra_data;
96         } spoolss_DeviceMode;
97
98         typedef [public] bitmap {
99                 PRINTER_ENUM_DEFAULT     = 0x00000001,
100                 PRINTER_ENUM_LOCAL       = 0x00000002,
101                 PRINTER_ENUM_CONNECTIONS = 0x00000004,
102                 PRINTER_ENUM_FAVORITE    = 0x00000004,
103                 PRINTER_ENUM_NAME        = 0x00000008,
104                 PRINTER_ENUM_REMOTE      = 0x00000010,
105                 PRINTER_ENUM_SHARED      = 0x00000020,
106                 PRINTER_ENUM_NETWORK     = 0x00000040,
107                 PRINTER_ENUM_EXPAND      = 0x00004000,
108                 PRINTER_ENUM_CONTAINER   = 0x00008000,
109                 PRINTER_ENUM_ICON1       = 0x00010000,
110                 PRINTER_ENUM_ICON2       = 0x00020000,
111                 PRINTER_ENUM_ICON3       = 0x00040000,
112                 PRINTER_ENUM_ICON4       = 0x00080000,
113                 PRINTER_ENUM_ICON5       = 0x00100000,
114                 PRINTER_ENUM_ICON6       = 0x00200000,
115                 PRINTER_ENUM_ICON7       = 0x00400000,
116                 PRINTER_ENUM_ICON8       = 0x00800000,
117                 PRINTER_ENUM_HIDE        = 0x01000000
118         } spoolss_EnumPrinterFlags;
119
120         typedef struct {
121                 spoolss_EnumPrinterFlags flags;
122                 [relative] nstring *name;
123                 [relative] nstring *description;
124                 [relative] nstring *comment;
125         } spoolss_PrinterInfo1;
126
127         typedef bitmap {
128                 PRINTER_ATTRIBUTE_QUEUED                = 0x00000001,
129                 PRINTER_ATTRIBUTE_DIRECT                = 0x00000002,
130                 PRINTER_ATTRIBUTE_DEFAULT               = 0x00000004,
131                 PRINTER_ATTRIBUTE_SHARED                = 0x00000008,
132                 PRINTER_ATTRIBUTE_NETWORK               = 0x00000010,
133                 PRINTER_ATTRIBUTE_HIDDEN                = 0x00000020,
134                 PRINTER_ATTRIBUTE_LOCAL                 = 0x00000040,
135                 PRINTER_ATTRIBUTE_ENABLE_DEVQ           = 0x00000080,
136                 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS       = 0x00000100,
137                 PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST     = 0x00000200,
138                 PRINTER_ATTRIBUTE_WORK_OFFLINE          = 0x00000400,
139                 PRINTER_ATTRIBUTE_ENABLE_BIDI           = 0x00000800,
140                 PRINTER_ATTRIBUTE_RAW_ONLY              = 0x00001000,
141                 PRINTER_ATTRIBUTE_PUBLISHED             = 0x00002000,
142                 PRINTER_ATTRIBUTE_FAX                   = 0x00004000,
143                 PRINTER_ATTRIBUTE_TS                    = 0x00008000
144         } spoolss_PrinterAttributes;
145
146         typedef bitmap {
147                 PRINTER_STATUS_PAUSED           = 0x00000001,
148                 PRINTER_STATUS_ERROR            = 0x00000002,
149                 PRINTER_STATUS_PENDING_DELETION = 0x00000004,
150                 PRINTER_STATUS_PAPER_JAM        = 0x00000008,
151                 PRINTER_STATUS_PAPER_OUT        = 0x00000010,
152                 PRINTER_STATUS_MANUAL_FEED      = 0x00000020,
153                 PRINTER_STATUS_PAPER_PROBLEM    = 0x00000040,
154                 PRINTER_STATUS_OFFLINE          = 0x00000080,
155                 PRINTER_STATUS_IO_ACTIVE        = 0x00000100,
156                 PRINTER_STATUS_BUSY             = 0x00000200,
157                 PRINTER_STATUS_PRINTING         = 0x00000400,
158                 PRINTER_STATUS_OUTPUT_BIN_FULL  = 0x00000800,
159                 PRINTER_STATUS_NOT_AVAILABLE    = 0x00001000,
160                 PRINTER_STATUS_WAITING          = 0x00002000,
161                 PRINTER_STATUS_PROCESSING       = 0x00004000,
162                 PRINTER_STATUS_INITIALIZING     = 0x00008000,
163                 PRINTER_STATUS_WARMING_UP       = 0x00010000,
164                 PRINTER_STATUS_TONER_LOW        = 0x00020000,
165                 PRINTER_STATUS_NO_TONER         = 0x00040000,
166                 PRINTER_STATUS_PAGE_PUNT        = 0x00080000,
167                 PRINTER_STATUS_USER_INTERVENTION= 0x00100000,
168                 PRINTER_STATUS_OUT_OF_MEMORY    = 0x00200000,
169                 PRINTER_STATUS_DOOR_OPEN        = 0x00400000,
170                 PRINTER_STATUS_SERVER_UNKNOWN   = 0x00800000,
171                 PRINTER_STATUS_POWER_SAVE       = 0x01000000
172         } spoolss_PrinterStatus;
173
174         typedef struct {
175                 [relative] nstring *servername;
176                 [relative] nstring *printername;
177                 [relative] nstring *sharename;
178                 [relative] nstring *portname;
179                 [relative] nstring *drivername;
180                 [relative] nstring *comment;
181                 [relative] nstring *location;
182                 [relative,subcontext(0)] spoolss_DeviceMode *devmode;
183                 [relative] nstring *sepfile;
184                 [relative] nstring *printprocessor;
185                 [relative] nstring *datatype;
186                 [relative] nstring *parameters;
187                 [relative,subcontext(0)] security_descriptor *secdesc;
188                 spoolss_PrinterAttributes attributes;
189                 uint32 priority;
190                 uint32 defaultpriority;
191                 uint32 starttime;
192                 uint32 untiltime;
193                 spoolss_PrinterStatus status;
194                 uint32 cjobs;
195                 uint32 averageppm;
196         } spoolss_PrinterInfo2;
197
198         typedef struct {
199                 [relative,subcontext(0)] security_descriptor *secdesc;
200         } spoolss_PrinterInfo3;
201
202         typedef struct {
203                 [relative] nstring *printername;
204                 [relative] nstring *servername;
205                 spoolss_PrinterAttributes attributes;
206         } spoolss_PrinterInfo4;
207
208         typedef struct {
209                 [relative] nstring *printername;
210                 [relative] nstring *portname;
211                 spoolss_PrinterAttributes attributes;
212                 uint32 device_not_selected_timeout;
213                 uint32 transmission_retry_timeout;
214         } spoolss_PrinterInfo5;
215
216         typedef struct {
217                 spoolss_PrinterStatus status;
218         } spoolss_PrinterInfo6;
219
220         typedef bitmap {
221                 DSPRINT_PUBLISH         = 0x00000001,
222                 DSPRINT_UPDATE          = 0x00000002,
223                 DSPRINT_UNPUBLISH       = 0x00000004,
224                 DSPRINT_REPUBLISH       = 0x00000008,
225                 DSPRINT_PENDING         = 0x80000000
226         } spoolss_DsPrintAction;
227
228         typedef struct {
229                 [relative] nstring *guid; /* text form of printer guid */
230                 spoolss_DsPrintAction action;
231         } spoolss_PrinterInfo7;
232
233         typedef struct {
234                 [relative,subcontext(0)] spoolss_DeviceMode *devmode;
235         } spoolss_DeviceModeInfo;
236
237         typedef [nodiscriminant,relative_base,public] union {
238                 [case(0)] spoolss_PrinterInfo0 info0;
239                 [case(1)] spoolss_PrinterInfo1 info1;
240                 [case(2)] spoolss_PrinterInfo2 info2;
241                 [case(3)] spoolss_PrinterInfo3 info3;
242                 [case(4)] spoolss_PrinterInfo4 info4;
243                 [case(5)] spoolss_PrinterInfo5 info5;
244                 [case(6)] spoolss_PrinterInfo6 info6;
245                 [case(7)] spoolss_PrinterInfo7 info7;
246                 [case(8)] spoolss_DeviceModeInfo info8;
247                 [case(9)] spoolss_DeviceModeInfo info9;
248                 [default];
249         } spoolss_PrinterInfo;
250
251         /******************/
252         /* Function: 0x00 */
253         /* we are using this as internal parsing code */
254         [public,noopnum,noprint] WERROR _spoolss_EnumPrinters(
255                 [in] spoolss_EnumPrinterFlags flags,
256                 [in,unique] [string,charset(UTF16)] uint16 *server,
257                 [in] uint32 level,
258                 [in,unique] DATA_BLOB *buffer,
259                 [in] uint32 offered,
260                 [out,unique] DATA_BLOB *info,
261                 [out,ref] uint32 *needed,
262                 [out] uint32 count
263         );
264         [public,noopnum,noprint] void __spoolss_EnumPrinters(
265                 [in] uint32 level,
266                 [in] uint32 count,
267                 [out,switch_is(level)] spoolss_PrinterInfo info[count]
268         );
269         [nopull,nopush] WERROR spoolss_EnumPrinters(
270                 [in] spoolss_EnumPrinterFlags flags,
271                 [in,unique] [string,charset(UTF16)] uint16 *server,
272                 [in] uint32 level,
273                 [in,unique] DATA_BLOB *buffer,
274                 [in] uint32 offered,
275                 /* what we have here is a subcontext containing an array of no discriminant unions
276                  * and the array has no size in front
277                  */
278                 [out,unique,switch_is(level),size_is(count)] spoolss_PrinterInfo *info,
279                 [out,ref] uint32 *needed,
280                 [out] uint32 count
281         );
282
283         /******************/
284         /* Function: 0x01 */
285         typedef struct {
286                 [value(_ndr_size_spoolss_DeviceMode(devmode, ndr->iconv_convenience, ndr->flags))] uint32 _ndr_size;
287                 [subcontext(4),subcontext_size(_ndr_size)] spoolss_DeviceMode *devmode;
288         } spoolss_DevmodeContainer;
289
290         [public] WERROR spoolss_OpenPrinter(
291                 [in,unique] [string,charset(UTF16)] uint16 *printername,
292                 [in,unique] [string,charset(UTF16)] uint16 *datatype,
293                 [in] spoolss_DevmodeContainer devmode_ctr,
294                 [in] uint32 access_mask,
295                 [out,ref] policy_handle *handle
296         );
297
298         /******************/
299         /* Function: 0x02 */
300         typedef struct {
301                 uint32 job_id;
302                 [relative] nstring *printer_name;
303                 [relative] nstring *server_name;
304                 [relative] nstring *user_name;
305                 [relative] nstring *document_name;
306                 [relative] nstring *data_type;
307                 [relative] nstring *text_status;
308                 uint32 status;
309                 uint32 priority;
310                 uint32 position;
311                 uint32 total_pages;
312                 uint32 pages_printed;
313                 spoolss_Time time;
314         } spoolss_JobInfo1;
315
316         typedef [nodiscriminant,relative_base,public] union {
317                 [case(1)] spoolss_JobInfo1 info1;
318                 [case(2)]; /* TODO */
319                 [case(3)]; /* TODO */
320                 [default];
321         } spoolss_JobInfo;
322
323         typedef struct {
324                 uint32 level;
325                 [switch_is(level)] spoolss_JobInfo info;
326         } spoolss_JobInfoContainer;
327
328         typedef [v1_enum] enum {
329                 SPOOLSS_JOB_CONTROL_PAUSE               = 1,
330                 SPOOLSS_JOB_CONTROL_RESUME              = 2,
331                 SPOOLSS_JOB_CONTROL_CANCEL              = 3,
332                 SPOOLSS_JOB_CONTROL_RESTART             = 4,
333                 SPOOLSS_JOB_CONTROL_DELETE              = 5,
334                 SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER     = 6,
335                 SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED   = 7
336         } spoolss_JobControl;
337
338         WERROR spoolss_SetJob(
339                 [in,ref] policy_handle *handle,
340                 [in] uint32 job_id,
341                 [in,unique] spoolss_JobInfoContainer *ctr,
342                 [in] spoolss_JobControl command
343         );
344
345         /******************/
346         /* Function: 0x03 */
347         WERROR spoolss_GetJob(
348                 [in,ref] policy_handle *handle,
349                 [in]     uint32 job_id,
350                 [in]     uint32 level,
351                 [in,unique] DATA_BLOB *buffer,
352                 [in]     uint32 offered,
353                 [out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_JobInfo *info,
354                 [out,ref] uint32 *needed
355         );
356
357         /******************/
358         /* Function: 0x04 */
359         [public,noopnum,noprint] WERROR _spoolss_EnumJobs(
360                 [in,ref] policy_handle *handle,
361                 [in]     uint32 firstjob,
362                 [in]     uint32 numjobs,
363                 [in]     uint32 level,
364                 [in,unique] DATA_BLOB *buffer,
365                 [in]     uint32 offered,
366                 [out,unique] DATA_BLOB *info,
367                 [out,ref] uint32 *needed,
368                 [out]    uint32 count
369         );
370         [public,noopnum,noprint] void __spoolss_EnumJobs(
371                 [in] uint32 level,
372                 [in] uint32 count,
373                 [out,switch_is(level)] spoolss_JobInfo info[count]
374         );
375         [nopull,nopush] WERROR spoolss_EnumJobs(
376                 [in,ref] policy_handle *handle,
377                 [in]     uint32 firstjob,
378                 [in]     uint32 numjobs,
379                 [in]     uint32 level,
380                 [in,unique] DATA_BLOB *buffer,
381                 [in]     uint32 offered,
382                 [out,unique,switch_is(level),size_is(count)] spoolss_JobInfo *info,
383                 [out,ref] uint32 *needed,
384                 [out]    uint32 count
385         );
386
387         /******************/
388         /* Function: 0x05 */
389         [todo] WERROR spoolss_AddPrinter(
390                 /* This function is not implemented in Samba 3 as no
391                    clients have been observed using it. */
392         );
393
394         /******************/
395         /* Function: 0x06 */
396         WERROR spoolss_DeletePrinter(
397                 [in] policy_handle *handle
398         );
399
400         /******************/
401         /* Function: 0x07 */
402         typedef [v1_enum] enum {
403                 SPOOLSS_PRINTER_CONTROL_UNPAUSE    = 0,
404                 SPOOLSS_PRINTER_CONTROL_PAUSE      = 1,
405                 SPOOLSS_PRINTER_CONTROL_RESUME     = 2,
406                 SPOOLSS_PRINTER_CONTROL_PURGE      = 3,
407                 SPOOLSS_PRINTER_CONTROL_SET_STATUS = 4
408         } spoolss_PrinterControl;
409
410         typedef [switch_type(uint32)] union {
411                 [case(0)] spoolss_PrinterInfo0 *info0;
412                 [case(1)] spoolss_PrinterInfo1 *info1;
413                 [case(2)] spoolss_PrinterInfo2 *info2;
414                 [case(3)] spoolss_PrinterInfo3 *info3;
415                 [case(4)] spoolss_PrinterInfo4 *info4;
416                 [case(5)] spoolss_PrinterInfo5 *info5;
417                 [case(6)] spoolss_PrinterInfo6 *info6;
418                 [case(7)] spoolss_PrinterInfo7 *info7;
419                 [case(8)] spoolss_DeviceModeInfo *info8;
420                 [case(9)] spoolss_DeviceModeInfo *info9;
421                 [default];
422         } spoolss_SetPrinterInfo;
423
424         WERROR spoolss_SetPrinter(
425                 [in,ref] policy_handle *handle,
426                 [in] uint32 level,
427                 [in,switch_is(level)] spoolss_SetPrinterInfo info,
428                 [in] spoolss_DevmodeContainer devmode_ctr,
429                 [in] sec_desc_buf secdesc_ctr,
430                 [in] spoolss_PrinterControl command
431         );
432
433         /******************/
434         /* Function: 0x08 */
435         [public] WERROR spoolss_GetPrinter(
436                 [in,ref] policy_handle *handle,
437                 [in]     uint32 level,
438                 [in,unique] DATA_BLOB *buffer,
439                 [in]     uint32 offered,
440                 [out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_PrinterInfo *info,
441                 [out,ref] uint32 *needed
442         );
443
444         /******************/
445         /* Function: 0x09 */
446         [todo] WERROR spoolss_AddPrinterDriver(
447         );
448
449         typedef struct {
450                 [relative] nstring *driver_name;
451         } spoolss_DriverInfo1;
452
453         typedef [v1_enum] enum {
454                 SPOOLSS_DRIVER_VERSION_9X       = 0,
455                 SPOOLSS_DRIVER_VERSION_NT35     = 1,
456                 SPOOLSS_DRIVER_VERSION_NT4      = 2,
457                 SPOOLSS_DRIVER_VERSION_200X     = 3
458         } spoolss_DriverOSVersion;
459
460         typedef struct {
461                 spoolss_DriverOSVersion version;
462                 [relative] nstring *driver_name;
463                 [relative] nstring *architecture;
464                 [relative] nstring *driver_path;
465                 [relative] nstring *data_file;
466                 [relative] nstring *config_file;
467         } spoolss_DriverInfo2;
468
469         typedef struct {
470                 spoolss_DriverOSVersion version;
471                 [relative] nstring *driver_name;
472                 [relative] nstring *architecture;
473                 [relative] nstring *driver_path;
474                 [relative] nstring *data_file;
475                 [relative] nstring *config_file;
476                 [relative] nstring *help_file;
477                 [relative] nstring_array *dependent_files;
478                 [relative] nstring *monitor_name;
479                 [relative] nstring *default_datatype;
480         } spoolss_DriverInfo3;
481
482         typedef struct {
483                 spoolss_DriverOSVersion version;
484                 [relative] nstring *driver_name;
485                 [relative] nstring *architecture;
486                 [relative] nstring *driver_path;
487                 [relative] nstring *data_file;
488                 [relative] nstring *config_file;
489                 [relative] nstring *help_file;
490                 [relative] nstring_array *dependent_files;
491                 [relative] nstring *monitor_name;
492                 [relative] nstring *default_datatype;
493                 [relative] nstring_array *previous_names;
494         } spoolss_DriverInfo4;
495
496         typedef struct {
497                 spoolss_DriverOSVersion version;
498                 [relative] nstring *driver_name;
499                 [relative] nstring *architecture;
500                 [relative] nstring *driver_path;
501                 [relative] nstring *data_file;
502                 [relative] nstring *config_file;
503                 uint32 driver_attributes;
504                 uint32 config_version;
505                 uint32 driver_version;
506         } spoolss_DriverInfo5;
507
508         typedef struct {
509                 spoolss_DriverOSVersion version;
510                 [relative] nstring *driver_name;
511                 [relative] nstring *architecture;
512                 [relative] nstring *driver_path;
513                 [relative] nstring *data_file;
514                 [relative] nstring *config_file;
515                 [relative] nstring *help_file;
516                 [relative] nstring_array *dependent_files;
517                 [relative] nstring *monitor_name;
518                 [relative] nstring *default_datatype;
519                 [relative] nstring_array *previous_names;
520                 NTTIME driver_data;
521                 hyper driver_version;
522                 [relative] nstring *manufacturer_name;
523                 [relative] nstring *manufacturer_url;
524                 [relative] nstring *hardware_id;
525                 [relative] nstring *provider;
526         } spoolss_DriverInfo6;
527
528         typedef [nodiscriminant,relative_base,public] union {
529                 [case(1)] spoolss_DriverInfo1 info1;
530                 [case(2)] spoolss_DriverInfo2 info2;
531                 [case(3)] spoolss_DriverInfo3 info3;
532                 [case(4)] spoolss_DriverInfo4 info4;
533                 [case(5)] spoolss_DriverInfo5 info5;
534                 [case(6)] spoolss_DriverInfo6 info6;
535                 [default];
536         } spoolss_DriverInfo;
537
538         /******************/
539         /* Function: 0x0a */
540         [public,noopnum,noprint] WERROR _spoolss_EnumPrinterDrivers(
541                 [in,unique] [string,charset(UTF16)] uint16 *server,
542                 [in,unique] [string,charset(UTF16)] uint16 *environment,
543                 [in] uint32 level,
544                 [in,unique] DATA_BLOB *buffer,
545                 [in] uint32 offered,
546                 [out,unique] DATA_BLOB *info,
547                 [out,ref] uint32 *needed,
548                 [out] uint32 count
549         );
550         [public,noopnum,noprint] void __spoolss_EnumPrinterDrivers(
551                 [in] uint32 level,
552                 [in] uint32 count,
553                 [out,switch_is(level)] spoolss_DriverInfo info[count]
554         );
555         [nopull,nopush] WERROR spoolss_EnumPrinterDrivers(
556                 [in,unique] [string,charset(UTF16)] uint16 *server,
557                 [in,unique] [string,charset(UTF16)] uint16 *environment,
558                 [in] uint32 level,
559                 [in,unique] DATA_BLOB *buffer,
560                 [in] uint32 offered,
561                 [out,unique,switch_is(level),size_is(count)] spoolss_DriverInfo *info,
562                 [out,ref] uint32 *needed,
563                 [out] uint32 count
564         );
565
566         /******************/
567         /* Function: 0x0b */
568         [todo] WERROR spoolss_GetPrinterDriver(
569         );
570
571         /******************/
572         /* Function: 0x0c */
573         typedef struct {
574                 nstring directory_name;
575         } spoolss_DriverDirectoryInfo1;
576
577         /* NOTE: it's seems that w2k3 completly ignores the level
578                  in its server code
579          */
580         typedef [nodiscriminant,relative_base,gensize,public] union {
581                 [case(1)] spoolss_DriverDirectoryInfo1 info1;
582                 [default] spoolss_DriverDirectoryInfo1 info1;
583         } spoolss_DriverDirectoryInfo;
584
585         [public] WERROR spoolss_GetPrinterDriverDirectory(
586                 [in,unique] [string,charset(UTF16)] uint16 *server,
587                 [in,unique] [string,charset(UTF16)] uint16 *environment,
588                 [in] uint32 level,
589                 [in,unique] DATA_BLOB *buffer,
590                 [in] uint32 offered,
591                 [out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_DriverDirectoryInfo *info,
592                 [out,ref] uint32 *needed
593         );
594
595         /******************/
596         /* Function: 0x0d */
597         WERROR spoolss_DeletePrinterDriver(
598                 [in,unique] [string,charset(UTF16)] uint16 *server,
599                 [in] [string,charset(UTF16)] uint16 architecture[],
600                 [in] [string,charset(UTF16)] uint16 driver[]
601         );
602
603         /******************/
604         /* Function: 0x0e */
605         WERROR spoolss_AddPrintProcessor(
606                 [in,unique] [string,charset(UTF16)] uint16 *server,
607                 [in] [string,charset(UTF16)] uint16 architecture[],
608                 [in] [string,charset(UTF16)] uint16 path_name[],
609                 [in] [string,charset(UTF16)] uint16 print_processor_name[]
610         );
611
612         /******************/
613         /* Function: 0x0f */
614         typedef struct {
615                 [relative] nstring *print_processor_name;
616         } spoolss_PrintProcessorInfo1;
617
618         typedef [nodiscriminant,relative_base,public] union {
619                 [case(1)] spoolss_PrintProcessorInfo1 info1;
620                 [default];
621         } spoolss_PrintProcessorInfo;
622
623         [public,noopnum,noprint] WERROR _spoolss_EnumPrintProcessors(
624                 [in,unique] [string,charset(UTF16)] uint16 *servername,
625                 [in,unique] [string,charset(UTF16)] uint16 *environment,
626                 [in] uint32 level,
627                 [in,unique] DATA_BLOB *buffer,
628                 [in] uint32 offered,
629                 [out,unique] DATA_BLOB *info,
630                 [out,ref] uint32 *needed,
631                 [out] uint32 count
632         );
633         [public,noopnum,noprint] void __spoolss_EnumPrintProcessors(
634                 [in] uint32 level,
635                 [in] uint32 count,
636                 [out,switch_is(level)] spoolss_PrintProcessorInfo info[count]
637         );
638         [nopull,nopush] WERROR spoolss_EnumPrintProcessors(
639                 [in,unique] [string,charset(UTF16)] uint16 *servername,
640                 [in,unique] [string,charset(UTF16)] uint16 *environment,
641                 [in] uint32 level,
642                 [in,unique] DATA_BLOB *buffer,
643                 [in] uint32 offered,
644                 [out,unique,switch_is(level),size_is(count)] spoolss_PrintProcessorInfo *info,
645                 [out,ref] uint32 *needed,
646                 [out] uint32 count
647         );
648
649         /******************/
650         /* Function: 0x10 */
651         [todo] WERROR spoolss_GetPrintProcessorDirectory(
652         );
653
654         /******************/
655         /* Function: 0x11 */
656         typedef struct {
657                 [string,charset(UTF16)] uint16 *document_name;
658                 [string,charset(UTF16)] uint16 *output_file;
659                 [string,charset(UTF16)] uint16 *datatype;
660         } spoolss_DocumentInfo1;
661
662         typedef [switch_type(uint32)] union {
663                 [case(1)] spoolss_DocumentInfo1 *info1;
664                 [case(2)]; /* TODO */
665                 [case(3)]; /* TODO */
666                 [default];
667         } spoolss_DocumentInfo;
668
669         WERROR spoolss_StartDocPrinter(
670                 [in,ref] policy_handle *handle,
671                 [in] uint32 level,
672                 [in,switch_is(level)] spoolss_DocumentInfo info,
673                 [out,ref] uint32 *job_id
674         );
675
676         /******************/
677         /* Function: 0x12 */
678         WERROR spoolss_StartPagePrinter(
679                 [in,ref] policy_handle *handle
680         );
681
682         /******************/
683         /* Function: 0x13 */
684         WERROR spoolss_WritePrinter(
685                 [in,ref] policy_handle *handle,
686                 [in] DATA_BLOB data,
687                 [in,value(r->in.data.length)] uint32 _data_size,
688                 [out,ref] uint32 *num_written
689         );
690
691         /******************/
692         /* Function: 0x14 */
693         WERROR spoolss_EndPagePrinter(
694                 [in,ref] policy_handle *handle
695         );
696
697         /******************/
698         /* Function: 0x15 */
699         WERROR spoolss_AbortPrinter(
700                 [in,ref] policy_handle *handle
701         );
702
703         /******************/
704         /* Function: 0x16 */
705         WERROR spoolss_ReadPrinter(
706                 [in,ref] policy_handle *handle,
707                 [out,ref] [size_is(data_size)] uint8 *data,
708                 [in] uint32 data_size,
709                 [out,ref] uint32 *_data_size
710         );
711
712         /******************/
713         /* Function: 0x17 */
714         WERROR spoolss_EndDocPrinter(
715                 [in,ref] policy_handle *handle
716         );
717
718         /******************/
719         /* Function: 0x18 */
720         [todo] WERROR spoolss_AddJob(
721         );
722
723         /******************/
724         /* Function: 0x19 */
725         [todo] WERROR spoolss_ScheduleJob(
726         );
727
728         /******************/
729         /* Function: 0x1a */
730         const string SPOOLSS_ARCHITECTURE_NT_X86                = "Windows NT x86";
731
732         typedef [public,gensize] struct {
733                 [value(ndr_size_spoolss_OSVersion(r,ndr->iconv_convenience,ndr->flags))] uint32 _ndr_size;
734                 uint32 major;
735                 uint32 minor;
736                 uint32 build;
737                 [value(2)] uint32 unknown;
738                 [subcontext(0),subcontext_size(256)] nstring extra_string;
739         } spoolss_OSVersion;
740
741         typedef [public,gensize] struct {
742                 [value(ndr_size_spoolss_OSVersionEx(r,ndr->iconv_convenience,ndr->flags))] uint32 _ndr_size;
743                 uint32 major;
744                 uint32 minor;
745                 uint32 build;
746                 [value(2)] uint32 unknown1;
747                 [subcontext(0),subcontext_size(256)] nstring extra_string;
748                 uint32 unknown2;/* service pack number? I saw 0 from w2k3 and 1 from winxp sp1*/
749                 uint32 unknown3;/* hmm? w2k3: 131346(0x20112) winxp sp1: 503382272 0x1E010100 */
750         } spoolss_OSVersionEx;
751
752         typedef [v1_enum] enum {
753                 SPOOLSS_PRINTER_DATA_TYPE_NULL = 0,
754                 SPOOLSS_PRINTER_DATA_TYPE_STRING = 1,
755                 SPOOLSS_PRINTER_DATA_TYPE_BINARY = 3,
756                 SPOOLSS_PRINTER_DATA_TYPE_UINT32 = 4,
757                 SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY = 7
758         } spoolss_PrinterDataType;
759
760         typedef [nodiscriminant,public,gensize] union {
761                 [case(SPOOLSS_PRINTER_DATA_TYPE_NULL)];
762                 [case(SPOOLSS_PRINTER_DATA_TYPE_STRING)] nstring string;
763                 [case(SPOOLSS_PRINTER_DATA_TYPE_BINARY),flag(NDR_REMAINING)] DATA_BLOB binary;
764                 [case(SPOOLSS_PRINTER_DATA_TYPE_UINT32)] uint32 value;
765                 [case(SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY)] nstring_array string_array;
766                 [default,flag(NDR_REMAINING)] DATA_BLOB data;
767         } spoolss_PrinterData;
768
769         [noopnum,noprint,public] WERROR _spoolss_GetPrinterData(
770                 [in,ref] policy_handle *handle,
771                 [in]     [string,charset(UTF16)] uint16 value_name[],
772                 [in]     uint32 offered,
773                 [out,ref] spoolss_PrinterDataType *type,
774                 [out]    DATA_BLOB data,
775                 [out,ref] uint32 *needed
776         );
777         [noopnum,noprint,public] void __spoolss_GetPrinterData(
778                 [in] spoolss_PrinterDataType type,
779                 [out,switch_is(type)] spoolss_PrinterData data
780         );
781         [nopull,nopush,public] WERROR spoolss_GetPrinterData(
782                 [in,ref] policy_handle *handle,
783                 [in]     [string,charset(UTF16)] uint16 value_name[],
784                 [in]     uint32 offered,
785                 [out,ref] spoolss_PrinterDataType *type,
786                 [out,subcontext(4),subcontext_size(offered),switch_is(*type)] spoolss_PrinterData data,
787                 [out,ref] uint32 *needed
788         );
789
790         /******************/
791         /* Function: 0x1b */
792         [noopnum,nopull,noprint,public] WERROR _spoolss_SetPrinterData(
793                 [in,ref] policy_handle *handle,
794                 [in] [string,charset(UTF16)] uint16 value_name[],
795                 [in] spoolss_PrinterDataType type,
796                 [in] DATA_BLOB data,
797                 [in] uint32 _offered
798         );
799         [noopnum,nopull,noprint,public] void __spoolss_SetPrinterData(
800                 [in] spoolss_PrinterDataType type,
801                 [out,switch_is(type)] spoolss_PrinterData data
802         );
803         [nopush] WERROR spoolss_SetPrinterData(
804                 [in,ref] policy_handle *handle,
805                 [in] [string,charset(UTF16)] uint16 value_name[],
806                 [in] spoolss_PrinterDataType type,
807                 [in,subcontext(4),switch_is(type)] spoolss_PrinterData data,
808                 [in,value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] uint32 _offered
809         );
810
811         /******************/
812         /* Function: 0x1c */
813         [todo] WERROR spoolss_WaitForPrinterChange(
814         );
815
816         /******************/
817         /* Function: 0x1d */
818         [public] WERROR spoolss_ClosePrinter(
819                 [in,out,ref]     policy_handle *handle
820         );
821
822         /******************/
823         /* Function: 0x1e */
824         typedef [v1_enum] enum {
825                 SPOOLSS_FORM_USER       = 0,
826                 SPOOLSS_FORM_BUILTIN    = 1,
827                 SPOOLSS_FORM_PRINTER    = 2
828         } spoolss_FormFlags;
829
830         typedef struct {
831                 uint32 width;
832                 uint32 height;
833         } spoolss_FormSize;
834
835         typedef struct {
836                 uint32 left;
837                 uint32 top;
838                 uint32 right;
839                 uint32 bottom;
840         } spoolss_FormArea;
841
842         typedef struct {
843                 spoolss_FormFlags flags;
844                 [relative] nstring *form_name;
845                 spoolss_FormSize size;
846                 spoolss_FormArea area;
847         } spoolss_FormInfo1;
848
849         typedef [nodiscriminant,relative_base,public,gensize] union {
850                 [case(1)] spoolss_FormInfo1 info1;
851                 [default];
852         } spoolss_FormInfo;
853
854         typedef struct {
855                 spoolss_FormFlags flags;
856                 [string,charset(UTF16)] uint16 *form_name;
857                 spoolss_FormSize size;
858                 spoolss_FormArea area;
859         } spoolss_AddFormInfo1;
860
861         typedef [switch_type(uint32)] union {
862                 [case(1)] spoolss_AddFormInfo1 *info1;
863         } spoolss_AddFormInfo;
864
865         WERROR spoolss_AddForm(
866                 [in,ref] policy_handle *handle,
867                 [in] uint32 level,
868                 [in,switch_is(level)] spoolss_AddFormInfo info
869         );
870
871         /******************/
872         /* Function: 0x1f */
873         WERROR spoolss_DeleteForm(
874                 [in,ref] policy_handle *handle,
875                 [in] [string,charset(UTF16)] uint16 form_name[]
876         );
877
878         /******************/
879         /* Function: 0x20 */
880         WERROR spoolss_GetForm(
881                 [in,ref] policy_handle *handle,
882                 [in] [string,charset(UTF16)] uint16 form_name[],
883                 [in] uint32 level,
884                 [in,unique] DATA_BLOB *buffer,
885                 [in] uint32 offered,
886                 [out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_FormInfo *info,
887                 [out,ref] uint32 *needed
888         );
889
890         /******************/
891         /* Function: 0x21 */
892         WERROR spoolss_SetForm(
893                 [in,ref] policy_handle *handle,
894                 [in] [string,charset(UTF16)] uint16 form_name[],
895                 [in] uint32 level,
896                 [in,switch_is(level)] spoolss_AddFormInfo info
897         );
898
899         /******************/
900         /* Function: 0x22 */
901         [public,noopnum,noprint] WERROR _spoolss_EnumForms(
902                 [in,ref] policy_handle *handle,
903                 [in]     uint32 level,
904                 [in,unique] DATA_BLOB *buffer,
905                 [in]     uint32 offered,
906                 [out,unique] DATA_BLOB *info,
907                 [out,ref] uint32 *needed,
908                 [out]    uint32 count
909         );
910         [public,noopnum,noprint] void __spoolss_EnumForms(
911                 [in] uint32 level,
912                 [in] uint32 count,
913                 [out,switch_is(level)] spoolss_FormInfo info[count]
914         );
915         [nopull,nopush] WERROR spoolss_EnumForms(
916                 [in,ref] policy_handle *handle,
917                 [in]     uint32 level,
918                 [in,unique] DATA_BLOB *buffer,
919                 [in]     uint32 offered,
920                 [out,unique,switch_is(level),size_is(count)] spoolss_FormInfo *info,
921                 [out,ref] uint32 *needed,
922                 [out] uint32 count
923         );
924
925         typedef struct {
926                 [relative] nstring *port_name;
927         } spoolss_PortInfo1;
928
929         typedef bitmap {
930                 SPOOLSS_PORT_TYPE_WRITE         = 0x00000001,
931                 SPOOLSS_PORT_TYPE_READ          = 0x00000002,
932                 SPOOLSS_PORT_TYPE_REDIRECTED    = 0x00000004,
933                 SPOOLSS_PORT_TYPE_NET_ATTACHED  = 0x00000008
934         } spoolss_PortType;
935
936         typedef struct {
937                 [relative] nstring *port_name;
938                 [relative] nstring *monitor_name;
939                 [relative] nstring *description;
940                 spoolss_PortType port_type;
941                 uint32 reserved;
942         } spoolss_PortInfo2;
943
944         typedef [nodiscriminant,relative_base,public] union {
945                 [case(1)] spoolss_PortInfo1 info1;
946                 [case(2)] spoolss_PortInfo2 info2;
947                 [case(3)]; /* TODO */
948                 [default];
949         } spoolss_PortInfo;
950
951         /******************/
952         /* Function: 0x23 */
953         [public,noopnum,noprint] WERROR _spoolss_EnumPorts(
954                 [in,unique] [string,charset(UTF16)] uint16 *servername,
955                 [in] uint32 level,
956                 [in,unique] DATA_BLOB *buffer,
957                 [in] uint32 offered,
958                 [out,unique] DATA_BLOB *info,
959                 [out,ref] uint32 *needed,
960                 [out] uint32 count
961         );
962         [public,noopnum,noprint] void __spoolss_EnumPorts(
963                 [in] uint32 level,
964                 [in] uint32 count,
965                 [out,switch_is(level)] spoolss_PortInfo info[count]
966         );
967         [nopull,nopush] WERROR spoolss_EnumPorts(
968                 [in,unique] [string,charset(UTF16)] uint16 *servername,
969                 [in] uint32 level,
970                 [in,unique] DATA_BLOB *buffer,
971                 [in] uint32 offered,
972                 [out,unique,switch_is(level),size_is(count)] spoolss_PortInfo *info,
973                 [out,ref] uint32 *needed,
974                 [out] uint32 count
975         );
976
977         /******************/
978         /* Function: 0x24 */
979         typedef struct {
980                 [relative] nstring *monitor_name;
981         } spoolss_MonitorInfo1;
982
983         typedef struct {
984                 [relative] nstring *monitor_name;
985                 [relative] nstring *environment;
986                 [relative] nstring *dll_name;
987         } spoolss_MonitorInfo2;
988
989         typedef [nodiscriminant,relative_base,public] union {
990                 [case(1)] spoolss_MonitorInfo1 info1;
991                 [case(2)] spoolss_MonitorInfo2 info2;
992                 [default];
993         } spoolss_MonitorInfo;
994
995         [public,noopnum,noprint] WERROR _spoolss_EnumMonitors(
996                 [in,unique] [string,charset(UTF16)] uint16 *servername,
997                 [in] uint32 level,
998                 [in,unique] DATA_BLOB *buffer,
999                 [in] uint32 offered,
1000                 [out,unique] DATA_BLOB *info,
1001                 [out,ref] uint32 *needed,
1002                 [out] uint32 count
1003         );
1004         [public,noopnum,noprint] void __spoolss_EnumMonitors(
1005                 [in] uint32 level,
1006                 [in] uint32 count,
1007                 [out,switch_is(level)] spoolss_MonitorInfo info[count]
1008         );
1009         [nopull,nopush] WERROR spoolss_EnumMonitors(
1010                 [in,unique] [string,charset(UTF16)] uint16 *servername,
1011                 [in] uint32 level,
1012                 [in,unique] DATA_BLOB *buffer,
1013                 [in] uint32 offered,
1014                 [out,unique,switch_is(level),size_is(count)] spoolss_MonitorInfo *info,
1015                 [out,ref] uint32 *needed,
1016                 [out] uint32 count
1017         );
1018
1019         /******************/
1020         /* Function: 0x25 */
1021         WERROR spoolss_AddPort(
1022                [in,unique] [string,charset(UTF16)] uint16 *server_name,
1023                [in] uint32 unknown,
1024                [in] [string,charset(UTF16)] uint16 monitor_name[]
1025         );
1026
1027         /******************/
1028         /* Function: 0x26 */
1029         [todo] WERROR spoolss_ConfigurePort(
1030         );
1031
1032         /******************/
1033         /* Function: 0x27 */
1034         [todo] WERROR spoolss_DeletePort(
1035         );
1036
1037         /******************/
1038         /* Function: 0x28 */
1039         [todo] WERROR spoolss_CreatePrinterIC(
1040         );
1041
1042         /******************/
1043         /* Function: 0x29 */
1044         [todo] WERROR spoolss_PlayGDIScriptOnPrinterIC(
1045         );
1046
1047         /******************/
1048         /* Function: 0x2a */
1049         [todo] WERROR spoolss_DeletePrinterIC(
1050         );
1051
1052         /******************/
1053         /* Function: 0x2b */
1054         [todo] WERROR spoolss_AddPrinterConnection(
1055         );
1056
1057         /******************/
1058         /* Function: 0x2c */
1059         [todo] WERROR spoolss_DeletePrinterConnection(
1060         );
1061
1062         /******************/
1063         /* Function: 0x2d */
1064         [todo] WERROR spoolss_PrinterMessageBox(
1065                 /* Marked as obsolete in MSDN.  "Not necessary and has
1066                    no effect". */
1067         );
1068
1069         /******************/
1070         /* Function: 0x2e */
1071         [todo] WERROR spoolss_AddMonitor(
1072         );
1073
1074         /******************/
1075         /* Function: 0x2f */
1076         [todo] WERROR spoolss_DeleteMonitor(
1077         );
1078
1079         /******************/
1080         /* Function: 0x30 */
1081         [todo] WERROR spoolss_DeletePrintProcessor(
1082         );
1083
1084         /******************/
1085         /* Function: 0x31 */
1086         [todo] WERROR spoolss_AddPrintProvidor(
1087         );
1088
1089         /******************/
1090         /* Function: 0x32 */
1091         [todo] WERROR spoolss_DeletePrintProvidor(
1092         );
1093
1094         /******************/
1095         /* Function: 0x33 */
1096         [todo] WERROR spoolss_EnumPrintProcDataTypes(
1097         );
1098
1099         /******************/
1100         /* Function: 0x34 */
1101         [todo] WERROR spoolss_ResetPrinter(
1102         );
1103
1104         /******************/
1105         /* Function: 0x35 */
1106         WERROR spoolss_GetPrinterDriver2(
1107                 [in,ref] policy_handle *handle,
1108                 [in,unique] [string,charset(UTF16)] uint16 *architecture,
1109                 [in]     uint32 level,
1110                 [in,unique] DATA_BLOB *buffer,
1111                 [in]     uint32 offered,
1112                 [in]     uint32 client_major_version,
1113                 [in]     uint32 client_minor_version,
1114                 [out,unique] DATA_BLOB *info,
1115                 [out,ref] uint32 *needed,
1116                 [out,ref] uint32 *server_major_version,
1117                 [out,ref] uint32 *server_minor_version
1118         );
1119
1120         /******************/
1121         /* Function: 0x36 */
1122         [todo] WERROR spoolss_FindFirstPrinterChangeNotification(
1123         );
1124
1125         /******************/
1126         /* Function: 0x37 */
1127         [todo] WERROR spoolss_FindNextPrinterChangeNotification(
1128         );
1129
1130         /******************/
1131         /* Function: 0x38 */
1132         [public] WERROR spoolss_FindClosePrinterNotify(
1133                 [in,ref] policy_handle *handle
1134         );
1135
1136         /******************/
1137         /* Function: 0x39 */
1138         [todo] WERROR spoolss_RouterFindFirstPrinterChangeNotificationOld(
1139         );
1140
1141         /******************/
1142         /* Function: 0x3a */
1143         [public] WERROR spoolss_ReplyOpenPrinter(
1144                 [in,string,charset(UTF16)] uint16 server_name[],
1145                 [in] uint32 printer_local,
1146                 [in] winreg_Type type,
1147                 [in] uint32 unknown1,
1148                 [in] uint32 unknown2,
1149                 [out,ref] policy_handle *handle
1150         );
1151
1152         /******************/
1153         /* Function: 0x3b */
1154
1155         typedef [bitmap32bit] bitmap {
1156                 PRINTER_CHANGE_ADD_PRINTER                      = 0x00000001,
1157                 PRINTER_CHANGE_SET_PRINTER                      = 0x00000002,
1158                 PRINTER_CHANGE_DELETE_PRINTER                   = 0x00000004,
1159                 PRINTER_CHANGE_FAILED_CONNECTION_PRINTER        = 0x00000008,
1160                 PRINTER_CHANGE_ADD_JOB                          = 0x00000100,
1161                 PRINTER_CHANGE_SET_JOB                          = 0x00000200,
1162                 PRINTER_CHANGE_DELETE_JOB                       = 0x00000400,
1163                 PRINTER_CHANGE_WRITE_JOB                        = 0x00000800,
1164                 PRINTER_CHANGE_ADD_FORM                         = 0x00010000,
1165                 PRINTER_CHANGE_SET_FORM                         = 0x00020000,
1166                 PRINTER_CHANGE_DELETE_FORM                      = 0x00040000,
1167                 PRINTER_CHANGE_ADD_PORT                         = 0x00100000,
1168                 PRINTER_CHANGE_CONFIGURE_PORT                   = 0x00200000,
1169                 PRINTER_CHANGE_DELETE_PORT                      = 0x00400000,
1170                 PRINTER_CHANGE_ADD_PRINT_PROCESSOR              = 0x01000000,
1171                 PRINTER_CHANGE_DELETE_PRINT_PROCESSOR           = 0x04000000,
1172                 PRINTER_CHANGE_ADD_PRINTER_DRIVER               = 0x10000000,
1173                 PRINTER_CHANGE_SET_PRINTER_DRIVER               = 0x20000000,
1174                 PRINTER_CHANGE_DELETE_PRINTER_DRIVER            = 0x40000000,
1175                 PRINTER_CHANGE_TIMEOUT                          = 0x80000000
1176         } spoolss_PrinterChangeFlags;
1177
1178         const int PRINTER_CHANGE_PRINTER                        = (PRINTER_CHANGE_ADD_PRINTER |
1179                                                                    PRINTER_CHANGE_SET_PRINTER |
1180                                                                    PRINTER_CHANGE_DELETE_PRINTER |
1181                                                                    PRINTER_CHANGE_FAILED_CONNECTION_PRINTER); /* 0x000000FF */
1182
1183         const int PRINTER_CHANGE_JOB                            = (PRINTER_CHANGE_ADD_JOB |
1184                                                                    PRINTER_CHANGE_SET_JOB |
1185                                                                    PRINTER_CHANGE_DELETE_JOB |
1186                                                                    PRINTER_CHANGE_WRITE_JOB); /* 0x0000FF00 */
1187
1188         const int PRINTER_CHANGE_FORM                           = (PRINTER_CHANGE_ADD_FORM |
1189                                                                    PRINTER_CHANGE_SET_FORM |
1190                                                                    PRINTER_CHANGE_DELETE_FORM); /* 0x00070000 */
1191
1192         const int PRINTER_CHANGE_PORT                           = (PRINTER_CHANGE_ADD_PORT |
1193                                                                    PRINTER_CHANGE_CONFIGURE_PORT |
1194                                                                    PRINTER_CHANGE_DELETE_PORT); /* 0x00700000 */
1195
1196         const int PRINTER_CHANGE_PRINT_PROCESSOR                = (PRINTER_CHANGE_ADD_PRINT_PROCESSOR |
1197                                                                    PRINTER_CHANGE_DELETE_PRINT_PROCESSOR); /* 0x07000000 */
1198
1199         const int PRINTER_CHANGE_PRINTER_DRIVER                 = (PRINTER_CHANGE_ADD_PRINTER_DRIVER |
1200                                                                    PRINTER_CHANGE_SET_PRINTER_DRIVER |
1201                                                                    PRINTER_CHANGE_DELETE_PRINTER_DRIVER); /* 0x70000000 */
1202
1203         const int PRINTER_CHANGE_ALL                            = (PRINTER_CHANGE_JOB |
1204                                                                    PRINTER_CHANGE_FORM |
1205                                                                    PRINTER_CHANGE_PORT |
1206                                                                    PRINTER_CHANGE_PRINT_PROCESSOR |
1207                                                                    PRINTER_CHANGE_PRINTER_DRIVER); /* 0x7777FFFF */
1208         WERROR spoolss_RouterReplyPrinter(
1209                 [in,ref] policy_handle *handle,
1210                 [in] spoolss_PrinterChangeFlags flags,
1211                 [in,range(0,512)] uint32 bufsize,
1212                 [in,unique,size_is(bufsize)] uint8 *buffer
1213         );
1214
1215         /******************/
1216         /* Function: 0x3c */
1217         [public] WERROR spoolss_ReplyClosePrinter(
1218                 [in,out,ref] policy_handle *handle
1219         );
1220
1221         /******************/
1222         /* Function: 0x3d */
1223         [todo] WERROR spoolss_AddPortEx(
1224         );
1225
1226         /******************/
1227         /* Function: 0x3e */
1228         [todo] WERROR spoolss_RouterFindFirstPrinterChangeNotification(
1229         );
1230
1231         /******************/
1232         /* Function: 0x3f */
1233         [todo] WERROR spoolss_SpoolerInit(
1234         );
1235
1236         /******************/
1237         /* Function: 0x40 */
1238         [todo] WERROR spoolss_ResetPrinterEx(
1239         );
1240
1241         typedef [enum16bit] enum {
1242                 SPOOLSS_FIELD_SERVER_NAME               =  0,
1243                 SPOOLSS_FIELD_PRINTER_NAME              =  1,
1244                 SPOOLSS_FIELD_SHARE_NAME        =  2,
1245                 SPOOLSS_FIELD_PORT_NAME                 =  3,
1246                 SPOOLSS_FIELD_DRIVER_NAME               =  4,
1247                 SPOOLSS_FIELD_COMMENT                   =  5,
1248                 SPOOLSS_FIELD_LOCATION                  =  6,
1249                 SPOOLSS_FIELD_DEVMODE                   =  7,
1250                 SPOOLSS_FIELD_SEPFILE                   =  8,
1251                 SPOOLSS_FIELD_PRINT_PROCESSOR   =  9,
1252                 SPOOLSS_FIELD_PARAMETERS                = 10,
1253                 SPOOLSS_FIELD_DATATYPE                  = 11,
1254                 SPOOLSS_FIELD_SECURITY_DESCRIPTOR=12,
1255                 SPOOLSS_FIELD_ATTRIBUTES                = 13,
1256                 SPOOLSS_FIELD_PRIORITY                  = 14,
1257                 SPOOLSS_FIELD_DEFAULT_PRIORITY  = 15,
1258                 SPOOLSS_FIELD_START_TIME                = 16,
1259                 SPOOLSS_FIELD_UNTIL_TIME                = 17,
1260                 SPOOLSS_FIELD_STATUS                    = 18,
1261                 SPOOLSS_FIELD_STATUS_STRING             = 19,
1262                 SPOOLSS_FIELD_CJOBS                             = 20,
1263                 SPOOLSS_FIELD_AVERAGE_PPM               = 21,
1264                 SPOOLSS_FIELD_TOTAL_PAGES               = 22,
1265                 SPOOLSS_FIELD_PAGES_PRINTED     = 23,
1266                 SPOOLSS_FIELD_TOTAL_BYTES               = 24,
1267                 SPOOLSS_FIELD_BYTES_PRINTED             = 25
1268         } spoolss_Field;
1269
1270         typedef [enum16bit] enum {
1271                 SPOOLSS_NOTIFY_PRINTER                  = 0,
1272                 SPOOLSS_NOTIFY_JOB                              = 1
1273         } spoolss_NotifyType;
1274
1275         /******************/
1276         /* Function: 0x41 */
1277         typedef struct {
1278                 spoolss_NotifyType type;
1279                 uint16 u1;
1280                 uint32 u2;
1281                 uint32 u3;
1282                 uint32 count;
1283                 [size_is(count)] spoolss_Field *fields;
1284         } spoolss_NotifyOptionsArray;
1285
1286         typedef struct {
1287                 uint32 version;
1288                 uint32 flags;
1289                 uint32 count;
1290                 [size_is(count)] spoolss_NotifyOptionsArray *options;
1291         } spoolss_NotifyOptionsContainer;
1292
1293         [public] WERROR spoolss_RemoteFindFirstPrinterChangeNotifyEx(
1294                 [in,ref] policy_handle *handle,
1295                 [in] uint32 flags,
1296                 [in] uint32 options,
1297                 [in,unique] [string,charset(UTF16)] uint16 *str,
1298                 [in] uint32 printer_local,
1299                 [in,unique] spoolss_NotifyOptionsContainer *t1
1300         );
1301
1302         /******************/
1303         /* Function: 0x42 */
1304         [todo] WERROR spoolss_RouterRefreshPrinterChangeNotification(
1305         );
1306
1307         typedef struct {
1308                 uint32 size;
1309                 [size_is(size/2),unique,charset(UTF16)] uint16 *string;
1310         } spoolss_NotifyUTF16String;
1311
1312         typedef struct {
1313                 uint32 size;
1314                 [size_is(size),charset(DOS)] uint8 *string;
1315         } spoolss_NotifyDOSString;
1316
1317         typedef struct {
1318                 uint16 data[8];
1319         } spoolss_NotifyBlobData;
1320
1321         typedef struct {
1322                 uint32 len;
1323                 [unique] spoolss_NotifyBlobData *data;
1324         } spoolss_NotifyBlob;
1325
1326         typedef [switch_type(uint32)] union {
1327                 [case(1)] dlong integer;
1328                 [case(2)] spoolss_NotifyUTF16String utf16_string;
1329                 [case(3)] spoolss_NotifyDOSString ascii_string;
1330                 [case(4)] spoolss_NotifyBlob blob;
1331                 [case(5)] spoolss_NotifyDOSString ascii_string;
1332         } spoolss_NotifyData;
1333
1334         typedef struct {
1335                 spoolss_NotifyType type;
1336                 spoolss_Field field;
1337                 uint32 variable_type;
1338                 uint32 job_id;
1339                 [switch_is(variable_type)] spoolss_NotifyData data;
1340         } spoolss_Notify;
1341
1342         typedef struct {
1343                 uint32 version;
1344                 uint32 flags;
1345                 uint32 count;
1346                 [size_is(count)] spoolss_Notify notifies[];
1347         } spoolss_NotifyInfo;
1348
1349         /******************/
1350         /* Function: 0x43 */
1351         [public] WERROR spoolss_RemoteFindNextPrinterChangeNotifyEx(
1352                 [in,ref] policy_handle *handle,
1353                 [in] uint32 change_low,
1354                 [in,unique] spoolss_NotifyOptionsContainer *container,
1355                 [out,ref] spoolss_NotifyInfo **info
1356         );
1357
1358         /******************/
1359         /* Function: 0x44 */
1360         [todo] WERROR spoolss_44(
1361         );
1362
1363         typedef struct {
1364                 uint32 size;
1365                 [string,charset(UTF16)] uint16 *client;
1366                 [string,charset(UTF16)] uint16 *user;
1367                 uint32 build;
1368                 uint32 major;
1369                 uint32 minor;
1370                 uint32 processor;
1371         } spoolss_UserLevel1;
1372
1373         typedef union {
1374                 [case(1)]  spoolss_UserLevel1 *level1;
1375         } spoolss_UserLevel;
1376
1377         typedef bitmap {
1378                 SERVER_ACCESS_ADMINISTER        = 0x00000001,
1379                 SERVER_ACCESS_ENUMERATE         = 0x00000002,
1380                 PRINTER_ACCESS_ADMINISTER       = 0x00000004,
1381                 PRINTER_ACCESS_USE              = 0x00000008,
1382                 JOB_ACCESS_ADMINISTER           = 0x00000010
1383         } spoolss_AccessRights;
1384
1385         /* Access rights for print servers */
1386         const int SERVER_ALL_ACCESS     = SEC_STD_REQUIRED |
1387                                           SERVER_ACCESS_ADMINISTER |
1388                                           SERVER_ACCESS_ENUMERATE;
1389
1390         const int SERVER_READ           = SEC_STD_READ_CONTROL |
1391                                           SERVER_ACCESS_ENUMERATE;
1392
1393         const int SERVER_WRITE          = STANDARD_RIGHTS_WRITE_ACCESS |
1394                                           SERVER_ACCESS_ADMINISTER |
1395                                           SERVER_ACCESS_ENUMERATE;
1396
1397         const int SERVER_EXECUTE        = SEC_STD_READ_CONTROL |
1398                                           SERVER_ACCESS_ENUMERATE;
1399
1400         /* Access rights for printers */
1401         const int PRINTER_ALL_ACCESS    = SEC_STD_REQUIRED |
1402                                           PRINTER_ACCESS_ADMINISTER |
1403                                           PRINTER_ACCESS_USE;
1404
1405         const int PRINTER_READ          = SEC_STD_READ_CONTROL |
1406                                           PRINTER_ACCESS_USE;
1407
1408         const int PRINTER_WRITE         = STANDARD_RIGHTS_WRITE_ACCESS |
1409                                           PRINTER_ACCESS_USE;
1410
1411         const int PRINTER_EXECUTE       = SEC_STD_READ_CONTROL |
1412                                           PRINTER_ACCESS_USE;
1413
1414         /* Access rights for jobs */
1415         const int JOB_ALL_ACCESS        = SEC_STD_REQUIRED |
1416                                           JOB_ACCESS_ADMINISTER;
1417
1418         const int JOB_READ              = SEC_STD_READ_CONTROL |
1419                                           JOB_ACCESS_ADMINISTER;
1420
1421         const int JOB_WRITE             = STANDARD_RIGHTS_WRITE_ACCESS |
1422                                           JOB_ACCESS_ADMINISTER;
1423
1424         const int JOB_EXECUTE           = SEC_STD_READ_CONTROL |
1425                                           JOB_ACCESS_ADMINISTER;
1426
1427         /* ACE masks for various print permissions */
1428         const int PRINTER_ACE_FULL_CONTROL = SEC_GENERIC_ALL |
1429                                                 PRINTER_ALL_ACCESS;
1430
1431         const int PRINTER_ACE_MANAGE_DOCUMENTS = SEC_GENERIC_ALL |
1432                                                 READ_CONTROL_ACCESS;
1433
1434         const int PRINTER_ACE_PRINT     = GENERIC_EXECUTE_ACCESS |
1435                                           READ_CONTROL_ACCESS |
1436                                           PRINTER_ACCESS_USE;
1437
1438         /******************/
1439         /* Function: 0x45 */
1440         [public] WERROR spoolss_OpenPrinterEx(
1441                 [in,unique]           [string,charset(UTF16)] uint16 *printername,
1442                 [in,unique]           [string,charset(UTF16)] uint16 *datatype,
1443                 [in]                  spoolss_DevmodeContainer devmode_ctr,
1444                 [in]                  uint32 access_mask,
1445                 [in]                  uint32 level,
1446                 [in,switch_is(level)] spoolss_UserLevel userlevel,
1447                 [out,ref]             policy_handle *handle
1448         );
1449
1450         /******************/
1451         /* Function: 0x46 */
1452         WERROR spoolss_AddPrinterEx(
1453                 [in,unique] [string,charset(UTF16)] uint16 *server,
1454                 [in] uint32 level,
1455                 [in,unique,switch_is(level)] spoolss_PrinterInfo *info,
1456                 [in] spoolss_DevmodeContainer devmode_ctr,
1457                 [in,unique] security_descriptor *secdesc,
1458                 [in] uint32 ulevel,
1459                 [in,switch_is(ulevel)] spoolss_UserLevel userlevel
1460         );
1461
1462         /******************/
1463         /* Function: 0x47 */
1464         [todo] WERROR spoolss_47(
1465         );
1466
1467         /******************/
1468         /* Function: 0x48 */
1469         WERROR spoolss_EnumPrinterData(
1470                 [in,ref] policy_handle *handle,
1471                 [in]     uint32 enum_index,
1472                 [out,ref,size_is(value_offered/2),charset(UTF16)] uint16 *value_name,
1473                 [in]     uint32 value_offered,
1474                 [out,ref] uint32 *value_needed,
1475                 [out,ref] uint32 *printerdata_type,
1476                 [out,ref] DATA_BLOB *buffer,
1477                 [in]     uint32 data_offered,
1478                 [out,ref] uint32 *data_needed
1479         );
1480
1481         /******************/
1482         /* Function: 0x49 */
1483         WERROR spoolss_DeletePrinterData(
1484                 [in,ref] policy_handle *handle,
1485                 [in] [string,charset(UTF16)] uint16 value_name[]
1486         );
1487
1488         /******************/
1489         /* Function: 0x4a */
1490         [todo] WERROR spoolss_4a(
1491         );
1492
1493         /******************/
1494         /* Function: 0x4b */
1495         [todo] WERROR spoolss_4b(
1496         );
1497
1498         /******************/
1499         /* Function: 0x4c */
1500         [todo] WERROR spoolss_4c(
1501         );
1502
1503         /******************/
1504         /* Function: 0x4d */
1505         WERROR spoolss_SetPrinterDataEx(
1506                 [in,ref] policy_handle *handle,
1507                 [in]     [string,charset(UTF16)] uint16 key_name[],
1508                 [in]     [string,charset(UTF16)] uint16 value_name[],
1509                 [in]     uint32 type,
1510                 [in]     DATA_BLOB buffer,
1511                 [in]     uint32 offered
1512         );
1513
1514         /******************/
1515         /* Function: 0x4e */
1516         WERROR spoolss_GetPrinterDataEx(
1517                 [in,ref] policy_handle *handle,
1518                 [in]     [string,charset(UTF16)] uint16 key_name[],
1519                 [in]     [string,charset(UTF16)] uint16 value_name[],
1520                 [out,ref] uint32 *type,
1521                 [out,ref] [size_is(offered)] uint8 *buffer,
1522                 [in]     uint32 offered,
1523                 [out,ref] uint32 *needed
1524         );
1525
1526         /******************/
1527         /* Function: 0x4f */
1528         [public] WERROR spoolss_EnumPrinterDataEx(
1529                 [in,ref] policy_handle *handle,
1530                 [in]     [string,charset(UTF16)] uint16 key_name[],
1531                 [out,ref] [size_is(offered)] uint8 *buffer,
1532                 [in]     uint32 offered,
1533                 [out,ref] uint32 *needed,
1534                 [out,ref] uint32 *count
1535         );
1536
1537         /******************/
1538         /* Function: 0x50 */
1539         [public] WERROR spoolss_EnumPrinterKey(
1540                 [in, ref] policy_handle *handle,
1541                 [in] [string,charset(UTF16)] uint16 key_name[],
1542                 [out,ref] [size_is(key_buffer_size/2)] uint16 *key_buffer,
1543                 [in] uint32 key_buffer_size,
1544                 [out,ref] uint32 *needed
1545         );
1546
1547         /******************/
1548         /* Function: 0x51 */
1549         WERROR spoolss_DeletePrinterDataEx(
1550                 [in,ref] policy_handle *handle,
1551                 [in] [string,charset(UTF16)] uint16 key_name[],
1552                 [in] [string,charset(UTF16)] uint16 value_name[]
1553         );
1554
1555         /******************/
1556         /* Function: 0x52 */
1557         WERROR spoolss_DeletePrinterKey(
1558                 [in,ref] policy_handle *handle,
1559                 [in] [string,charset(UTF16)] uint16 key_name[]
1560         );
1561
1562         /******************/
1563         /* Function: 0x53 */
1564         [todo] WERROR spoolss_53(
1565         );
1566
1567         /******************/
1568         /* Function: 0x54 */
1569         typedef [public,bitmap32bit] bitmap {
1570                 DPD_DELETE_UNUSED_FILES         = 0x00000001,
1571                 DPD_DELETE_SPECIFIC_VERSION     = 0x00000002,
1572                 DPD_DELETE_ALL_FILES            = 0x00000004
1573         } spoolss_DeleteDriverFlags;
1574
1575         WERROR spoolss_DeletePrinterDriverEx(
1576                 [in,unique] [string,charset(UTF16)] uint16 *server,
1577                 [in] [string,charset(UTF16)] uint16 architecture[],
1578                 [in] [string,charset(UTF16)] uint16 driver[],
1579                 [in] spoolss_DeleteDriverFlags delete_flags,
1580                 [in] uint32 version
1581         );
1582
1583         /******************/
1584         /* Function: 0x55 */
1585         [todo] WERROR spoolss_55(
1586         );
1587
1588         /******************/
1589         /* Function: 0x56 */
1590         [todo] WERROR spoolss_56(
1591         );
1592
1593         /******************/
1594         /* Function: 0x57 */
1595         [todo] WERROR spoolss_57(
1596         );
1597
1598         /******************/
1599         /* Function: 0x58 */
1600         WERROR spoolss_XcvData(
1601                 [in,ref] policy_handle *handle,
1602                 [in] [string,charset(UTF16)] uint16 function_name[],
1603                 [in] DATA_BLOB in_data,
1604                 [in,value(r->in.in_data.length)] uint32 _in_data_length,
1605                 [out,ref] [size_is(out_data_size)] uint8 *out_data,
1606                 [in] uint32 out_data_size,
1607                 [out,ref] uint32 *needed,
1608                 [in,out,ref] uint32 *status_code
1609         );
1610
1611         /******************/
1612         /* Function: 0x59 */
1613         [public,todo] WERROR spoolss_AddPrinterDriverEx(
1614         );
1615
1616         /******************/
1617         /* Function: 0x5a */
1618         [todo] WERROR spoolss_5a(
1619         );
1620
1621         /******************/
1622         /* Function: 0x5b */
1623         [todo] WERROR spoolss_5b(
1624         );
1625
1626         /******************/
1627         /* Function: 0x5c */
1628         [todo] WERROR spoolss_5c(
1629         );
1630
1631         /******************/
1632         /* Function: 0x5d */
1633         [todo] WERROR spoolss_5d(
1634         );
1635
1636         /******************/
1637         /* Function: 0x5e */
1638         [todo] WERROR spoolss_5e(
1639         );
1640
1641         /******************/
1642         /* Function: 0x5f */
1643         [todo] WERROR spoolss_5f(
1644         );
1645 }