← Back to branch summary

~vcs-imports/samba/main

« back to all changes in this revision

Viewing changes to source/rpc_server/srv_spoolss.c

  • Committer: jerry
  • Date: 2006-07-14 21:48:39 UTC
  • Revision ID: vcs-imports@canonical.com-20060714214839-586d8c489a8fcead
gutting trunk to move to svn:externals

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/rpc_server/srv_spoolss.c
1
 
/* 
2
 
 *  Unix SMB/CIFS implementation.
3
 
 *  RPC Pipe client / server routines
4
 
 *  Copyright (C) Andrew Tridgell              1992-2000,
5
 
 *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6
 
 *  Copyright (C) Jean Fran�ois Micouleau      1998-2000,
7
 
 *  Copyright (C) Jeremy Allison                    2001,
8
 
 *  Copyright (C) Gerald Carter                2001-2002,
9
 
 *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2003.
10
 
 *  
11
 
 *  This program is free software; you can redistribute it and/or modify
12
 
 *  it under the terms of the GNU General Public License as published by
13
 
 *  the Free Software Foundation; either version 2 of the License, or
14
 
 *  (at your option) any later version.
15
 
 *  
16
 
 *  This program is distributed in the hope that it will be useful,
17
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
 
 *  GNU General Public License for more details.
20
 
 *  
21
 
 *  You should have received a copy of the GNU General Public License
22
 
 *  along with this program; if not, write to the Free Software
23
 
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24
 
 */
25
 
 
26
 
#include "includes.h"
27
 
 
28
 
#undef DBGC_CLASS
29
 
#define DBGC_CLASS DBGC_RPC_SRV
30
 
 
31
 
/********************************************************************
32
 
 * api_spoolss_open_printer_ex (rarely seen - older call)
33
 
 ********************************************************************/
34
 
 
35
 
static BOOL api_spoolss_open_printer(pipes_struct *p)
36
 
{
37
 
        SPOOL_Q_OPEN_PRINTER q_u;
38
 
        SPOOL_R_OPEN_PRINTER r_u;
39
 
        prs_struct *data = &p->in_data.data;
40
 
        prs_struct *rdata = &p->out_data.rdata;
41
 
 
42
 
        ZERO_STRUCT(q_u);
43
 
        ZERO_STRUCT(r_u);
44
 
 
45
 
        if (!spoolss_io_q_open_printer("", &q_u, data, 0)) {
46
 
                DEBUG(0,("spoolss_io_q_open_printer: unable to unmarshall SPOOL_Q_OPEN_PRINTER.\n"));
47
 
                return False;
48
 
        }
49
 
 
50
 
        r_u.status = _spoolss_open_printer( p, &q_u, &r_u);
51
 
        
52
 
        if (!spoolss_io_r_open_printer("",&r_u,rdata,0)){
53
 
                DEBUG(0,("spoolss_io_r_open_printer: unable to marshall SPOOL_R_OPEN_PRINTER.\n"));
54
 
                return False;
55
 
        }
56
 
 
57
 
        return True;
58
 
}
59
 
 
60
 
 
61
 
/********************************************************************
62
 
 * api_spoolss_open_printer_ex
63
 
 ********************************************************************/
64
 
 
65
 
static BOOL api_spoolss_open_printer_ex(pipes_struct *p)
66
 
{
67
 
        SPOOL_Q_OPEN_PRINTER_EX q_u;
68
 
        SPOOL_R_OPEN_PRINTER_EX r_u;
69
 
        prs_struct *data = &p->in_data.data;
70
 
        prs_struct *rdata = &p->out_data.rdata;
71
 
 
72
 
        ZERO_STRUCT(q_u);
73
 
        ZERO_STRUCT(r_u);
74
 
 
75
 
        if (!spoolss_io_q_open_printer_ex("", &q_u, data, 0)) {
76
 
                DEBUG(0,("spoolss_io_q_open_printer_ex: unable to unmarshall SPOOL_Q_OPEN_PRINTER_EX.\n"));
77
 
                return False;
78
 
        }
79
 
 
80
 
        r_u.status = _spoolss_open_printer_ex( p, &q_u, &r_u);
81
 
 
82
 
        if (!spoolss_io_r_open_printer_ex("",&r_u,rdata,0)){
83
 
                DEBUG(0,("spoolss_io_r_open_printer_ex: unable to marshall SPOOL_R_OPEN_PRINTER_EX.\n"));
84
 
                return False;
85
 
        }
86
 
 
87
 
        return True;
88
 
}
89
 
 
90
 
/********************************************************************
91
 
 * api_spoolss_getprinterdata
92
 
 *
93
 
 * called from the spoolss dispatcher
94
 
 ********************************************************************/
95
 
 
96
 
static BOOL api_spoolss_getprinterdata(pipes_struct *p)
97
 
{
98
 
        SPOOL_Q_GETPRINTERDATA q_u;
99
 
        SPOOL_R_GETPRINTERDATA r_u;
100
 
        prs_struct *data = &p->in_data.data;
101
 
        prs_struct *rdata = &p->out_data.rdata;
102
 
 
103
 
        ZERO_STRUCT(q_u);
104
 
        ZERO_STRUCT(r_u);
105
 
 
106
 
        /* read the stream and fill the struct */
107
 
        if (!spoolss_io_q_getprinterdata("", &q_u, data, 0)) {
108
 
                DEBUG(0,("spoolss_io_q_getprinterdata: unable to unmarshall SPOOL_Q_GETPRINTERDATA.\n"));
109
 
                return False;
110
 
        }
111
 
        
112
 
        r_u.status = _spoolss_getprinterdata( p, &q_u, &r_u);
113
 
 
114
 
        if (!spoolss_io_r_getprinterdata("", &r_u, rdata, 0)) {
115
 
                DEBUG(0,("spoolss_io_r_getprinterdata: unable to marshall SPOOL_R_GETPRINTERDATA.\n"));
116
 
                return False;
117
 
        }
118
 
 
119
 
        return True;
120
 
}
121
 
 
122
 
/********************************************************************
123
 
 * api_spoolss_deleteprinterdata
124
 
 *
125
 
 * called from the spoolss dispatcher
126
 
 ********************************************************************/
127
 
 
128
 
static BOOL api_spoolss_deleteprinterdata(pipes_struct *p)
129
 
{
130
 
        SPOOL_Q_DELETEPRINTERDATA q_u;
131
 
        SPOOL_R_DELETEPRINTERDATA r_u;
132
 
        prs_struct *data = &p->in_data.data;
133
 
        prs_struct *rdata = &p->out_data.rdata;
134
 
 
135
 
        ZERO_STRUCT(q_u);
136
 
        ZERO_STRUCT(r_u);
137
 
 
138
 
        /* read the stream and fill the struct */
139
 
        if (!spoolss_io_q_deleteprinterdata("", &q_u, data, 0)) {
140
 
                DEBUG(0,("spoolss_io_q_deleteprinterdata: unable to unmarshall SPOOL_Q_DELETEPRINTERDATA.\n"));
141
 
                return False;
142
 
        }
143
 
        
144
 
        r_u.status = _spoolss_deleteprinterdata( p, &q_u, &r_u );
145
 
 
146
 
        if (!spoolss_io_r_deleteprinterdata("", &r_u, rdata, 0)) {
147
 
                DEBUG(0,("spoolss_io_r_deleteprinterdata: unable to marshall SPOOL_R_DELETEPRINTERDATA.\n"));
148
 
                return False;
149
 
        }
150
 
 
151
 
        return True;
152
 
}
153
 
 
154
 
/********************************************************************
155
 
 * api_spoolss_closeprinter
156
 
 *
157
 
 * called from the spoolss dispatcher
158
 
 ********************************************************************/
159
 
 
160
 
static BOOL api_spoolss_closeprinter(pipes_struct *p)
161
 
{
162
 
        SPOOL_Q_CLOSEPRINTER q_u;
163
 
        SPOOL_R_CLOSEPRINTER r_u;
164
 
        prs_struct *data = &p->in_data.data;
165
 
        prs_struct *rdata = &p->out_data.rdata;
166
 
 
167
 
        ZERO_STRUCT(q_u);
168
 
        ZERO_STRUCT(r_u);
169
 
 
170
 
        if (!spoolss_io_q_closeprinter("", &q_u, data, 0)) {
171
 
                DEBUG(0,("spoolss_io_q_closeprinter: unable to unmarshall SPOOL_Q_CLOSEPRINTER.\n"));
172
 
                return False;
173
 
        }
174
 
 
175
 
        r_u.status = _spoolss_closeprinter(p, &q_u, &r_u);
176
 
 
177
 
        if (!spoolss_io_r_closeprinter("",&r_u,rdata,0)) {
178
 
                DEBUG(0,("spoolss_io_r_closeprinter: unable to marshall SPOOL_R_CLOSEPRINTER.\n"));
179
 
                return False;
180
 
        }
181
 
 
182
 
        return True;
183
 
}
184
 
 
185
 
/********************************************************************
186
 
 * api_spoolss_abortprinter
187
 
 *
188
 
 * called from the spoolss dispatcher
189
 
 ********************************************************************/
190
 
 
191
 
static BOOL api_spoolss_abortprinter(pipes_struct *p)
192
 
{
193
 
        SPOOL_Q_ABORTPRINTER q_u;
194
 
        SPOOL_R_ABORTPRINTER r_u;
195
 
        prs_struct *data = &p->in_data.data;
196
 
        prs_struct *rdata = &p->out_data.rdata;
197
 
 
198
 
        ZERO_STRUCT(q_u);
199
 
        ZERO_STRUCT(r_u);
200
 
 
201
 
        if (!spoolss_io_q_abortprinter("", &q_u, data, 0)) {
202
 
                DEBUG(0,("spoolss_io_q_abortprinter: unable to unmarshall SPOOL_Q_ABORTPRINTER.\n"));
203
 
                return False;
204
 
        }
205
 
 
206
 
        r_u.status = _spoolss_abortprinter(p, &q_u, &r_u);
207
 
 
208
 
        if (!spoolss_io_r_abortprinter("",&r_u,rdata,0)) {
209
 
                DEBUG(0,("spoolss_io_r_abortprinter: unable to marshall SPOOL_R_ABORTPRINTER.\n"));
210
 
                return False;
211
 
        }
212
 
 
213
 
        return True;
214
 
}
215
 
 
216
 
/********************************************************************
217
 
 * api_spoolss_deleteprinter
218
 
 *
219
 
 * called from the spoolss dispatcher
220
 
 ********************************************************************/
221
 
 
222
 
static BOOL api_spoolss_deleteprinter(pipes_struct *p)
223
 
{
224
 
        SPOOL_Q_DELETEPRINTER q_u;
225
 
        SPOOL_R_DELETEPRINTER r_u;
226
 
        prs_struct *data = &p->in_data.data;
227
 
        prs_struct *rdata = &p->out_data.rdata;
228
 
 
229
 
        ZERO_STRUCT(q_u);
230
 
        ZERO_STRUCT(r_u);
231
 
 
232
 
        if (!spoolss_io_q_deleteprinter("", &q_u, data, 0)) {
233
 
                DEBUG(0,("spoolss_io_q_deleteprinter: unable to unmarshall SPOOL_Q_DELETEPRINTER.\n"));
234
 
                return False;
235
 
        }
236
 
 
237
 
        r_u.status = _spoolss_deleteprinter(p, &q_u, &r_u);
238
 
 
239
 
        if (!spoolss_io_r_deleteprinter("",&r_u,rdata,0)) {
240
 
                DEBUG(0,("spoolss_io_r_deleteprinter: unable to marshall SPOOL_R_DELETEPRINTER.\n"));
241
 
                return False;
242
 
        }
243
 
 
244
 
        return True;
245
 
}
246
 
 
247
 
 
248
 
/********************************************************************
249
 
 * api_spoolss_deleteprinterdriver
250
 
 *
251
 
 * called from the spoolss dispatcher
252
 
 ********************************************************************/
253
 
 
254
 
static BOOL api_spoolss_deleteprinterdriver(pipes_struct *p)
255
 
{
256
 
        SPOOL_Q_DELETEPRINTERDRIVER q_u;
257
 
        SPOOL_R_DELETEPRINTERDRIVER r_u;
258
 
        prs_struct *data = &p->in_data.data;
259
 
        prs_struct *rdata = &p->out_data.rdata;
260
 
 
261
 
        ZERO_STRUCT(q_u);
262
 
        ZERO_STRUCT(r_u);
263
 
 
264
 
        if (!spoolss_io_q_deleteprinterdriver("", &q_u, data, 0)) {
265
 
                DEBUG(0,("spoolss_io_q_deleteprinterdriver: unable to unmarshall SPOOL_Q_DELETEPRINTERDRIVER.\n"));
266
 
                return False;
267
 
        }
268
 
 
269
 
        r_u.status = _spoolss_deleteprinterdriver(p, &q_u, &r_u);
270
 
 
271
 
        if (!spoolss_io_r_deleteprinterdriver("",&r_u,rdata,0)) {
272
 
                DEBUG(0,("spoolss_io_r_deleteprinter: unable to marshall SPOOL_R_DELETEPRINTER.\n"));
273
 
                return False;
274
 
        }
275
 
 
276
 
        return True;
277
 
}
278
 
 
279
 
 
280
 
/********************************************************************
281
 
 * api_spoolss_rffpcnex
282
 
 * ReplyFindFirstPrinterChangeNotifyEx
283
 
 ********************************************************************/
284
 
 
285
 
static BOOL api_spoolss_rffpcnex(pipes_struct *p)
286
 
{
287
 
        SPOOL_Q_RFFPCNEX q_u;
288
 
        SPOOL_R_RFFPCNEX r_u;
289
 
        prs_struct *data = &p->in_data.data;
290
 
        prs_struct *rdata = &p->out_data.rdata;
291
 
 
292
 
        ZERO_STRUCT(q_u);
293
 
        ZERO_STRUCT(r_u);
294
 
 
295
 
        if (!spoolss_io_q_rffpcnex("", &q_u, data, 0)) {
296
 
                DEBUG(0,("spoolss_io_q_rffpcnex: unable to unmarshall SPOOL_Q_RFFPCNEX.\n"));
297
 
                return False;
298
 
        }
299
 
 
300
 
        r_u.status = _spoolss_rffpcnex(p, &q_u, &r_u);
301
 
 
302
 
        if (!spoolss_io_r_rffpcnex("", &r_u, rdata, 0)) {
303
 
                DEBUG(0,("spoolss_io_r_rffpcnex: unable to marshall SPOOL_R_RFFPCNEX.\n"));
304
 
                return False;
305
 
        }
306
 
 
307
 
        return True;
308
 
}
309
 
 
310
 
 
311
 
/********************************************************************
312
 
 * api_spoolss_rfnpcnex
313
 
 * ReplyFindNextPrinterChangeNotifyEx
314
 
 * called from the spoolss dispatcher
315
 
 
316
 
 * Note - this is the *ONLY* function that breaks the RPC call
317
 
 * symmetry in all the other calls. We need to do this to fix
318
 
 * the massive memory allocation problem with thousands of jobs...
319
 
 * JRA.
320
 
 ********************************************************************/
321
 
 
322
 
static BOOL api_spoolss_rfnpcnex(pipes_struct *p)
323
 
{
324
 
        SPOOL_Q_RFNPCNEX q_u;
325
 
        SPOOL_R_RFNPCNEX r_u;
326
 
        prs_struct *data = &p->in_data.data;
327
 
        prs_struct *rdata = &p->out_data.rdata;
328
 
 
329
 
        ZERO_STRUCT(q_u);
330
 
        ZERO_STRUCT(r_u);
331
 
 
332
 
        if (!spoolss_io_q_rfnpcnex("", &q_u, data, 0)) {
333
 
                DEBUG(0,("spoolss_io_q_rfnpcnex: unable to unmarshall SPOOL_Q_RFNPCNEX.\n"));
334
 
                return False;
335
 
        }
336
 
 
337
 
        r_u.status = _spoolss_rfnpcnex(p, &q_u, &r_u);
338
 
 
339
 
        if (!spoolss_io_r_rfnpcnex("", &r_u, rdata, 0)) {
340
 
                SAFE_FREE(r_u.info.data);
341
 
                DEBUG(0,("spoolss_io_r_rfnpcnex: unable to marshall SPOOL_R_RFNPCNEX.\n"));
342
 
                return False;
343
 
        }
344
 
 
345
 
        SAFE_FREE(r_u.info.data);
346
 
 
347
 
        return True;
348
 
}
349
 
 
350
 
 
351
 
/********************************************************************
352
 
 * api_spoolss_enumprinters
353
 
 * called from the spoolss dispatcher
354
 
 *
355
 
 ********************************************************************/
356
 
 
357
 
static BOOL api_spoolss_enumprinters(pipes_struct *p)
358
 
{
359
 
        SPOOL_Q_ENUMPRINTERS q_u;
360
 
        SPOOL_R_ENUMPRINTERS r_u;
361
 
        prs_struct *data = &p->in_data.data;
362
 
        prs_struct *rdata = &p->out_data.rdata;
363
 
 
364
 
        ZERO_STRUCT(q_u);
365
 
        ZERO_STRUCT(r_u);
366
 
 
367
 
        if (!spoolss_io_q_enumprinters("", &q_u, data, 0)) {
368
 
                DEBUG(0,("spoolss_io_q_enumprinters: unable to unmarshall SPOOL_Q_ENUMPRINTERS.\n"));
369
 
                return False;
370
 
        }
371
 
 
372
 
        r_u.status = _spoolss_enumprinters( p, &q_u, &r_u);
373
 
 
374
 
        if (!spoolss_io_r_enumprinters("", &r_u, rdata, 0)) {
375
 
                DEBUG(0,("spoolss_io_r_enumprinters: unable to marshall SPOOL_R_ENUMPRINTERS.\n"));
376
 
                return False;
377
 
        }
378
 
 
379
 
        return True;
380
 
}
381
 
 
382
 
/********************************************************************
383
 
 * api_spoolss_getprinter
384
 
 * called from the spoolss dispatcher
385
 
 *
386
 
 ********************************************************************/
387
 
 
388
 
static BOOL api_spoolss_getprinter(pipes_struct *p)
389
 
{
390
 
        SPOOL_Q_GETPRINTER q_u;
391
 
        SPOOL_R_GETPRINTER r_u;
392
 
        prs_struct *data = &p->in_data.data;
393
 
        prs_struct *rdata = &p->out_data.rdata;
394
 
 
395
 
        ZERO_STRUCT(q_u);
396
 
        ZERO_STRUCT(r_u);
397
 
 
398
 
        if(!spoolss_io_q_getprinter("", &q_u, data, 0)) {
399
 
                DEBUG(0,("spoolss_io_q_getprinter: unable to unmarshall SPOOL_Q_GETPRINTER.\n"));
400
 
                return False;
401
 
        }
402
 
 
403
 
        r_u.status = _spoolss_getprinter(p, &q_u, &r_u);
404
 
 
405
 
        if(!spoolss_io_r_getprinter("",&r_u,rdata,0)) {
406
 
                DEBUG(0,("spoolss_io_r_getprinter: unable to marshall SPOOL_R_GETPRINTER.\n"));
407
 
                return False;
408
 
        }
409
 
 
410
 
        return True;
411
 
}
412
 
 
413
 
/********************************************************************
414
 
 * api_spoolss_getprinter
415
 
 * called from the spoolss dispatcher
416
 
 *
417
 
 ********************************************************************/
418
 
 
419
 
static BOOL api_spoolss_getprinterdriver2(pipes_struct *p)
420
 
{
421
 
        SPOOL_Q_GETPRINTERDRIVER2 q_u;
422
 
        SPOOL_R_GETPRINTERDRIVER2 r_u;
423
 
        prs_struct *data = &p->in_data.data;
424
 
        prs_struct *rdata = &p->out_data.rdata;
425
 
 
426
 
        ZERO_STRUCT(q_u);
427
 
        ZERO_STRUCT(r_u);
428
 
 
429
 
        if(!spoolss_io_q_getprinterdriver2("", &q_u, data, 0)) {
430
 
                DEBUG(0,("spoolss_io_q_getprinterdriver2: unable to unmarshall SPOOL_Q_GETPRINTERDRIVER2.\n"));
431
 
                return False;
432
 
        }
433
 
 
434
 
        r_u.status = _spoolss_getprinterdriver2(p, &q_u, &r_u);
435
 
        
436
 
        if(!spoolss_io_r_getprinterdriver2("",&r_u,rdata,0)) {
437
 
                DEBUG(0,("spoolss_io_r_getprinterdriver2: unable to marshall SPOOL_R_GETPRINTERDRIVER2.\n"));
438
 
                return False;
439
 
        }
440
 
        
441
 
        return True;
442
 
}
443
 
 
444
 
/********************************************************************
445
 
 * api_spoolss_getprinter
446
 
 * called from the spoolss dispatcher
447
 
 *
448
 
 ********************************************************************/
449
 
 
450
 
static BOOL api_spoolss_startpageprinter(pipes_struct *p)
451
 
{
452
 
        SPOOL_Q_STARTPAGEPRINTER q_u;
453
 
        SPOOL_R_STARTPAGEPRINTER r_u;
454
 
        prs_struct *data = &p->in_data.data;
455
 
        prs_struct *rdata = &p->out_data.rdata;
456
 
 
457
 
        ZERO_STRUCT(q_u);
458
 
        ZERO_STRUCT(r_u);
459
 
 
460
 
        if(!spoolss_io_q_startpageprinter("", &q_u, data, 0)) {
461
 
                DEBUG(0,("spoolss_io_q_startpageprinter: unable to unmarshall SPOOL_Q_STARTPAGEPRINTER.\n"));
462
 
                return False;
463
 
        }
464
 
 
465
 
        r_u.status = _spoolss_startpageprinter(p, &q_u, &r_u);
466
 
 
467
 
        if(!spoolss_io_r_startpageprinter("",&r_u,rdata,0)) {
468
 
                DEBUG(0,("spoolss_io_r_startpageprinter: unable to marshall SPOOL_R_STARTPAGEPRINTER.\n"));
469
 
                return False;
470
 
        }
471
 
 
472
 
        return True;
473
 
}
474
 
 
475
 
/********************************************************************
476
 
 * api_spoolss_getprinter
477
 
 * called from the spoolss dispatcher
478
 
 *
479
 
 ********************************************************************/
480
 
 
481
 
static BOOL api_spoolss_endpageprinter(pipes_struct *p)
482
 
{
483
 
        SPOOL_Q_ENDPAGEPRINTER q_u;
484
 
        SPOOL_R_ENDPAGEPRINTER r_u;
485
 
        prs_struct *data = &p->in_data.data;
486
 
        prs_struct *rdata = &p->out_data.rdata;
487
 
 
488
 
        ZERO_STRUCT(q_u);
489
 
        ZERO_STRUCT(r_u);
490
 
 
491
 
        if(!spoolss_io_q_endpageprinter("", &q_u, data, 0)) {
492
 
                DEBUG(0,("spoolss_io_q_endpageprinter: unable to unmarshall SPOOL_Q_ENDPAGEPRINTER.\n"));
493
 
                return False;
494
 
        }
495
 
 
496
 
        r_u.status = _spoolss_endpageprinter(p, &q_u, &r_u);
497
 
 
498
 
        if(!spoolss_io_r_endpageprinter("",&r_u,rdata,0)) {
499
 
                DEBUG(0,("spoolss_io_r_endpageprinter: unable to marshall SPOOL_R_ENDPAGEPRINTER.\n"));
500
 
                return False;
501
 
        }
502
 
 
503
 
        return True;
504
 
}
505
 
 
506
 
/********************************************************************
507
 
********************************************************************/
508
 
 
509
 
static BOOL api_spoolss_startdocprinter(pipes_struct *p)
510
 
{
511
 
        SPOOL_Q_STARTDOCPRINTER q_u;
512
 
        SPOOL_R_STARTDOCPRINTER r_u;
513
 
        prs_struct *data = &p->in_data.data;
514
 
        prs_struct *rdata = &p->out_data.rdata;
515
 
 
516
 
        ZERO_STRUCT(q_u);
517
 
        ZERO_STRUCT(r_u);
518
 
 
519
 
        if(!spoolss_io_q_startdocprinter("", &q_u, data, 0)) {
520
 
                DEBUG(0,("spoolss_io_q_startdocprinter: unable to unmarshall SPOOL_Q_STARTDOCPRINTER.\n"));
521
 
                return False;
522
 
        }
523
 
 
524
 
        r_u.status = _spoolss_startdocprinter(p, &q_u, &r_u);
525
 
 
526
 
        if(!spoolss_io_r_startdocprinter("",&r_u,rdata,0)) {
527
 
                DEBUG(0,("spoolss_io_r_startdocprinter: unable to marshall SPOOL_R_STARTDOCPRINTER.\n"));
528
 
                return False;
529
 
        }
530
 
 
531
 
        return True;
532
 
}
533
 
 
534
 
/********************************************************************
535
 
********************************************************************/
536
 
 
537
 
static BOOL api_spoolss_enddocprinter(pipes_struct *p)
538
 
{
539
 
        SPOOL_Q_ENDDOCPRINTER q_u;
540
 
        SPOOL_R_ENDDOCPRINTER r_u;
541
 
        prs_struct *data = &p->in_data.data;
542
 
        prs_struct *rdata = &p->out_data.rdata;
543
 
 
544
 
        ZERO_STRUCT(q_u);
545
 
        ZERO_STRUCT(r_u);
546
 
 
547
 
        if(!spoolss_io_q_enddocprinter("", &q_u, data, 0)) {
548
 
                DEBUG(0,("spoolss_io_q_enddocprinter: unable to unmarshall SPOOL_Q_ENDDOCPRINTER.\n"));
549
 
                return False;
550
 
        }
551
 
 
552
 
        r_u.status = _spoolss_enddocprinter(p, &q_u, &r_u);
553
 
 
554
 
        if(!spoolss_io_r_enddocprinter("",&r_u,rdata,0)) {
555
 
                DEBUG(0,("spoolss_io_r_enddocprinter: unable to marshall SPOOL_R_ENDDOCPRINTER.\n"));
556
 
                return False;
557
 
        }
558
 
 
559
 
        return True;            
560
 
}
561
 
 
562
 
/********************************************************************
563
 
********************************************************************/
564
 
 
565
 
static BOOL api_spoolss_writeprinter(pipes_struct *p)
566
 
{
567
 
        SPOOL_Q_WRITEPRINTER q_u;
568
 
        SPOOL_R_WRITEPRINTER r_u;
569
 
        prs_struct *data = &p->in_data.data;
570
 
        prs_struct *rdata = &p->out_data.rdata;
571
 
 
572
 
        ZERO_STRUCT(q_u);
573
 
        ZERO_STRUCT(r_u);
574
 
 
575
 
        if(!spoolss_io_q_writeprinter("", &q_u, data, 0)) {
576
 
                DEBUG(0,("spoolss_io_q_writeprinter: unable to unmarshall SPOOL_Q_WRITEPRINTER.\n"));
577
 
                return False;
578
 
        }
579
 
 
580
 
        r_u.status = _spoolss_writeprinter(p, &q_u, &r_u);
581
 
 
582
 
        if(!spoolss_io_r_writeprinter("",&r_u,rdata,0)) {
583
 
                DEBUG(0,("spoolss_io_r_writeprinter: unable to marshall SPOOL_R_WRITEPRINTER.\n"));
584
 
                return False;
585
 
        }
586
 
 
587
 
        return True;
588
 
}
589
 
 
590
 
/****************************************************************************
591
 
 
592
 
****************************************************************************/
593
 
 
594
 
static BOOL api_spoolss_setprinter(pipes_struct *p)
595
 
{
596
 
        SPOOL_Q_SETPRINTER q_u;
597
 
        SPOOL_R_SETPRINTER r_u;
598
 
        prs_struct *data = &p->in_data.data;
599
 
        prs_struct *rdata = &p->out_data.rdata;
600
 
 
601
 
        ZERO_STRUCT(q_u);
602
 
        ZERO_STRUCT(r_u);
603
 
 
604
 
        if(!spoolss_io_q_setprinter("", &q_u, data, 0)) {
605
 
                DEBUG(0,("spoolss_io_q_setprinter: unable to unmarshall SPOOL_Q_SETPRINTER.\n"));
606
 
                return False;
607
 
        }
608
 
        
609
 
        r_u.status = _spoolss_setprinter(p, &q_u, &r_u);
610
 
        
611
 
        if(!spoolss_io_r_setprinter("",&r_u,rdata,0)) {
612
 
                DEBUG(0,("spoolss_io_r_setprinter: unable to marshall SPOOL_R_SETPRINTER.\n"));
613
 
                return False;
614
 
        }
615
 
 
616
 
        return True;
617
 
}
618
 
 
619
 
/****************************************************************************
620
 
****************************************************************************/
621
 
 
622
 
static BOOL api_spoolss_fcpn(pipes_struct *p)
623
 
{
624
 
        SPOOL_Q_FCPN q_u;
625
 
        SPOOL_R_FCPN r_u;
626
 
        prs_struct *data = &p->in_data.data;
627
 
        prs_struct *rdata = &p->out_data.rdata;
628
 
 
629
 
        ZERO_STRUCT(q_u);
630
 
        ZERO_STRUCT(r_u);
631
 
 
632
 
        if(!spoolss_io_q_fcpn("", &q_u, data, 0)) {
633
 
                DEBUG(0,("spoolss_io_q_fcpn: unable to unmarshall SPOOL_Q_FCPN.\n"));
634
 
                return False;
635
 
        }
636
 
 
637
 
        r_u.status = _spoolss_fcpn(p, &q_u, &r_u);
638
 
 
639
 
        if(!spoolss_io_r_fcpn("",&r_u,rdata,0)) {
640
 
                DEBUG(0,("spoolss_io_r_fcpn: unable to marshall SPOOL_R_FCPN.\n"));
641
 
                return False;
642
 
        }
643
 
 
644
 
        return True;
645
 
}
646
 
 
647
 
/****************************************************************************
648
 
****************************************************************************/
649
 
 
650
 
static BOOL api_spoolss_addjob(pipes_struct *p)
651
 
{
652
 
        SPOOL_Q_ADDJOB q_u;
653
 
        SPOOL_R_ADDJOB r_u;
654
 
        prs_struct *data = &p->in_data.data;
655
 
        prs_struct *rdata = &p->out_data.rdata;
656
 
 
657
 
        ZERO_STRUCT(q_u);
658
 
        ZERO_STRUCT(r_u);
659
 
 
660
 
        if(!spoolss_io_q_addjob("", &q_u, data, 0)) {
661
 
                DEBUG(0,("spoolss_io_q_addjob: unable to unmarshall SPOOL_Q_ADDJOB.\n"));
662
 
                return False;
663
 
        }
664
 
 
665
 
        r_u.status = _spoolss_addjob(p, &q_u, &r_u);
666
 
                
667
 
        if(!spoolss_io_r_addjob("",&r_u,rdata,0)) {
668
 
                DEBUG(0,("spoolss_io_r_addjob: unable to marshall SPOOL_R_ADDJOB.\n"));
669
 
                return False;
670
 
        }
671
 
 
672
 
        return True;            
673
 
}
674
 
 
675
 
/****************************************************************************
676
 
****************************************************************************/
677
 
 
678
 
static BOOL api_spoolss_enumjobs(pipes_struct *p)
679
 
{
680
 
        SPOOL_Q_ENUMJOBS q_u;
681
 
        SPOOL_R_ENUMJOBS r_u;
682
 
        prs_struct *data = &p->in_data.data;
683
 
        prs_struct *rdata = &p->out_data.rdata;
684
 
 
685
 
        ZERO_STRUCT(q_u);
686
 
        ZERO_STRUCT(r_u);
687
 
 
688
 
        if (!spoolss_io_q_enumjobs("", &q_u, data, 0)) {
689
 
                DEBUG(0,("spoolss_io_q_enumjobs: unable to unmarshall SPOOL_Q_ENUMJOBS.\n"));
690
 
                return False;
691
 
        }
692
 
 
693
 
        r_u.status = _spoolss_enumjobs(p, &q_u, &r_u);
694
 
 
695
 
        if (!spoolss_io_r_enumjobs("",&r_u,rdata,0)) {
696
 
                DEBUG(0,("spoolss_io_r_enumjobs: unable to marshall SPOOL_R_ENUMJOBS.\n"));
697
 
                return False;
698
 
        }
699
 
 
700
 
        return True;
701
 
}
702
 
 
703
 
/****************************************************************************
704
 
****************************************************************************/
705
 
 
706
 
static BOOL api_spoolss_schedulejob(pipes_struct *p)
707
 
{
708
 
        SPOOL_Q_SCHEDULEJOB q_u;
709
 
        SPOOL_R_SCHEDULEJOB r_u;
710
 
        prs_struct *data = &p->in_data.data;
711
 
        prs_struct *rdata = &p->out_data.rdata;
712
 
 
713
 
        ZERO_STRUCT(q_u);
714
 
        ZERO_STRUCT(r_u);
715
 
 
716
 
        if(!spoolss_io_q_schedulejob("", &q_u, data, 0)) {
717
 
                DEBUG(0,("spoolss_io_q_schedulejob: unable to unmarshall SPOOL_Q_SCHEDULEJOB.\n"));
718
 
                return False;
719
 
        }
720
 
 
721
 
        r_u.status = _spoolss_schedulejob(p, &q_u, &r_u);
722
 
 
723
 
        if(!spoolss_io_r_schedulejob("",&r_u,rdata,0)) {
724
 
                DEBUG(0,("spoolss_io_r_schedulejob: unable to marshall SPOOL_R_SCHEDULEJOB.\n"));
725
 
                return False;
726
 
        }
727
 
 
728
 
        return True;
729
 
}
730
 
 
731
 
/****************************************************************************
732
 
****************************************************************************/
733
 
 
734
 
static BOOL api_spoolss_setjob(pipes_struct *p)
735
 
{
736
 
        SPOOL_Q_SETJOB q_u;
737
 
        SPOOL_R_SETJOB r_u;
738
 
        prs_struct *data = &p->in_data.data;
739
 
        prs_struct *rdata = &p->out_data.rdata;
740
 
 
741
 
        ZERO_STRUCT(q_u);
742
 
        ZERO_STRUCT(r_u);
743
 
 
744
 
        if(!spoolss_io_q_setjob("", &q_u, data, 0)) {
745
 
                DEBUG(0,("spoolss_io_q_setjob: unable to unmarshall SPOOL_Q_SETJOB.\n"));
746
 
                return False;
747
 
        }
748
 
 
749
 
        r_u.status = _spoolss_setjob(p, &q_u, &r_u);
750
 
 
751
 
        if(!spoolss_io_r_setjob("",&r_u,rdata,0)) {
752
 
                DEBUG(0,("spoolss_io_r_setjob: unable to marshall SPOOL_R_SETJOB.\n"));
753
 
                return False;
754
 
        }
755
 
 
756
 
        return True;
757
 
}
758
 
 
759
 
/****************************************************************************
760
 
****************************************************************************/
761
 
 
762
 
static BOOL api_spoolss_enumprinterdrivers(pipes_struct *p)
763
 
{
764
 
        SPOOL_Q_ENUMPRINTERDRIVERS q_u;
765
 
        SPOOL_R_ENUMPRINTERDRIVERS r_u;
766
 
        prs_struct *data = &p->in_data.data;
767
 
        prs_struct *rdata = &p->out_data.rdata;
768
 
 
769
 
        ZERO_STRUCT(q_u);
770
 
        ZERO_STRUCT(r_u);
771
 
 
772
 
        if (!spoolss_io_q_enumprinterdrivers("", &q_u, data, 0)) {
773
 
                DEBUG(0,("spoolss_io_q_enumprinterdrivers: unable to unmarshall SPOOL_Q_ENUMPRINTERDRIVERS.\n"));
774
 
                return False;
775
 
        }
776
 
 
777
 
        r_u.status = _spoolss_enumprinterdrivers(p, &q_u, &r_u);
778
 
 
779
 
        if (!spoolss_io_r_enumprinterdrivers("",&r_u,rdata,0)) {
780
 
                DEBUG(0,("spoolss_io_r_enumprinterdrivers: unable to marshall SPOOL_R_ENUMPRINTERDRIVERS.\n"));
781
 
                return False;
782
 
        }
783
 
 
784
 
        return True;
785
 
}
786
 
 
787
 
/****************************************************************************
788
 
****************************************************************************/
789
 
 
790
 
static BOOL api_spoolss_getform(pipes_struct *p)
791
 
{
792
 
        SPOOL_Q_GETFORM q_u;
793
 
        SPOOL_R_GETFORM r_u;
794
 
        prs_struct *data = &p->in_data.data;
795
 
        prs_struct *rdata = &p->out_data.rdata;
796
 
 
797
 
        ZERO_STRUCT(q_u);
798
 
        ZERO_STRUCT(r_u);
799
 
 
800
 
        if (!spoolss_io_q_getform("", &q_u, data, 0)) {
801
 
                DEBUG(0,("spoolss_io_q_getform: unable to unmarshall SPOOL_Q_GETFORM.\n"));
802
 
                return False;
803
 
        }
804
 
 
805
 
        r_u.status = _spoolss_getform(p, &q_u, &r_u);
806
 
 
807
 
        if (!spoolss_io_r_getform("",&r_u,rdata,0)) {
808
 
                DEBUG(0,("spoolss_io_r_getform: unable to marshall SPOOL_R_GETFORM.\n"));
809
 
                return False;
810
 
        }
811
 
 
812
 
        return True;
813
 
}
814
 
 
815
 
/****************************************************************************
816
 
****************************************************************************/
817
 
 
818
 
static BOOL api_spoolss_enumforms(pipes_struct *p)
819
 
{
820
 
        SPOOL_Q_ENUMFORMS q_u;
821
 
        SPOOL_R_ENUMFORMS r_u;
822
 
        prs_struct *data = &p->in_data.data;
823
 
        prs_struct *rdata = &p->out_data.rdata;
824
 
 
825
 
        ZERO_STRUCT(q_u);
826
 
        ZERO_STRUCT(r_u);
827
 
 
828
 
        if (!spoolss_io_q_enumforms("", &q_u, data, 0)) {
829
 
                DEBUG(0,("spoolss_io_q_enumforms: unable to unmarshall SPOOL_Q_ENUMFORMS.\n"));
830
 
                return False;
831
 
        }
832
 
 
833
 
        r_u.status = _spoolss_enumforms(p, &q_u, &r_u);
834
 
 
835
 
        if (!spoolss_io_r_enumforms("",&r_u,rdata,0)) {
836
 
                DEBUG(0,("spoolss_io_r_enumforms: unable to marshall SPOOL_R_ENUMFORMS.\n"));
837
 
                return False;
838
 
        }
839
 
 
840
 
        return True;
841
 
}
842
 
 
843
 
/****************************************************************************
844
 
****************************************************************************/
845
 
 
846
 
static BOOL api_spoolss_enumports(pipes_struct *p)
847
 
{
848
 
        SPOOL_Q_ENUMPORTS q_u;
849
 
        SPOOL_R_ENUMPORTS r_u;
850
 
        prs_struct *data = &p->in_data.data;
851
 
        prs_struct *rdata = &p->out_data.rdata;
852
 
 
853
 
        ZERO_STRUCT(q_u);
854
 
        ZERO_STRUCT(r_u);
855
 
 
856
 
        if(!spoolss_io_q_enumports("", &q_u, data, 0)) {
857
 
                DEBUG(0,("spoolss_io_q_enumports: unable to unmarshall SPOOL_Q_ENUMPORTS.\n"));
858
 
                return False;
859
 
        }
860
 
 
861
 
        r_u.status = _spoolss_enumports(p, &q_u, &r_u);
862
 
 
863
 
        if (!spoolss_io_r_enumports("",&r_u,rdata,0)) {
864
 
                DEBUG(0,("spoolss_io_r_enumports: unable to marshall SPOOL_R_ENUMPORTS.\n"));
865
 
                return False;
866
 
        }
867
 
 
868
 
        return True;
869
 
}
870
 
 
871
 
/****************************************************************************
872
 
****************************************************************************/
873
 
 
874
 
static BOOL api_spoolss_addprinterex(pipes_struct *p)
875
 
{
876
 
        SPOOL_Q_ADDPRINTEREX q_u;
877
 
        SPOOL_R_ADDPRINTEREX r_u;
878
 
        prs_struct *data = &p->in_data.data;
879
 
        prs_struct *rdata = &p->out_data.rdata;
880
 
        
881
 
        ZERO_STRUCT(q_u);
882
 
        ZERO_STRUCT(r_u);
883
 
        
884
 
        if(!spoolss_io_q_addprinterex("", &q_u, data, 0)) {
885
 
                DEBUG(0,("spoolss_io_q_addprinterex: unable to unmarshall SPOOL_Q_ADDPRINTEREX.\n"));
886
 
                return False;
887
 
        }
888
 
        
889
 
        r_u.status = _spoolss_addprinterex(p, &q_u, &r_u);
890
 
                                
891
 
        if(!spoolss_io_r_addprinterex("", &r_u, rdata, 0)) {
892
 
                DEBUG(0,("spoolss_io_r_addprinterex: unable to marshall SPOOL_R_ADDPRINTEREX.\n"));
893
 
                return False;
894
 
        }
895
 
        
896
 
        return True;
897
 
}
898
 
 
899
 
/****************************************************************************
900
 
****************************************************************************/
901
 
 
902
 
static BOOL api_spoolss_addprinterdriver(pipes_struct *p)
903
 
{
904
 
        SPOOL_Q_ADDPRINTERDRIVER q_u;
905
 
        SPOOL_R_ADDPRINTERDRIVER r_u;
906
 
        prs_struct *data = &p->in_data.data;
907
 
        prs_struct *rdata = &p->out_data.rdata;
908
 
        
909
 
        ZERO_STRUCT(q_u);
910
 
        ZERO_STRUCT(r_u);
911
 
        
912
 
        if(!spoolss_io_q_addprinterdriver("", &q_u, data, 0)) {
913
 
                DEBUG(0,("spoolss_io_q_addprinterdriver: unable to unmarshall SPOOL_Q_ADDPRINTERDRIVER.\n"));
914
 
                return False;
915
 
        }
916
 
        
917
 
        r_u.status = _spoolss_addprinterdriver(p, &q_u, &r_u);
918
 
                                
919
 
        if(!spoolss_io_r_addprinterdriver("", &r_u, rdata, 0)) {
920
 
                DEBUG(0,("spoolss_io_r_addprinterdriver: unable to marshall SPOOL_R_ADDPRINTERDRIVER.\n"));
921
 
                return False;
922
 
        }
923
 
        
924
 
        return True;
925
 
}
926
 
 
927
 
/****************************************************************************
928
 
****************************************************************************/
929
 
 
930
 
static BOOL api_spoolss_getprinterdriverdirectory(pipes_struct *p)
931
 
{
932
 
        SPOOL_Q_GETPRINTERDRIVERDIR q_u;
933
 
        SPOOL_R_GETPRINTERDRIVERDIR r_u;
934
 
        prs_struct *data = &p->in_data.data;
935
 
        prs_struct *rdata = &p->out_data.rdata;
936
 
 
937
 
        ZERO_STRUCT(q_u);
938
 
        ZERO_STRUCT(r_u);
939
 
 
940
 
        if(!spoolss_io_q_getprinterdriverdir("", &q_u, data, 0)) {
941
 
                DEBUG(0,("spoolss_io_q_getprinterdriverdir: unable to unmarshall SPOOL_Q_GETPRINTERDRIVERDIR.\n"));
942
 
                return False;
943
 
        }
944
 
 
945
 
        r_u.status = _spoolss_getprinterdriverdirectory(p, &q_u, &r_u);
946
 
 
947
 
        if(!spoolss_io_r_getprinterdriverdir("", &r_u, rdata, 0)) {
948
 
                DEBUG(0,("spoolss_io_r_getprinterdriverdir: unable to marshall SPOOL_R_GETPRINTERDRIVERDIR.\n"));
949
 
                return False;
950
 
        }
951
 
 
952
 
        return True;
953
 
}
954
 
 
955
 
/****************************************************************************
956
 
****************************************************************************/
957
 
 
958
 
static BOOL api_spoolss_enumprinterdata(pipes_struct *p)
959
 
{
960
 
        SPOOL_Q_ENUMPRINTERDATA q_u;
961
 
        SPOOL_R_ENUMPRINTERDATA r_u;
962
 
        prs_struct *data = &p->in_data.data;
963
 
        prs_struct *rdata = &p->out_data.rdata;
964
 
        
965
 
        ZERO_STRUCT(q_u);
966
 
        ZERO_STRUCT(r_u);
967
 
        
968
 
        if(!spoolss_io_q_enumprinterdata("", &q_u, data, 0)) {
969
 
                DEBUG(0,("spoolss_io_q_enumprinterdata: unable to unmarshall SPOOL_Q_ENUMPRINTERDATA.\n"));
970
 
                return False;
971
 
        }
972
 
        
973
 
        r_u.status = _spoolss_enumprinterdata(p, &q_u, &r_u);
974
 
                                
975
 
        if(!spoolss_io_r_enumprinterdata("", &r_u, rdata, 0)) {
976
 
                DEBUG(0,("spoolss_io_r_enumprinterdata: unable to marshall SPOOL_R_ENUMPRINTERDATA.\n"));
977
 
                return False;
978
 
        }
979
 
 
980
 
        return True;
981
 
}
982
 
 
983
 
/****************************************************************************
984
 
****************************************************************************/
985
 
 
986
 
static BOOL api_spoolss_setprinterdata(pipes_struct *p)
987
 
{
988
 
        SPOOL_Q_SETPRINTERDATA q_u;
989
 
        SPOOL_R_SETPRINTERDATA r_u;
990
 
        prs_struct *data = &p->in_data.data;
991
 
        prs_struct *rdata = &p->out_data.rdata;
992
 
        
993
 
        ZERO_STRUCT(q_u);
994
 
        ZERO_STRUCT(r_u);
995
 
        
996
 
        if(!spoolss_io_q_setprinterdata("", &q_u, data, 0)) {
997
 
                DEBUG(0,("spoolss_io_q_setprinterdata: unable to unmarshall SPOOL_Q_SETPRINTERDATA.\n"));
998
 
                return False;
999
 
        }
1000
 
        
1001
 
        r_u.status = _spoolss_setprinterdata(p, &q_u, &r_u);
1002
 
                                
1003
 
        if(!spoolss_io_r_setprinterdata("", &r_u, rdata, 0)) {
1004
 
                DEBUG(0,("spoolss_io_r_setprinterdata: unable to marshall SPOOL_R_SETPRINTERDATA.\n"));
1005
 
                return False;
1006
 
        }
1007
 
 
1008
 
        return True;
1009
 
}
1010
 
 
1011
 
/****************************************************************************
1012
 
****************************************************************************/
1013
 
static BOOL api_spoolss_reset_printer(pipes_struct *p)
1014
 
{
1015
 
        SPOOL_Q_RESETPRINTER q_u;
1016
 
        SPOOL_R_RESETPRINTER r_u;
1017
 
        prs_struct *data = &p->in_data.data;
1018
 
        prs_struct *rdata = &p->out_data.rdata;
1019
 
 
1020
 
        ZERO_STRUCT(q_u);
1021
 
        ZERO_STRUCT(r_u);
1022
 
 
1023
 
        if(!spoolss_io_q_resetprinter("", &q_u, data, 0)) {
1024
 
                DEBUG(0,("spoolss_io_q_setprinterdata: unable to unmarshall SPOOL_Q_SETPRINTERDATA.\n"));
1025
 
                return False;
1026
 
        }
1027
 
        
1028
 
        r_u.status = _spoolss_resetprinter(p, &q_u, &r_u);
1029
 
 
1030
 
        if(!spoolss_io_r_resetprinter("", &r_u, rdata, 0)) {
1031
 
                DEBUG(0,("spoolss_io_r_setprinterdata: unable to marshall SPOOL_R_RESETPRINTER.\n"));
1032
 
                return False;
1033
 
        }
1034
 
 
1035
 
        return True;
1036
 
}
1037
 
 
1038
 
/****************************************************************************
1039
 
****************************************************************************/
1040
 
static BOOL api_spoolss_addform(pipes_struct *p)
1041
 
{
1042
 
        SPOOL_Q_ADDFORM q_u;
1043
 
        SPOOL_R_ADDFORM r_u;
1044
 
        prs_struct *data = &p->in_data.data;
1045
 
        prs_struct *rdata = &p->out_data.rdata;
1046
 
 
1047
 
        ZERO_STRUCT(q_u);
1048
 
        ZERO_STRUCT(r_u);
1049
 
        
1050
 
        if(!spoolss_io_q_addform("", &q_u, data, 0)) {
1051
 
                DEBUG(0,("spoolss_io_q_addform: unable to unmarshall SPOOL_Q_ADDFORM.\n"));
1052
 
                return False;
1053
 
        }
1054
 
        
1055
 
        r_u.status = _spoolss_addform(p, &q_u, &r_u);
1056
 
        
1057
 
        if(!spoolss_io_r_addform("", &r_u, rdata, 0)) {
1058
 
                DEBUG(0,("spoolss_io_r_addform: unable to marshall SPOOL_R_ADDFORM.\n"));
1059
 
                return False;
1060
 
        }
1061
 
 
1062
 
        return True;
1063
 
}
1064
 
 
1065
 
/****************************************************************************
1066
 
****************************************************************************/
1067
 
 
1068
 
static BOOL api_spoolss_deleteform(pipes_struct *p)
1069
 
{
1070
 
        SPOOL_Q_DELETEFORM q_u;
1071
 
        SPOOL_R_DELETEFORM r_u;
1072
 
        prs_struct *data = &p->in_data.data;
1073
 
        prs_struct *rdata = &p->out_data.rdata;
1074
 
 
1075
 
        ZERO_STRUCT(q_u);
1076
 
        ZERO_STRUCT(r_u);
1077
 
        
1078
 
        if(!spoolss_io_q_deleteform("", &q_u, data, 0)) {
1079
 
                DEBUG(0,("spoolss_io_q_deleteform: unable to unmarshall SPOOL_Q_DELETEFORM.\n"));
1080
 
                return False;
1081
 
        }
1082
 
        
1083
 
        r_u.status = _spoolss_deleteform(p, &q_u, &r_u);
1084
 
        
1085
 
        if(!spoolss_io_r_deleteform("", &r_u, rdata, 0)) {
1086
 
                DEBUG(0,("spoolss_io_r_deleteform: unable to marshall SPOOL_R_DELETEFORM.\n"));
1087
 
                return False;
1088
 
        }
1089
 
 
1090
 
        return True;
1091
 
}
1092
 
 
1093
 
/****************************************************************************
1094
 
****************************************************************************/
1095
 
 
1096
 
static BOOL api_spoolss_setform(pipes_struct *p)
1097
 
{
1098
 
        SPOOL_Q_SETFORM q_u;
1099
 
        SPOOL_R_SETFORM r_u;
1100
 
        prs_struct *data = &p->in_data.data;
1101
 
        prs_struct *rdata = &p->out_data.rdata;
1102
 
 
1103
 
        ZERO_STRUCT(q_u);
1104
 
        ZERO_STRUCT(r_u);
1105
 
        
1106
 
        if(!spoolss_io_q_setform("", &q_u, data, 0)) {
1107
 
                DEBUG(0,("spoolss_io_q_setform: unable to unmarshall SPOOL_Q_SETFORM.\n"));
1108
 
                return False;
1109
 
        }
1110
 
        
1111
 
        r_u.status = _spoolss_setform(p, &q_u, &r_u);
1112
 
                                      
1113
 
        if(!spoolss_io_r_setform("", &r_u, rdata, 0)) {
1114
 
                DEBUG(0,("spoolss_io_r_setform: unable to marshall SPOOL_R_SETFORM.\n"));
1115
 
                return False;
1116
 
        }
1117
 
 
1118
 
        return True;
1119
 
}
1120
 
 
1121
 
/****************************************************************************
1122
 
****************************************************************************/
1123
 
 
1124
 
static BOOL api_spoolss_enumprintprocessors(pipes_struct *p)
1125
 
{
1126
 
        SPOOL_Q_ENUMPRINTPROCESSORS q_u;
1127
 
        SPOOL_R_ENUMPRINTPROCESSORS r_u;
1128
 
        prs_struct *data = &p->in_data.data;
1129
 
        prs_struct *rdata = &p->out_data.rdata;
1130
 
 
1131
 
        ZERO_STRUCT(q_u);
1132
 
        ZERO_STRUCT(r_u);
1133
 
        
1134
 
        if(!spoolss_io_q_enumprintprocessors("", &q_u, data, 0)) {
1135
 
                DEBUG(0,("spoolss_io_q_enumprintprocessors: unable to unmarshall SPOOL_Q_ENUMPRINTPROCESSORS.\n"));
1136
 
                return False;
1137
 
        }
1138
 
        
1139
 
        r_u.status = _spoolss_enumprintprocessors(p, &q_u, &r_u);
1140
 
 
1141
 
        if(!spoolss_io_r_enumprintprocessors("", &r_u, rdata, 0)) {
1142
 
                DEBUG(0,("spoolss_io_r_enumprintprocessors: unable to marshall SPOOL_R_ENUMPRINTPROCESSORS.\n"));
1143
 
                return False;
1144
 
        }
1145
 
        
1146
 
        return True;
1147
 
}
1148
 
 
1149
 
/****************************************************************************
1150
 
****************************************************************************/
1151
 
 
1152
 
static BOOL api_spoolss_addprintprocessor(pipes_struct *p)
1153
 
{
1154
 
        SPOOL_Q_ADDPRINTPROCESSOR q_u;
1155
 
        SPOOL_R_ADDPRINTPROCESSOR r_u;
1156
 
        prs_struct *data = &p->in_data.data;
1157
 
        prs_struct *rdata = &p->out_data.rdata;
1158
 
 
1159
 
        ZERO_STRUCT(q_u);
1160
 
        ZERO_STRUCT(r_u);
1161
 
        
1162
 
        if(!spoolss_io_q_addprintprocessor("", &q_u, data, 0)) {
1163
 
                DEBUG(0,("spoolss_io_q_addprintprocessor: unable to unmarshall SPOOL_Q_ADDPRINTPROCESSOR.\n"));
1164
 
                return False;
1165
 
        }
1166
 
        
1167
 
        /* for now, just indicate success and ignore the add.  We'll
1168
 
           automatically set the winprint processor for printer
1169
 
           entries later.  Used to debug the LexMark Optra S 1855 PCL
1170
 
           driver --jerry */
1171
 
        r_u.status = WERR_OK;
1172
 
 
1173
 
        if(!spoolss_io_r_addprintprocessor("", &r_u, rdata, 0)) {
1174
 
                DEBUG(0,("spoolss_io_r_addprintprocessor: unable to marshall SPOOL_R_ADDPRINTPROCESSOR.\n"));
1175
 
                return False;
1176
 
        }
1177
 
        
1178
 
        return True;
1179
 
}
1180
 
 
1181
 
/****************************************************************************
1182
 
****************************************************************************/
1183
 
 
1184
 
static BOOL api_spoolss_enumprintprocdatatypes(pipes_struct *p)
1185
 
{
1186
 
        SPOOL_Q_ENUMPRINTPROCDATATYPES q_u;
1187
 
        SPOOL_R_ENUMPRINTPROCDATATYPES r_u;
1188
 
        prs_struct *data = &p->in_data.data;
1189
 
        prs_struct *rdata = &p->out_data.rdata;
1190
 
 
1191
 
        ZERO_STRUCT(q_u);
1192
 
        ZERO_STRUCT(r_u);
1193
 
        
1194
 
        if(!spoolss_io_q_enumprintprocdatatypes("", &q_u, data, 0)) {
1195
 
                DEBUG(0,("spoolss_io_q_enumprintprocdatatypes: unable to unmarshall SPOOL_Q_ENUMPRINTPROCDATATYPES.\n"));
1196
 
                return False;
1197
 
        }
1198
 
        
1199
 
        r_u.status = _spoolss_enumprintprocdatatypes(p, &q_u, &r_u);
1200
 
 
1201
 
        if(!spoolss_io_r_enumprintprocdatatypes("", &r_u, rdata, 0)) {
1202
 
                DEBUG(0,("spoolss_io_r_enumprintprocdatatypes: unable to marshall SPOOL_R_ENUMPRINTPROCDATATYPES.\n"));
1203
 
                return False;
1204
 
        }
1205
 
        
1206
 
        return True;
1207
 
}
1208
 
 
1209
 
/****************************************************************************
1210
 
****************************************************************************/
1211
 
 
1212
 
static BOOL api_spoolss_enumprintmonitors(pipes_struct *p)
1213
 
{
1214
 
        SPOOL_Q_ENUMPRINTMONITORS q_u;
1215
 
        SPOOL_R_ENUMPRINTMONITORS r_u;
1216
 
        prs_struct *data = &p->in_data.data;
1217
 
        prs_struct *rdata = &p->out_data.rdata;
1218
 
 
1219
 
        ZERO_STRUCT(q_u);
1220
 
        ZERO_STRUCT(r_u);
1221
 
        
1222
 
        if (!spoolss_io_q_enumprintmonitors("", &q_u, data, 0)) {
1223
 
                DEBUG(0,("spoolss_io_q_enumprintmonitors: unable to unmarshall SPOOL_Q_ENUMPRINTMONITORS.\n"));
1224
 
                return False;
1225
 
        }
1226
 
                
1227
 
        r_u.status = _spoolss_enumprintmonitors(p, &q_u, &r_u);
1228
 
 
1229
 
        if (!spoolss_io_r_enumprintmonitors("", &r_u, rdata, 0)) {
1230
 
                DEBUG(0,("spoolss_io_r_enumprintmonitors: unable to marshall SPOOL_R_ENUMPRINTMONITORS.\n"));
1231
 
                return False;
1232
 
        }
1233
 
        
1234
 
        return True;
1235
 
}
1236
 
 
1237
 
/****************************************************************************
1238
 
****************************************************************************/
1239
 
 
1240
 
static BOOL api_spoolss_getjob(pipes_struct *p)
1241
 
{
1242
 
        SPOOL_Q_GETJOB q_u;
1243
 
        SPOOL_R_GETJOB r_u;
1244
 
        prs_struct *data = &p->in_data.data;
1245
 
        prs_struct *rdata = &p->out_data.rdata;
1246
 
        
1247
 
        ZERO_STRUCT(q_u);
1248
 
        ZERO_STRUCT(r_u);
1249
 
        
1250
 
        if(!spoolss_io_q_getjob("", &q_u, data, 0)) {
1251
 
                DEBUG(0,("spoolss_io_q_getjob: unable to unmarshall SPOOL_Q_GETJOB.\n"));
1252
 
                return False;
1253
 
        }
1254
 
 
1255
 
        r_u.status = _spoolss_getjob(p, &q_u, &r_u);
1256
 
        
1257
 
        if(!spoolss_io_r_getjob("",&r_u,rdata,0)) {
1258
 
                DEBUG(0,("spoolss_io_r_getjob: unable to marshall SPOOL_R_GETJOB.\n"));
1259
 
                return False;
1260
 
        }
1261
 
                
1262
 
        return True;
1263
 
}
1264
 
 
1265
 
/********************************************************************
1266
 
 * api_spoolss_getprinterdataex
1267
 
 *
1268
 
 * called from the spoolss dispatcher
1269
 
 ********************************************************************/
1270
 
 
1271
 
static BOOL api_spoolss_getprinterdataex(pipes_struct *p)
1272
 
{
1273
 
        SPOOL_Q_GETPRINTERDATAEX q_u;
1274
 
        SPOOL_R_GETPRINTERDATAEX r_u;
1275
 
        prs_struct *data = &p->in_data.data;
1276
 
        prs_struct *rdata = &p->out_data.rdata;
1277
 
 
1278
 
        ZERO_STRUCT(q_u);
1279
 
        ZERO_STRUCT(r_u);
1280
 
 
1281
 
        /* read the stream and fill the struct */
1282
 
        if (!spoolss_io_q_getprinterdataex("", &q_u, data, 0)) {
1283
 
                DEBUG(0,("spoolss_io_q_getprinterdataex: unable to unmarshall SPOOL_Q_GETPRINTERDATAEX.\n"));
1284
 
                return False;
1285
 
        }
1286
 
        
1287
 
        r_u.status = _spoolss_getprinterdataex( p, &q_u, &r_u);
1288
 
 
1289
 
        if (!spoolss_io_r_getprinterdataex("", &r_u, rdata, 0)) {
1290
 
                DEBUG(0,("spoolss_io_r_getprinterdataex: unable to marshall SPOOL_R_GETPRINTERDATAEX.\n"));
1291
 
                return False;
1292
 
        }
1293
 
 
1294
 
        return True;
1295
 
}
1296
 
 
1297
 
/****************************************************************************
1298
 
****************************************************************************/
1299
 
 
1300
 
static BOOL api_spoolss_setprinterdataex(pipes_struct *p)
1301
 
{
1302
 
        SPOOL_Q_SETPRINTERDATAEX q_u;
1303
 
        SPOOL_R_SETPRINTERDATAEX r_u;
1304
 
        prs_struct *data = &p->in_data.data;
1305
 
        prs_struct *rdata = &p->out_data.rdata;
1306
 
        
1307
 
        ZERO_STRUCT(q_u);
1308
 
        ZERO_STRUCT(r_u);
1309
 
        
1310
 
        if(!spoolss_io_q_setprinterdataex("", &q_u, data, 0)) {
1311
 
                DEBUG(0,("spoolss_io_q_setprinterdataex: unable to unmarshall SPOOL_Q_SETPRINTERDATAEX.\n"));
1312
 
                return False;
1313
 
        }
1314
 
        
1315
 
        r_u.status = _spoolss_setprinterdataex(p, &q_u, &r_u);
1316
 
                                
1317
 
        if(!spoolss_io_r_setprinterdataex("", &r_u, rdata, 0)) {
1318
 
                DEBUG(0,("spoolss_io_r_setprinterdataex: unable to marshall SPOOL_R_SETPRINTERDATAEX.\n"));
1319
 
                return False;
1320
 
        }
1321
 
 
1322
 
        return True;
1323
 
}
1324
 
 
1325
 
 
1326
 
/****************************************************************************
1327
 
****************************************************************************/
1328
 
 
1329
 
static BOOL api_spoolss_enumprinterkey(pipes_struct *p)
1330
 
{
1331
 
        SPOOL_Q_ENUMPRINTERKEY q_u;
1332
 
        SPOOL_R_ENUMPRINTERKEY r_u;
1333
 
        prs_struct *data = &p->in_data.data;
1334
 
        prs_struct *rdata = &p->out_data.rdata;
1335
 
        
1336
 
        ZERO_STRUCT(q_u);
1337
 
        ZERO_STRUCT(r_u);
1338
 
        
1339
 
        if(!spoolss_io_q_enumprinterkey("", &q_u, data, 0)) {
1340
 
                DEBUG(0,("spoolss_io_q_setprinterkey: unable to unmarshall SPOOL_Q_ENUMPRINTERKEY.\n"));
1341
 
                return False;
1342
 
        }
1343
 
        
1344
 
        r_u.status = _spoolss_enumprinterkey(p, &q_u, &r_u);
1345
 
                                
1346
 
        if(!spoolss_io_r_enumprinterkey("", &r_u, rdata, 0)) {
1347
 
                DEBUG(0,("spoolss_io_r_enumprinterkey: unable to marshall SPOOL_R_ENUMPRINTERKEY.\n"));
1348
 
                return False;
1349
 
        }
1350
 
 
1351
 
        return True;
1352
 
}
1353
 
 
1354
 
/****************************************************************************
1355
 
****************************************************************************/
1356
 
 
1357
 
static BOOL api_spoolss_enumprinterdataex(pipes_struct *p)
1358
 
{
1359
 
        SPOOL_Q_ENUMPRINTERDATAEX q_u;
1360
 
        SPOOL_R_ENUMPRINTERDATAEX r_u;
1361
 
        prs_struct *data = &p->in_data.data;
1362
 
        prs_struct *rdata = &p->out_data.rdata;
1363
 
        
1364
 
        ZERO_STRUCT(q_u);
1365
 
        ZERO_STRUCT(r_u);
1366
 
        
1367
 
        if(!spoolss_io_q_enumprinterdataex("", &q_u, data, 0)) {
1368
 
                DEBUG(0,("spoolss_io_q_enumprinterdataex: unable to unmarshall SPOOL_Q_ENUMPRINTERDATAEX.\n"));
1369
 
                return False;
1370
 
        }
1371
 
        
1372
 
        r_u.status = _spoolss_enumprinterdataex(p, &q_u, &r_u);
1373
 
                                
1374
 
        if(!spoolss_io_r_enumprinterdataex("", &r_u, rdata, 0)) {
1375
 
                DEBUG(0,("spoolss_io_r_enumprinterdataex: unable to marshall SPOOL_R_ENUMPRINTERDATAEX.\n"));
1376
 
                return False;
1377
 
        }
1378
 
 
1379
 
        return True;
1380
 
}
1381
 
 
1382
 
/****************************************************************************
1383
 
****************************************************************************/
1384
 
 
1385
 
static BOOL api_spoolss_getprintprocessordirectory(pipes_struct *p)
1386
 
{
1387
 
        SPOOL_Q_GETPRINTPROCESSORDIRECTORY q_u;
1388
 
        SPOOL_R_GETPRINTPROCESSORDIRECTORY r_u;
1389
 
        prs_struct *data = &p->in_data.data;
1390
 
        prs_struct *rdata = &p->out_data.rdata;
1391
 
        
1392
 
        ZERO_STRUCT(q_u);
1393
 
        ZERO_STRUCT(r_u);
1394
 
        
1395
 
        if(!spoolss_io_q_getprintprocessordirectory("", &q_u, data, 0)) {
1396
 
                DEBUG(0,("spoolss_io_q_getprintprocessordirectory: unable to unmarshall SPOOL_Q_GETPRINTPROCESSORDIRECTORY.\n"));
1397
 
                return False;
1398
 
        }
1399
 
        
1400
 
        r_u.status = _spoolss_getprintprocessordirectory(p, &q_u, &r_u);
1401
 
                                
1402
 
        if(!spoolss_io_r_getprintprocessordirectory("", &r_u, rdata, 0)) {
1403
 
                DEBUG(0,("spoolss_io_r_getprintprocessordirectory: unable to marshall SPOOL_R_GETPRINTPROCESSORDIRECTORY.\n"));
1404
 
                return False;
1405
 
        }
1406
 
        
1407
 
        return True;
1408
 
}
1409
 
 
1410
 
/****************************************************************************
1411
 
****************************************************************************/
1412
 
 
1413
 
static BOOL api_spoolss_deleteprinterdataex(pipes_struct *p)
1414
 
{
1415
 
        SPOOL_Q_DELETEPRINTERDATAEX q_u;
1416
 
        SPOOL_R_DELETEPRINTERDATAEX r_u;
1417
 
        prs_struct *data = &p->in_data.data;
1418
 
        prs_struct *rdata = &p->out_data.rdata;
1419
 
        
1420
 
        ZERO_STRUCT(q_u);
1421
 
        ZERO_STRUCT(r_u);
1422
 
        
1423
 
        if(!spoolss_io_q_deleteprinterdataex("", &q_u, data, 0)) {
1424
 
                DEBUG(0,("spoolss_io_q_deleteprinterdataex: unable to unmarshall SPOOL_Q_DELETEPRINTERDATAEX.\n"));
1425
 
                return False;
1426
 
        }
1427
 
        
1428
 
        r_u.status = _spoolss_deleteprinterdataex(p, &q_u, &r_u);
1429
 
                                
1430
 
        if(!spoolss_io_r_deleteprinterdataex("", &r_u, rdata, 0)) {
1431
 
                DEBUG(0,("spoolss_io_r_deleteprinterdataex: unable to marshall SPOOL_R_DELETEPRINTERDATAEX.\n"));
1432
 
                return False;
1433
 
        }
1434
 
        
1435
 
        return True;
1436
 
}
1437
 
 
1438
 
/****************************************************************************
1439
 
****************************************************************************/
1440
 
 
1441
 
static BOOL api_spoolss_deleteprinterkey(pipes_struct *p)
1442
 
{
1443
 
        SPOOL_Q_DELETEPRINTERKEY q_u;
1444
 
        SPOOL_R_DELETEPRINTERKEY r_u;
1445
 
        prs_struct *data = &p->in_data.data;
1446
 
        prs_struct *rdata = &p->out_data.rdata;
1447
 
        
1448
 
        ZERO_STRUCT(q_u);
1449
 
        ZERO_STRUCT(r_u);
1450
 
        
1451
 
        if(!spoolss_io_q_deleteprinterkey("", &q_u, data, 0)) {
1452
 
                DEBUG(0,("spoolss_io_q_deleteprinterkey: unable to unmarshall SPOOL_Q_DELETEPRINTERKEY.\n"));
1453
 
                return False;
1454
 
        }
1455
 
        
1456
 
        r_u.status = _spoolss_deleteprinterkey(p, &q_u, &r_u);
1457
 
                                
1458
 
        if(!spoolss_io_r_deleteprinterkey("", &r_u, rdata, 0)) {
1459
 
                DEBUG(0,("spoolss_io_r_deleteprinterkey: unable to marshall SPOOL_R_DELETEPRINTERKEY.\n"));
1460
 
                return False;
1461
 
        }
1462
 
        
1463
 
        return True;
1464
 
}
1465
 
 
1466
 
/****************************************************************************
1467
 
****************************************************************************/
1468
 
 
1469
 
static BOOL api_spoolss_addprinterdriverex(pipes_struct *p)
1470
 
{
1471
 
        SPOOL_Q_ADDPRINTERDRIVEREX q_u;
1472
 
        SPOOL_R_ADDPRINTERDRIVEREX r_u;
1473
 
        prs_struct *data = &p->in_data.data;
1474
 
        prs_struct *rdata = &p->out_data.rdata;
1475
 
        
1476
 
        ZERO_STRUCT(q_u);
1477
 
        ZERO_STRUCT(r_u);
1478
 
        
1479
 
        if(!spoolss_io_q_addprinterdriverex("", &q_u, data, 0)) {
1480
 
                DEBUG(0,("spoolss_io_q_addprinterdriverex: unable to unmarshall SPOOL_Q_ADDPRINTERDRIVEREX.\n"));
1481
 
                return False;
1482
 
        }
1483
 
        
1484
 
        r_u.status = _spoolss_addprinterdriverex(p, &q_u, &r_u);
1485
 
                                
1486
 
        if(!spoolss_io_r_addprinterdriverex("", &r_u, rdata, 0)) {
1487
 
                DEBUG(0,("spoolss_io_r_addprinterdriverex: unable to marshall SPOOL_R_ADDPRINTERDRIVEREX.\n"));
1488
 
                return False;
1489
 
        }
1490
 
        
1491
 
        return True;
1492
 
}
1493
 
 
1494
 
/****************************************************************************
1495
 
****************************************************************************/
1496
 
 
1497
 
static BOOL api_spoolss_deleteprinterdriverex(pipes_struct *p)
1498
 
{
1499
 
        SPOOL_Q_DELETEPRINTERDRIVEREX q_u;
1500
 
        SPOOL_R_DELETEPRINTERDRIVEREX r_u;
1501
 
        prs_struct *data = &p->in_data.data;
1502
 
        prs_struct *rdata = &p->out_data.rdata;
1503
 
        
1504
 
        ZERO_STRUCT(q_u);
1505
 
        ZERO_STRUCT(r_u);
1506
 
        
1507
 
        if(!spoolss_io_q_deleteprinterdriverex("", &q_u, data, 0)) {
1508
 
                DEBUG(0,("spoolss_io_q_deleteprinterdriverex: unable to unmarshall SPOOL_Q_DELETEPRINTERDRIVEREX.\n"));
1509
 
                return False;
1510
 
        }
1511
 
        
1512
 
        r_u.status = _spoolss_deleteprinterdriverex(p, &q_u, &r_u);
1513
 
                                
1514
 
        if(!spoolss_io_r_deleteprinterdriverex("", &r_u, rdata, 0)) {
1515
 
                DEBUG(0,("spoolss_io_r_deleteprinterdriverex: unable to marshall SPOOL_R_DELETEPRINTERDRIVEREX.\n"));
1516
 
                return False;
1517
 
        }
1518
 
        
1519
 
        return True;
1520
 
}
1521
 
 
1522
 
/****************************************************************************
1523
 
****************************************************************************/
1524
 
 
1525
 
static BOOL api_spoolss_xcvdataport(pipes_struct *p)
1526
 
{
1527
 
        SPOOL_Q_XCVDATAPORT q_u;
1528
 
        SPOOL_R_XCVDATAPORT r_u;
1529
 
        prs_struct *data = &p->in_data.data;
1530
 
        prs_struct *rdata = &p->out_data.rdata;
1531
 
        
1532
 
        ZERO_STRUCT(q_u);
1533
 
        ZERO_STRUCT(r_u);
1534
 
        
1535
 
        if(!spoolss_io_q_xcvdataport("", &q_u, data, 0)) {
1536
 
                DEBUG(0,("spoolss_io_q_replyopenprinter: unable to unmarshall SPOOL_Q_XCVDATAPORT.\n"));
1537
 
                return False;
1538
 
        }
1539
 
        
1540
 
        r_u.status = _spoolss_xcvdataport(p, &q_u, &r_u);
1541
 
                                
1542
 
        if(!spoolss_io_r_xcvdataport("", &r_u, rdata, 0)) {
1543
 
                DEBUG(0,("spoolss_io_r_replyopenprinter: unable to marshall SPOOL_R_XCVDATAPORT.\n"));
1544
 
                return False;
1545
 
        }
1546
 
        
1547
 
        return True;
1548
 
}
1549
 
 
1550
 
/*******************************************************************
1551
 
\pipe\spoolss commands
1552
 
********************************************************************/
1553
 
 
1554
 
  struct api_struct api_spoolss_cmds[] = 
1555
 
    {
1556
 
 {"SPOOLSS_OPENPRINTER",               SPOOLSS_OPENPRINTER,               api_spoolss_open_printer              },
1557
 
 {"SPOOLSS_OPENPRINTEREX",             SPOOLSS_OPENPRINTEREX,             api_spoolss_open_printer_ex           },
1558
 
 {"SPOOLSS_GETPRINTERDATA",            SPOOLSS_GETPRINTERDATA,            api_spoolss_getprinterdata            },
1559
 
 {"SPOOLSS_CLOSEPRINTER",              SPOOLSS_CLOSEPRINTER,              api_spoolss_closeprinter              },
1560
 
 {"SPOOLSS_DELETEPRINTER",             SPOOLSS_DELETEPRINTER,             api_spoolss_deleteprinter             },
1561
 
 {"SPOOLSS_ABORTPRINTER",              SPOOLSS_ABORTPRINTER,              api_spoolss_abortprinter              },
1562
 
 {"SPOOLSS_RFFPCNEX",                  SPOOLSS_RFFPCNEX,                  api_spoolss_rffpcnex                  },
1563
 
 {"SPOOLSS_RFNPCNEX",                  SPOOLSS_RFNPCNEX,                  api_spoolss_rfnpcnex                  },
1564
 
 {"SPOOLSS_ENUMPRINTERS",              SPOOLSS_ENUMPRINTERS,              api_spoolss_enumprinters              },
1565
 
 {"SPOOLSS_GETPRINTER",                SPOOLSS_GETPRINTER,                api_spoolss_getprinter                },
1566
 
 {"SPOOLSS_GETPRINTERDRIVER2",         SPOOLSS_GETPRINTERDRIVER2,         api_spoolss_getprinterdriver2         }, 
1567
 
 {"SPOOLSS_STARTPAGEPRINTER",          SPOOLSS_STARTPAGEPRINTER,          api_spoolss_startpageprinter          },
1568
 
 {"SPOOLSS_ENDPAGEPRINTER",            SPOOLSS_ENDPAGEPRINTER,            api_spoolss_endpageprinter            }, 
1569
 
 {"SPOOLSS_STARTDOCPRINTER",           SPOOLSS_STARTDOCPRINTER,           api_spoolss_startdocprinter           },
1570
 
 {"SPOOLSS_ENDDOCPRINTER",             SPOOLSS_ENDDOCPRINTER,             api_spoolss_enddocprinter             },
1571
 
 {"SPOOLSS_WRITEPRINTER",              SPOOLSS_WRITEPRINTER,              api_spoolss_writeprinter              },
1572
 
 {"SPOOLSS_SETPRINTER",                SPOOLSS_SETPRINTER,                api_spoolss_setprinter                },
1573
 
 {"SPOOLSS_FCPN",                      SPOOLSS_FCPN,                      api_spoolss_fcpn                      },
1574
 
 {"SPOOLSS_ADDJOB",                    SPOOLSS_ADDJOB,                    api_spoolss_addjob                    },
1575
 
 {"SPOOLSS_ENUMJOBS",                  SPOOLSS_ENUMJOBS,                  api_spoolss_enumjobs                  },
1576
 
 {"SPOOLSS_SCHEDULEJOB",               SPOOLSS_SCHEDULEJOB,               api_spoolss_schedulejob               },
1577
 
 {"SPOOLSS_SETJOB",                    SPOOLSS_SETJOB,                    api_spoolss_setjob                    },
1578
 
 {"SPOOLSS_ENUMFORMS",                 SPOOLSS_ENUMFORMS,                 api_spoolss_enumforms                 },
1579
 
 {"SPOOLSS_ENUMPORTS",                 SPOOLSS_ENUMPORTS,                 api_spoolss_enumports                 },
1580
 
 {"SPOOLSS_ENUMPRINTERDRIVERS",        SPOOLSS_ENUMPRINTERDRIVERS,        api_spoolss_enumprinterdrivers        },
1581
 
 {"SPOOLSS_ADDPRINTEREX",              SPOOLSS_ADDPRINTEREX,              api_spoolss_addprinterex              },
1582
 
 {"SPOOLSS_ADDPRINTERDRIVER",          SPOOLSS_ADDPRINTERDRIVER,          api_spoolss_addprinterdriver          },
1583
 
 {"SPOOLSS_DELETEPRINTERDRIVER",       SPOOLSS_DELETEPRINTERDRIVER,       api_spoolss_deleteprinterdriver       },
1584
 
 {"SPOOLSS_GETPRINTERDRIVERDIRECTORY", SPOOLSS_GETPRINTERDRIVERDIRECTORY, api_spoolss_getprinterdriverdirectory },
1585
 
 {"SPOOLSS_ENUMPRINTERDATA",           SPOOLSS_ENUMPRINTERDATA,           api_spoolss_enumprinterdata           },
1586
 
 {"SPOOLSS_SETPRINTERDATA",            SPOOLSS_SETPRINTERDATA,            api_spoolss_setprinterdata            },
1587
 
 {"SPOOLSS_RESETPRINTER",              SPOOLSS_RESETPRINTER,              api_spoolss_reset_printer             },
1588
 
 {"SPOOLSS_DELETEPRINTERDATA",         SPOOLSS_DELETEPRINTERDATA,         api_spoolss_deleteprinterdata         },
1589
 
 {"SPOOLSS_ADDFORM",                   SPOOLSS_ADDFORM,                   api_spoolss_addform                   },
1590
 
 {"SPOOLSS_DELETEFORM",                SPOOLSS_DELETEFORM,                api_spoolss_deleteform                },
1591
 
 {"SPOOLSS_GETFORM",                   SPOOLSS_GETFORM,                   api_spoolss_getform                   },
1592
 
 {"SPOOLSS_SETFORM",                   SPOOLSS_SETFORM,                   api_spoolss_setform                   },
1593
 
 {"SPOOLSS_ADDPRINTPROCESSOR",         SPOOLSS_ADDPRINTPROCESSOR,         api_spoolss_addprintprocessor         },
1594
 
 {"SPOOLSS_ENUMPRINTPROCESSORS",       SPOOLSS_ENUMPRINTPROCESSORS,       api_spoolss_enumprintprocessors       },
1595
 
 {"SPOOLSS_ENUMMONITORS",              SPOOLSS_ENUMMONITORS,              api_spoolss_enumprintmonitors         },
1596
 
 {"SPOOLSS_GETJOB",                    SPOOLSS_GETJOB,                    api_spoolss_getjob                    },
1597
 
 {"SPOOLSS_ENUMPRINTPROCDATATYPES",    SPOOLSS_ENUMPRINTPROCDATATYPES,    api_spoolss_enumprintprocdatatypes    },
1598
 
 {"SPOOLSS_GETPRINTERDATAEX",          SPOOLSS_GETPRINTERDATAEX,          api_spoolss_getprinterdataex          },
1599
 
 {"SPOOLSS_SETPRINTERDATAEX",          SPOOLSS_SETPRINTERDATAEX,          api_spoolss_setprinterdataex          },
1600
 
 {"SPOOLSS_DELETEPRINTERDATAEX",       SPOOLSS_DELETEPRINTERDATAEX,       api_spoolss_deleteprinterdataex       },
1601
 
 {"SPOOLSS_ENUMPRINTERDATAEX",         SPOOLSS_ENUMPRINTERDATAEX,         api_spoolss_enumprinterdataex         },
1602
 
 {"SPOOLSS_ENUMPRINTERKEY",            SPOOLSS_ENUMPRINTERKEY,            api_spoolss_enumprinterkey            },
1603
 
 {"SPOOLSS_DELETEPRINTERKEY",          SPOOLSS_DELETEPRINTERKEY,          api_spoolss_deleteprinterkey          },
1604
 
 {"SPOOLSS_GETPRINTPROCESSORDIRECTORY",SPOOLSS_GETPRINTPROCESSORDIRECTORY,api_spoolss_getprintprocessordirectory},
1605
 
 {"SPOOLSS_ADDPRINTERDRIVEREX",        SPOOLSS_ADDPRINTERDRIVEREX,        api_spoolss_addprinterdriverex        },
1606
 
 {"SPOOLSS_DELETEPRINTERDRIVEREX",     SPOOLSS_DELETEPRINTERDRIVEREX,     api_spoolss_deleteprinterdriverex     },
1607
 
 {"SPOOLSS_XCVDATAPORT",               SPOOLSS_XCVDATAPORT,               api_spoolss_xcvdataport               },
1608
 
};
1609
 
 
1610
 
void spoolss_get_pipe_fns( struct api_struct **fns, int *n_fns )
1611
 
{
1612
 
        *fns = api_spoolss_cmds;
1613
 
        *n_fns = sizeof(api_spoolss_cmds) / sizeof(struct api_struct);
1614
 
}
1615
 
 
1616
 
NTSTATUS rpc_spoolss_init(void)
1617
 
{
1618
 
  return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "spoolss", "spoolss", api_spoolss_cmds,
1619
 
                                    sizeof(api_spoolss_cmds) / sizeof(struct api_struct));
1620
 
}