Context Navigation

spoolss.idl@ 1043

Visit:

Last change on this file since 1043 was 862, checked in by Silvan Scherrer, 11 years ago
Samba Server: update trunk to 3.6.23
File size: 98.9 KB

Line
1	#include "idl_types.h"
2
3	/*
4	spoolss interface definitions
5	*/
6	import "misc.idl", "security.idl", "winreg.idl";
7
8
9	cpp_quote("#define spoolss_security_descriptor security_descriptor")
10
11	[ uuid("12345678-1234-abcd-ef00-0123456789ab"),
12	version(1.0),
13	endpoint("ncacn_np:[\\pipe\\spoolss]"),
14	pointer_default(unique),
15	helpstring("Spooler SubSystem"),
16	helper("../librpc/ndr/ndr_spoolss_buf.h")
17	] interface spoolss
18	{
19	typedef [v1_enum] enum winreg_Type winreg_Type;
20	typedef [gensize,noprint] struct {
21	uint16 year;
22	uint16 month;
23	uint16 day_of_week;
24	uint16 day;
25	uint16 hour;
26	uint16 minute;
27	uint16 second;
28	uint16 millisecond;
29	} spoolss_Time;
30
31	typedef struct {
32	[value(ndr_size_spoolss_Time(time, ndr->flags))] uint32 size;
33	[unique] spoolss_Time *time;
34	} spoolss_TimeCtr;
35
36	typedef enum {
37	PROCESSOR_ARCHITECTURE_INTEL = 0x0000,
38	PROCESSOR_ARCHITECTURE_IA64 = 0x0006,
39	PROCESSOR_ARCHITECTURE_AMD64 = 0x0009
40	} spoolss_ProcessorArchitecture;
41
42	typedef [v1_enum] enum {
43	PROCESSOR_INTEL_386 = 0x00000182,
44	PROCESSOR_INTEL_486 = 0x000001E6,
45	PROCESSOR_INTEL_PENTIUM = 0x0000024A,
46	PROCESSOR_INTEL_IA64 = 0x00000898,
47	PROCESSOR_AMD_X8664 = 0x000022A0
48	} spoolss_ProcessorType;
49
50	typedef [v1_enum] enum {
51	/* Windows 95, Windows 98, Windows Me, Windows NT4 */
52	SPOOLSS_MAJOR_VERSION_NT4_95_98_ME = 0x00000004,
53	/* Windows 2000, Windows 2003, Windows XP */
54	SPOOLSS_MAJOR_VERSION_2000_2003_XP = 0x00000005,
55	/* Windows Vista, Windows 2008 */
56	SPOOLSS_MAJOR_VERSION_2008_VISTA = 0x00000006
57	} spoolss_MajorVersion;
58
59	typedef [v1_enum] enum {
60	/* Windows 2008, Windows Vista, Windows 2000, Windows NT4, Windows 95 */
61	SPOOLSS_MINOR_VERSION_0 = 0x00000000,
62	/* Windows XP */
63	SPOOLSS_MINOR_VERSION_XP = 0x00000001,
64	/* Windows 2003, Windows XP x64 */
65	SPOOLSS_MINOR_VERSION_2003_XP64 = 0x00000002,
66	/* Windows 98 */
67	SPOOLSS_MINOR_VERSION_98 = 0x0000000a,
68	/* Windows Me */
69	SPOOLSS_MINOR_VERSION_ME = 0x0000005a
70	} spoolss_MinorVersion;
71
72	const int PRINTER_STATUS_OK = 0x00000000;
73
74	typedef [public] bitmap {
75	PRINTER_STATUS_PAUSED = 0x00000001,
76	PRINTER_STATUS_ERROR = 0x00000002,
77	PRINTER_STATUS_PENDING_DELETION = 0x00000004,
78	PRINTER_STATUS_PAPER_JAM = 0x00000008,
79	PRINTER_STATUS_PAPER_OUT = 0x00000010,
80	PRINTER_STATUS_MANUAL_FEED = 0x00000020,
81	PRINTER_STATUS_PAPER_PROBLEM = 0x00000040,
82	PRINTER_STATUS_OFFLINE = 0x00000080,
83	PRINTER_STATUS_IO_ACTIVE = 0x00000100,
84	PRINTER_STATUS_BUSY = 0x00000200,
85	PRINTER_STATUS_PRINTING = 0x00000400,
86	PRINTER_STATUS_OUTPUT_BIN_FULL = 0x00000800,
87	PRINTER_STATUS_NOT_AVAILABLE = 0x00001000,
88	PRINTER_STATUS_WAITING = 0x00002000,
89	PRINTER_STATUS_PROCESSING = 0x00004000,
90	PRINTER_STATUS_INITIALIZING = 0x00008000,
91	PRINTER_STATUS_WARMING_UP = 0x00010000,
92	PRINTER_STATUS_TONER_LOW = 0x00020000,
93	PRINTER_STATUS_NO_TONER = 0x00040000,
94	PRINTER_STATUS_PAGE_PUNT = 0x00080000,
95	PRINTER_STATUS_USER_INTERVENTION= 0x00100000,
96	PRINTER_STATUS_OUT_OF_MEMORY = 0x00200000,
97	PRINTER_STATUS_DOOR_OPEN = 0x00400000,
98	PRINTER_STATUS_SERVER_UNKNOWN = 0x00800000,
99	PRINTER_STATUS_POWER_SAVE = 0x01000000
100	} spoolss_PrinterStatus;
101
102	/* JOB status codes. */
103
104	const int JOB_STATUS_QUEUED = 0x0000;
105
106	typedef [bitmap32bit] bitmap {
107	JOB_STATUS_PAUSED = 0x00000001,
108	JOB_STATUS_ERROR = 0x00000002,
109	JOB_STATUS_DELETING = 0x00000004,
110	JOB_STATUS_SPOOLING = 0x00000008,
111	JOB_STATUS_PRINTING = 0x00000010,
112	JOB_STATUS_OFFLINE = 0x00000020,
113	JOB_STATUS_PAPEROUT = 0x00000040,
114	JOB_STATUS_PRINTED = 0x00000080,
115	JOB_STATUS_DELETED = 0x00000100,
116	JOB_STATUS_BLOCKED_DEVQ = 0x00000200,
117	JOB_STATUS_USER_INTERVENTION = 0x00000400,
118	JOB_STATUS_RESTART = 0x00000800,
119	JOB_STATUS_COMPLETE = 0x00001000
120	} spoolss_JobStatus;
121
122	typedef [v1_enum] enum {
123	SPOOLSS_DEBUGGING_BUILD = 0x00000000,
124	SPOOLSS_RELEASE_BUILD = 0x00000001
125	} spoolss_Build;
126
127	typedef [public,gensize] struct {
128	[relative] nstring *printername;
129	[relative] nstring *servername;
130	uint32 cjobs;
131	uint32 total_jobs;
132	uint32 total_bytes;
133	spoolss_Time time;
134	uint32 global_counter;
135	uint32 total_pages;
136	uint32 version;
137	spoolss_Build free_build;
138	uint32 spooling;
139	uint32 max_spooling;
140	uint32 session_counter;
141	uint32 num_error_out_of_paper;
142	uint32 num_error_not_ready;
143	spoolss_JobStatus job_error;
144	uint32 number_of_processors;
145	spoolss_ProcessorType processor_type;
146	uint32 high_part_total_bytes;
147	uint32 change_id;
148	WERROR last_error;
149	spoolss_PrinterStatus status;
150	uint32 enumerate_network_printers;
151	uint32 c_setprinter;
152	spoolss_ProcessorArchitecture processor_architecture;
153	uint16 processor_level;
154	uint32 ref_ic;
155	uint32 reserved2;
156	uint32 reserved3;
157	} spoolss_PrinterInfo0;
158
159	/* Device Mode Extra Data */
160
161	typedef [v1_enum] enum {
162	SPOOLSS_DM_SIGNATURE_UNIDRVEXTRA = 0x554e4944, /* 0x44494e55 */
163	SPOOLSS_DM_SIGNATURE_JTEXP = 0x4a544d53, /* 0x534d544a */
164	SPOOLSS_DM_SIGNATURE_PSEXTRA = 0x50524956 /* 0x56495250 */
165	} spoolss_DM_Signature;
166
167	typedef [v1_enum] enum {
168	SPOOLSS_DM_LAYOUT_NUP_DISABLED = 0x00000000,
169	SPOOLSS_DM_LAYOUT_NUP_2 = 0x00000001,
170	SPOOLSS_DM_LAYOUT_NUP_4 = 0x00000002,
171	SPOOLSS_DM_LAYOUT_NUP_6 = 0x00000003,
172	SPOOLSS_DM_LAYOUT_NUP_9 = 0x00000004,
173	SPOOLSS_DM_LAYOUT_NUP_16 = 0x00000005,
174	SPOOLSS_DM_LAYOUT_BOOKLET = 0x00000006
175	} spoolss_DM_Layout;
176
177	typedef [v1_enum] enum {
178	SPOOLSS_DM_NUP_DIRECTION_L2R_T2B = 0x00000001,
179	SPOOLSS_DM_NUP_DIRECTION_T2B_L2R = 0x00000002,
180	SPOOLSS_DM_NUP_DIRECTION_R2L_T2B = 0x00000004,
181	SPOOLSS_DM_NUP_DIRECTION_T2B_R2L = 0x00000008
182	} spoolss_DM_NupDirection;
183
184	typedef [v1_enum] enum {
185	SPOOLSS_DM_NUP_BORDER_PRINT = 0x00000000,
186	SPOOLSS_DM_NUP_BORDER_NONE = 0x00000001
187	} spoolss_DM_NupBorderFlags;
188
189	typedef [v1_enum] enum {
190	SPOOLSS_DM_BOOKLET_LEFT_FLIP = 0x00000000,
191	SPOOLSS_DM_BOOKLET_RIGHT_FLIP = 0x00000001
192	} spoolss_DM_BookletFlags;
193
194	/* Device Mode Extra Data: PostScript */
195
196	/* NT 3.51 */
197
198	typedef [bitmap32bit] bitmap {
199	SPOOLSS_DM_PS_FLAGS_DRV_ERROR_HANDLER = 0x00000002,
200	SPOOLSS_DM_PS_FLAGS_PRINT_MIRROR = 0x00000004,
201	SPOOLSS_DM_PS_FLAGS_PRINT_NEGATIVE = 0x00000010,
202	SPOOLSS_DM_PS_FLAGS_COMPRESS_BITMAP = 0x00000040,
203	SPOOLSS_DM_PS_FLAGS_ROTATE_180 = 0x00000200,
204	SPOOLSS_DM_PS_FLAGS_GDI_METAFILE_SPOOL = 0x00002000
205	} spoolss_DMPS_Flags;
206
207	typedef struct {
208	[value(SPOOLSS_DM_SIGNATURE_PSEXTRA)] spoolss_DM_Signature dwSignature;
209	spoolss_DMPS_Flags dwFlags;
210	uint32 wchEPSFile[12];
211	[value(24)] uint16 caSize;
212	uint16 caFlags;
213	uint16 caIlluminantIndex;
214	uint16 caRedGamma;
215	uint16 caGreenGamma;
216	uint16 caBlueGamma;
217	uint16 caReferenceBlack;
218	uint16 caReferenceWhite;
219	uint16 caContrast;
220	uint16 caBrightness;
221	uint16 caColorfulness;
222	uint16 caRedGreenTint;
223	} spoolss_PSDRVEXTRA351;
224
225	/* NT 4.0 */
226
227	typedef struct {
228	[value(SPOOLSS_DM_SIGNATURE_PSEXTRA)] spoolss_DM_Signature dwSignature;
229	spoolss_DMPS_Flags dwFlags;
230	uint32 wchEPSFile[12];
231	[value(24)] uint16 caSize;
232	uint16 caFlags;
233	uint16 caIlluminantIndex;
234	uint16 caRedGamma;
235	uint16 caGreenGamma;
236	uint16 caBlueGamma;
237	uint16 caReferenceBlack;
238	uint16 caReferenceWhite;
239	uint16 caContrast;
240	uint16 caBrightness;
241	uint16 caColorfulness;
242	uint16 caRedGreenTint;
243	uint16 wChecksum;
244	uint16 wOptions;
245	uint32 aubOptions[8];
246	} spoolss_PSDRVEXTRA400;
247
248	/* 2000 & XP */
249
250	typedef [v1_enum] enum {
251	SPOOLSS_DM_PS_OPTIMIZE_SPEED = 0x00000000,
252	SPOOLSS_DM_PS_OPTIMIZE_PORTABILITY = 0x00000001,
253	SPOOLSS_DM_PS_OPTIMIZE_EPS = 0x00000002,
254	SPOOLSS_DM_PS_OPTIMIZE_ARCHIVAL = 0x00000003
255	} spoolss_DMPS_Dialect;
256
257	typedef [v1_enum] enum {
258	SPOOLSS_DM_PS_TTDLFMT_DEFAULT = 0x00000000,
259	SPOOLSS_DM_PS_TTDLFMT_TYPE_1 = 0x00000001,
260	SPOOLSS_DM_PS_TTDLFMT_TYPE_3 = 0x00000002,
261	SPOOLSS_DM_PS_TTDLFMT_TYPE_42 = 0x00000003
262	} spoolss_DMPS_TTDLFmt;
263
264	typedef [v1_enum] enum {
265	SPOOLSS_DM_PS_PSLEVEL_1 = 0x00000001,
266	SPOOLSS_DM_PS_PSLEVEL_2 = 0x00000002,
267	SPOOLSS_DM_PS_PSLEVEL_3 = 0x00000003
268	} spoolss_DMPS_PSLevel;
269
270	typedef enum {
271	SPOOLSS_DM_PS_FEED_DIRECTION_LONG_EDGE_FIRST = 0x0000,
272	SPOOLSS_DM_PS_FEED_DIRECTION_SHORT_EDGE_FIRST = 0x0001,
273	SPOOLSS_DM_PS_FEED_DIRECTION_LONG_EDGE_FIRST_UPSIDEDOWN = 0x0002,
274	SPOOLSS_DM_PS_FEED_DIRECTION_SHORT_EDGE_FIRST_UPSIDEDOWN= 0x0003
275	} spoolss_DMPS_FeedDirection;
276
277	typedef struct {
278	[value(SPOOLSS_DM_SIGNATURE_PSEXTRA)] spoolss_DM_Signature dwSignature;
279	spoolss_DMPS_Flags dwFlags;
280	uint32 wchEPSFile[12];
281	[value(24)] uint16 caSize;
282	uint16 caFlags;
283	uint16 caIlluminantIndex;
284	uint16 caRedGamma;
285	uint16 caGreenGamma;
286	uint16 caBlueGamma;
287	uint16 caReferenceBlack;
288	uint16 caReferenceWhite;
289	uint16 caContrast;
290	uint16 caBrightness;
291	uint16 caColorfulness;
292	uint16 caRedGreenTint;
293	uint16 wReserved1;
294	uint16 wSize;
295	uint32 fxScrFreq;
296	uint32 fxScrAngle;
297	spoolss_DMPS_Dialect iDialect;
298	spoolss_DMPS_TTDLFmt iTTDLFmt;
299	boolean32 bReversePrint;
300	spoolss_DM_Layout iLayout;
301	spoolss_DMPS_PSLevel iPSLevel;
302	uint32 dwReserved2;
303	uint16 wOEMExtra;
304	[value(0x0010)] uint16 wVer;
305	uint32 dwX;
306	uint32 dwY;
307	uint32 dwWidthOffset;
308	uint32 dwHeightOffset;
309	spoolss_DMPS_FeedDirection wFeedDirection;
310	uint16 wCutSheet;
311	uint32 dwReserved3[4];
312	uint32 dwChecksum32;
313	uint32 dwOptions;
314	uint32 aOptions[128];
315	} spoolss_PSDRVEXTRA500;
316
317	/* Vista, 2008, 7 */
318
319	typedef struct {
320	[value(SPOOLSS_DM_SIGNATURE_PSEXTRA)] spoolss_DM_Signature dwSignature;
321	spoolss_DMPS_Flags dwFlags;
322	uint32 wchEPSFile[12];
323	[value(24)] uint16 caSize;
324	uint16 caFlags;
325	uint16 caIlluminantIndex;
326	uint16 caRedGamma;
327	uint16 caGreenGamma;
328	uint16 caBlueGamma;
329	uint16 caReferenceBlack;
330	uint16 caReferenceWhite;
331	uint16 caContrast;
332	uint16 caBrightness;
333	uint16 caColorfulness;
334	uint16 caRedGreenTint;
335	uint16 wCoreJTExpSize;
336	[value(ndr_size_spoolss_PSDRVEXTRA(r, ndr->flags) + wCoreJTExpSize)] uint16 wCoreFullSize;
337	uint32 fxScrFreq;
338	uint32 fxScrAngle;
339	spoolss_DMPS_Dialect iDialect;
340	spoolss_DMPS_TTDLFmt iTTDLFmt;
341	boolean32 bReversePrint;
342	spoolss_DM_Layout iLayout;
343	spoolss_DMPS_PSLevel iPSLevel;
344	uint32 dwReserved2;
345	uint16 wOEMExtra;
346	[value(0x0010)] uint16 wVer;
347	uint32 dwX;
348	uint32 dwY;
349	uint32 dwWidthOffset;
350	uint32 dwHeightOffset;
351	spoolss_DMPS_FeedDirection wFeedDirection;
352	uint16 wCutSheet;
353	uint32 dwReserved3[4];
354	uint32 dwChecksum32;
355	uint32 dwOptions;
356	uint32 aOptions[128];
357	spoolss_DM_NupDirection dwNupDirection;
358	spoolss_DM_NupBorderFlags dwNupBorderFlags;
359	spoolss_DM_BookletFlags dwBookletFlags;
360	uint32 dwPadding;
361	} spoolss_PSDRVEXTRA;
362
363	/* Device Mode Extra Data: UniDriver */
364
365	/* NT 3.5, NT 4.0 */
366
367	typedef struct {
368	uint16 wReserved[56];
369	} spoolss_UNIDRVEXTRA3_4;
370
371	/* 2000, XP */
372
373	typedef [v1_enum] enum {
374	SPOOLSS_DM_UNI_QUALITY_BEST = 0x00000000,
375	SPOOLSS_DM_UNI_QUALITY_MEDIUM = 0x00000001,
376	SPOOLSS_DM_UNI_QUALITY_DRAFT = 0x00000002
377	} spoolss_DMUNI_Quality;
378
379	typedef [bitmap32bit] bitmap {
380	SPOOLSS_DM_UNI_FLAGS_PRINT_TEXT_AS_GRAPHICS = 0x00000002,
381	SPOOLSS_DM_UNI_FLAGS_AVOID_EMFSPOOL = 0x00000010,
382	SPOOLSS_DM_UNI_FLAGS_CUSTOM_HALFTONING = 0x00000080
383	} spoolss_DMUNI_Flags;
384
385	typedef struct {
386	[value(SPOOLSS_DM_SIGNATURE_UNIDRVEXTRA)] spoolss_DM_Signature dwSignature;
387	[value(0x0022)] uint16 wVer;
388	uint16 sPadding;
389	uint16 wSize;
390	uint16 wOEMExtra;
391	uint32 dwChecksum32;
392	spoolss_DMUNI_Flags dwFlags;
393	boolean32 bReversePrint;
394	spoolss_DM_Layout iLayout;
395	spoolss_DMUNI_Quality iQuality;
396	uint16 wReserved[6];
397	uint32 dwOptions;
398	uint32 aOptions[128];
399	} spoolss_UNIDRVEXTRA500;
400
401	/* Vista, 2008, 7 */
402
403	typedef [public,gensize] struct {
404	[value(SPOOLSS_DM_SIGNATURE_UNIDRVEXTRA)] spoolss_DM_Signature dwSignature;
405	[value(0x0022)] uint16 wVer;
406	uint16 wCoreJTExpSize;
407	[value(ndr_size_spoolss_UNIDRVEXTRA(r, ndr->flags) + wCoreJTExpSize)] uint16 wCoreFullSize;
408	uint16 wOEMExtra;
409	uint32 dwChecksum32;
410	spoolss_DMUNI_Flags dwFlags;
411	boolean32 bReversePrint;
412	spoolss_DM_Layout iLayout;
413	spoolss_DMUNI_Quality iQuality;
414	uint16 wReserved[6];
415	uint32 dwOptions;
416	uint32 aOptions[128];
417	spoolss_DM_NupDirection dwNupDirection;
418	spoolss_DM_NupBorderFlags dwNupBorderFlags;
419	spoolss_DM_BookletFlags dwBookletFlags;
420	} spoolss_UNIDRVEXTRA;
421
422	/* Device Mode Extra Data: JTEXP */
423
424	typedef struct {
425	uint32 dwSize;
426	[value(SPOOLSS_DM_SIGNATURE_JTEXP)] spoolss_DM_Signature dwSignature;
427	[value(0)] uint32 dwVersion;
428	[value(16)] uint32 wJTHdrSize;
429	uint32 wCoreMFOSize;
430	[string,charset(UTF16)] uint16 *ModelName;
431	nstring_array FeatureOptionPairs;
432	} spoolss_JTEXP;
433
434	/* Device Mode Extra Data: OEM_DMEXTRA */
435
436	typedef struct {
437	uint32 dwSize;
438	spoolss_DM_Signature dwSignature;
439	uint32 dwVersion;
440	[flag(NDR_REMAINING)] DATA_BLOB Data;
441	} spoolss_OEM_DMEXTRA;
442
443	typedef [nodiscriminant] union {
444	[case(0x0350)] spoolss_PSDRVEXTRA351 psdrvextra351;
445	[case(0x0400)] spoolss_PSDRVEXTRA400 psdrvextra400;
446	[case(0x0501)] spoolss_PSDRVEXTRA500 psdrvextra500;
447	[case(0x0600)] spoolss_PSDRVEXTRA psdrvextra;
448	[default] [flag(NDR_REMAINING)] DATA_BLOB psblob;
449	} spoolss_DeviceModeExtraDataPostScript;
450
451	typedef [nodiscriminant] union {
452	[case(0x0301)] spoolss_UNIDRVEXTRA3_4 unidrvextra3_4;
453	[case(0x0500)] spoolss_UNIDRVEXTRA500 unidrvextra500;
454	[case(0x0600)] spoolss_UNIDRVEXTRA unidrvextra;
455	[default] [flag(NDR_REMAINING)] DATA_BLOB uniblob;
456	} spoolss_DeviceModeExtraDataUniDriver;
457
458	typedef [bitmap32bit] bitmap {
459	DEVMODE_ORIENTATION = 0x00000001,
460	DEVMODE_PAPERSIZE = 0x00000002,
461	DEVMODE_PAPERLENGTH = 0x00000004,
462	DEVMODE_PAPERWIDTH = 0x00000008,
463	DEVMODE_SCALE = 0x00000010,
464	DEVMODE_POSITION = 0x00000020,
465	DEVMODE_NUP = 0x00000040,
466	DEVMODE_COPIES = 0x00000100,
467	DEVMODE_DEFAULTSOURCE = 0x00000200,
468	DEVMODE_PRINTQUALITY = 0x00000400,
469	DEVMODE_COLOR = 0x00000800,
470	DEVMODE_DUPLEX = 0x00001000,
471	DEVMODE_YRESOLUTION = 0x00002000,
472	DEVMODE_TTOPTION = 0x00004000,
473	DEVMODE_COLLATE = 0x00008000,
474	DEVMODE_FORMNAME = 0x00010000,
475	DEVMODE_LOGPIXELS = 0x00020000,
476	DEVMODE_BITSPERPEL = 0x00040000,
477	DEVMODE_PELSWIDTH = 0x00080000,
478	DEVMODE_PELSHEIGHT = 0x00100000,
479	DEVMODE_DISPLAYFLAGS = 0x00200000,
480	DEVMODE_DISPLAYFREQUENCY = 0x00400000,
481	DEVMODE_ICMMETHOD = 0x00800000,
482	DEVMODE_ICMINTENT = 0x01000000,
483	DEVMODE_MEDIATYPE = 0x02000000,
484	DEVMODE_DITHERTYPE = 0x04000000,
485	DEVMODE_PANNINGWIDTH = 0x08000000,
486	DEVMODE_PANNINGHEIGHT = 0x10000000
487	} spoolss_DeviceModeFields;
488
489	typedef [enum16bit] enum {
490	DMSPEC_NT3 = 0x320,
491	DMSPEC_WIN95_98_ME = 0x400,
492	DMSPEC_NT4_AND_ABOVE = 0x401
493	} spoolss_DeviceModeSpecVersion;
494
495	typedef [enum16bit] enum {
496	DMORIENT_PORTRAIT = 0x0001,
497	DMORIENT_LANDSCAPE = 0x0002
498	} spoolss_DeviceModeOrientation;
499
500	typedef [enum16bit] enum {
501	DMPAPER_LETTER = 0x0001, /* Letter, 8 1/2 x 11 inches */
502	DMPAPER_LETTERSMALL = 0x0002, /* Letter Small, 8 1/2 x 11 inches */
503	DMPAPER_TABLOID = 0x0003, /* Tabloid, 11 x 17 inches */
504	DMPAPER_LEDGER = 0x0004, /* Ledger, 17 x 11 inches */
505	DMPAPER_LEGAL = 0x0005, /* Legal, 8 1/2 x 14 inches */
506	DMPAPER_STATEMENT = 0x0006, /* Statement, 5 1/2 x 8 1/2 inches */
507	DMPAPER_EXECUTIVE = 0x0007, /* Executive, 7 1/4 x 10 1/2 inches */
508	DMPAPER_A3 = 0x0008, /* A3 sheet, 297 x 420 millimeters */
509	DMPAPER_A4 = 0x0009, /* A4 sheet, 210 x 297 millimeters */
510	DMPAPER_A4SMALL = 0x000A, /* A4 small sheet, 210 x 297 millimeters */
511	DMPAPER_A5 = 0x000B, /* A5 sheet, 148 x 210 millimeters */
512	DMPAPER_B4 = 0x000C, /* B4 sheet, 250 x 354 millimeters */
513	DMPAPER_B5 = 0x000D, /* B5 sheet, 182 x 257-millimeter paper */
514	DMPAPER_FOLIO = 0x000E, /* Folio, 8 1/2 x 13-inch paper */
515	DMPAPER_QUARTO = 0x000F, /* Quarto, 215 x 275 millimeter paper */
516	DMPAPER_10X14 = 0x0010, /* 10 x 14-inch sheet */
517	DMPAPER_11X17 = 0x0011, /* 11 x 17-inch sheet */
518	DMPAPER_NOTE = 0x0012, /* Note, 8 1/2 x 11-inches */
519	DMPAPER_ENV_9 = 0x0013, /* #9 Envelope, 3 7/8 x 8 7/8 inches */
520	DMPAPER_ENV_10 = 0x0014, /* #10 Envelope, 4 1/8 x 9 1/2 inches */
521	DMPAPER_ENV_11 = 0x0015, /* #11 Envelope, 4 1/2 x 10 3/8 inches */
522	DMPAPER_ENV_12 = 0x0016, /* #12 Envelope, 4 3/4 x 11 inches */
523	DMPAPER_ENV_14 = 0x0017, /* #14 Envelope, 5 x 11 1/2 inches */
524	DMPAPER_CSHEET = 0x0018, /* C Sheet, 17 x 22 inches */
525	DMPAPER_DSHEET = 0x0019, /* D Sheet, 22 x 34 inches */
526	DMPAPER_ESHEET = 0x001A, /* E Sheet, 34 x 44 inches */
527	DMPAPER_ENV_DL = 0x001B, /* DL Envelope, 110 x 220 millimeters */
528	DMPAPER_ENV_C5 = 0x001C, /* C5 Envelope, 162 x 229 millimeters */
529	DMPAPER_ENV_C3 = 0x001D, /* C3 Envelope, 324 x 458 millimeters */
530	DMPAPER_ENV_C4 = 0x001E, /* C4 Envelope, 229 x 324 millimeters */
531	DMPAPER_ENV_C6 = 0x001F, /* C6 Envelope, 114 x 162 millimeters */
532	DMPAPER_ENV_C65 = 0x0020, /* C65 Envelope, 114 x 229 millimeters */
533	DMPAPER_ENV_B4 = 0x0021, /* B4 Envelope, 250 x 353 millimeters */
534	DMPAPER_ENV_B5 = 0x0022, /* B5 Envelope, 176 x 250 millimeters */
535	DMPAPER_ENV_B6 = 0x0023, /* B6 Envelope, 176 x 125 millimeters */
536	DMPAPER_ENV_ITALY = 0x0024, /* Italy Envelope, 110 x 230 millimeters */
537	DMPAPER_ENV_MONARCH = 0x0025, /* Monarch Envelope, 3 7/8 x 7 1/2 inches */
538	DMPAPER_ENV_PERSONAL = 0x0026, /* 6 3/4 Envelope, 3 5/8 x 6 1/2 inches */
539	DMPAPER_FANFOLD_US = 0x0027, /* US Std Fanfold, 14 7/8 x 11 inches */
540	DMPAPER_FANFOLD_STD_GERMAN = 0x0028, /* German Std Fanfold, 8 1/2 x 12 inches */
541	DMPAPER_FANFOLD_LGL_GERMAN = 0x0029, /* German Legal Fanfold, 8 x 13 inches */
542	DMPAPER_DBL_JAPANESE_POSTCARD = 0x0045, /* Double Japanese Postcard, 200 x 148 millimeters */
543	DMPAPER_A6 = 0x0046, /* A6 sheet, 105 x 148 millimeters */
544	DMPAPER_JENV_KAKU2 = 0x0047, /* Japanese Envelope Kaku #2 */
545	DMPAPER_JENV_KAKU3 = 0x0048, /* Japanese Envelope Kaku #3 */
546	DMPAPER_JENV_CHOU3 = 0x0049, /* Japanese Envelope Chou #3 */
547	DMPAPER_JENV_CHOU4 = 0x004A, /* Japanese Envelope Chou #4 */
548	DMPAPER_LETTER_ROTATED = 0x004B, /* Letter Rotated, 11 by 8 1/2 inches */
549	DMPAPER_A3_ROTATED = 0x004C, /* A3 rotated sheet, 420 x 297 millimeters */
550	DMPAPER_A4_ROTATED = 0x004D, /* A4 rotated sheet, 297 x 210 millimeters */
551	DMPAPER_A5_ROTATED = 0x004E, /* A5 rotated sheet, 210 x 148 millimeters */
552	DMPAPER_B4_JIS_ROTATED = 0x004F, /* B4 (JIS) rotated sheet, 364 x 257 millimeters */
553	DMPAPER_B5_JIS_ROTATED = 0x0050, /* B5 (JIS) rotated sheet, 257 x 182 millimeters */
554	DMPAPER_JAPANESE_POSTCARD_ROTATED = 0x0051, /* Japanese Postcard Rotated, 148 x 100 millimeters */
555	DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED = 0x0052, /* Double Japanese Postcard Rotated, 148 x 200 millimeters */
556	DMPAPER_A6_ROTATED = 0x0053, /* A6 rotated sheet, 148 x 105 millimeters */
557	DMPAPER_JENV_KAKU2_ROTATED = 0x0054, /* Japanese Envelope Kaku #2 Rotated */
558	DMPAPER_JENV_KAKU3_ROTATED = 0x0055, /* Japanese Envelope Kaku #3 Rotated */
559	DMPAPER_JENV_CHOU3_ROTATED = 0x0056, /* Japanese Envelope Chou #3 Rotated */
560	DMPAPER_JENV_CHOU4_ROTATED = 0x0057, /* Japanese Envelope Chou #4 Rotated */
561	DMPAPER_B6_JIS = 0x0058, /* B6 (JIS) sheet, 128 x 182 millimeters */
562	DMPAPER_B6_JIS_ROTATED = 0x0059, /* B6 (JIS) rotated sheet, 182 x 128 millimeters */
563	DMPAPER_12X11 = 0x005A, /* 12 x 11-inch sheet */
564	DMPAPER_JENV_YOU4 = 0x005B, /* Japanese Envelope You #4 */
565	DMPAPER_JENV_YOU4_ROTATED = 0x005C, /* Japanese Envelope You #4 */
566	DMPAPER_P16K = 0x005D, /* PRC 16K, 146 x 215 millimeters */
567	DMPAPER_P32K = 0x005E, /* PRC 32K, 97 x 151 millimeters */
568	DMPAPER_P32KBIG = 0x005F, /* PRC 32K(Big) 97 x 151 millimeters */
569	DMPAPER_PENV_1 = 0x0060, /* PRC Envelope #1, 102 by 165 millimeters */
570	DMPAPER_PENV_2 = 0x0061, /* PRC Envelope #2, 102 x 176 millimeters */
571	DMPAPER_PENV_3 = 0x0062, /* PRC Envelope #3, 125 x 176 millimeters */
572	DMPAPER_PENV_4 = 0x0063, /* PRC Envelope #4, 110 x 208 millimeters */
573	DMPAPER_PENV_5 = 0x0064, /* PRC Envelope #5, 110 x 220 millimeters */
574	DMPAPER_PENV_6 = 0x0065, /* PRC Envelope #6, 120 x 230 millimeters */
575	DMPAPER_PENV_7 = 0x0066, /* PRC Envelope #7, 160 x 230 millimeters */
576	DMPAPER_PENV_8 = 0x0067, /* PRC Envelope #8, 120 x 309 millimeters */
577	DMPAPER_PENV_9 = 0x0068, /* PRC Envelope #9, 229 x 324 millimeters */
578	DMPAPER_PENV_10 = 0x0069, /* PRC Envelope #10, 324 x 458 millimeters */
579	DMPAPER_P16K_ROTATED = 0x006A, /* PRC 16K Rotated, 215 x 146 millimeters */
580	DMPAPER_P32K_ROTATED = 0x006B, /* PRC 32K Rotated, 151 x 97 millimeters */
581	DMPAPER_P32KBIG_ROTATED = 0x006C, /* PRC 32K(Big) Rotated, 151 x 97 millimeters */
582	DMPAPER_PENV_1_ROTATED = 0x006D, /* PRC Envelope #1 Rotated, 165 x 102 millimeters */
583	DMPAPER_PENV_2_ROTATED = 0x006E, /* PRC Envelope #2 Rotated, 176 x 102 millimeters */
584	DMPAPER_PENV_3_ROTATED = 0x006F, /* PRC Envelope #3 Rotated, 176 x 125 millimeters */
585	DMPAPER_PENV_4_ROTATED = 0x0070, /* PRC Envelope #4 Rotated, 208 x 110 millimeters */
586	DMPAPER_PENV_5_ROTATED = 0x0071, /* PRC Envelope #5 Rotated, 220 x 110 millimeters */
587	DMPAPER_PENV_6_ROTATED = 0x0072, /* PRC Envelope #6 Rotated, 230 x 120 millimeters */
588	DMPAPER_PENV_7_ROTATED = 0x0073, /* PRC Envelope #7 Rotated, 230 x 160 millimeters */
589	DMPAPER_PENV_8_ROTATED = 0x0074, /* PRC Envelope #8 Rotated, 309 x 120 millimeters */
590	DMPAPER_PENV_9_ROTATED = 0x0075, /* PRC Envelope #9 Rotated, 324 x 229 millimeters */
591	DMPAPER_PENV_10_ROTATED = 0x0076 /* PRC Envelope #10 Rotated, 458 x 324 millimeters */
592	} spoolss_DeviceModePaperSize;
593
594	typedef [enum16bit] enum {
595	DMBIN_UPPER = 0x0001,
596	DMBIN_LOWER = 0x0002,
597	DMBIN_MIDDLE = 0x0003,
598	DMBIN_MANUAL = 0x0004,
599	DMBIN_ENVELOPE = 0x0005,
600	DMBIN_ENVMANUAL = 0x0006,
601	DMBIN_AUTO = 0x0007,
602	DMBIN_TRACTOR = 0x0008,
603	DMBIN_SMALLFMT = 0x0009,
604	DMBIN_LARGEFMT = 0x000a,
605	DMBIN_LARGECAPACITY = 0x000b,
606	DMBIN_CASSETTE = 0x000e,
607	DMBIN_FORMSOURCE = 0x000f
608	} spoolss_DeviceModeDefaultSource;
609
610	typedef [enum16bit] enum {
611	DMRES_HIGH = 0xfffc,
612	DMRES_MEDIUM = 0xfffd,
613	DMRES_LOW = 0xfffe,
614	DMRES_DRAFT = 0xffff
615	} spoolss_DeviceModePrintQuality;
616
617	typedef [enum16bit] enum {
618	DMRES_MONOCHROME = 0x0001,
619	DMRES_COLOR = 0x0002
620	} spoolss_DeviceModeColor;
621
622	typedef [enum16bit] enum {
623	DMDUP_SIMPLEX = 0x0001,
624	DMDUP_VERTICAL = 0x0002,
625	DMDUP_HORIZONTAL = 0x0003
626	} spoolss_DeviceModeDuplex;
627
628	typedef [enum16bit] enum {
629	DMTT_BITMAP = 0x0001,
630	DMTT_DOWNLOAD = 0x0002,
631	DMTT_SUBDEV = 0x0003,
632	DMTT_DOWNLOAD_OUTLINE = 0x0004
633	} spoolss_DeviceModeTTOption;
634
635	typedef [enum16bit] enum {
636	DMCOLLATE_FALSE = 0x0000,
637	DMCOLLATE_TRUE = 0x0001
638	} spoolss_DeviceModeCollate;
639
640	typedef [v1_enum] enum {
641	DMNUP_SYSTEM = 0x00000001,
642	DMNUP_ONEUP = 0x00000002
643	} spoolss_DeviceModeNUp;
644
645	typedef [v1_enum] enum {
646	DMICMMETHOD_NONE = 0x00000001,
647	DMICMMETHOD_SYSTEM = 0x00000002,
648	DMICMMETHOD_DRIVER = 0x00000003,
649	DMICMMETHOD_DEVICE = 0x00000004
650	} spoolss_DeviceModeICMMethod;
651
652	typedef [v1_enum] enum {
653	DMICM_SATURATE = 0x00000001,
654	DMICM_CONTRAST = 0x00000002,
655	DMICM_COLORIMETRIC = 0x00000003,
656	DMICM_ABS_COLORIMETRIC = 0x00000004
657	} spoolss_DeviceModeICMIntent;
658
659	typedef [v1_enum] enum {
660	DMMEDIA_STANDARD = 0x00000001,
661	DMMEDIA_TRANSPARENCY = 0x00000002,
662	DMMEDIA_GLOSSY = 0x00000003
663	} spoolss_DeviceModeMediaType;
664
665	typedef [v1_enum] enum {
666	DMDITHER_NONE = 0x00000001,
667	DMDITHER_COARSE = 0x00000002,
668	DMDITHER_FINE = 0x00000003,
669	DMDITHER_LINEART = 0x00000004,
670	DMDITHER_ERRORDIFFUSION = 0x00000005,
671	DMDITHER_RESERVED6 = 0x00000006,
672	DMDITHER_RESERVED7 = 0x00000007,
673	DMDITHER_RESERVED8 = 0x00000008,
674	DMDITHER_RESERVED9 = 0x00000009,
675	DMDITHER_GRAYSCALE = 0x0000000A
676	} spoolss_DeviceModeDitherType;
677
678	const int MAXDEVICENAME = 32;
679
680	typedef [public,gensize] struct {
681	[charset(UTF16),to_null] uint16 devicename[MAXDEVICENAME];
682	spoolss_DeviceModeSpecVersion specversion;
683	uint16 driverversion;
684	uint16 size;
685	[value(r->driverextra_data.length)] uint16 __driverextra_length;
686	spoolss_DeviceModeFields fields;
687	spoolss_DeviceModeOrientation orientation;
688	spoolss_DeviceModePaperSize papersize;
689	uint16 paperlength;
690	uint16 paperwidth;
691	uint16 scale;
692	uint16 copies;
693	spoolss_DeviceModeDefaultSource defaultsource;
694	spoolss_DeviceModePrintQuality printquality;
695	spoolss_DeviceModeColor color;
696	spoolss_DeviceModeDuplex duplex;
697	uint16 yresolution;
698	spoolss_DeviceModeTTOption ttoption;
699	spoolss_DeviceModeCollate collate;
700	[charset(UTF16),to_null] uint16 formname[MAXDEVICENAME];
701	uint16 logpixels; /* reserved */
702	uint32 bitsperpel; /* reserved */
703	uint32 pelswidth; /* reserved */
704	uint32 pelsheight; /* reserved */
705	spoolss_DeviceModeNUp displayflags;
706	uint32 displayfrequency; /* reserved */
707	spoolss_DeviceModeICMMethod icmmethod;
708	spoolss_DeviceModeICMIntent icmintent;
709	spoolss_DeviceModeMediaType mediatype;
710	spoolss_DeviceModeDitherType dithertype;
711	uint32 reserved1;
712	uint32 reserved2;
713	uint32 panningwidth; /* reserved */
714	uint32 panningheight; /* reserved */
715	[subcontext_size(__driverextra_length),subcontext(0),flag(NDR_REMAINING)] DATA_BLOB driverextra_data;
716	} spoolss_DeviceMode;
717
718	typedef [public] bitmap {
719	PRINTER_ENUM_DEFAULT = 0x00000001,
720	PRINTER_ENUM_LOCAL = 0x00000002,
721	PRINTER_ENUM_CONNECTIONS = 0x00000004,
722	PRINTER_ENUM_FAVORITE = 0x00000004,
723	PRINTER_ENUM_NAME = 0x00000008,
724	PRINTER_ENUM_REMOTE = 0x00000010,
725	PRINTER_ENUM_SHARED = 0x00000020,
726	PRINTER_ENUM_NETWORK = 0x00000040,
727	PRINTER_ENUM_EXPAND = 0x00004000,
728	PRINTER_ENUM_CONTAINER = 0x00008000,
729	PRINTER_ENUM_ICON1 = 0x00010000,
730	PRINTER_ENUM_ICON2 = 0x00020000,
731	PRINTER_ENUM_ICON3 = 0x00040000,
732	PRINTER_ENUM_ICON4 = 0x00080000,
733	PRINTER_ENUM_ICON5 = 0x00100000,
734	PRINTER_ENUM_ICON6 = 0x00200000,
735	PRINTER_ENUM_ICON7 = 0x00400000,
736	PRINTER_ENUM_ICON8 = 0x00800000,
737	PRINTER_ENUM_HIDE = 0x01000000
738	} spoolss_EnumPrinterFlags;
739
740	const int PRINTER_ENUM_ICONMASK = (PRINTER_ENUM_ICON1 \|
741	PRINTER_ENUM_ICON2 \|
742	PRINTER_ENUM_ICON3 \|
743	PRINTER_ENUM_ICON4 \|
744	PRINTER_ENUM_ICON5 \|
745	PRINTER_ENUM_ICON6 \|
746	PRINTER_ENUM_ICON7 \|
747	PRINTER_ENUM_ICON8); /* 0x00ff0000 */
748
749	typedef [public] bitmap {
750	PRINTER_ATTRIBUTE_QUEUED = 0x00000001,
751	PRINTER_ATTRIBUTE_DIRECT = 0x00000002,
752	PRINTER_ATTRIBUTE_DEFAULT = 0x00000004,
753	PRINTER_ATTRIBUTE_SHARED = 0x00000008,
754	PRINTER_ATTRIBUTE_NETWORK = 0x00000010,
755	PRINTER_ATTRIBUTE_HIDDEN = 0x00000020,
756	PRINTER_ATTRIBUTE_LOCAL = 0x00000040,
757	PRINTER_ATTRIBUTE_ENABLE_DEVQ = 0x00000080,
758	PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS = 0x00000100,
759	PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST = 0x00000200,
760	PRINTER_ATTRIBUTE_WORK_OFFLINE = 0x00000400,
761	PRINTER_ATTRIBUTE_ENABLE_BIDI = 0x00000800,
762	PRINTER_ATTRIBUTE_RAW_ONLY = 0x00001000,
763	PRINTER_ATTRIBUTE_PUBLISHED = 0x00002000,
764	PRINTER_ATTRIBUTE_FAX = 0x00004000,
765	PRINTER_ATTRIBUTE_TS = 0x00008000
766	} spoolss_PrinterAttributes;
767
768	typedef [public,gensize] struct {
769	spoolss_EnumPrinterFlags flags;
770	[relative] nstring *description;
771	[relative] nstring *name;
772	[relative] nstring *comment;
773	} spoolss_PrinterInfo1;
774
775	typedef [public,gensize,nopush] struct {
776	[relative] nstring *servername;
777	[relative] nstring *printername;
778	[relative] nstring *sharename;
779	[relative] nstring *portname;
780	[relative] nstring *drivername;
781	[relative] nstring *comment;
782	[relative] nstring *location;
783	[relative,subcontext(0),flag(NDR_ALIGN4)] spoolss_DeviceMode *devmode;
784	[relative] nstring *sepfile;
785	[relative] nstring *printprocessor;
786	[relative] nstring *datatype;
787	[relative] nstring *parameters;
788	[relative,subcontext(0),flag(NDR_ALIGN4)] spoolss_security_descriptor *secdesc;
789	spoolss_PrinterAttributes attributes;
790	[range(0,99)] uint32 priority;
791	uint32 defaultpriority;
792	uint32 starttime;
793	uint32 untiltime;
794	spoolss_PrinterStatus status;
795	uint32 cjobs;
796	uint32 averageppm;
797	} spoolss_PrinterInfo2;
798
799	typedef [public,gensize] struct {
800	[relative,subcontext(0),flag(NDR_ALIGN4)] spoolss_security_descriptor *secdesc;
801	} spoolss_PrinterInfo3;
802
803	typedef [public,gensize] struct {
804	[relative] nstring *printername;
805	[relative] nstring *servername;
806	spoolss_PrinterAttributes attributes;
807	} spoolss_PrinterInfo4;
808
809	typedef [public,gensize] struct {
810	[relative] nstring *printername;
811	[relative] nstring *portname;
812	spoolss_PrinterAttributes attributes;
813	uint32 device_not_selected_timeout;
814	uint32 transmission_retry_timeout;
815	} spoolss_PrinterInfo5;
816
817	typedef [public,gensize] struct {
818	spoolss_PrinterStatus status;
819	} spoolss_PrinterInfo6;
820
821	typedef bitmap {
822	DSPRINT_PUBLISH = 0x00000001,
823	DSPRINT_UPDATE = 0x00000002,
824	DSPRINT_UNPUBLISH = 0x00000004,
825	DSPRINT_REPUBLISH = 0x00000008,
826	DSPRINT_PENDING = 0x80000000
827	} spoolss_DsPrintAction;
828
829	typedef [public,gensize] struct {
830	[relative] nstring guid; / text form of printer guid */
831	spoolss_DsPrintAction action;
832	} spoolss_PrinterInfo7;
833
834	typedef struct {
835	[relative,subcontext(0),flag(NDR_ALIGN4)] spoolss_DeviceMode *devmode;
836	} spoolss_DeviceModeInfo;
837
838	typedef [nodiscriminant,relative_base,public,gensize,flag(NDR_RELATIVE_REVERSE)] union {
839	[case(0)] spoolss_PrinterInfo0 info0;
840	[case(1)] spoolss_PrinterInfo1 info1;
841	[case(2)] spoolss_PrinterInfo2 info2;
842	[case(3)] spoolss_PrinterInfo3 info3;
843	[case(4)] spoolss_PrinterInfo4 info4;
844	[case(5)] spoolss_PrinterInfo5 info5;
845	[case(6)] spoolss_PrinterInfo6 info6;
846	[case(7)] spoolss_PrinterInfo7 info7;
847	[case(8)] spoolss_DeviceModeInfo info8;
848	[case(9)] spoolss_DeviceModeInfo info9;
849	[default];
850	} spoolss_PrinterInfo;
851
852	/******************/
853	/* Function: 0x00 */
854	/* we are using this as internal parsing code */
855	[public,noopnum,noprint] WERROR _spoolss_EnumPrinters(
856	[in] spoolss_EnumPrinterFlags flags,
857	[in,unique] [string,charset(UTF16)] uint16 *server,
858	[in] uint32 level,
859	[in,unique] DATA_BLOB *buffer,
860	[in] uint32 offered,
861	[out,unique] DATA_BLOB *info,
862	[out,ref] uint32 *needed,
863	[out,ref] uint32 *count
864	);
865	[public,noopnum,noprint] void __spoolss_EnumPrinters(
866	[in] uint32 level,
867	[in] uint32 count,
868	[out,switch_is(level)] spoolss_PrinterInfo info[count]
869	);
870	[nopull,nopush] WERROR spoolss_EnumPrinters(
871	[in] spoolss_EnumPrinterFlags flags,
872	[in,unique] [string,charset(UTF16)] uint16 *server,
873	[in] uint32 level,
874	[in,unique] DATA_BLOB *buffer,
875	[in] uint32 offered,
876	/* what we have here is a subcontext containing an array of no discriminant unions
877	* and the array has no size in front
878	*/
879	[out,ref] uint32 *count,
880	[out,ref,switch_is(level),size_is(,count)] spoolss_PrinterInfo *info,
881	[out,ref] uint32 *needed
882	);
883
884	/******************/
885	/* Function: 0x01 */
886	typedef struct {
887	[value(_ndr_size_spoolss_DeviceMode(devmode, ndr->flags))] uint32 _ndr_size;
888	[subcontext(4),subcontext_size(_ndr_size)] spoolss_DeviceMode *devmode;
889	} spoolss_DevmodeContainer;
890
891	[public] WERROR spoolss_OpenPrinter(
892	[in,unique] [string,charset(UTF16)] uint16 *printername,
893	[in,unique] [string,charset(UTF16)] uint16 *datatype,
894	[in] spoolss_DevmodeContainer devmode_ctr,
895	[in] spoolss_AccessRights access_mask,
896	[out,ref] policy_handle *handle
897	);
898
899	/******************/
900	/* Function: 0x02 */
901
902	typedef [public,gensize] struct {
903	uint32 job_id;
904	[relative] nstring *printer_name;
905	[relative] nstring *server_name;
906	[relative] nstring *user_name;
907	[relative] nstring *document_name;
908	[relative] nstring *data_type;
909	[relative] nstring *text_status;
910	spoolss_JobStatus status;
911	[range(0,99)] uint32 priority;
912	uint32 position;
913	uint32 total_pages;
914	uint32 pages_printed;
915	spoolss_Time submitted;
916	} spoolss_JobInfo1;
917
918	typedef [public,gensize] struct {
919	uint32 job_id;
920	[relative] nstring *printer_name;
921	[relative] nstring *server_name;
922	[relative] nstring *user_name;
923	[relative] nstring *document_name;
924	[relative] nstring *notify_name;
925	[relative] nstring *data_type;
926	[relative] nstring *print_processor;
927	[relative] nstring *parameters;
928	[relative] nstring *driver_name;
929	[relative,subcontext(0),flag(NDR_ALIGN4)] spoolss_DeviceMode *devmode;
930	[relative] nstring *text_status;
931	[relative,subcontext(0),flag(NDR_ALIGN4)] spoolss_security_descriptor *secdesc;
932	spoolss_JobStatus status;
933	[range(0,99)] uint32 priority;
934	uint32 position;
935	uint32 start_time;
936	uint32 until_time;
937	uint32 total_pages;
938	uint32 size;
939	spoolss_Time submitted;
940	uint32 time;
941	uint32 pages_printed;
942	} spoolss_JobInfo2;
943
944	typedef [public,gensize] struct {
945	uint32 job_id;
946	uint32 next_job_id;
947	uint32 reserved;
948	} spoolss_JobInfo3;
949
950	typedef [public,gensize] struct {
951	uint32 job_id;
952	[relative] nstring *printer_name;
953	[relative] nstring *server_name;
954	[relative] nstring *user_name;
955	[relative] nstring *document_name;
956	[relative] nstring *notify_name;
957	[relative] nstring *data_type;
958	[relative] nstring *print_processor;
959	[relative] nstring *parameters;
960	[relative] nstring *driver_name;
961	[relative,subcontext(0),flag(NDR_ALIGN4)] spoolss_DeviceMode *devmode;
962	[relative] nstring *text_status;
963	[relative,subcontext(0),flag(NDR_ALIGN4)] spoolss_security_descriptor *secdesc;
964	spoolss_JobStatus status;
965	[range(0,99)] uint32 priority;
966	uint32 position;
967	uint32 start_time;
968	uint32 until_time;
969	uint32 total_pages;
970	uint32 size;
971	spoolss_Time submitted;
972	uint32 time;
973	uint32 pages_printed;
974	uint32 size_high;
975	} spoolss_JobInfo4;
976
977	typedef [nodiscriminant,relative_base,public,gensize,flag(NDR_RELATIVE_REVERSE)] union {
978	[case(1)] spoolss_JobInfo1 info1;
979	[case(2)] spoolss_JobInfo2 info2;
980	[case(3)] spoolss_JobInfo3 info3;
981	[case(4)] spoolss_JobInfo4 info4;
982	[default];
983	} spoolss_JobInfo;
984
985	typedef struct {
986	uint32 job_id;
987	[string,charset(UTF16)] uint16 *printer_name;
988	[string,charset(UTF16)] uint16 *server_name;
989	[string,charset(UTF16)] uint16 *user_name;
990	[string,charset(UTF16)] uint16 *document_name;
991	[string,charset(UTF16)] uint16 *data_type;
992	[string,charset(UTF16)] uint16 *text_status;
993	spoolss_JobStatus status;
994	[range(0,99)] uint32 priority;
995	uint32 position;
996	uint32 total_pages;
997	uint32 pages_printed;
998	spoolss_Time submitted;
999	} spoolss_SetJobInfo1;
1000
1001	typedef struct {
1002	uint32 job_id;
1003	[string,charset(UTF16)] uint16 *printer_name;
1004	[string,charset(UTF16)] uint16 *server_name;
1005	[string,charset(UTF16)] uint16 *user_name;
1006	[string,charset(UTF16)] uint16 *document_name;
1007	[string,charset(UTF16)] uint16 *notify_name;
1008	[string,charset(UTF16)] uint16 *data_type;
1009	[string,charset(UTF16)] uint16 *print_processor;
1010	[string,charset(UTF16)] uint16 *parameters;
1011	[string,charset(UTF16)] uint16 *driver_name;
1012	uint32 _devmode_ptr; /* pointer to truncated devicemode */
1013	[string,charset(UTF16)] uint16 *text_status;
1014	uint32 _secdesc_ptr;
1015	spoolss_JobStatus status;
1016	[range(0,99)] uint32 priority;
1017	uint32 position;
1018	uint32 start_time;
1019	uint32 until_time;
1020	uint32 total_pages;
1021	uint32 size;
1022	spoolss_Time submitted;
1023	uint32 time;
1024	uint32 pages_printed;
1025	} spoolss_SetJobInfo2;
1026
1027	typedef struct {
1028	uint32 job_id;
1029	[string,charset(UTF16)] uint16 *printer_name;
1030	[string,charset(UTF16)] uint16 *server_name;
1031	[string,charset(UTF16)] uint16 *user_name;
1032	[string,charset(UTF16)] uint16 *document_name;
1033	[string,charset(UTF16)] uint16 *notify_name;
1034	[string,charset(UTF16)] uint16 *data_type;
1035	[string,charset(UTF16)] uint16 *print_processor;
1036	[string,charset(UTF16)] uint16 *parameters;
1037	[string,charset(UTF16)] uint16 *driver_name;
1038	uint32 _devmode_ptr; /* pointer to truncated devicemode */
1039	[string,charset(UTF16)] uint16 *text_status;
1040	uint32 _secdesc_ptr;
1041	spoolss_JobStatus status;
1042	[range(0,99)] uint32 priority;
1043	uint32 position;
1044	uint32 start_time;
1045	uint32 until_time;
1046	uint32 total_pages;
1047	uint32 size;
1048	spoolss_Time submitted;
1049	uint32 time;
1050	uint32 pages_printed;
1051	uint32 size_high;
1052	} spoolss_SetJobInfo4;
1053
1054	typedef [public] union {
1055	[case(1)] spoolss_SetJobInfo1 *info1;
1056	[case(2)] spoolss_SetJobInfo2 *info2;
1057	[case(3)] spoolss_JobInfo3 *info3;
1058	[case(4)] spoolss_SetJobInfo4 *info4;
1059	[default];
1060	} spoolss_SetJobInfo;
1061
1062	typedef struct {
1063	uint32 level;
1064	[switch_is(level)] spoolss_SetJobInfo info;
1065	} spoolss_JobInfoContainer;
1066
1067	typedef [v1_enum] enum {
1068	SPOOLSS_JOB_CONTROL_PAUSE = 1,
1069	SPOOLSS_JOB_CONTROL_RESUME = 2,
1070	SPOOLSS_JOB_CONTROL_CANCEL = 3,
1071	SPOOLSS_JOB_CONTROL_RESTART = 4,
1072	SPOOLSS_JOB_CONTROL_DELETE = 5,
1073	SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER = 6,
1074	SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED = 7,
1075	SPOOLSS_JOB_CONTROL_RETAIN = 8,
1076	SPOOLSS_JOB_CONTROL_RELEASE = 9
1077	} spoolss_JobControl;
1078
1079	WERROR spoolss_SetJob(
1080	[in,ref] policy_handle *handle,
1081	[in] uint32 job_id,
1082	[in,unique] spoolss_JobInfoContainer *ctr,
1083	[in] spoolss_JobControl command
1084	);
1085
1086	/******************/
1087	/* Function: 0x03 */
1088	WERROR spoolss_GetJob(
1089	[in,ref] policy_handle *handle,
1090	[in] uint32 job_id,
1091	[in] uint32 level,
1092	[in,unique] DATA_BLOB *buffer,
1093	[in] uint32 offered,
1094	[out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_JobInfo *info,
1095	[out,ref] uint32 *needed
1096	);
1097
1098	/******************/
1099	/* Function: 0x04 */
1100	[public,noopnum,noprint] WERROR _spoolss_EnumJobs(
1101	[in,ref] policy_handle *handle,
1102	[in] uint32 firstjob,
1103	[in] uint32 numjobs,
1104	[in] uint32 level,
1105	[in,unique] DATA_BLOB *buffer,
1106	[in] uint32 offered,
1107	[out,unique] DATA_BLOB *info,
1108	[out,ref] uint32 *needed,
1109	[out,ref] uint32 *count
1110	);
1111	[public,noopnum,noprint] void __spoolss_EnumJobs(
1112	[in] uint32 level,
1113	[in] uint32 count,
1114	[out,switch_is(level)] spoolss_JobInfo info[count]
1115	);
1116	[nopull,nopush] WERROR spoolss_EnumJobs(
1117	[in,ref] policy_handle *handle,
1118	[in] uint32 firstjob,
1119	[in] uint32 numjobs,
1120	[in] uint32 level,
1121	[in,unique] DATA_BLOB *buffer,
1122	[in] uint32 offered,
1123	[out,ref] uint32 *count,
1124	[out,ref,switch_is(level),size_is(,count)] spoolss_JobInfo *info,
1125	[out,ref] uint32 *needed
1126	);
1127
1128	/******************/
1129	/* Function: 0x05 */
1130	WERROR spoolss_AddPrinter(
1131	[in,unique] [string,charset(UTF16)] uint16 *server,
1132	[in,ref] spoolss_SetPrinterInfoCtr *info_ctr,
1133	[in,ref] spoolss_DevmodeContainer *devmode_ctr,
1134	[in,ref] sec_desc_buf *secdesc_ctr,
1135	[out,ref] policy_handle *handle
1136	);
1137
1138	/******************/
1139	/* Function: 0x06 */
1140	WERROR spoolss_DeletePrinter(
1141	[in] policy_handle *handle
1142	);
1143
1144	/******************/
1145	/* Function: 0x07 */
1146	typedef [v1_enum] enum {
1147	SPOOLSS_PRINTER_CONTROL_UNPAUSE = 0,
1148	SPOOLSS_PRINTER_CONTROL_PAUSE = 1,
1149	SPOOLSS_PRINTER_CONTROL_RESUME = 2,
1150	SPOOLSS_PRINTER_CONTROL_PURGE = 3,
1151	SPOOLSS_PRINTER_CONTROL_SET_STATUS = 4
1152	} spoolss_PrinterControl;
1153
1154	typedef struct {
1155	[string,charset(UTF16)] uint16 *servername;
1156	[string,charset(UTF16)] uint16 *printername;
1157	uint32 cjobs;
1158	uint32 total_jobs;
1159	uint32 total_bytes;
1160	spoolss_Time time;
1161	uint32 global_counter;
1162	uint32 total_pages;
1163	uint32 version;
1164	spoolss_Build free_build;
1165	uint32 spooling;
1166	uint32 max_spooling;
1167	uint32 session_counter;
1168	uint32 num_error_out_of_paper;
1169	uint32 num_error_not_ready;
1170	spoolss_JobStatus job_error;
1171	uint32 number_of_processors;
1172	spoolss_ProcessorType processor_type;
1173	uint32 high_part_total_bytes;
1174	uint32 change_id;
1175	WERROR last_error;
1176	spoolss_PrinterStatus status;
1177	uint32 enumerate_network_printers;
1178	uint32 c_setprinter;
1179	spoolss_ProcessorArchitecture processor_architecture;
1180	uint16 processor_level;
1181	uint32 ref_ic;
1182	uint32 reserved2;
1183	uint32 reserved3;
1184	} spoolss_SetPrinterInfo0;
1185
1186	typedef struct {
1187	spoolss_PrinterAttributes flags;
1188	[string,charset(UTF16)] uint16 *description;
1189	[string,charset(UTF16)] uint16 *name;
1190	[string,charset(UTF16)] uint16 *comment;
1191	} spoolss_SetPrinterInfo1;
1192
1193	typedef struct {
1194	[string,charset(UTF16)] uint16 *servername;
1195	[string,charset(UTF16)] uint16 *printername;
1196	[string,charset(UTF16)] uint16 *sharename;
1197	[string,charset(UTF16)] uint16 *portname;
1198	[string,charset(UTF16)] uint16 *drivername;
1199	[string,charset(UTF16)] uint16 *comment;
1200	[string,charset(UTF16)] uint16 *location;
1201	uint32 devmode_ptr;
1202	[string,charset(UTF16)] uint16 *sepfile;
1203	[string,charset(UTF16)] uint16 *printprocessor;
1204	[string,charset(UTF16)] uint16 *datatype;
1205	[string,charset(UTF16)] uint16 *parameters;
1206	uint32 secdesc_ptr;
1207	spoolss_PrinterAttributes attributes;
1208	[range(0,99)] uint32 priority;
1209	uint32 defaultpriority;
1210	uint32 starttime;
1211	uint32 untiltime;
1212	spoolss_PrinterStatus status;
1213	uint32 cjobs;
1214	uint32 averageppm;
1215	} spoolss_SetPrinterInfo2;
1216
1217	typedef struct {
1218	uint32 sec_desc_ptr;
1219	} spoolss_SetPrinterInfo3;
1220
1221	typedef struct {
1222	[string,charset(UTF16)] uint16 *printername;
1223	[string,charset(UTF16)] uint16 *servername;
1224	spoolss_PrinterAttributes attributes;
1225	} spoolss_SetPrinterInfo4;
1226
1227	typedef struct {
1228	[string,charset(UTF16)] uint16 *printername;
1229	[string,charset(UTF16)] uint16 *portname;
1230	spoolss_PrinterAttributes attributes;
1231	uint32 device_not_selected_timeout;
1232	uint32 transmission_retry_timeout;
1233	} spoolss_SetPrinterInfo5;
1234
1235	typedef struct {
1236	spoolss_PrinterStatus status;
1237	} spoolss_SetPrinterInfo6;
1238
1239	typedef struct {
1240	[string,charset(UTF16)] uint16 guid; / text form of printer guid */
1241	spoolss_DsPrintAction action;
1242	} spoolss_SetPrinterInfo7;
1243
1244	typedef struct {
1245	uint32 devmode_ptr;
1246	} spoolss_SetPrinterInfo8;
1247
1248	typedef struct {
1249	uint32 devmode_ptr;
1250	} spoolss_SetPrinterInfo9;
1251
1252	typedef [switch_type(uint32)] union {
1253	[case(0)] spoolss_SetPrinterInfo0 *info0;
1254	[case(1)] spoolss_SetPrinterInfo1 *info1;
1255	[case(2)] spoolss_SetPrinterInfo2 *info2;
1256	[case(3)] spoolss_SetPrinterInfo3 *info3;
1257	[case(4)] spoolss_SetPrinterInfo4 *info4;
1258	[case(5)] spoolss_SetPrinterInfo5 *info5;
1259	[case(6)] spoolss_SetPrinterInfo6 *info6;
1260	[case(7)] spoolss_SetPrinterInfo7 *info7;
1261	[case(8)] spoolss_SetPrinterInfo8 *info8;
1262	[case(9)] spoolss_SetPrinterInfo9 *info9;
1263	[default];
1264	} spoolss_SetPrinterInfo;
1265
1266	typedef struct {
1267	uint32 level;
1268	[switch_is(level)] spoolss_SetPrinterInfo info;
1269	} spoolss_SetPrinterInfoCtr;
1270
1271	WERROR spoolss_SetPrinter(
1272	[in,ref] policy_handle *handle,
1273	[in,ref] spoolss_SetPrinterInfoCtr *info_ctr,
1274	[in,ref] spoolss_DevmodeContainer *devmode_ctr,
1275	[in,ref] sec_desc_buf *secdesc_ctr,
1276	[in] spoolss_PrinterControl command
1277	);
1278
1279	/******************/
1280	/* Function: 0x08 */
1281	[public] WERROR spoolss_GetPrinter(
1282	[in,ref] policy_handle *handle,
1283	[in] uint32 level,
1284	[in,unique] DATA_BLOB *buffer,
1285	[in] uint32 offered,
1286	[out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_PrinterInfo *info,
1287	[out,ref] uint32 *needed
1288	);
1289
1290	/******************/
1291	/* Function: 0x09 */
1292
1293	typedef [public] struct {
1294	[value((ndr_size_spoolss_StringArray(r, ndr->flags)-4)/2)] uint32 _ndr_size;
1295	/[subcontext(0),subcontext_size(_ndr_size2)]*/ nstring_array string;
1296	} spoolss_StringArray;
1297
1298	typedef struct {
1299	[string,charset(UTF16)] uint16 *driver_name;
1300	} spoolss_AddDriverInfo1;
1301
1302	typedef [v1_enum,public] enum {
1303	SPOOLSS_DRIVER_VERSION_9X = 0,
1304	SPOOLSS_DRIVER_VERSION_NT35 = 1,
1305	SPOOLSS_DRIVER_VERSION_NT4 = 2,
1306	SPOOLSS_DRIVER_VERSION_200X = 3,
1307	SPOOLSS_DRIVER_VERSION_2012 = 4
1308	} spoolss_DriverOSVersion;
1309
1310	typedef struct {
1311	spoolss_DriverOSVersion version;
1312	[string,charset(UTF16)] uint16 *driver_name;
1313	[string,charset(UTF16)] uint16 *architecture;
1314	[string,charset(UTF16)] uint16 *driver_path;
1315	[string,charset(UTF16)] uint16 *data_file;
1316	[string,charset(UTF16)] uint16 *config_file;
1317	} spoolss_AddDriverInfo2;
1318
1319	typedef struct {
1320	spoolss_DriverOSVersion version;
1321	[string,charset(UTF16)] uint16 *driver_name;
1322	[string,charset(UTF16)] uint16 *architecture;
1323	[string,charset(UTF16)] uint16 *driver_path;
1324	[string,charset(UTF16)] uint16 *data_file;
1325	[string,charset(UTF16)] uint16 *config_file;
1326	[string,charset(UTF16)] uint16 *help_file;
1327	[string,charset(UTF16)] uint16 *monitor_name;
1328	[string,charset(UTF16)] uint16 *default_datatype;
1329	[value(((ndr_size_spoolss_StringArray(dependent_files, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
1330	spoolss_StringArray *dependent_files;
1331	} spoolss_AddDriverInfo3;
1332
1333	typedef struct {
1334	spoolss_DriverOSVersion version;
1335	[string,charset(UTF16)] uint16 *driver_name;
1336	[string,charset(UTF16)] uint16 *architecture;
1337	[string,charset(UTF16)] uint16 *driver_path;
1338	[string,charset(UTF16)] uint16 *data_file;
1339	[string,charset(UTF16)] uint16 *config_file;
1340	[string,charset(UTF16)] uint16 *help_file;
1341	[string,charset(UTF16)] uint16 *monitor_name;
1342	[string,charset(UTF16)] uint16 *default_datatype;
1343	[value(((ndr_size_spoolss_StringArray(dependent_files, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
1344	spoolss_StringArray *dependent_files;
1345	[value(((ndr_size_spoolss_StringArray(previous_names, ndr->flags)-4)/2))] uint32 _ndr_size_previous_names;
1346	spoolss_StringArray *previous_names;
1347	} spoolss_AddDriverInfo4;
1348
1349	typedef [bitmap32bit] bitmap {
1350	PRINTER_DRIVER_PACKAGE_AWARE = 0x00000002
1351	} spoolss_DriverAttributes;
1352
1353	typedef struct {
1354	spoolss_DriverOSVersion version;
1355	[string,charset(UTF16)] uint16 *driver_name;
1356	[string,charset(UTF16)] uint16 *architecture;
1357	[string,charset(UTF16)] uint16 *driver_path;
1358	[string,charset(UTF16)] uint16 *data_file;
1359	[string,charset(UTF16)] uint16 *config_file;
1360	spoolss_DriverAttributes driver_attributes;
1361	uint32 config_version;
1362	uint32 driver_version;
1363	} spoolss_AddDriverInfo5;
1364
1365	typedef struct {
1366	spoolss_DriverOSVersion version;
1367	[string,charset(UTF16)] uint16 *driver_name;
1368	[string,charset(UTF16)] uint16 *architecture;
1369	[string,charset(UTF16)] uint16 *driver_path;
1370	[string,charset(UTF16)] uint16 *data_file;
1371	[string,charset(UTF16)] uint16 *config_file;
1372	[string,charset(UTF16)] uint16 *help_file;
1373	[string,charset(UTF16)] uint16 *monitor_name;
1374	[string,charset(UTF16)] uint16 *default_datatype;
1375	[value(((ndr_size_spoolss_StringArray(dependent_files, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
1376	spoolss_StringArray *dependent_files;
1377	[value(((ndr_size_spoolss_StringArray(previous_names, ndr->flags)-4)/2))] uint32 _ndr_size_previous_names;
1378	spoolss_StringArray *previous_names;
1379	NTTIME driver_date;
1380	hyper driver_version;
1381	[string,charset(UTF16)] uint16 *manufacturer_name;
1382	[string,charset(UTF16)] uint16 *manufacturer_url;
1383	[string,charset(UTF16)] uint16 *hardware_id;
1384	[string,charset(UTF16)] uint16 *provider;
1385	} spoolss_AddDriverInfo6;
1386
1387	typedef struct {
1388	spoolss_DriverOSVersion version;
1389	[string,charset(UTF16)] uint16 *driver_name;
1390	[string,charset(UTF16)] uint16 *architecture;
1391	[string,charset(UTF16)] uint16 *driver_path;
1392	[string,charset(UTF16)] uint16 *data_file;
1393	[string,charset(UTF16)] uint16 *config_file;
1394	[string,charset(UTF16)] uint16 *help_file;
1395	[string,charset(UTF16)] uint16 *monitor_name;
1396	[string,charset(UTF16)] uint16 *default_datatype;
1397	[value(((ndr_size_spoolss_StringArray(dependent_files, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
1398	spoolss_StringArray *dependent_files;
1399	[value(((ndr_size_spoolss_StringArray(previous_names, ndr->flags)-4)/2))] uint32 _ndr_size_previous_names;
1400	spoolss_StringArray *previous_names;
1401	NTTIME driver_date;
1402	hyper driver_version;
1403	[string,charset(UTF16)] uint16 *manufacturer_name;
1404	[string,charset(UTF16)] uint16 *manufacturer_url;
1405	[string,charset(UTF16)] uint16 *hardware_id;
1406	[string,charset(UTF16)] uint16 *provider;
1407	[string,charset(UTF16)] uint16 *print_processor;
1408	[string,charset(UTF16)] uint16 *vendor_setup;
1409	[value(((ndr_size_spoolss_StringArray(color_profiles, ndr->flags)-4)/2))] uint32 _ndr_size_color_profiles;
1410	spoolss_StringArray *color_profiles;
1411	[string,charset(UTF16)] uint16 *inf_path;
1412	uint32 printer_driver_attributes;
1413	[value(((ndr_size_spoolss_StringArray(core_driver_dependencies, ndr->flags)-4)/2))] uint32 _ndr_size_core_driver_dependencies;
1414	spoolss_StringArray *core_driver_dependencies;
1415	NTTIME min_inbox_driver_ver_date;
1416	hyper min_inbox_driver_ver_version;
1417	} spoolss_AddDriverInfo8;
1418
1419	typedef [switch_type(uint32)] union {
1420	[case(1)] spoolss_AddDriverInfo1 *info1;
1421	[case(2)] spoolss_AddDriverInfo2 *info2;
1422	[case(3)] spoolss_AddDriverInfo3 *info3;
1423	[case(4)] spoolss_AddDriverInfo4 *info4;
1424	[case(6)] spoolss_AddDriverInfo6 *info6;
1425	[case(8)] spoolss_AddDriverInfo8 *info8;
1426	} spoolss_AddDriverInfo;
1427
1428	typedef struct {
1429	uint32 level;
1430	[switch_is(level)] spoolss_AddDriverInfo info;
1431	} spoolss_AddDriverInfoCtr;
1432
1433	WERROR spoolss_AddPrinterDriver(
1434	[in,unique] [string,charset(UTF16)] uint16 *servername,
1435	[in,ref] spoolss_AddDriverInfoCtr *info_ctr
1436	);
1437
1438	typedef [public,gensize] struct {
1439	[relative] nstring *driver_name;
1440	} spoolss_DriverInfo1;
1441
1442	typedef [public,gensize] struct {
1443	spoolss_DriverOSVersion version;
1444	[relative] nstring *driver_name;
1445	[relative] nstring *architecture;
1446	[relative] nstring *driver_path;
1447	[relative] nstring *data_file;
1448	[relative] nstring *config_file;
1449	} spoolss_DriverInfo2;
1450
1451	typedef [public,gensize] struct {
1452	spoolss_DriverOSVersion version;
1453	[relative] nstring *driver_name;
1454	[relative] nstring *architecture;
1455	[relative] nstring *driver_path;
1456	[relative] nstring *data_file;
1457	[relative] nstring *config_file;
1458	[relative] nstring *help_file;
1459	[relative] nstring_array *dependent_files;
1460	[relative] nstring *monitor_name;
1461	[relative] nstring *default_datatype;
1462	} spoolss_DriverInfo3;
1463
1464	typedef [public,gensize] struct {
1465	spoolss_DriverOSVersion version;
1466	[relative] nstring *driver_name;
1467	[relative] nstring *architecture;
1468	[relative] nstring *driver_path;
1469	[relative] nstring *data_file;
1470	[relative] nstring *config_file;
1471	[relative] nstring *help_file;
1472	[relative] nstring_array *dependent_files;
1473	[relative] nstring *monitor_name;
1474	[relative] nstring *default_datatype;
1475	[relative] nstring_array *previous_names;
1476	} spoolss_DriverInfo4;
1477
1478	typedef [public,gensize] struct {
1479	spoolss_DriverOSVersion version;
1480	[relative] nstring *driver_name;
1481	[relative] nstring *architecture;
1482	[relative] nstring *driver_path;
1483	[relative] nstring *data_file;
1484	[relative] nstring *config_file;
1485	spoolss_DriverAttributes driver_attributes;
1486	uint32 config_version;
1487	uint32 driver_version;
1488	} spoolss_DriverInfo5;
1489
1490	typedef [public,gensize] struct {
1491	spoolss_DriverOSVersion version;
1492	[relative] nstring *driver_name;
1493	[relative] nstring *architecture;
1494	[relative] nstring *driver_path;
1495	[relative] nstring *data_file;
1496	[relative] nstring *config_file;
1497	[relative] nstring *help_file;
1498	[relative] nstring_array *dependent_files;
1499	[relative] nstring *monitor_name;
1500	[relative] nstring *default_datatype;
1501	[relative] nstring_array *previous_names;
1502	NTTIME driver_date;
1503	hyper driver_version;
1504	[relative] nstring *manufacturer_name;
1505	[relative] nstring *manufacturer_url;
1506	[relative] nstring *hardware_id;
1507	[relative] nstring *provider;
1508	} spoolss_DriverInfo6;
1509
1510	typedef [public,gensize] struct {
1511	uint32 size;
1512	spoolss_DriverOSVersion version;
1513	[relative] nstring *driver_name;
1514	[relative] nstring *inf_name;
1515	[relative] nstring *install_source_root;
1516	} spoolss_DriverInfo7;
1517
1518	typedef [public,gensize] struct {
1519	spoolss_DriverOSVersion version;
1520	[relative] nstring *driver_name;
1521	[relative] nstring *architecture;
1522	[relative] nstring *driver_path;
1523	[relative] nstring *data_file;
1524	[relative] nstring *config_file;
1525	[relative] nstring *help_file;
1526	[relative] nstring_array *dependent_files;
1527	[relative] nstring *monitor_name;
1528	[relative] nstring *default_datatype;
1529	[relative] nstring_array *previous_names;
1530	NTTIME driver_date;
1531	hyper driver_version;
1532	[relative] nstring *manufacturer_name;
1533	[relative] nstring *manufacturer_url;
1534	[relative] nstring *hardware_id;
1535	[relative] nstring *provider;
1536	[relative] nstring *print_processor;
1537	[relative] nstring *vendor_setup;
1538	[relative] nstring_array *color_profiles;
1539	[relative] nstring *inf_path;
1540	uint32 printer_driver_attributes;
1541	[relative] nstring_array *core_driver_dependencies;
1542	NTTIME min_inbox_driver_ver_date;
1543	hyper min_inbox_driver_ver_version;
1544	} spoolss_DriverInfo8;
1545
1546	typedef [v1_enum] enum {
1547	SPOOLSS_DRIVER_FILE_TYPE_RENDERING = 0x00000000,
1548	SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION = 0x00000001,
1549	SPOOLSS_DRIVER_FILE_TYPE_DATA = 0x00000002,
1550	SPOOLSS_DRIVER_FILE_TYPE_HELP = 0x00000003,
1551	SPOOLSS_DRIVER_FILE_TYPE_OTHER = 0x00000004
1552	} spoolss_DriverFileType;
1553
1554	typedef [public] struct {
1555	[relative] nstring *file_name;
1556	spoolss_DriverFileType file_type;
1557	uint32 file_version;
1558	} spoolss_DriverFileInfo;
1559
1560	typedef [public,gensize,nopush,nopull] struct {
1561	spoolss_DriverOSVersion version;
1562	[relative] nstring *driver_name;
1563	[relative] nstring *architecture;
1564	[relative,size_is(file_count),flag(NDR_ALIGN4)] spoolss_DriverFileInfo *file_info;
1565	uint32 file_count;
1566	[relative] nstring *monitor_name;
1567	[relative] nstring *default_datatype;
1568	[relative] nstring_array *previous_names;
1569	NTTIME driver_date;
1570	hyper driver_version;
1571	[relative] nstring *manufacturer_name;
1572	[relative] nstring *manufacturer_url;
1573	[relative] nstring *hardware_id;
1574	[relative] nstring *provider;
1575	} spoolss_DriverInfo101;
1576
1577	typedef [nodiscriminant,relative_base,public,gensize,flag(NDR_RELATIVE_REVERSE)] union {
1578	[case(1)] spoolss_DriverInfo1 info1;
1579	[case(2)] spoolss_DriverInfo2 info2;
1580	[case(3)] spoolss_DriverInfo3 info3;
1581	[case(4)] spoolss_DriverInfo4 info4;
1582	[case(5)] spoolss_DriverInfo5 info5;
1583	[case(6)] spoolss_DriverInfo6 info6;
1584	[case(7)] spoolss_DriverInfo7 info7;
1585	[case(8)] spoolss_DriverInfo8 info8;
1586	[case(101)] spoolss_DriverInfo101 info101;
1587	[default];
1588	} spoolss_DriverInfo;
1589
1590	/******************/
1591	/* Function: 0x0a */
1592	[public,noopnum,noprint] WERROR _spoolss_EnumPrinterDrivers(
1593	[in,unique] [string,charset(UTF16)] uint16 *server,
1594	[in,unique] [string,charset(UTF16)] uint16 *environment,
1595	[in] uint32 level,
1596	[in,unique] DATA_BLOB *buffer,
1597	[in] uint32 offered,
1598	[out,unique] DATA_BLOB *info,
1599	[out,ref] uint32 *needed,
1600	[out,ref] uint32 *count
1601	);
1602	[public,noopnum,noprint] void __spoolss_EnumPrinterDrivers(
1603	[in] uint32 level,
1604	[in] uint32 count,
1605	[out,switch_is(level)] spoolss_DriverInfo info[count]
1606	);
1607	[nopull,nopush] WERROR spoolss_EnumPrinterDrivers(
1608	[in,unique] [string,charset(UTF16)] uint16 *server,
1609	[in,unique] [string,charset(UTF16)] uint16 *environment,
1610	[in] uint32 level,
1611	[in,unique] DATA_BLOB *buffer,
1612	[in] uint32 offered,
1613	[out,ref] uint32 *count,
1614	[out,ref,switch_is(level),size_is(,count)] spoolss_DriverInfo *info,
1615	[out,ref] uint32 *needed
1616	);
1617
1618	/******************/
1619	/* Function: 0x0b */
1620	WERROR spoolss_GetPrinterDriver(
1621	[in,ref] policy_handle *handle,
1622	[in,unique] [string,charset(UTF16)] uint16 *architecture,
1623	[in] uint32 level,
1624	[in,unique] DATA_BLOB *buffer,
1625	[in] uint32 offered,
1626	[out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_DriverInfo *info,
1627	[out,ref] uint32 *needed
1628	);
1629
1630	/******************/
1631	/* Function: 0x0c */
1632	typedef [public,gensize] struct {
1633	nstring directory_name;
1634	} spoolss_DriverDirectoryInfo1;
1635
1636	/* NOTE: it's seems that w2k3 completly ignores the level
1637	in its server code
1638	*/
1639	typedef [nodiscriminant,relative_base,public,gensize,flag(NDR_RELATIVE_REVERSE)] union {
1640	[case(1)] spoolss_DriverDirectoryInfo1 info1;
1641	[default] spoolss_DriverDirectoryInfo1 info1;
1642	} spoolss_DriverDirectoryInfo;
1643
1644	[public] WERROR spoolss_GetPrinterDriverDirectory(
1645	[in,unique] [string,charset(UTF16)] uint16 *server,
1646	[in,unique] [string,charset(UTF16)] uint16 *environment,
1647	[in] uint32 level,
1648	[in,unique] DATA_BLOB *buffer,
1649	[in] uint32 offered,
1650	[out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_DriverDirectoryInfo *info,
1651	[out,ref] uint32 *needed
1652	);
1653
1654	/******************/
1655	/* Function: 0x0d */
1656	WERROR spoolss_DeletePrinterDriver(
1657	[in,unique] [string,charset(UTF16)] uint16 *server,
1658	[in] [string,charset(UTF16)] uint16 architecture[],
1659	[in] [string,charset(UTF16)] uint16 driver[]
1660	);
1661
1662	/******************/
1663	/* Function: 0x0e */
1664	WERROR spoolss_AddPrintProcessor(
1665	[in,unique] [string,charset(UTF16)] uint16 *server,
1666	[in] [string,charset(UTF16)] uint16 architecture[],
1667	[in] [string,charset(UTF16)] uint16 path_name[],
1668	[in] [string,charset(UTF16)] uint16 print_processor_name[]
1669	);
1670
1671	/******************/
1672	/* Function: 0x0f */
1673	typedef [public,gensize] struct {
1674	[relative] nstring *print_processor_name;
1675	} spoolss_PrintProcessorInfo1;
1676
1677	typedef [nodiscriminant,relative_base,public,flag(NDR_RELATIVE_REVERSE)] union {
1678	[case(1)] spoolss_PrintProcessorInfo1 info1;
1679	[default];
1680	} spoolss_PrintProcessorInfo;
1681
1682	[public,noopnum,noprint] WERROR _spoolss_EnumPrintProcessors(
1683	[in,unique] [string,charset(UTF16)] uint16 *servername,
1684	[in,unique] [string,charset(UTF16)] uint16 *environment,
1685	[in] uint32 level,
1686	[in,unique] DATA_BLOB *buffer,
1687	[in] uint32 offered,
1688	[out,unique] DATA_BLOB *info,
1689	[out,ref] uint32 *needed,
1690	[out,ref] uint32 *count
1691	);
1692	[public,noopnum,noprint] void __spoolss_EnumPrintProcessors(
1693	[in] uint32 level,
1694	[in] uint32 count,
1695	[out,switch_is(level)] spoolss_PrintProcessorInfo info[count]
1696	);
1697	[nopull,nopush] WERROR spoolss_EnumPrintProcessors(
1698	[in,unique] [string,charset(UTF16)] uint16 *servername,
1699	[in,unique] [string,charset(UTF16)] uint16 *environment,
1700	[in] uint32 level,
1701	[in,unique] DATA_BLOB *buffer,
1702	[in] uint32 offered,
1703	[out,ref] uint32 *count,
1704	[out,ref,switch_is(level),size_is(,count)] spoolss_PrintProcessorInfo *info,
1705	[out,ref] uint32 *needed
1706	);
1707
1708	/******************/
1709	/* Function: 0x10 */
1710	typedef [public,gensize] struct {
1711	nstring directory_name;
1712	} spoolss_PrintProcessorDirectoryInfo1;
1713
1714	typedef [nodiscriminant,relative_base,public,gensize,flag(NDR_RELATIVE_REVERSE)] union {
1715	[case(1)] spoolss_PrintProcessorDirectoryInfo1 info1;
1716	[default] spoolss_PrintProcessorDirectoryInfo1 info1;
1717	} spoolss_PrintProcessorDirectoryInfo;
1718
1719	WERROR spoolss_GetPrintProcessorDirectory(
1720	[in,unique] [string,charset(UTF16)] uint16 *server,
1721	[in,unique] [string,charset(UTF16)] uint16 *environment,
1722	[in] uint32 level,
1723	[in,unique] DATA_BLOB *buffer,
1724	[in] uint32 offered,
1725	[out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_PrintProcessorDirectoryInfo *info,
1726	[out,ref] uint32 *needed
1727	);
1728
1729	/******************/
1730	/* Function: 0x11 */
1731	typedef struct {
1732	[string,charset(UTF16)] uint16 *document_name;
1733	[string,charset(UTF16)] uint16 *output_file;
1734	[string,charset(UTF16)] uint16 *datatype;
1735	} spoolss_DocumentInfo1;
1736
1737	typedef [switch_type(uint32)] union {
1738	[case(1)] spoolss_DocumentInfo1 *info1;
1739	[case(2)]; /* TODO */
1740	[case(3)]; /* TODO */
1741	[default];
1742	} spoolss_DocumentInfo;
1743
1744	WERROR spoolss_StartDocPrinter(
1745	[in,ref] policy_handle *handle,
1746	[in] uint32 level,
1747	[in,switch_is(level)] spoolss_DocumentInfo info,
1748	[out,ref] uint32 *job_id
1749	);
1750
1751	/******************/
1752	/* Function: 0x12 */
1753	WERROR spoolss_StartPagePrinter(
1754	[in,ref] policy_handle *handle
1755	);
1756
1757	/******************/
1758	/* Function: 0x13 */
1759	WERROR spoolss_WritePrinter(
1760	[in,ref] policy_handle *handle,
1761	[in] DATA_BLOB data,
1762	[in,value(r->in.data.length)] uint32 _data_size,
1763	[out,ref] uint32 *num_written
1764	);
1765
1766	/******************/
1767	/* Function: 0x14 */
1768	WERROR spoolss_EndPagePrinter(
1769	[in,ref] policy_handle *handle
1770	);
1771
1772	/******************/
1773	/* Function: 0x15 */
1774	WERROR spoolss_AbortPrinter(
1775	[in,ref] policy_handle *handle
1776	);
1777
1778	/******************/
1779	/* Function: 0x16 */
1780	WERROR spoolss_ReadPrinter(
1781	[in,ref] policy_handle *handle,
1782	[out,ref] [size_is(data_size)] uint8 *data,
1783	[in] uint32 data_size,
1784	[out,ref] uint32 *_data_size
1785	);
1786
1787	/******************/
1788	/* Function: 0x17 */
1789	WERROR spoolss_EndDocPrinter(
1790	[in,ref] policy_handle *handle
1791	);
1792
1793	/******************/
1794	/* Function: 0x18 */
1795	WERROR spoolss_AddJob(
1796	[in,ref] policy_handle *handle,
1797	[in] uint32 level,
1798	[in,out,unique] [size_is(offered)] uint8 *buffer,
1799	[in] uint32 offered,
1800	[out,ref] uint32 *needed
1801	);
1802
1803	/******************/
1804	/* Function: 0x19 */
1805	WERROR spoolss_ScheduleJob(
1806	[in,ref] policy_handle *handle,
1807	[in] uint32 jobid
1808	);
1809
1810	/******************/
1811	/* Function: 0x1a */
1812
1813	const string SPL_ARCH_WIN40 = "WIN40";
1814	const string SPL_ARCH_W32X86 = "W32X86";
1815	const string SPL_ARCH_W32MIPS = "W32MIPS";
1816	const string SPL_ARCH_W32ALPHA = "W32ALPHA";
1817	const string SPL_ARCH_W32PPC = "W32PPC";
1818	const string SPL_ARCH_IA64 = "IA64";
1819	const string SPL_ARCH_X64 = "x64";
1820
1821	const string SPOOLSS_ARCHITECTURE_ALL = "All";
1822	const string SPOOLSS_ARCHITECTURE_ALL_CLUSTER = "AllCluster";
1823	const string SPOOLSS_ARCHITECTURE_NT_X86 = "Windows NT x86";
1824	const string SPOOLSS_ARCHITECTURE_IA_64 = "Windows IA64";
1825	const string SPOOLSS_ARCHITECTURE_x64 = "Windows x64";
1826	const string SPOOLSS_ARCHITECTURE_4_0 = "Windows 4.0";
1827	const string SPOOLSS_DEFAULT_SERVER_PATH = "C:\\WINDOWS\\system32\\spool";
1828
1829	typedef [public,gensize] struct {
1830	[value(ndr_size_spoolss_OSVersion(r,ndr->flags))] uint32 _ndr_size;
1831	uint32 major;
1832	uint32 minor;
1833	uint32 build;
1834	[value(2)] uint32 platform_id;
1835	[subcontext(0),subcontext_size(256)] nstring extra_string;
1836	} spoolss_OSVersion;
1837
1838	typedef [public,gensize] struct {
1839	[value(ndr_size_spoolss_OSVersionEx(r,ndr->flags))] uint32 _ndr_size;
1840	uint32 major;
1841	uint32 minor;
1842	uint32 build;
1843	[value(2)] uint32 platform_id;
1844	[subcontext(0),subcontext_size(256)] nstring extra_string;
1845	uint16 service_pack_major;
1846	uint16 service_pack_minor;
1847	uint16 suite_mask;
1848	uint8 product_type;
1849	uint8 reserved;
1850	} spoolss_OSVersionEx;
1851
1852	typedef [nodiscriminant,public] union {
1853	[case(REG_NONE)];
1854	[case(REG_SZ)] nstring string;
1855	[case(REG_BINARY),flag(NDR_REMAINING)] DATA_BLOB binary;
1856	[case(REG_DWORD)] uint32 value;
1857	[case(REG_MULTI_SZ)] nstring_array string_array;
1858	[default,flag(NDR_REMAINING)] DATA_BLOB data;
1859	} spoolss_PrinterData;
1860
1861	/* predefined registry key names for printer data */
1862
1863	const string SPOOL_PRINTERDATA_KEY = "PrinterDriverData";
1864	const string SPOOL_DSSPOOLER_KEY = "DsSpooler";
1865	const string SPOOL_DSDRIVER_KEY = "DsDriver";
1866	const string SPOOL_DSUSER_KEY = "DsUser";
1867	const string SPOOL_PNPDATA_KEY = "PnPData";
1868	const string SPOOL_OID_KEY = "OID";
1869
1870	/* predefined value names for printer data */
1871
1872	const string SPOOL_REG_ASSETNUMBER = "assetNumber";
1873	const string SPOOL_REG_BYTESPERMINUTE = "bytesPerMinute";
1874	const string SPOOL_REG_DEFAULTPRIORITY = "defaultPriority";
1875	const string SPOOL_REG_DESCRIPTION = "description";
1876	const string SPOOL_REG_DRIVERNAME = "driverName";
1877	const string SPOOL_REG_DRIVERVERSION = "driverVersion";
1878	const string SPOOL_REG_FLAGS = "flags";
1879	const string SPOOL_REG_LOCATION = "location";
1880	const string SPOOL_REG_OPERATINGSYSTEM = "operatingSystem";
1881	const string SPOOL_REG_OPERATINGSYSTEMHOTFIX = "operatingSystemHotfix";
1882	const string SPOOL_REG_OPERATINGSYSTEMSERVICEPACK = "operatingSystemServicePack";
1883	const string SPOOL_REG_OPERATINGSYSTEMVERSION = "operatingSystemVersion";
1884	const string SPOOL_REG_PORTNAME = "portName";
1885	const string SPOOL_REG_PRINTATTRIBUTES = "printAttributes";
1886	const string SPOOL_REG_PRINTBINNAMES = "printBinNames";
1887	const string SPOOL_REG_PRINTCOLLATE = "printCollate";
1888	const string SPOOL_REG_PRINTCOLOR = "printColor";
1889	const string SPOOL_REG_PRINTDUPLEXSUPPORTED = "printDuplexSupported";
1890	const string SPOOL_REG_PRINTENDTIME = "printEndTime";
1891	const string SPOOL_REG_PRINTERNAME = "printerName";
1892	const string SPOOL_REG_PRINTFORMNAME = "printFormName";
1893	const string SPOOL_REG_PRINTKEEPPRINTEDJOBS = "printKeepPrintedJobs";
1894	const string SPOOL_REG_PRINTLANGUAGE = "printLanguage";
1895	const string SPOOL_REG_PRINTMACADDRESS = "printMACAddress";
1896	const string SPOOL_REG_PRINTMAXCOPIES = "printMaxCopies";
1897	const string SPOOL_REG_PRINTMAXRESOLUTIONSUPPORTED = "printMaxResolutionSupported";
1898	const string SPOOL_REG_PRINTMAXXEXTENT = "printMaxXExtent";
1899	const string SPOOL_REG_PRINTMAXYEXTENT = "printMaxYExtent";
1900	const string SPOOL_REG_PRINTMEDIAREADY = "printMediaReady";
1901	const string SPOOL_REG_PRINTMEDIASUPPORTED = "printMediaSupported";
1902	const string SPOOL_REG_PRINTMEMORY = "printMemory";
1903	const string SPOOL_REG_PRINTMINXEXTENT = "printMinXExtent";
1904	const string SPOOL_REG_PRINTMINYEXTENT = "printMinYExtent";
1905	const string SPOOL_REG_PRINTNETWORKADDRESS = "printNetworkAddress";
1906	const string SPOOL_REG_PRINTNOTIFY = "printNotify";
1907	const string SPOOL_REG_PRINTNUMBERUP = "printNumberUp";
1908	const string SPOOL_REG_PRINTORIENTATIONSSUPPORTED = "printOrientationsSupported";
1909	const string SPOOL_REG_PRINTOWNER = "printOwner";
1910	const string SPOOL_REG_PRINTPAGESPERMINUTE = "printPagesPerMinute";
1911	const string SPOOL_REG_PRINTRATE = "printRate";
1912	const string SPOOL_REG_PRINTRATEUNIT = "printRateUnit";
1913	const string SPOOL_REG_PRINTSEPARATORFILE = "printSeparatorFile";
1914	const string SPOOL_REG_PRINTSHARENAME = "printShareName";
1915	const string SPOOL_REG_PRINTSPOOLING = "printSpooling";
1916	const string SPOOL_REGVAL_PRINTWHILESPOOLING = "PrintWhileSpooling";
1917	const string SPOOL_REGVAL_PRINTAFTERSPOOLED = "PrintAfterSpooled";
1918	const string SPOOL_REGVAL_PRINTDIRECT = "PrintDirect";
1919	const string SPOOL_REG_PRINTSTAPLINGSUPPORTED = "printStaplingSupported";
1920	const string SPOOL_REG_PRINTSTARTTIME = "printStartTime";
1921	const string SPOOL_REG_PRINTSTATUS = "printStatus";
1922	const string SPOOL_REG_PRIORITY = "priority";
1923	const string SPOOL_REG_SERVERNAME = "serverName";
1924	const string SPOOL_REG_SHORTSERVERNAME = "shortServerName";
1925	const string SPOOL_REG_UNCNAME = "uNCName";
1926	const string SPOOL_REG_URL = "url";
1927	const string SPOOL_REG_VERSIONNUMBER = "versionNumber";
1928
1929	[public] WERROR spoolss_GetPrinterData(
1930	[in,ref] policy_handle *handle,
1931	[in] [string,charset(UTF16)] uint16 value_name[],
1932	[out,ref] winreg_Type *type,
1933	[out,ref,size_is(offered)] uint8 *data,
1934	[in] uint32 offered,
1935	[out,ref] uint32 *needed
1936	);
1937
1938	/******************/
1939	/* Function: 0x1b */
1940	WERROR spoolss_SetPrinterData(
1941	[in,ref] policy_handle *handle,
1942	[in] [string,charset(UTF16)] uint16 value_name[],
1943	[in] winreg_Type type,
1944	[in,ref] [size_is(offered)] uint8 *data,
1945	[in] uint32 offered
1946	);
1947
1948	/******************/
1949	/* Function: 0x1c */
1950	[todo] WERROR spoolss_WaitForPrinterChange(
1951	);
1952
1953	/******************/
1954	/* Function: 0x1d */
1955	[public] WERROR spoolss_ClosePrinter(
1956	[in,out,ref] policy_handle *handle
1957	);
1958
1959	/******************/
1960	/* Function: 0x1e */
1961	typedef [v1_enum] enum {
1962	SPOOLSS_FORM_USER = 0,
1963	SPOOLSS_FORM_BUILTIN = 1,
1964	SPOOLSS_FORM_PRINTER = 2
1965	} spoolss_FormFlags;
1966
1967	typedef struct {
1968	uint32 width;
1969	uint32 height;
1970	} spoolss_FormSize;
1971
1972	typedef struct {
1973	uint32 left;
1974	uint32 top;
1975	uint32 right;
1976	uint32 bottom;
1977	} spoolss_FormArea;
1978
1979	typedef [public,gensize] struct {
1980	spoolss_FormFlags flags;
1981	[relative] nstring *form_name;
1982	spoolss_FormSize size;
1983	spoolss_FormArea area;
1984	} spoolss_FormInfo1;
1985
1986	typedef [bitmap32bit] bitmap {
1987	SPOOLSS_FORM_STRING_TYPE_NONE = 0x00000001,
1988	SPOOLSS_FORM_STRING_TYPE_MUI_DLL = 0x00000002,
1989	SPOOLSS_FORM_STRING_TYPE_LANG_PAIR = 0x00000004
1990	} spoolss_FormStringType;
1991
1992	typedef [public,gensize] struct {
1993	spoolss_FormFlags flags;
1994	[relative] nstring *form_name;
1995	spoolss_FormSize size;
1996	spoolss_FormArea area;
1997	[relative] astring *keyword;
1998	spoolss_FormStringType string_type;
1999	[relative] nstring *mui_dll;
2000	uint32 ressource_id;
2001	[relative] nstring *display_name;
2002	uint16 lang_id;
2003	uint16 unused;
2004	} spoolss_FormInfo2;
2005
2006	typedef [nodiscriminant,relative_base,public,gensize,flag(NDR_RELATIVE_REVERSE)] union {
2007	[case(1)] spoolss_FormInfo1 info1;
2008	[case(2)] spoolss_FormInfo2 info2;
2009	[default];
2010	} spoolss_FormInfo;
2011
2012	typedef struct {
2013	spoolss_FormFlags flags;
2014	[string,charset(UTF16)] uint16 *form_name;
2015	spoolss_FormSize size;
2016	spoolss_FormArea area;
2017	} spoolss_AddFormInfo1;
2018
2019	typedef struct {
2020	spoolss_FormFlags flags;
2021	[string,charset(UTF16)] uint16 *form_name;
2022	spoolss_FormSize size;
2023	spoolss_FormArea area;
2024	[string,charset(DOS)] uint8 *keyword;
2025	spoolss_FormStringType string_type;
2026	[string,charset(UTF16)] uint16 *mui_dll;
2027	uint32 ressource_id;
2028	[string,charset(UTF16)] uint16 *display_name;
2029	uint32 lang_id;
2030	} spoolss_AddFormInfo2;
2031
2032	typedef [switch_type(uint32)] union {
2033	[case(1)] spoolss_AddFormInfo1 *info1;
2034	[case(2)] spoolss_AddFormInfo2 *info2;
2035	} spoolss_AddFormInfo;
2036
2037	WERROR spoolss_AddForm(
2038	[in,ref] policy_handle *handle,
2039	[in] uint32 level,
2040	[in,switch_is(level)] spoolss_AddFormInfo info
2041	);
2042
2043	/******************/
2044	/* Function: 0x1f */
2045	WERROR spoolss_DeleteForm(
2046	[in,ref] policy_handle *handle,
2047	[in] [string,charset(UTF16)] uint16 form_name[]
2048	);
2049
2050	/******************/
2051	/* Function: 0x20 */
2052	WERROR spoolss_GetForm(
2053	[in,ref] policy_handle *handle,
2054	[in] [string,charset(UTF16)] uint16 form_name[],
2055	[in] uint32 level,
2056	[in,unique] DATA_BLOB *buffer,
2057	[in] uint32 offered,
2058	[out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_FormInfo *info,
2059	[out,ref] uint32 *needed
2060	);
2061
2062	/******************/
2063	/* Function: 0x21 */
2064	WERROR spoolss_SetForm(
2065	[in,ref] policy_handle *handle,
2066	[in] [string,charset(UTF16)] uint16 form_name[],
2067	[in] uint32 level,
2068	[in,switch_is(level)] spoolss_AddFormInfo info
2069	);
2070
2071	/******************/
2072	/* Function: 0x22 */
2073	[public,noopnum,noprint] WERROR _spoolss_EnumForms(
2074	[in,ref] policy_handle *handle,
2075	[in] uint32 level,
2076	[in,unique] DATA_BLOB *buffer,
2077	[in] uint32 offered,
2078	[out,unique] DATA_BLOB *info,
2079	[out,ref] uint32 *needed,
2080	[out,ref] uint32 *count
2081	);
2082	[public,noopnum,noprint] void __spoolss_EnumForms(
2083	[in] uint32 level,
2084	[in] uint32 count,
2085	[out,switch_is(level)] spoolss_FormInfo info[count]
2086	);
2087	[nopull,nopush] WERROR spoolss_EnumForms(
2088	[in,ref] policy_handle *handle,
2089	[in] uint32 level,
2090	[in,unique] DATA_BLOB *buffer,
2091	[in] uint32 offered,
2092	[out,ref] uint32 *count,
2093	[out,ref,switch_is(level),size_is(,count)] spoolss_FormInfo *info,
2094	[out,ref] uint32 *needed
2095	);
2096
2097	/*
2098	* Special strings for the OpenPrinter() call. See the MSDN DDK
2099	* docs on the XcvDataPort() for more details.
2100	*/
2101
2102	const string SPL_LOCAL_PORT = "Local Port";
2103	const string SPL_TCPIP_PORT = "Standard TCP/IP Port";
2104	const string SPL_XCV_MONITOR_LOCALMON = ",XcvMonitor Local Port";
2105	const string SPL_XCV_MONITOR_TCPMON = ",XcvMonitor Standard TCP/IP Port";
2106
2107	typedef [public,gensize] struct {
2108	[relative] nstring *port_name;
2109	} spoolss_PortInfo1;
2110
2111	typedef bitmap {
2112	SPOOLSS_PORT_TYPE_WRITE = 0x00000001,
2113	SPOOLSS_PORT_TYPE_READ = 0x00000002,
2114	SPOOLSS_PORT_TYPE_REDIRECTED = 0x00000004,
2115	SPOOLSS_PORT_TYPE_NET_ATTACHED = 0x00000008
2116	} spoolss_PortType;
2117
2118	typedef [public,gensize] struct {
2119	[relative] nstring *port_name;
2120	[relative] nstring *monitor_name;
2121	[relative] nstring *description;
2122	spoolss_PortType port_type;
2123	uint32 reserved;
2124	} spoolss_PortInfo2;
2125
2126	typedef [v1_enum] enum {
2127	PORT_STATUS_CLEAR = 0x00000000,
2128	PORT_STATUS_OFFLINE = 0x00000001,
2129	PORT_STATUS_PAPER_JAM = 0x00000002,
2130	PORT_STATUS_PAPER_OUT = 0x00000003,
2131	PORT_STATUS_OUTPUT_BIN_FULL = 0x00000004,
2132	PORT_STATUS_PAPER_PROBLEM = 0x00000005,
2133	PORT_STATUS_NO_TONER = 0x00000006,
2134	PORT_STATUS_DOOR_OPEN = 0x00000007,
2135	PORT_STATUS_USER_INTERVENTION = 0x00000008,
2136	PORT_STATUS_OUT_OF_MEMORY = 0x00000009,
2137	PORT_STATUS_TONER_LOW = 0x0000000A,
2138	PORT_STATUS_WARMING_UP = 0x0000000B,
2139	PORT_STATUS_POWER_SAVE = 0x0000000C
2140	} spoolss_PortStatus;
2141
2142	typedef [v1_enum] enum {
2143	PORT_STATUS_TYPE_ERROR = 0x00000001,
2144	PORT_STATUS_TYPE_WARNING = 0x00000002,
2145	PORT_STATUS_TYPE_INFO = 0x00000003
2146	} spoolss_PortSeverity;
2147
2148	typedef [public,gensize] struct {
2149	spoolss_PortStatus status;
2150	[relative] nstring *status_string;
2151	spoolss_PortSeverity severity;
2152	} spoolss_PortInfo3;
2153
2154	typedef [public,gensize] struct {
2155	[relative] nstring *port_name;
2156	DATA_BLOB monitor_data; /* relative ?? */
2157	} spoolss_PortInfoFF;
2158
2159	typedef [nodiscriminant,relative_base,public,flag(NDR_RELATIVE_REVERSE)] union {
2160	[case(1)] spoolss_PortInfo1 info1;
2161	[case(2)] spoolss_PortInfo2 info2;
2162	[case(3)] spoolss_PortInfo3 info3;
2163	[case(0xff)] spoolss_PortInfoFF infoFF;
2164	[default];
2165	} spoolss_PortInfo;
2166
2167	/******************/
2168	/* Function: 0x23 */
2169	[public,noopnum,noprint] WERROR _spoolss_EnumPorts(
2170	[in,unique] [string,charset(UTF16)] uint16 *servername,
2171	[in] uint32 level,
2172	[in,unique] DATA_BLOB *buffer,
2173	[in] uint32 offered,
2174	[out,unique] DATA_BLOB *info,
2175	[out,ref] uint32 *needed,
2176	[out,ref] uint32 *count
2177	);
2178	[public,noopnum,noprint] void __spoolss_EnumPorts(
2179	[in] uint32 level,
2180	[in] uint32 count,
2181	[out,switch_is(level)] spoolss_PortInfo info[count]
2182	);
2183	[nopull,nopush] WERROR spoolss_EnumPorts(
2184	[in,unique] [string,charset(UTF16)] uint16 *servername,
2185	[in] uint32 level,
2186	[in,unique] DATA_BLOB *buffer,
2187	[in] uint32 offered,
2188	[out,ref] uint32 *count,
2189	[out,ref,switch_is(level),size_is(,count)] spoolss_PortInfo *info,
2190	[out,ref] uint32 *needed
2191	);
2192
2193	/******************/
2194	/* Function: 0x24 */
2195	typedef [public,gensize] struct {
2196	[relative] nstring *monitor_name;
2197	} spoolss_MonitorInfo1;
2198
2199	typedef [public,gensize] struct {
2200	[relative] nstring *monitor_name;
2201	[relative] nstring *environment;
2202	[relative] nstring *dll_name;
2203	} spoolss_MonitorInfo2;
2204
2205	typedef [nodiscriminant,relative_base,public,flag(NDR_RELATIVE_REVERSE)] union {
2206	[case(1)] spoolss_MonitorInfo1 info1;
2207	[case(2)] spoolss_MonitorInfo2 info2;
2208	[default];
2209	} spoolss_MonitorInfo;
2210
2211	[public,noopnum,noprint] WERROR _spoolss_EnumMonitors(
2212	[in,unique] [string,charset(UTF16)] uint16 *servername,
2213	[in] uint32 level,
2214	[in,unique] DATA_BLOB *buffer,
2215	[in] uint32 offered,
2216	[out,unique] DATA_BLOB *info,
2217	[out,ref] uint32 *needed,
2218	[out,ref] uint32 *count
2219	);
2220	[public,noopnum,noprint] void __spoolss_EnumMonitors(
2221	[in] uint32 level,
2222	[in] uint32 count,
2223	[out,switch_is(level)] spoolss_MonitorInfo info[count]
2224	);
2225	[nopull,nopush] WERROR spoolss_EnumMonitors(
2226	[in,unique] [string,charset(UTF16)] uint16 *servername,
2227	[in] uint32 level,
2228	[in,unique] DATA_BLOB *buffer,
2229	[in] uint32 offered,
2230	[out,ref] uint32 *count,
2231	[out,ref,switch_is(level),size_is(,count)] spoolss_MonitorInfo *info,
2232	[out,ref] uint32 *needed
2233	);
2234
2235	/******************/
2236	/* Function: 0x25 */
2237
2238	typedef [public,gensize] struct {
2239	[string,charset(UTF16)] uint16 *port_name;
2240	} spoolss_SetPortInfo1;
2241
2242	typedef [public,gensize] struct {
2243	[string,charset(UTF16)] uint16 *port_name;
2244	[string,charset(UTF16)] uint16 *monitor_name;
2245	[string,charset(UTF16)] uint16 *description;
2246	spoolss_PortType port_type;
2247	uint32 reserved;
2248	} spoolss_SetPortInfo2;
2249
2250	typedef [public,gensize] struct {
2251	spoolss_PortStatus status;
2252	[string,charset(UTF16)] uint16 *status_string;
2253	spoolss_PortSeverity severity;
2254	} spoolss_SetPortInfo3;
2255
2256	typedef [public,gensize] struct {
2257	[string,charset(UTF16)] uint16 *port_name;
2258	DATA_BLOB monitor_data; /* relative ?? */
2259	} spoolss_SetPortInfoFF;
2260
2261	typedef [switch_type(uint32)] union {
2262	[case(1)] spoolss_SetPortInfo1 *info1;
2263	[case(2)] spoolss_SetPortInfo2 *info2;
2264	[case(3)] spoolss_SetPortInfo3 *info3;
2265	[case(0xff)] spoolss_SetPortInfoFF *infoFF;
2266	} spoolss_SetPortInfo;
2267
2268	typedef struct {
2269	uint32 level;
2270	[switch_is(level)] spoolss_SetPrinterInfo info;
2271	} spoolss_SetPortInfoContainer;
2272
2273	WERROR spoolss_AddPort(
2274	[in,unique] [string,charset(UTF16)] uint16 *server_name,
2275	[in] uint32 unknown,
2276	[in] [string,charset(UTF16)] uint16 monitor_name[]
2277	);
2278
2279	/******************/
2280	/* Function: 0x26 */
2281	[todo] WERROR spoolss_ConfigurePort(
2282	);
2283
2284	/******************/
2285	/* Function: 0x27 */
2286	WERROR spoolss_DeletePort(
2287	[in,unique] [string,charset(UTF16)] uint16 *server_name,
2288	[in] uint32 ptr,
2289	[in,ref] [string,charset(UTF16)] uint16 *port_name
2290	);
2291
2292	/******************/
2293	/* Function: 0x28 */
2294	WERROR spoolss_CreatePrinterIC(
2295	[in,ref] policy_handle *handle,
2296	[out,ref] policy_handle *gdi_handle,
2297	[in,ref] spoolss_DevmodeContainer *devmode_ctr
2298	);
2299
2300	/******************/
2301	/* Function: 0x29 */
2302	[todo] WERROR spoolss_PlayGDIScriptOnPrinterIC(
2303	);
2304
2305	/******************/
2306	/* Function: 0x2a */
2307	WERROR spoolss_DeletePrinterIC(
2308	[in,out,ref] policy_handle *gdi_handle
2309	);
2310
2311	/******************/
2312	/* Function: 0x2b */
2313	[todo] WERROR spoolss_AddPrinterConnection(
2314	);
2315
2316	/******************/
2317	/* Function: 0x2c */
2318	[todo] WERROR spoolss_DeletePrinterConnection(
2319	);
2320
2321	/******************/
2322	/* Function: 0x2d */
2323	[todo] WERROR spoolss_PrinterMessageBox(
2324	/* Marked as obsolete in MSDN. "Not necessary and has
2325	no effect". */
2326	);
2327
2328	/******************/
2329	/* Function: 0x2e */
2330	[todo] WERROR spoolss_AddMonitor(
2331	);
2332
2333	/******************/
2334	/* Function: 0x2f */
2335	[todo] WERROR spoolss_DeleteMonitor(
2336	);
2337
2338	/******************/
2339	/* Function: 0x30 */
2340	[todo] WERROR spoolss_DeletePrintProcessor(
2341	);
2342
2343	/******************/
2344	/* Function: 0x31 */
2345	[todo] WERROR spoolss_AddPrintProvidor(
2346	);
2347
2348	/******************/
2349	/* Function: 0x32 */
2350	[todo] WERROR spoolss_DeletePrintProvidor(
2351	);
2352
2353	/******************/
2354	/* Function: 0x33 */
2355
2356	typedef [public,gensize] struct {
2357	[relative] nstring *name_array;
2358	} spoolss_PrintProcDataTypesInfo1;
2359
2360	typedef [nodiscriminant,relative_base,public,flag(NDR_RELATIVE_REVERSE)] union {
2361	[case(1)] spoolss_PrintProcDataTypesInfo1 info1;
2362	[default];
2363	} spoolss_PrintProcDataTypesInfo;
2364
2365	[public,noopnum,noprint] WERROR _spoolss_EnumPrintProcDataTypes(
2366	[in,unique] [string,charset(UTF16)] uint16 *servername,
2367	[in,unique] [string,charset(UTF16)] uint16 *print_processor_name,
2368	[in] uint32 level,
2369	[in,unique] DATA_BLOB *buffer,
2370	[in] uint32 offered,
2371	[out,unique] DATA_BLOB *info,
2372	[out,ref] uint32 *needed,
2373	[out,ref] uint32 *count
2374	);
2375	[public,noopnum,noprint] void __spoolss_EnumPrintProcDataTypes(
2376	[in] uint32 level,
2377	[in] uint32 count,
2378	[out,switch_is(level)] spoolss_PrintProcDataTypesInfo info[count]
2379	);
2380	[nopull,nopush] WERROR spoolss_EnumPrintProcDataTypes(
2381	[in,unique] [string,charset(UTF16)] uint16 *servername,
2382	[in,unique] [string,charset(UTF16)] uint16 *print_processor_name,
2383	[in] uint32 level,
2384	[in,unique] DATA_BLOB *buffer,
2385	[in] uint32 offered,
2386	[out,ref] uint32 *count,
2387	[out,ref,switch_is(level),size_is(,count)] spoolss_PrintProcDataTypesInfo *info,
2388	[out,ref] uint32 *needed
2389	);
2390
2391	/******************/
2392	/* Function: 0x34 */
2393	WERROR spoolss_ResetPrinter(
2394	[in,ref] policy_handle *handle,
2395	[in,unique] [string,charset(UTF16)] uint16 *data_type,
2396	[in,ref] spoolss_DevmodeContainer *devmode_ctr
2397	);
2398
2399	/******************/
2400	/* Function: 0x35 */
2401	[public] WERROR spoolss_GetPrinterDriver2(
2402	[in,ref] policy_handle *handle,
2403	[in,unique] [string,charset(UTF16)] uint16 *architecture,
2404	[in] uint32 level,
2405	[in,unique] DATA_BLOB *buffer,
2406	[in] uint32 offered,
2407	[in] uint32 client_major_version,
2408	[in] uint32 client_minor_version,
2409	[out,unique,subcontext(4),subcontext_size(offered),switch_is(level)] spoolss_DriverInfo *info,
2410	[out,ref] uint32 *needed,
2411	[out,ref] uint32 *server_major_version,
2412	[out,ref] uint32 *server_minor_version
2413	);
2414
2415	/******************/
2416	/* Function: 0x36 */
2417	[todo] WERROR spoolss_FindFirstPrinterChangeNotification(
2418	);
2419
2420	/******************/
2421	/* Function: 0x37 */
2422	[todo] WERROR spoolss_FindNextPrinterChangeNotification(
2423	);
2424
2425	/******************/
2426	/* Function: 0x38 */
2427	[public] WERROR spoolss_FindClosePrinterNotify(
2428	[in,ref] policy_handle *handle
2429	);
2430
2431	/******************/
2432	/* Function: 0x39 */
2433	[todo] WERROR spoolss_RouterFindFirstPrinterChangeNotificationOld(
2434	);
2435
2436	/******************/
2437	/* Function: 0x3a */
2438	[public] WERROR spoolss_ReplyOpenPrinter(
2439	[in,string,charset(UTF16)] uint16 server_name[],
2440	[in] uint32 printer_local,
2441	[in] winreg_Type type,
2442	[in,range(0,512)] uint32 bufsize,
2443	[in,unique,size_is(bufsize)] uint8 *buffer,
2444	[out,ref] policy_handle *handle
2445	);
2446
2447	/******************/
2448	/* Function: 0x3b */
2449
2450	typedef [bitmap32bit] bitmap {
2451	PRINTER_CHANGE_ADD_PRINTER = 0x00000001,
2452	PRINTER_CHANGE_SET_PRINTER = 0x00000002,
2453	PRINTER_CHANGE_DELETE_PRINTER = 0x00000004,
2454	PRINTER_CHANGE_FAILED_CONNECTION_PRINTER = 0x00000008,
2455	PRINTER_CHANGE_ADD_JOB = 0x00000100,
2456	PRINTER_CHANGE_SET_JOB = 0x00000200,
2457	PRINTER_CHANGE_DELETE_JOB = 0x00000400,
2458	PRINTER_CHANGE_WRITE_JOB = 0x00000800,
2459	PRINTER_CHANGE_ADD_FORM = 0x00010000,
2460	PRINTER_CHANGE_SET_FORM = 0x00020000,
2461	PRINTER_CHANGE_DELETE_FORM = 0x00040000,
2462	PRINTER_CHANGE_ADD_PORT = 0x00100000,
2463	PRINTER_CHANGE_CONFIGURE_PORT = 0x00200000,
2464	PRINTER_CHANGE_DELETE_PORT = 0x00400000,
2465	PRINTER_CHANGE_ADD_PRINT_PROCESSOR = 0x01000000,
2466	PRINTER_CHANGE_DELETE_PRINT_PROCESSOR = 0x04000000,
2467	PRINTER_CHANGE_SERVER = 0x08000000,
2468	PRINTER_CHANGE_ADD_PRINTER_DRIVER = 0x10000000,
2469	PRINTER_CHANGE_SET_PRINTER_DRIVER = 0x20000000,
2470	PRINTER_CHANGE_DELETE_PRINTER_DRIVER = 0x40000000,
2471	PRINTER_CHANGE_TIMEOUT = 0x80000000
2472	} spoolss_PrinterChangeFlags;
2473
2474	const int PRINTER_CHANGE_PRINTER = 0x000000FF;
2475
2476	const int PRINTER_CHANGE_JOB = 0x0000FF00;
2477
2478	const int PRINTER_CHANGE_FORM = (PRINTER_CHANGE_ADD_FORM \|
2479	PRINTER_CHANGE_SET_FORM \|
2480	PRINTER_CHANGE_DELETE_FORM); /* 0x00070000 */
2481
2482	const int PRINTER_CHANGE_PORT = (PRINTER_CHANGE_ADD_PORT \|
2483	PRINTER_CHANGE_CONFIGURE_PORT \|
2484	PRINTER_CHANGE_DELETE_PORT); /* 0x00700000 */
2485
2486	const int PRINTER_CHANGE_PRINT_PROCESSOR = 0x07000000;
2487
2488	const int PRINTER_CHANGE_PRINTER_DRIVER = (PRINTER_CHANGE_ADD_PRINTER_DRIVER \|
2489	PRINTER_CHANGE_SET_PRINTER_DRIVER \|
2490	PRINTER_CHANGE_DELETE_PRINTER_DRIVER); /* 0x70000000 */
2491
2492	const int PRINTER_CHANGE_ALL = (PRINTER_CHANGE_PRINTER \|
2493	PRINTER_CHANGE_JOB \|
2494	PRINTER_CHANGE_FORM \|
2495	PRINTER_CHANGE_PORT \|
2496	PRINTER_CHANGE_PRINT_PROCESSOR \|
2497	PRINTER_CHANGE_PRINTER_DRIVER); /* 0x7777FFFF */
2498	WERROR spoolss_RouterReplyPrinter(
2499	[in,ref] policy_handle *handle,
2500	[in] spoolss_PrinterChangeFlags flags,
2501	[in,range(0,512)] uint32 bufsize,
2502	[in,unique,size_is(bufsize)] uint8 *buffer
2503	);
2504
2505	/******************/
2506	/* Function: 0x3c */
2507	[public] WERROR spoolss_ReplyClosePrinter(
2508	[in,out,ref] policy_handle *handle
2509	);
2510
2511	/******************/
2512	/* Function: 0x3d */
2513
2514	typedef struct {
2515	uint32 monitor_data_size;
2516	[size_is(monitor_data_size),unique] uint8 *monitor_data;
2517	} spoolss_PortVarContainer;
2518
2519	WERROR spoolss_AddPortEx(
2520	[in,unique] [string,charset(UTF16)] uint16 *servername,
2521	[in,ref] spoolss_SetPortInfoContainer *port_ctr,
2522	[in,ref] spoolss_PortVarContainer *port_var_ctr,
2523	[in,unique] [string,charset(UTF16)] uint16 *monitor_name
2524	);
2525
2526	/******************/
2527	/* Function: 0x3e */
2528	[todo] WERROR spoolss_RouterFindFirstPrinterChangeNotification(
2529	);
2530
2531	/******************/
2532	/* Function: 0x3f */
2533	[todo] WERROR spoolss_SpoolerInit(
2534	);
2535
2536	/******************/
2537	/* Function: 0x40 */
2538	[todo] WERROR spoolss_ResetPrinterEx(
2539	);
2540
2541	typedef [enum16bit,public] enum {
2542	JOB_NOTIFY_FIELD_PRINTER_NAME = 0x00,
2543	JOB_NOTIFY_FIELD_MACHINE_NAME = 0x01,
2544	JOB_NOTIFY_FIELD_PORT_NAME = 0x02,
2545	JOB_NOTIFY_FIELD_USER_NAME = 0x03,
2546	JOB_NOTIFY_FIELD_NOTIFY_NAME = 0x04,
2547	JOB_NOTIFY_FIELD_DATATYPE = 0x05,
2548	JOB_NOTIFY_FIELD_PRINT_PROCESSOR = 0x06,
2549	JOB_NOTIFY_FIELD_PARAMETERS = 0x07,
2550	JOB_NOTIFY_FIELD_DRIVER_NAME = 0x08,
2551	JOB_NOTIFY_FIELD_DEVMODE = 0x09,
2552	JOB_NOTIFY_FIELD_STATUS = 0x0a,
2553	JOB_NOTIFY_FIELD_STATUS_STRING = 0x0b,
2554	JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR = 0x0c,
2555	JOB_NOTIFY_FIELD_DOCUMENT = 0x0d,
2556	JOB_NOTIFY_FIELD_PRIORITY = 0x0e,
2557	JOB_NOTIFY_FIELD_POSITION = 0x0f,
2558	JOB_NOTIFY_FIELD_SUBMITTED = 0x10,
2559	JOB_NOTIFY_FIELD_START_TIME = 0x11,
2560	JOB_NOTIFY_FIELD_UNTIL_TIME = 0x12,
2561	JOB_NOTIFY_FIELD_TIME = 0x13,
2562	JOB_NOTIFY_FIELD_TOTAL_PAGES = 0x14,
2563	JOB_NOTIFY_FIELD_PAGES_PRINTED = 0x15,
2564	JOB_NOTIFY_FIELD_TOTAL_BYTES = 0x16,
2565	JOB_NOTIFY_FIELD_BYTES_PRINTED = 0x17
2566	} spoolss_JobNotifyField;
2567
2568	typedef [enum16bit,public] enum {
2569	PRINTER_NOTIFY_FIELD_SERVER_NAME = 0x00,
2570	PRINTER_NOTIFY_FIELD_PRINTER_NAME = 0x01,
2571	PRINTER_NOTIFY_FIELD_SHARE_NAME = 0x02,
2572	PRINTER_NOTIFY_FIELD_PORT_NAME = 0x03,
2573	PRINTER_NOTIFY_FIELD_DRIVER_NAME = 0x04,
2574	PRINTER_NOTIFY_FIELD_COMMENT = 0x05,
2575	PRINTER_NOTIFY_FIELD_LOCATION = 0x06,
2576	PRINTER_NOTIFY_FIELD_DEVMODE = 0x07,
2577	PRINTER_NOTIFY_FIELD_SEPFILE = 0x08,
2578	PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR = 0x09,
2579	PRINTER_NOTIFY_FIELD_PARAMETERS = 0x0a,
2580	PRINTER_NOTIFY_FIELD_DATATYPE = 0x0b,
2581	PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR = 0x0c,
2582	PRINTER_NOTIFY_FIELD_ATTRIBUTES = 0x0d,
2583	PRINTER_NOTIFY_FIELD_PRIORITY = 0x0e,
2584	PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY = 0x0f,
2585	PRINTER_NOTIFY_FIELD_START_TIME = 0x10,
2586	PRINTER_NOTIFY_FIELD_UNTIL_TIME = 0x11,
2587	PRINTER_NOTIFY_FIELD_STATUS = 0x12,
2588	PRINTER_NOTIFY_FIELD_STATUS_STRING = 0x13,
2589	PRINTER_NOTIFY_FIELD_CJOBS = 0x14,
2590	PRINTER_NOTIFY_FIELD_AVERAGE_PPM = 0x15,
2591	PRINTER_NOTIFY_FIELD_TOTAL_PAGES = 0x16,
2592	PRINTER_NOTIFY_FIELD_PAGES_PRINTED = 0x17,
2593	PRINTER_NOTIFY_FIELD_TOTAL_BYTES = 0x18,
2594	PRINTER_NOTIFY_FIELD_BYTES_PRINTED = 0x19,
2595	PRINTER_NOTIFY_FIELD_OBJECT_GUID = 0x1a,
2596	PRINTER_NOTIFY_FIELD_FRIENDLY_NAME = 0x1b
2597	} spoolss_PrintNotifyField;
2598
2599	typedef [enum16bit] enum {
2600	PRINTER_NOTIFY_TYPE = 0x00,
2601	JOB_NOTIFY_TYPE = 0x01
2602	} spoolss_NotifyType;
2603
2604	typedef [nodiscriminant,noprint] union {
2605	[case(PRINTER_NOTIFY_TYPE)] uint16 field;
2606	[case(JOB_NOTIFY_TYPE)] uint16 field;
2607	[default] uint16 field;
2608	} spoolss_Field;
2609
2610	/******************/
2611	/* Function: 0x41 */
2612	typedef struct {
2613	spoolss_NotifyType type;
2614	uint16 u1;
2615	uint32 u2;
2616	uint32 u3;
2617	uint32 count;
2618	[size_is(count),switch_is(type)] spoolss_Field *fields;
2619	} spoolss_NotifyOptionType;
2620
2621	typedef [bitmap32bit] bitmap {
2622	PRINTER_NOTIFY_OPTIONS_REFRESH = 0x00000001
2623	} spoolssNotifyOptionFlags;
2624
2625	typedef struct {
2626	[value(2)] uint32 version;
2627	spoolssNotifyOptionFlags flags;
2628	uint32 count;
2629	[size_is(count)] spoolss_NotifyOptionType *types;
2630	} spoolss_NotifyOption;
2631
2632	[public] WERROR spoolss_RemoteFindFirstPrinterChangeNotifyEx(
2633	[in,ref] policy_handle *handle,
2634	[in] spoolss_PrinterChangeFlags flags,
2635	[in] uint32 options,
2636	[in,unique] [string,charset(UTF16)] uint16 *local_machine,
2637	[in] uint32 printer_local,
2638	[in,unique] spoolss_NotifyOption *notify_options
2639	);
2640
2641	/******************/
2642	/* Function: 0x42 */
2643
2644	typedef struct {
2645	uint32 size;
2646	[size_is(size/2),unique,charset(UTF16)] uint16 *string;
2647	} spoolss_NotifyString;
2648
2649	typedef [v1_enum] enum {
2650	NOTIFY_TABLE_DWORD = 0x0001,
2651	NOTIFY_TABLE_STRING = 0x0002,
2652	NOTIFY_TABLE_DEVMODE = 0x0003,
2653	NOTIFY_TABLE_TIME = 0x0004,
2654	NOTIFY_TABLE_SECURITYDESCRIPTOR = 0x0005
2655	} spoolss_NotifyTable;
2656
2657	typedef [switch_type(uint32)] union {
2658	[case(1)] uint32 integer[2];
2659	[case(2)] spoolss_NotifyString string;
2660	[case(3)] spoolss_DevmodeContainer devmode;
2661	[case(4)] spoolss_TimeCtr time;
2662	[case(5)] sec_desc_buf sd;
2663	} spoolss_NotifyData;
2664
2665	typedef struct {
2666	spoolss_NotifyType type;
2667	[switch_is(type)] spoolss_Field field;
2668	spoolss_NotifyTable variable_type;
2669	uint32 job_id;
2670	[switch_is(variable_type)] spoolss_NotifyData data;
2671	} spoolss_Notify;
2672
2673	typedef struct {
2674	[value(2)] uint32 version;
2675	uint32 flags;
2676	uint32 count;
2677	[size_is(count)] spoolss_Notify notifies[];
2678	} spoolss_NotifyInfo;
2679
2680	typedef [switch_type(uint32)] union {
2681	[case(0)] spoolss_NotifyInfo *info0;
2682	} spoolss_ReplyPrinterInfo;
2683
2684	typedef [bitmap32bit] bitmap {
2685	PRINTER_NOTIFY_INFO_DISCARDED = 0x00000001,
2686	PRINTER_NOTIFY_INFO_DISCARDNOTED = 0x00010000,
2687	PRINTER_NOTIFY_INFO_COLOR_MISMATCH = 0x00080000
2688	} spoolss_PrinterNotifyFlags;
2689
2690	WERROR spoolss_RouterReplyPrinterEx(
2691	[in,ref] policy_handle *handle,
2692	[in] uint32 color,
2693	[in] spoolss_PrinterChangeFlags flags,
2694	[out,ref] spoolss_PrinterNotifyFlags *reply_result,
2695	[in] uint32 reply_type,
2696	[in,switch_is(reply_type)] spoolss_ReplyPrinterInfo info
2697	);
2698
2699	/******************/
2700	/* Function: 0x43 */
2701	[public] WERROR spoolss_RouterRefreshPrinterChangeNotify(
2702	[in,ref] policy_handle *handle,
2703	[in] uint32 change_low,
2704	[in,unique] spoolss_NotifyOption *options,
2705	[out,ref] spoolss_NotifyInfo **info
2706	);
2707
2708	/******************/
2709	/* Function: 0x44 */
2710	[todo] WERROR spoolss_44(
2711	);
2712
2713	typedef struct {
2714	uint32 size;
2715	[string,charset(UTF16)] uint16 *client;
2716	[string,charset(UTF16)] uint16 *user;
2717	uint32 build;
2718	spoolss_MajorVersion major;
2719	spoolss_MinorVersion minor;
2720	spoolss_ProcessorArchitecture processor;
2721	} spoolss_UserLevel1;
2722
2723	typedef struct {
2724	uint32 not_used;
2725	} spoolss_UserLevel2;
2726
2727	typedef struct {
2728	uint32 size;
2729	uint32 flags;
2730	uint32 size2;
2731	[string,charset(UTF16)] uint16 *client;
2732	[string,charset(UTF16)] uint16 *user;
2733	uint32 build;
2734	spoolss_MajorVersion major;
2735	spoolss_MinorVersion minor;
2736	spoolss_ProcessorArchitecture processor;
2737	udlong reserved;
2738	} spoolss_UserLevel3;
2739
2740	typedef [switch_type(uint32)] union {
2741	[case(1)] spoolss_UserLevel1 *level1;
2742	[case(2)] spoolss_UserLevel2 *level2;
2743	[case(3)] spoolss_UserLevel3 *level3;
2744	} spoolss_UserLevel;
2745
2746	typedef struct {
2747	uint32 level;
2748	[switch_is(level)] spoolss_UserLevel user_info;
2749	} spoolss_UserLevelCtr;
2750
2751	typedef bitmap {
2752	SERVER_ACCESS_ADMINISTER = 0x00000001,
2753	SERVER_ACCESS_ENUMERATE = 0x00000002,
2754	PRINTER_ACCESS_ADMINISTER = 0x00000004,
2755	PRINTER_ACCESS_USE = 0x00000008,
2756	JOB_ACCESS_ADMINISTER = 0x00000010,
2757	JOB_ACCESS_READ = 0x00000020
2758	} spoolss_AccessRights;
2759
2760	/* Access rights for print servers */
2761	const int SERVER_ALL_ACCESS = SEC_STD_REQUIRED \|
2762	SERVER_ACCESS_ADMINISTER \|
2763	SERVER_ACCESS_ENUMERATE;
2764
2765	const int SERVER_READ = SEC_STD_READ_CONTROL \|
2766	SERVER_ACCESS_ENUMERATE;
2767
2768	const int SERVER_WRITE = STANDARD_RIGHTS_WRITE_ACCESS \|
2769	SERVER_ACCESS_ADMINISTER \|
2770	SERVER_ACCESS_ENUMERATE;
2771
2772	const int SERVER_EXECUTE = SEC_STD_READ_CONTROL \|
2773	SERVER_ACCESS_ENUMERATE;
2774
2775	/* Access rights for printers */
2776	const int PRINTER_ALL_ACCESS = SEC_STD_REQUIRED \|
2777	PRINTER_ACCESS_ADMINISTER \|
2778	PRINTER_ACCESS_USE;
2779
2780	const int PRINTER_READ = SEC_STD_READ_CONTROL \|
2781	PRINTER_ACCESS_USE;
2782
2783	const int PRINTER_WRITE = STANDARD_RIGHTS_WRITE_ACCESS \|
2784	PRINTER_ACCESS_USE;
2785
2786	const int PRINTER_EXECUTE = SEC_STD_READ_CONTROL \|
2787	PRINTER_ACCESS_USE;
2788
2789	/* Access rights for jobs */
2790	const int JOB_ALL_ACCESS = SEC_STD_REQUIRED \|
2791	JOB_ACCESS_ADMINISTER;
2792
2793	const int JOB_READ = SEC_STD_READ_CONTROL \|
2794	JOB_ACCESS_ADMINISTER;
2795
2796	const int JOB_WRITE = STANDARD_RIGHTS_WRITE_ACCESS \|
2797	JOB_ACCESS_ADMINISTER;
2798
2799	const int JOB_EXECUTE = SEC_STD_READ_CONTROL \|
2800	JOB_ACCESS_ADMINISTER;
2801
2802	/* ACE masks for various print permissions */
2803	const int PRINTER_ACE_FULL_CONTROL = SEC_GENERIC_ALL \|
2804	PRINTER_ALL_ACCESS;
2805
2806	const int PRINTER_ACE_MANAGE_DOCUMENTS = SEC_GENERIC_ALL \|
2807	READ_CONTROL_ACCESS;
2808
2809	const int PRINTER_ACE_PRINT = GENERIC_EXECUTE_ACCESS \|
2810	READ_CONTROL_ACCESS \|
2811	PRINTER_ACCESS_USE;
2812
2813	/******************/
2814	/* Function: 0x45 */
2815	[public] WERROR spoolss_OpenPrinterEx(
2816	[in,unique] [string,charset(UTF16)] uint16 *printername,
2817	[in,unique] [string,charset(UTF16)] uint16 *datatype,
2818	[in] spoolss_DevmodeContainer devmode_ctr,
2819	[in] spoolss_AccessRights access_mask,
2820	[in] uint32 level,
2821	[in,switch_is(level)] spoolss_UserLevel userlevel,
2822	[out,ref] policy_handle *handle
2823	);
2824
2825	/******************/
2826	/* Function: 0x46 */
2827	WERROR spoolss_AddPrinterEx(
2828	[in,unique] [string,charset(UTF16)] uint16 *server,
2829	[in,ref] spoolss_SetPrinterInfoCtr *info_ctr,
2830	[in,ref] spoolss_DevmodeContainer *devmode_ctr,
2831	[in,ref] sec_desc_buf *secdesc_ctr,
2832	[in,ref] spoolss_UserLevelCtr *userlevel_ctr,
2833	[out,ref] policy_handle *handle
2834	);
2835
2836	/******************/
2837	/* Function: 0x47 */
2838	WERROR spoolss_SetPort(
2839	[in,unique] [string,charset(UTF16)] uint16 *servername,
2840	[in,unique] [string,charset(UTF16)] uint16 *port_name,
2841	[in,ref] spoolss_SetPortInfoContainer *port_ctr
2842	);
2843
2844	/******************/
2845	/* Function: 0x48 */
2846	WERROR spoolss_EnumPrinterData(
2847	[in,ref] policy_handle *handle,
2848	[in] uint32 enum_index,
2849	[out,size_is(value_offered/2),charset(UTF16)] uint16 value_name[],
2850	[in] uint32 value_offered,
2851	[out,ref] uint32 *value_needed,
2852	[out,ref] winreg_Type *type,
2853	[out,ref,size_is(data_offered),flag(LIBNDR_PRINT_ARRAY_HEX)] uint8 *data,
2854	[in] uint32 data_offered,
2855	[out,ref] uint32 *data_needed
2856	);
2857
2858	/******************/
2859	/* Function: 0x49 */
2860	WERROR spoolss_DeletePrinterData(
2861	[in,ref] policy_handle *handle,
2862	[in] [string,charset(UTF16)] uint16 value_name[]
2863	);
2864
2865	/******************/
2866	/* Function: 0x4a */
2867	[todo] WERROR spoolss_4a(
2868	);
2869
2870	/******************/
2871	/* Function: 0x4b */
2872	[todo] WERROR spoolss_4b(
2873	);
2874
2875	/******************/
2876	/* Function: 0x4c */
2877	[todo] WERROR spoolss_4c(
2878	);
2879
2880	/******************/
2881	/* Function: 0x4d */
2882	WERROR spoolss_SetPrinterDataEx(
2883	[in,ref] policy_handle *handle,
2884	[in] [string,charset(UTF16)] uint16 key_name[],
2885	[in] [string,charset(UTF16)] uint16 value_name[],
2886	[in] winreg_Type type,
2887	[in,ref] [size_is(offered)] uint8 *data,
2888	[in] uint32 offered
2889	);
2890
2891	/******************/
2892	/* Function: 0x4e */
2893	WERROR spoolss_GetPrinterDataEx(
2894	[in,ref] policy_handle *handle,
2895	[in] [string,charset(UTF16)] uint16 key_name[],
2896	[in] [string,charset(UTF16)] uint16 value_name[],
2897	[out,ref] winreg_Type *type,
2898	[out,ref,size_is(offered)] uint8 *data,
2899	[in] uint32 offered,
2900	[out,ref] uint32 *needed
2901	);
2902
2903	/******************/
2904	/* Function: 0x4f */
2905
2906	typedef [relative_base,public,gensize] struct {
2907	[relative] nstring *value_name;
2908	[value(2*strlen_m_term(value_name))] uint32 value_name_len;
2909	winreg_Type type;
2910	[relative,subcontext(0),subcontext_size(data_length),flag(NDR_REMAINING\|ndr_spoolss_PrinterEnumValues_align(r->type))] DATA_BLOB *data;
2911	[value(data ? data->length : 0)] uint32 data_length;
2912	} spoolss_PrinterEnumValues;
2913
2914	[public,noopnum,noprint] WERROR _spoolss_EnumPrinterDataEx(
2915	[in,ref] policy_handle *handle,
2916	[in] [string,charset(UTF16)] uint16 key_name[],
2917	[out] DATA_BLOB info,
2918	[in] uint32 offered,
2919	[out,ref] uint32 *needed,
2920	[out,ref] uint32 *count
2921	);
2922	[public,noopnum,noprint] void __spoolss_EnumPrinterDataEx(
2923	[in] uint32 count,
2924	[out] spoolss_PrinterEnumValues info[count]
2925	);
2926	[nopull,nopush] WERROR spoolss_EnumPrinterDataEx(
2927	[in,ref] policy_handle *handle,
2928	[in] [string,charset(UTF16)] uint16 key_name[],
2929	[in] uint32 offered,
2930	[out,ref] uint32 *count,
2931	[out,ref,size_is(,count)] spoolss_PrinterEnumValues *info,
2932	[out,ref] uint32 *needed
2933	);
2934
2935	typedef [nodiscriminant] union {
2936	[case(0)];
2937	[case(1)];
2938	[default] nstring_array string_array;
2939	} spoolss_KeyNames;
2940
2941	/******************/
2942	/* Function: 0x50 */
2943	[public] WERROR spoolss_EnumPrinterKey(
2944	[in, ref] policy_handle *handle,
2945	[in] [string,charset(UTF16)] uint16 key_name[],
2946	[out,ref] uint32 *_ndr_size,
2947	[out,ref,subcontext(0),subcontext_size(_ndr_size2),switch_is(_ndr_size)] spoolss_KeyNames key_buffer,
2948	[in] uint32 offered,
2949	[out,ref] uint32 *needed
2950	);
2951
2952	/******************/
2953	/* Function: 0x51 */
2954	WERROR spoolss_DeletePrinterDataEx(
2955	[in,ref] policy_handle *handle,
2956	[in] [string,charset(UTF16)] uint16 key_name[],
2957	[in] [string,charset(UTF16)] uint16 value_name[]
2958	);
2959
2960	/******************/
2961	/* Function: 0x52 */
2962	WERROR spoolss_DeletePrinterKey(
2963	[in,ref] policy_handle *handle,
2964	[in] [string,charset(UTF16)] uint16 key_name[]
2965	);
2966
2967	/******************/
2968	/* Function: 0x53 */
2969	[todo] WERROR spoolss_53(
2970	);
2971
2972	/******************/
2973	/* Function: 0x54 */
2974	typedef [public,bitmap32bit] bitmap {
2975	DPD_DELETE_UNUSED_FILES = 0x00000001,
2976	DPD_DELETE_SPECIFIC_VERSION = 0x00000002,
2977	DPD_DELETE_ALL_FILES = 0x00000004
2978	} spoolss_DeleteDriverFlags;
2979
2980	WERROR spoolss_DeletePrinterDriverEx(
2981	[in,unique] [string,charset(UTF16)] uint16 *server,
2982	[in] [string,charset(UTF16)] uint16 architecture[],
2983	[in] [string,charset(UTF16)] uint16 driver[],
2984	[in] spoolss_DeleteDriverFlags delete_flags,
2985	[in] uint32 version
2986	);
2987
2988	/******************/
2989	/* Function: 0x55 */
2990	WERROR spoolss_AddPerMachineConnection(
2991	[in,unique] [string,charset(UTF16)] uint16 *server,
2992	[in,ref] [string,charset(UTF16)] uint16 *printername,
2993	[in,ref] [string,charset(UTF16)] uint16 *printserver,
2994	[in,ref] [string,charset(UTF16)] uint16 *provider
2995	);
2996
2997	/******************/
2998	/* Function: 0x56 */
2999	WERROR spoolss_DeletePerMachineConnection(
3000	[in,unique] [string,charset(UTF16)] uint16 *server,
3001	[in,ref] [string,charset(UTF16)] uint16 *printername
3002	);
3003
3004	/******************/
3005	/* Function: 0x57 */
3006	[todo] WERROR spoolss_EnumPerMachineConnections(
3007	);
3008
3009	/******************/
3010	/* Function: 0x58 */
3011
3012	typedef [v1_enum] enum {
3013	PROTOCOL_RAWTCP_TYPE = 1,
3014	PROTOCOL_LPR_TYPE = 2
3015	} spoolss_PortProtocol;
3016
3017	typedef [public] struct {
3018	[charset(UTF16)] uint16 portname[64];
3019	[value(0x00000001)] uint32 version;
3020	spoolss_PortProtocol protocol;
3021	[value(sizeof(r))] uint32 size;
3022	uint32 reserved;
3023	[charset(UTF16)] uint16 hostaddress[49];
3024	[charset(UTF16)] uint16 snmpcommunity[33];
3025	uint32 dblspool;
3026	[charset(UTF16)] uint16 queue[33];
3027	[charset(UTF16)] uint16 ip_address[16]; /* s3 had 17 */
3028	[charset(UTF16)] uint16 hardware_address[13];
3029	[charset(UTF16)] uint16 device_type[257];
3030	uint32 port_number;
3031	boolean32 snmp_enabled;
3032	uint32 snmp_dev_index;
3033	} spoolss_PortData1;
3034
3035	typedef [public] struct {
3036	[charset(UTF16)] uint16 portname[64];
3037	[value(0x00000002)] uint32 version;
3038	spoolss_PortProtocol protocol;
3039	[value(sizeof(r))] uint32 size;
3040	uint32 reserved;
3041	[charset(UTF16)] uint16 hostaddress[128];
3042	[charset(UTF16)] uint16 snmpcommunity[33];
3043	uint32 dblspool;
3044	[charset(UTF16)] uint16 queue[33];
3045	[charset(UTF16)] uint16 device_type[257];
3046	uint32 port_number;
3047	boolean32 snmp_enabled;
3048	uint32 snmp_dev_index;
3049	uint32 port_monitor_mib_index;
3050	} spoolss_PortData2;
3051
3052	typedef [public] struct {
3053	nstring dll_name;
3054	} spoolss_MonitorUi;
3055
3056	WERROR spoolss_XcvData(
3057	[in,ref] policy_handle *handle,
3058	[in] [string,charset(UTF16)] uint16 function_name[],
3059	[in] DATA_BLOB in_data,
3060	[in,value(r->in.in_data.length)] uint32 _in_data_length,
3061	[out,ref] [size_is(out_data_size)] uint8 *out_data,
3062	[in] uint32 out_data_size,
3063	[out,ref] uint32 *needed,
3064	[in,out,ref] uint32 *status_code
3065	);
3066
3067	/******************/
3068	/* Function: 0x59 */
3069
3070	typedef [bitmap32bit] bitmap {
3071	APD_STRICT_UPGRADE = 0x00000001,
3072	APD_STRICT_DOWNGRADE = 0x00000002,
3073	APD_COPY_ALL_FILES = 0x00000004,
3074	APD_COPY_NEW_FILES = 0x00000008,
3075	APD_COPY_FROM_DIRECTORY = 0x00000010,
3076	APD_DONT_COPY_FILES_TO_CLUSTER = 0x00001000,
3077	APD_COPY_TO_ALL_SPOOLERS = 0x00002000,
3078	APD_RETURN_BLOCKING_STATUS_CODE = 0x00010000
3079	} spoolss_AddPrinterDriverExFlags;
3080
3081	[public] WERROR spoolss_AddPrinterDriverEx(
3082	[in,unique] [string,charset(UTF16)] uint16 *servername,
3083	[in,ref] spoolss_AddDriverInfoCtr *info_ctr,
3084	[in] spoolss_AddPrinterDriverExFlags flags
3085	);
3086
3087	/******************/
3088	/* Function: 0x5a */
3089	[todo] WERROR spoolss_5a(
3090	);
3091
3092	/******************/
3093	/* Function: 0x5b */
3094	[todo] WERROR spoolss_5b(
3095	);
3096
3097	/******************/
3098	/* Function: 0x5c */
3099	[todo] WERROR spoolss_5c(
3100	);
3101
3102	/******************/
3103	/* Function: 0x5d */
3104	[todo] WERROR spoolss_5d(
3105	);
3106
3107	/******************/
3108	/* Function: 0x5e */
3109	[todo] WERROR spoolss_5e(
3110	);
3111
3112	/******************/
3113	/* Function: 0x5f */
3114	[todo] WERROR spoolss_5f(
3115	);
3116
3117	/******************/
3118	/* Function: 0x60 */
3119	[todo] WERROR spoolss_60(
3120	);
3121
3122	/******************/
3123	/* Function: 0x61 */
3124	[todo] WERROR spoolss_61(
3125	);
3126
3127	/******************/
3128	/* Function: 0x62 */
3129	[todo] WERROR spoolss_62(
3130	);
3131
3132	/******************/
3133	/* Function: 0x63 */
3134	[todo] WERROR spoolss_63(
3135	);
3136
3137	/******************/
3138	/* Function: 0x64 */
3139	[todo] WERROR spoolss_64(
3140	);
3141
3142	/******************/
3143	/* Function: 0x65 */
3144	[todo] WERROR spoolss_65(
3145	);
3146
3147	/******************/
3148	/* Function: 0x66 */
3149	typedef struct {
3150	GUID core_driver_guid;
3151	NTTIME driver_date;
3152	hyper driver_version;
3153	[charset(UTF8)] uint8 formname[520];
3154	} spoolss_CorePrinterDriver;
3155
3156	WERROR spoolss_GetCorePrinterDrivers(
3157	[in,unique] [string,charset(UTF16)] uint16 *servername,
3158	[in,ref] [string,charset(UTF16)] uint16 *architecture,
3159	[in] uint32 core_driver_size,
3160	[in,size_is(core_driver_size)] [charset(UTF16)] uint16 *core_driver_dependencies,
3161	[in] uint32 core_printer_driver_count,
3162	[out,size_is(core_printer_driver_count)] spoolss_CorePrinterDriver *core_printer_drivers
3163	);
3164
3165	/******************/
3166	/* Function: 0x67 */
3167	[todo] WERROR spoolss_67(
3168	);
3169
3170	/******************/
3171	/* Function: 0x68 */
3172	WERROR spoolss_GetPrinterDriverPackagePath(
3173	[in,unique] [string,charset(UTF16)] uint16 *servername,
3174	[in,ref] [string,charset(UTF16)] uint16 *architecture,
3175	[in,unique] [string,charset(UTF16)] uint16 *language,
3176	[in,ref] [string,charset(UTF16)] uint16 *package_id,
3177	[in,out,unique,size_is(driver_package_cab_size)] [charset(UTF16)] uint16 *driver_package_cab,
3178	[in] uint32 driver_package_cab_size,
3179	[out,ref] uint32 *required
3180	);
3181
3182	/******************/
3183	/* Function: 0x69 */
3184	[todo] WERROR spoolss_69(
3185	);
3186
3187	/******************/
3188	/* Function: 0x6a */
3189	[todo] WERROR spoolss_6a(
3190	);
3191
3192	/******************/
3193	/* Function: 0x6b */
3194	[todo] WERROR spoolss_6b(
3195	);
3196
3197	/******************/
3198	/* Function: 0x6c */
3199	[todo] WERROR spoolss_6c(
3200	);
3201
3202	/******************/
3203	/* Function: 0x6d */
3204	[todo] WERROR spoolss_6d(
3205	);
3206	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/server/librpc/idl/spoolss.idl@ 1043

Download in other formats: