Print this page
1575 untangle libmlrpc from SMB server
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Toomas Soome <tsoome@me.com>
Approved by: Richard Lowe <richlowe@richlowe.net>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/smbsrv/ndl/spoolss.ndl
+++ new/usr/src/uts/common/smbsrv/ndl/spoolss.ndl
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
23 + * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
23 24 */
24 25
25 26 #ifndef _SPOOLSS_NDL_
26 27 #define _SPOOLSS_NDL_
27 28
28 -#include "ndrtypes.ndl"
29 +#include <libmlrpc/ndrtypes.ndl>
29 30 #include "security.ndl"
30 31
31 32 #define TABLE_STRING 1
32 33 #define TABLE_DWORD 2
33 34 #define TABLE_TIME 3
34 35 #define TABLE_DEVMODE 4
35 36 #define TABLE_SECURITY_DESCRIPTOR 5
36 37
37 38 #define SPOOLSS_OPNUM_EnumPrinters 0x00
38 39 #define SPOOLSS_OPNUM_OpenPrinter 0x01
39 40 #define SPOOLSS_OPNUM_GetJob 0x03
40 41 #define SPOOLSS_OPNUM_EnumJobs 0x04
41 42 #define SPOOLSS_OPNUM_DeletePrinter 0x06
42 43 #define SPOOLSS_OPNUM_GetPrinter 0x08
43 44 #define SPOOLSS_OPNUM_GetPrinterDriver 0x0b
44 45 #define SPOOLSS_OPNUM_DeletePrinterDriver 0x0d
45 46 #define SPOOLSS_OPNUM_StartDocPrinter 0x11
46 47 #define SPOOLSS_OPNUM_StartPagePrinter 0x12
47 48 #define SPOOLSS_OPNUM_WritePrinter 0x13
48 49 #define SPOOLSS_OPNUM_EndPagePrinter 0x14
49 50 #define SPOOLSS_OPNUM_AbortPrinter 0x15
50 51 #define SPOOLSS_OPNUM_AddJob 0x18
51 52 #define SPOOLSS_OPNUM_ScheduleJob 0x19
52 53 #define SPOOLSS_OPNUM_GetPrinterData 0x1a
53 54 #define SPOOLSS_OPNUM_ClosePrinter 0x1d
54 55 #define SPOOLSS_OPNUM_AddForm 0x1e
55 56 #define SPOOLSS_OPNUM_DeleteForm 0x1f
56 57 #define SPOOLSS_OPNUM_EndDocPrinter 0x17
57 58 #define SPOOLSS_OPNUM_EnumForms 0x22
58 59 #define SPOOLSS_OPNUM_EnumPorts 0x23
59 60 #define SPOOLSS_OPNUM_EnumMonitor 0x24
60 61 #define SPOOLSS_OPNUM_DeletePort 0x27
61 62 #define SPOOLSS_OPNUM_CreatePrinterIC 0x28
62 63 #define SPOOLSS_OPNUM_AddMonitor 0x2e
63 64 #define SPOOLSS_OPNUM_DeleteMonitor 0x2f
64 65 #define SPOOLSS_OPNUM_ResetPrinter 0x34
65 66 #define SPOOLSS_OPNUM_GetPrinterDriver2 0x35
66 67 #define SPOOLSS_OPNUM_FCPN 0x38
67 68 #define SPOOLSS_OPNUM_ReplyOpenPrinter 0x3a
68 69 #define SPOOLSS_OPNUM_ReplyClosePrinter 0x3c
69 70 #define SPOOLSS_OPNUM_AddPortEx 0x3d
70 71 #define SPOOLSS_OPNUM_RFFPCNEX 0x41
71 72 #define SPOOLSS_OPNUM_RRPCN 0x42
72 73 #define SPOOLSS_OPNUM_RFNPCNEX 0x43
73 74 #define SPOOLSS_OPNUM_OpenPrinterEx 0x45
74 75 #define SPOOLSS_OPNUM_SetPort 0x47
75 76 #define SPOOLSS_OPNUM_EnumPrinterData 0x48
76 77 #define SPOOLSS_OPNUM_EnumPrinterDataEx 0x4f
77 78 #define SPOOLSS_OPNUM_EnumPrinterKey 0x50
78 79
79 80 CONTEXT_HANDLE(spoolss_handle) spoolss_handle_t;
80 81
81 82 struct spoolssDevmodeContainer {
82 83 BYTE DevContCount;
83 84 SIZE_IS(DevContCount)
84 85 BYTE *DevMode;
85 86 };
86 87
87 88
88 89 struct spoolss_DeviceMode {
89 90 BYTE devicename[64];
90 91 WORD specversion;
91 92 WORD driverversion;
92 93 WORD size;
93 94 WORD driverextra_length;
94 95 DWORD fields;
95 96 WORD orientation;
96 97 WORD papersize;
97 98 WORD paperlength;
98 99 WORD paperwidth;
99 100 WORD scale;
100 101 WORD copies;
101 102 WORD defaultsource;
102 103 WORD printquality;
103 104 WORD color;
104 105 WORD duplex;
105 106 WORD yresolution;
106 107 WORD ttoption;
107 108 WORD collate;
108 109 BYTE formname[64];
109 110 WORD logpixels;
110 111 DWORD bitsperpel;
111 112 DWORD pelswidth;
112 113 DWORD pelsheight;
113 114 DWORD displayflags;
114 115 DWORD displayfrequency;
115 116 DWORD icmmethod;
116 117 DWORD icmintent;
117 118 DWORD mediatype;
118 119 DWORD dithertype;
119 120 DWORD reserved1;
120 121 DWORD reserved2;
121 122 DWORD panningwidth;
122 123 DWORD panningheight;
123 124 struct spoolssDevmodeContainer driverextra_data;
124 125 };
125 126
126 127 OPERATION(SPOOLSS_OPNUM_CreatePrinterIC)
127 128 struct spoolss_CreatePrinterIC {
128 129 IN spoolss_handle_t handle;
129 130 OUT spoolss_handle_t gdi_handle;
130 131 IN struct spoolssDevmodeContainer dmodeContainer;
131 132 OUT DWORD status;
132 133 };
133 134
134 135 OPERATION(SPOOLSS_OPNUM_OpenPrinter)
135 136 struct spoolss_OpenPrinter {
136 137 IN LPTSTR printer_name;
137 138 OUT spoolss_handle_t handle;
138 139 IN LPTSTR data_type;
139 140 /* IN struct spoolssDevmodeContainer dmodeContainer; */
140 141 /* IN DWORD AccessRequired; */
141 142 OUT DWORD status;
142 143 };
143 144
144 145 OPERATION(SPOOLSS_OPNUM_EnumJobs)
145 146 struct spoolss_EnumJobs {
146 147 IN spoolss_handle_t handle;
147 148 IN DWORD FirstJob;
148 149 IN DWORD NoJobs;
149 150 IN DWORD level;
150 151 IN DWORD Buf2;
151 152 IN DWORD BufCount;
152 153 SIZE_IS(BufCount)
153 154 OUT BYTE *pJob;
154 155 OUT DWORD needed;
155 156 OUT DWORD needed2;
156 157 OUT DWORD status;
157 158 };
158 159
159 160 OPERATION(SPOOLSS_OPNUM_DeletePrinter)
160 161 struct spoolss_DeletePrinter {
161 162 IN DWORD dontcare;
162 163 OUT DWORD status;
163 164 };
164 165
165 166 #define SPOOLSS_ARCHITECTURE_NT_X86 ( "Windows NT x86" )
166 167 struct spoolss_Time {
167 168 WORD year;
168 169 WORD month;
169 170 WORD day_of_week;
170 171 WORD day;
171 172 WORD hour;
172 173 WORD minute;
173 174 WORD second;
174 175 WORD millisecond;
175 176 };
176 177
177 178 struct spoolss_GetPrinter0 {
178 179 DWORD printername;
179 180 DWORD servername;
180 181 DWORD cjobs;
181 182 DWORD total_jobs;
182 183 DWORD total_bytes;
183 184 DWORD time0;
184 185 DWORD time1;
185 186 DWORD time2;
186 187 DWORD time3;
187 188 DWORD global_counter;
188 189 DWORD total_pages;
189 190 DWORD version;
190 191 DWORD ffreebuild;
191 192 DWORD cspooling;
192 193 DWORD cmaxspooling;
193 194 DWORD session_counter;
194 195 DWORD out_of_paper;
195 196 DWORD not_ready;
196 197 DWORD job_error;
197 198 DWORD num_processors;
198 199 DWORD type_processor;
199 200 DWORD high_part_total_bytes;
200 201 DWORD change_id;
201 202 DWORD last_error;
202 203 DWORD status;
203 204 DWORD enum_network_printers;
204 205 DWORD c_setprinter;
205 206 WORD processor_arch;
206 207 WORD processor_level;
207 208 DWORD ref;
208 209 DWORD reserved2;
209 210 DWORD reserved3;
210 211 };
211 212
212 213 /* bitmap spoolss_EnumPrinterFlags */
213 214 #define PRINTER_ENUM_DEFAULT ( 0x00000001 )
214 215 #define PRINTER_ENUM_LOCAL ( 0x00000002 )
215 216 #define PRINTER_ENUM_CONNECTIONS ( 0x00000004 )
216 217 #define PRINTER_ENUM_FAVORITE ( 0x00000004 )
217 218 #define PRINTER_ENUM_NAME ( 0x00000008 )
218 219 #define PRINTER_ENUM_REMOTE ( 0x00000010 )
219 220 #define PRINTER_ENUM_SHARED ( 0x00000020 )
220 221 #define PRINTER_ENUM_NETWORK ( 0x00000040 )
221 222 #define PRINTER_ENUM_EXPAND ( 0x00004000 )
222 223 #define PRINTER_ENUM_CONTAINER ( 0x00008000 )
223 224 #define PRINTER_ENUM_ICON1 ( 0x00010000 )
224 225 #define PRINTER_ENUM_ICON2 ( 0x00020000 )
225 226 #define PRINTER_ENUM_ICON3 ( 0x00040000 )
226 227 #define PRINTER_ENUM_ICON4 ( 0x00080000 )
227 228 #define PRINTER_ENUM_ICON5 ( 0x00100000 )
228 229 #define PRINTER_ENUM_ICON6 ( 0x00200000 )
229 230 #define PRINTER_ENUM_ICON7 ( 0x00400000 )
230 231 #define PRINTER_ENUM_ICON8 ( 0x00800000 )
231 232 #define PRINTER_ENUM_HIDE ( 0x01000000 )
232 233
233 234 struct spoolss_GetPrinter1 {
234 235 DWORD flags;
235 236 DWORD name;
236 237 DWORD description;
237 238 DWORD comment;
238 239 };
239 240
240 241 /* bitmap spoolss_PrinterAttributes */
241 242 #define PRINTER_ATTRIBUTE_QUEUED ( 0x00000001 )
242 243 #define PRINTER_ATTRIBUTE_DIRECT ( 0x00000002 )
243 244 #define PRINTER_ATTRIBUTE_DEFAULT ( 0x00000004 )
244 245 #define PRINTER_ATTRIBUTE_SHARED ( 0x00000008 )
245 246 #define PRINTER_ATTRIBUTE_NETWORK ( 0x00000010 )
246 247 #define PRINTER_ATTRIBUTE_HIDDEN ( 0x00000020 )
247 248 #define PRINTER_ATTRIBUTE_LOCAL ( 0x00000040 )
248 249 #define PRINTER_ATTRIBUTE_ENABLE_DEVQ ( 0x00000080 )
249 250 #define PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS ( 0x00000100 )
250 251 #define PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST ( 0x00000200 )
251 252 #define PRINTER_ATTRIBUTE_WORK_OFFLINE ( 0x00000400 )
252 253 #define PRINTER_ATTRIBUTE_ENABLE_BIDI ( 0x00000800 )
253 254 #define PRINTER_ATTRIBUTE_RAW_ONLY ( 0x00001000 )
254 255 #define PRINTER_ATTRIBUTE_PUBLISHED ( 0x00002000 )
255 256 #define PRINTER_ATTRIBUTE_FAX ( 0x00004000 )
256 257 #define PRINTER_ATTRIBUTE_TS ( 0x00008000 )
257 258
258 259 /* bitmap spoolss_PrinterStatus */
259 260 #define PRINTER_STATUS_PAUSED ( 0x00000001 )
260 261 #define PRINTER_STATUS_ERROR ( 0x00000002 )
261 262 #define PRINTER_STATUS_PENDING_DELETION ( 0x00000004 )
262 263 #define PRINTER_STATUS_PAPER_JAM ( 0x00000008 )
263 264 #define PRINTER_STATUS_PAPER_OUT ( 0x00000010 )
264 265 #define PRINTER_STATUS_MANUAL_FEED ( 0x00000020 )
265 266 #define PRINTER_STATUS_PAPER_PROBLEM ( 0x00000040 )
266 267 #define PRINTER_STATUS_OFFLINE ( 0x00000080 )
267 268 #define PRINTER_STATUS_IO_ACTIVE ( 0x00000100 )
268 269 #define PRINTER_STATUS_BUSY ( 0x00000200 )
269 270 #define PRINTER_STATUS_PRINTING ( 0x00000400 )
270 271 #define PRINTER_STATUS_OUTPUT_BIN_FULL ( 0x00000800 )
271 272 #define PRINTER_STATUS_NOT_AVAILABLE ( 0x00001000 )
272 273 #define PRINTER_STATUS_WAITING ( 0x00002000 )
273 274 #define PRINTER_STATUS_PROCESSING ( 0x00004000 )
274 275 #define PRINTER_STATUS_INITIALIZING ( 0x00008000 )
275 276 #define PRINTER_STATUS_WARMING_UP ( 0x00010000 )
276 277 #define PRINTER_STATUS_TONER_LOW ( 0x00020000 )
277 278 #define PRINTER_STATUS_NO_TONER ( 0x00040000 )
278 279 #define PRINTER_STATUS_PAGE_PUNT ( 0x00080000 )
279 280 #define PRINTER_STATUS_USER_INTERVENTION ( 0x00100000 )
280 281 #define PRINTER_STATUS_OUT_OF_MEMORY ( 0x00200000 )
281 282 #define PRINTER_STATUS_DOOR_OPEN ( 0x00400000 )
282 283 #define PRINTER_STATUS_SERVER_UNKNOWN ( 0x00800000 )
283 284 #define PRINTER_STATUS_POWER_SAVE ( 0x01000000 )
284 285
285 286 struct spoolss_GetPrinter2 {
286 287 DWORD servername;
287 288 DWORD printername;
288 289 DWORD sharename;
289 290 DWORD portname;
290 291 DWORD drivername;
291 292 DWORD comment;
292 293 DWORD location;
293 294 DWORD devmode;
294 295 DWORD sepfile;
295 296 DWORD printprocessor;
296 297 DWORD datatype;
297 298 DWORD parameters;
298 299 DWORD secdesc;
299 300 DWORD attributes;
300 301 DWORD priority;
301 302 DWORD defaultpriority;
302 303 DWORD starttime;
303 304 DWORD untiltime;
304 305 DWORD status;
305 306 DWORD cjobs;
306 307 DWORD averageppm;
307 308 };
308 309
309 310 typedef struct spoolss_GetPrinter2 spoolss_GetPrinter2_t;
310 311
311 312 struct spoolss_GetPrinter3 {
312 313 DWORD dummy;
313 314 };
314 315
315 316 struct spoolss_GetPrinter4 {
316 317 DWORD printername;
317 318 DWORD servername;
318 319 DWORD attributes;
319 320 };
320 321
321 322 struct spoolss_GetPrinter5 {
322 323 DWORD printername;
323 324 DWORD portname;
324 325 DWORD attributes;
325 326 DWORD device_not_selected_timeout;
326 327 DWORD transmission_retry_timeout;
327 328 };
328 329
329 330 struct spoolss_GetPrinter6 {
330 331 DWORD status;
331 332 };
332 333
333 334 /* bitmap spoolss_DsPrintAction */
334 335 #define DSPRINT_PUBLISH ( 0x00000001 )
335 336 #define DSPRINT_UPDATE ( 0x00000002 )
336 337 #define DSPRINT_UNPUBLISH ( 0x00000004 )
337 338 #define DSPRINT_REPUBLISH ( 0x00000008 )
338 339 #define DSPRINT_PENDING ( 0x80000000 )
339 340
340 341 struct spoolss_GetPrinter7 {
341 342 DWORD guid;
342 343 DWORD action;
343 344 };
344 345
345 346 struct spoolss_GetPrinter8 {
346 347 DWORD flags;
347 348 DWORD name;
348 349 DWORD description;
349 350 DWORD comment;
350 351 };
351 352
352 353 union spoolss_GetPrinter_result_u {
353 354 UNION_INFO_ENT(0, spoolss_GetPrinter);
354 355 UNION_INFO_ENT(1, spoolss_GetPrinter);
355 356 UNION_INFO_ENT(2, spoolss_GetPrinter);
356 357 UNION_INFO_ENT(3, spoolss_GetPrinter);
357 358 UNION_INFO_ENT(4, spoolss_GetPrinter);
358 359 UNION_INFO_ENT(5, spoolss_GetPrinter);
359 360 UNION_INFO_ENT(6, spoolss_GetPrinter);
360 361 UNION_INFO_ENT(7, spoolss_GetPrinter);
361 362 UNION_INFO_ENT(8, spoolss_GetPrinter);
362 363 DEFAULT char *nullptr;
363 364 };
364 365
365 366 struct spoolss_GetPrinter_result {
366 367 DWORD switch_value;
367 368 SWITCH(switch_value)
368 369 union spoolss_GetPrinter_result_u ru;
369 370 };
370 371
371 372 struct spoolss_RPC_V2_NOTIFY_OPTIONS_TYPE {
372 373 WORD type;
373 374 WORD reserved0;
374 375 DWORD reserved1;
375 376 DWORD reserved2;
376 377 DWORD count;
377 378 SIZE_IS(count)
378 379 WORD *pFields;
379 380 };
380 381
381 382 struct spoolss_RPC_V2_NOTIFY_OPTIONS {
382 383 DWORD version;
383 384 DWORD reserved;
384 385 DWORD count;
385 386 SIZE_IS(count)
386 387 struct spoolss_RPC_V2_NOTIFY_OPTIONS_TYPE *ptypes;
387 388 };
388 389
389 390 struct SYSTEMTIME {
390 391 WORD year;
391 392 WORD month;
392 393 WORD dayofweek;
393 394 WORD day;
394 395 WORD hour;
395 396 WORD minute;
396 397 WORD second;
397 398 WORD millisecs;
398 399 };
399 400
400 401 struct SECURITY_CONTAINER {
401 402 DWORD count;
402 403 SIZE_IS(count)
403 404 BYTE *psecurity;
404 405 };
405 406
406 407 struct SYSTEMTIME_CONTAINER {
407 408 DWORD count;
408 409 struct SYSTEMTIME *psystemtime;
409 410 };
410 411
411 412 struct STRING_CONTAINER {
412 413 DWORD count;
413 414 SIZE_IS(count / 2)
414 415 LPTSTR pstring;
415 416 };
416 417
417 418 union spoolss_RPC_V2_NOTIFY_INFO_DATA_DATA {
418 419 CASE(TABLE_STRING)
419 420 struct STRING_CONTAINER pcont;
420 421 CASE(TABLE_DWORD)
421 422 DWORD data[2];
422 423 CASE(TABLE_TIME)
423 424 struct SYSTEMTIME_CONTAINER system_time;
424 425 CASE(TABLE_DEVMODE)
425 426 struct spoolssDevmodeContainer devmode;
426 427 CASE(TABLE_SECURITY_DESCRIPTOR)
427 428 struct SECURITY_CONTAINER security_descriptor;
428 429 };
429 430
430 431 struct spoolss_RPC_V2_NOTIFY_INFO_DATA {
431 432 WORD Type;
432 433 WORD Field;
433 434 DWORD Reserved;
434 435 DWORD Id;
435 436 SWITCH(Reserved & 0x0000FFFF)
436 437 union spoolss_RPC_V2_NOTIFY_INFO_DATA_DATA data;
437 438 };
438 439
439 440 struct spoolss_RPC_V2_NOTIFY_INFO {
440 441 DWORD Version;
441 442 DWORD Flags;
442 443 DWORD Count;
443 444 SIZE_IS(Count)
444 445 struct spoolss_RPC_V2_NOTIFY_INFO_DATA *aData;
445 446 };
446 447
447 448 OPERATION(SPOOLSS_OPNUM_GetPrinter)
448 449 struct spoolss_GetPrinter {
449 450 IN spoolss_handle_t handle;
450 451 IN DWORD switch_value;
451 452 IN DWORD Buf2;
452 453 IN DWORD BufCount;
453 454 SIZE_IS(BufCount)
454 455 OUT BYTE *Buf;
455 456 OUT DWORD needed;
456 457 OUT DWORD status;
457 458 };
458 459
459 460 OPERATION(SPOOLSS_OPNUM_GetPrinterData)
460 461 struct spoolss_GetPrinterData {
461 462 IN spoolss_handle_t handle;
462 463 IN REFERENCE LPTSTR pValueName;
463 464 OUT DWORD pType;
464 465 SIZE_IS(Size)
465 466 OUT REFERENCE LPBYTE Buf;
466 467 IN DWORD Size;
467 468 OUT DWORD Needed;
468 469 OUT DWORD status;
469 470 };
470 471
471 472 OPERATION(SPOOLSS_OPNUM_GetPrinterDriver)
472 473 struct spoolss_GetPrinterDriver {
473 474 IN DWORD dontcare;
474 475 OUT DWORD status;
475 476 };
476 477
477 478 OPERATION(SPOOLSS_OPNUM_DeletePrinterDriver)
478 479 struct spoolss_DeletePrinterDriver {
479 480 IN DWORD dontcare;
480 481 OUT DWORD status;
481 482 };
482 483
483 484 struct spoolss_DocInfo {
484 485 LPTSTR doc_name;
485 486 LPTSTR printer_name;
486 487 LPTSTR type;
487 488 };
488 489 typedef struct spoolss_DocInfo spoolss_DocInfo_t;
489 490
490 491 struct spoolss_DocInfo_Container {
491 492 DWORD level;
492 493 DWORD switch_value;
493 494 spoolss_DocInfo_t *DocInfoContainer;
494 495 };
495 496 typedef struct spoolss_DocInfo_Container spoolss_DocInfo_Container_t;
496 497
497 498 OPERATION(SPOOLSS_OPNUM_StartDocPrinter)
498 499 struct spoolss_StartDocPrinter {
499 500 IN spoolss_handle_t handle;
500 501 IN spoolss_DocInfo_Container_t dinfo;
501 502 OUT DWORD JobId;
502 503 OUT DWORD status;
503 504 };
504 505
505 506 OPERATION(SPOOLSS_OPNUM_AbortPrinter)
506 507 struct spoolss_AbortPrinter {
507 508 IN spoolss_handle_t handle;
508 509 OUT DWORD status;
509 510 };
510 511
511 512 OPERATION(SPOOLSS_OPNUM_EnumPorts)
512 513 struct spoolss_EnumPorts {
513 514 IN LPTSTR name;
514 515 IN DWORD level;
515 516 OUT DWORD needed;
516 517 OUT DWORD returned;
517 518 OUT DWORD status;
518 519 };
519 520
520 521 OPERATION(SPOOLSS_OPNUM_DeletePort)
521 522 struct spoolss_DeletePort {
522 523 IN LPTSTR name;
523 524 OUT DWORD status;
524 525 };
525 526
526 527 OPERATION(SPOOLSS_OPNUM_AddPortEx)
527 528 struct spoolss_AddPortEx {
528 529 IN LPTSTR name;
529 530 OUT DWORD status;
530 531 };
531 532
532 533 OPERATION(SPOOLSS_OPNUM_SetPort)
533 534 struct spoolss_SetPort {
534 535 IN LPTSTR name;
535 536 OUT DWORD status;
536 537 };
537 538
538 539 OPERATION(SPOOLSS_OPNUM_EnumMonitor)
539 540 struct spoolss_EnumMonitor {
540 541 IN LPTSTR name;
541 542 IN DWORD level;
542 543 OUT DWORD needed;
543 544 OUT DWORD returned;
544 545 OUT DWORD status;
545 546 };
546 547
547 548 OPERATION(SPOOLSS_OPNUM_AddMonitor)
548 549 struct spoolss_AddMonitor {
549 550 IN LPTSTR name;
550 551 OUT DWORD status;
551 552 };
552 553
553 554 OPERATION(SPOOLSS_OPNUM_DeleteMonitor)
554 555 struct spoolss_DeleteMonitor {
555 556 IN LPTSTR name;
556 557 OUT DWORD status;
557 558 };
558 559
559 560 OPERATION(SPOOLSS_OPNUM_ResetPrinter)
560 561 struct spoolss_ResetPrinter {
561 562 IN spoolss_handle_t handle;
562 563 OUT DWORD status;
563 564 };
564 565
565 566 OPERATION(SPOOLSS_OPNUM_StartPagePrinter)
566 567 struct spoolss_StartPagePrinter {
567 568 IN spoolss_handle_t handle;
568 569 OUT DWORD status;
569 570 };
570 571
571 572 OPERATION(SPOOLSS_OPNUM_EndPagePrinter)
572 573 struct spoolss_EndPagePrinter {
573 574 IN spoolss_handle_t handle;
574 575 OUT DWORD status;
575 576 };
576 577
577 578 OPERATION(SPOOLSS_OPNUM_WritePrinter)
578 579 struct spoolss_WritePrinter {
579 580 IN spoolss_handle_t handle;
580 581 IN DWORD BufCount;
581 582 SIZE_IS(BufCount)
582 583 IN REFERENCE LPBYTE pBuf;
583 584 OUT DWORD written;
584 585 OUT DWORD status;
585 586 };
586 587
587 588 OPERATION(SPOOLSS_OPNUM_ScheduleJob)
588 589 struct spoolss_ScheduleJob {
589 590 IN spoolss_handle_t handle;
590 591 IN DWORD JobId;
591 592 OUT DWORD status;
592 593 };
593 594
594 595 OPERATION(SPOOLSS_OPNUM_GetJob)
595 596 struct spoolss_GetJob {
596 597 IN spoolss_handle_t handle;
597 598 IN DWORD JobId;
598 599 IN DWORD level;
599 600 SIZE_IS(BufCount)
600 601 INOUT BYTE *pJob;
601 602 IN DWORD BufCount;
602 603 OUT DWORD needed;
603 604 OUT DWORD status;
604 605 };
605 606
606 607 OPERATION(SPOOLSS_OPNUM_AddJob)
607 608 struct spoolss_AddJob {
608 609 IN spoolss_handle_t handle;
609 610 IN DWORD level;
610 611 IN DWORD Buf2;
611 612 IN DWORD BufCount;
612 613 SIZE_IS(BufCount)
613 614 OUT BYTE *pAddJob;
614 615 OUT DWORD needed;
615 616 OUT DWORD status;
616 617 };
617 618
618 619 OPERATION(SPOOLSS_OPNUM_ClosePrinter)
619 620 struct spoolss_ClosePrinter {
620 621 IN spoolss_handle_t handle;
621 622 OUT spoolss_handle_t result_handle;
622 623 OUT DWORD status;
623 624 };
624 625
625 626 OPERATION(SPOOLSS_OPNUM_EndDocPrinter)
626 627 struct spoolss_EndDocPrinter {
627 628 IN spoolss_handle_t handle;
628 629 OUT DWORD status;
629 630 };
630 631
631 632 OPERATION(SPOOLSS_OPNUM_AddForm)
632 633 struct spoolss_AddForm {
633 634 IN spoolss_handle_t handle;
634 635 /* FORM_CONTAINER *form_container; */
635 636 OUT DWORD status;
636 637 };
637 638
638 639 OPERATION(SPOOLSS_OPNUM_DeleteForm)
639 640 struct spoolss_DeleteForm {
640 641 IN spoolss_handle_t handle;
641 642 /* IN REFERENCE LPTSTR form_name; */
642 643 OUT DWORD status;
643 644 };
644 645
645 646 OPERATION(SPOOLSS_OPNUM_EnumForms)
646 647 struct spoolss_EnumForms {
647 648 IN spoolss_handle_t handle;
648 649 IN DWORD level;
649 650 IN DWORD BufCount;
650 651 SIZE_IS(BufCount)
651 652 INOUT BYTE *pEnumForms;
652 653 OUT DWORD needed;
653 654 OUT DWORD pcRet;
654 655 OUT DWORD status;
655 656 };
656 657
657 658 OPERATION(SPOOLSS_OPNUM_GetPrinterDriver2)
658 659 struct spoolss_GetPrinterDriver2 {
659 660 IN DWORD dontcare;
660 661 OUT DWORD status;
661 662 };
662 663
663 664 OPERATION(SPOOLSS_OPNUM_FCPN)
664 665 struct spoolss_FCPN {
665 666 IN DWORD dontcare;
666 667 OUT DWORD status;
667 668 };
668 669
669 670 OPERATION(SPOOLSS_OPNUM_ReplyOpenPrinter)
670 671 struct spoolss_ReplyOpenPrinter {
671 672 IN DWORD dontcare;
672 673 OUT DWORD status;
673 674 };
674 675
675 676 OPERATION(SPOOLSS_OPNUM_ReplyClosePrinter)
676 677 struct spoolss_ReplyClosePrinter {
677 678 IN DWORD dontcare;
678 679 OUT DWORD status;
679 680 };
680 681
681 682
682 683 OPERATION(SPOOLSS_OPNUM_RFFPCNEX)
683 684 struct spoolss_RFFPCNEX {
684 685 IN spoolss_handle_t handle;
685 686 OUT DWORD status;
686 687 };
687 688
688 689 struct spoolss_infores {
689 690 DWORD entriesread;
690 691 struct spoolss_RPC_V2_NOTIFY_INFO *pinfo;
691 692 };
692 693
693 694 OPERATION(SPOOLSS_OPNUM_RFNPCNEX)
694 695 struct spoolss_RFNPCNEX {
695 696 IN spoolss_handle_t handle;
696 697 IN DWORD color;
697 698 IN struct spoolss_RPC_V2_NOTIFY_OPTIONS *poptions;
698 699 OUT struct spoolss_infores *ppinfo;
699 700 OUT DWORD status;
700 701 };
701 702
702 703 OPERATION(SPOOLSS_OPNUM_RRPCN)
703 704 struct spoolss_RRPCN {
704 705 IN DWORD dontcare;
705 706 OUT DWORD status;
706 707 };
707 708
708 709 OPERATION(SPOOLSS_OPNUM_OpenPrinterEx)
709 710 struct spoolss_OpenPrinterEx {
710 711 IN LPTSTR printer_name;
711 712 OUT spoolss_handle_t handle;
712 713 IN LPTSTR data_type;
713 714 /* IN struct spoolssDevmodeContainer dmodeContainer; */
714 715 /* IN DWORD AccessRequired; */
715 716 /* IN CLIENT_CONTAINER client_info; */
716 717 OUT DWORD status;
717 718 };
718 719
719 720 OPERATION(SPOOLSS_OPNUM_EnumPrinterData)
720 721 struct spoolss_EnumPrinterData {
721 722 IN DWORD dontcare;
722 723 OUT DWORD status;
723 724 };
724 725
725 726 OPERATION(SPOOLSS_OPNUM_EnumPrinterDataEx)
726 727 struct spoolss_EnumPrinterDataEx {
727 728 IN DWORD dontcare;
728 729 OUT DWORD status;
729 730 };
730 731
731 732 OPERATION(SPOOLSS_OPNUM_EnumPrinterKey)
732 733 struct spoolss_EnumPrinterKey {
733 734 IN DWORD dontcare;
734 735 OUT DWORD status;
735 736 };
736 737
737 738 /*
738 739 ***********************************************************************
739 740 * The spoolss interface definition.
740 741 ***********************************************************************
741 742 */
742 743
743 744 INTERFACE(0)
744 745 union spoolss_interface {
745 746 CASE(SPOOLSS_OPNUM_OpenPrinter)
746 747 struct spoolss_OpenPrinter OpenPrinter;
747 748
748 749 CASE(SPOOLSS_OPNUM_DeletePrinter)
749 750 struct spoolss_DeletePrinter DeletePrinter;
750 751
751 752 CASE(SPOOLSS_OPNUM_GetPrinter)
752 753 struct spoolss_GetPrinter GetPrinter;
753 754
754 755 CASE(SPOOLSS_OPNUM_GetPrinterData)
755 756 struct spoolss_GetPrinterData GetPrinterData;
756 757
757 758 CASE(SPOOLSS_OPNUM_AbortPrinter)
758 759 struct spoolss_AbortPrinter AbortPrinter;
759 760
760 761 CASE(SPOOLSS_OPNUM_StartDocPrinter)
761 762 struct spoolss_StartDocPrinter StartDocPrinter;
762 763
763 764 CASE(SPOOLSS_OPNUM_EndDocPrinter)
764 765 struct spoolss_EndDocPrinter EndDocPrinter;
765 766
766 767 CASE(SPOOLSS_OPNUM_CreatePrinterIC)
767 768 struct spoolss_CreatePrinterIC CreatePrinterIC;
768 769
769 770 CASE(SPOOLSS_OPNUM_ResetPrinter)
770 771 struct spoolss_ResetPrinter ResetPrinter;
771 772
772 773 CASE(SPOOLSS_OPNUM_EnumMonitor)
773 774 struct spoolss_EnumMonitor EnumMonitor;
774 775
775 776 CASE(SPOOLSS_OPNUM_AddMonitor)
776 777 struct spoolss_AddMonitor AddMonitor;
777 778
778 779 CASE(SPOOLSS_OPNUM_DeleteMonitor)
779 780 struct spoolss_DeleteMonitor DeleteMonitor;
780 781
781 782 CASE(SPOOLSS_OPNUM_WritePrinter)
782 783 struct spoolss_WritePrinter WritePrinter;
783 784
784 785 CASE(SPOOLSS_OPNUM_StartPagePrinter)
785 786 struct spoolss_StartPagePrinter StartPagePrinter;
786 787
787 788 CASE(SPOOLSS_OPNUM_EndPagePrinter)
788 789 struct spoolss_EndPagePrinter EndPagePrinter;
789 790
790 791 CASE(SPOOLSS_OPNUM_ClosePrinter)
791 792 struct spoolss_ClosePrinter ClosePrinter;
792 793
793 794 CASE(SPOOLSS_OPNUM_OpenPrinterEx)
794 795 struct spoolss_OpenPrinterEx OpenPrinterEx;
795 796
796 797 CASE(SPOOLSS_OPNUM_AddJob)
797 798 struct spoolss_AddJob AddJob;
798 799
799 800 CASE(SPOOLSS_OPNUM_GetJob)
800 801 struct spoolss_GetJob GetJob;
801 802
802 803 CASE(SPOOLSS_OPNUM_ScheduleJob)
803 804 struct spoolss_ScheduleJob ScheduleJob;
804 805
805 806 CASE(SPOOLSS_OPNUM_AddForm)
806 807 struct spoolss_AddForm AddForm;
807 808
808 809 CASE(SPOOLSS_OPNUM_DeleteForm)
809 810 struct spoolss_DeleteForm DeleteForm;
810 811
811 812 CASE(SPOOLSS_OPNUM_EnumForms)
812 813 struct spoolss_EnumForms EnumForms;
813 814
814 815 CASE(SPOOLSS_OPNUM_EnumPorts)
815 816 struct spoolss_EnumPorts EnumPorts;
816 817
817 818 CASE(SPOOLSS_OPNUM_DeletePort)
818 819 struct spoolss_DeletePort DeletePort;
819 820
820 821 CASE(SPOOLSS_OPNUM_AddPortEx)
821 822 struct spoolss_AddPortEx AddPortEx;
822 823
823 824 CASE(SPOOLSS_OPNUM_SetPort)
824 825 struct spoolss_SetPort SetPort;
825 826
826 827 CASE(SPOOLSS_OPNUM_RFNPCNEX)
827 828 struct spoolss_RFNPCNEX RFNPCNEX;
828 829
829 830 };
830 831 typedef union spoolss_interface spoolss_interface_t;
831 832 EXTERNTYPEINFO(spoolss_interface)
832 833
833 834 #endif /* _SPOOLSS_NDL_ */
|
↓ open down ↓ |
795 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX