s3-spoolss: remove old spoolss_EnumPrinterKey.
[ira/wip.git] / source3 / rpc_parse / parse_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) Gerald Carter                2000-2002,
8  *  Copyright (C) Tim Potter                   2001-2002.
9  *
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; either version 3 of the License, or
13  *  (at your option) any later version.
14  *  
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *  GNU General Public License for more details.
19  *  
20  *  You should have received a copy of the GNU General Public License
21  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
22  */
23
24 #include "includes.h"
25
26 #undef DBGC_CLASS
27 #define DBGC_CLASS DBGC_RPC_PARSE
28
29
30 /*******************************************************************
31 This should be moved in a more generic lib.
32 ********************************************************************/  
33
34 bool spoolss_io_system_time(const char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
35 {
36         if(!prs_uint16("year", ps, depth, &systime->year))
37                 return False;
38         if(!prs_uint16("month", ps, depth, &systime->month))
39                 return False;
40         if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
41                 return False;
42         if(!prs_uint16("day", ps, depth, &systime->day))
43                 return False;
44         if(!prs_uint16("hour", ps, depth, &systime->hour))
45                 return False;
46         if(!prs_uint16("minute", ps, depth, &systime->minute))
47                 return False;
48         if(!prs_uint16("second", ps, depth, &systime->second))
49                 return False;
50         if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
51                 return False;
52
53         return True;
54 }
55
56 /*******************************************************************
57 ********************************************************************/  
58
59 bool make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
60 {
61         systime->year=unixtime->tm_year+1900;
62         systime->month=unixtime->tm_mon+1;
63         systime->dayofweek=unixtime->tm_wday;
64         systime->day=unixtime->tm_mday;
65         systime->hour=unixtime->tm_hour;
66         systime->minute=unixtime->tm_min;
67         systime->second=unixtime->tm_sec;
68         systime->milliseconds=0;
69
70         return True;
71 }
72
73 /*******************************************************************
74  * read or write a DEVICEMODE struct.
75  * on reading allocate memory for the private member
76  ********************************************************************/
77
78 #define DM_NUM_OPTIONAL_FIELDS          8
79
80 bool spoolss_io_devmode(const char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
81 {
82         int available_space;            /* size of the device mode left to parse */
83                                         /* only important on unmarshalling       */
84         int i = 0;
85         uint16 *unistr_buffer;
86         int j;
87                                         
88         struct optional_fields {
89                 fstring         name;
90                 uint32*         field;
91         } opt_fields[DM_NUM_OPTIONAL_FIELDS] = {
92                 { "icmmethod",          NULL },
93                 { "icmintent",          NULL },
94                 { "mediatype",          NULL },
95                 { "dithertype",         NULL },
96                 { "reserved1",          NULL },
97                 { "reserved2",          NULL },
98                 { "panningwidth",       NULL },
99                 { "panningheight",      NULL }
100         };
101
102         /* assign at run time to keep non-gcc compilers happy */
103
104         opt_fields[0].field = &devmode->icmmethod;
105         opt_fields[1].field = &devmode->icmintent;
106         opt_fields[2].field = &devmode->mediatype;
107         opt_fields[3].field = &devmode->dithertype;
108         opt_fields[4].field = &devmode->reserved1;
109         opt_fields[5].field = &devmode->reserved2;
110         opt_fields[6].field = &devmode->panningwidth;
111         opt_fields[7].field = &devmode->panningheight;
112                 
113         
114         prs_debug(ps, depth, desc, "spoolss_io_devmode");
115         depth++;
116
117         if (UNMARSHALLING(ps)) {
118                 devmode->devicename.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
119                 if (devmode->devicename.buffer == NULL)
120                         return False;
121                 unistr_buffer = devmode->devicename.buffer;
122         }
123         else {
124                 /* devicename is a static sized string but the buffer we set is not */
125                 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
126                 memset( unistr_buffer, 0x0, MAXDEVICENAME );
127                 for ( j=0; devmode->devicename.buffer[j]; j++ )
128                         unistr_buffer[j] = devmode->devicename.buffer[j];
129         }
130                 
131         if (!prs_uint16uni(True,"devicename", ps, depth, unistr_buffer, MAXDEVICENAME))
132                 return False;
133         
134         if (!prs_uint16("specversion",      ps, depth, &devmode->specversion))
135                 return False;
136                 
137         if (!prs_uint16("driverversion",    ps, depth, &devmode->driverversion))
138                 return False;
139         if (!prs_uint16("size",             ps, depth, &devmode->size))
140                 return False;
141         if (!prs_uint16("driverextra",      ps, depth, &devmode->driverextra))
142                 return False;
143         if (!prs_uint32("fields",           ps, depth, &devmode->fields))
144                 return False;
145         if (!prs_uint16("orientation",      ps, depth, &devmode->orientation))
146                 return False;
147         if (!prs_uint16("papersize",        ps, depth, &devmode->papersize))
148                 return False;
149         if (!prs_uint16("paperlength",      ps, depth, &devmode->paperlength))
150                 return False;
151         if (!prs_uint16("paperwidth",       ps, depth, &devmode->paperwidth))
152                 return False;
153         if (!prs_uint16("scale",            ps, depth, &devmode->scale))
154                 return False;
155         if (!prs_uint16("copies",           ps, depth, &devmode->copies))
156                 return False;
157         if (!prs_uint16("defaultsource",    ps, depth, &devmode->defaultsource))
158                 return False;
159         if (!prs_uint16("printquality",     ps, depth, &devmode->printquality))
160                 return False;
161         if (!prs_uint16("color",            ps, depth, &devmode->color))
162                 return False;
163         if (!prs_uint16("duplex",           ps, depth, &devmode->duplex))
164                 return False;
165         if (!prs_uint16("yresolution",      ps, depth, &devmode->yresolution))
166                 return False;
167         if (!prs_uint16("ttoption",         ps, depth, &devmode->ttoption))
168                 return False;
169         if (!prs_uint16("collate",          ps, depth, &devmode->collate))
170                 return False;
171
172         if (UNMARSHALLING(ps)) {
173                 devmode->formname.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
174                 if (devmode->formname.buffer == NULL)
175                         return False;
176                 unistr_buffer = devmode->formname.buffer;
177         }
178         else {
179                 /* devicename is a static sized string but the buffer we set is not */
180                 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
181                 memset( unistr_buffer, 0x0, MAXDEVICENAME );
182                 for ( j=0; devmode->formname.buffer[j]; j++ )
183                         unistr_buffer[j] = devmode->formname.buffer[j];
184         }
185         
186         if (!prs_uint16uni(True, "formname",  ps, depth, unistr_buffer, MAXDEVICENAME))
187                 return False;
188         if (!prs_uint16("logpixels",        ps, depth, &devmode->logpixels))
189                 return False;
190         if (!prs_uint32("bitsperpel",       ps, depth, &devmode->bitsperpel))
191                 return False;
192         if (!prs_uint32("pelswidth",        ps, depth, &devmode->pelswidth))
193                 return False;
194         if (!prs_uint32("pelsheight",       ps, depth, &devmode->pelsheight))
195                 return False;
196         if (!prs_uint32("displayflags",     ps, depth, &devmode->displayflags))
197                 return False;
198         if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
199                 return False;
200         /* 
201          * every device mode I've ever seen on the wire at least has up 
202          * to the displayfrequency field.   --jerry (05-09-2002)
203          */
204          
205         /* add uint32's + uint16's + two UNICODE strings */
206          
207         available_space = devmode->size - (sizeof(uint32)*6 + sizeof(uint16)*18 + sizeof(uint16)*64);
208         
209         /* Sanity check - we only have uint32's left tp parse */
210         
211         if ( available_space && ((available_space % sizeof(uint32)) != 0) ) {
212                 DEBUG(0,("spoolss_io_devmode: available_space [%d] no in multiple of 4 bytes (size = %d)!\n",
213                         available_space, devmode->size));
214                 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
215                 return False;
216         }
217
218         /* 
219          * Conditional parsing.  Assume that the DeviceMode has been 
220          * zero'd by the caller. 
221          */
222         
223         while ((available_space > 0)  && (i < DM_NUM_OPTIONAL_FIELDS))
224         {
225                 DEBUG(11, ("spoolss_io_devmode: [%d] bytes left to parse in devmode\n", available_space));
226                 if (!prs_uint32(opt_fields[i].name, ps, depth, opt_fields[i].field))
227                         return False;
228                 available_space -= sizeof(uint32);
229                 i++;
230         }        
231         
232         /* Sanity Check - we should no available space at this point unless 
233            MS changes the device mode structure */
234                 
235         if (available_space) {
236                 DEBUG(0,("spoolss_io_devmode: I've parsed all I know and there is still stuff left|\n"));
237                 DEBUG(0,("spoolss_io_devmode: available_space = [%d], devmode_size = [%d]!\n",
238                         available_space, devmode->size));
239                 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
240                 return False;
241         }
242
243
244         if (devmode->driverextra!=0) {
245                 if (UNMARSHALLING(ps)) {
246                         devmode->dev_private=PRS_ALLOC_MEM(ps, uint8, devmode->driverextra);
247                         if(devmode->dev_private == NULL)
248                                 return False;
249                         DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for dev_private\n",devmode->driverextra)); 
250                 }
251                         
252                 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of dev_private\n",devmode->driverextra));
253                 if (!prs_uint8s(False, "dev_private",  ps, depth,
254                                 devmode->dev_private, devmode->driverextra))
255                         return False;
256         }
257
258         return True;
259 }
260
261 /*******************************************************************
262  * return the length of a uint32 (obvious, but the code is clean)
263  ********************************************************************/
264
265 static uint32 size_of_uint32(uint32 *value)
266 {
267         return (sizeof(*value));
268 }
269
270 /*******************************************************************
271 return the size required by a struct in the stream
272 ********************************************************************/  
273 uint32 spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES *p)
274 {
275         uint32  size = 0; 
276         
277         if (!p)
278                 return 0;
279         
280         /* uint32(offset) + uint32(length) + length) */
281         size += (size_of_uint32(&p->value_len)*2) + p->value_len;
282         size += (size_of_uint32(&p->data_len)*2) + p->data_len + (p->data_len%2) ;
283         
284         size += size_of_uint32(&p->type);
285                        
286         return size;
287 }
288
289 /*******************************************************************
290  make a BUFFER5 struct from a uint16*
291  ******************************************************************/
292
293 bool make_spoolss_buffer5(TALLOC_CTX *mem_ctx, BUFFER5 *buf5, uint32 len, uint16 *src)
294 {
295
296         buf5->buf_len = len;
297         if (src) {
298                 if (len) {
299                         if((buf5->buffer=(uint16*)TALLOC_MEMDUP(mem_ctx, src, sizeof(uint16)*len)) == NULL) {
300                                 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
301                                 return False;
302                         }
303                 } else {
304                         buf5->buffer = NULL;
305                 }
306         } else {
307                 buf5->buffer=NULL;
308         }
309         
310         return True;
311 }
312
313 /*******************************************************************
314 ********************************************************************/  
315
316 bool make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX *q_u,
317                                       const POLICY_HND *hnd, const char *key,
318                                       uint32 size)
319 {
320         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
321         init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
322         q_u->size = size;
323
324         return True;
325 }
326
327 /*******************************************************************
328  * read a structure.
329  ********************************************************************/  
330
331 bool spoolss_io_q_enumprinterdataex(const char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
332 {
333         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
334         depth++;
335
336         if(!prs_align(ps))
337                 return False;
338         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
339                 return False;
340                 
341         if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
342                 return False;
343
344         if(!prs_align(ps))
345                 return False;
346         
347         if(!prs_uint32("size", ps, depth, &q_u->size))
348                 return False;
349
350         return True;
351 }
352
353 /*******************************************************************
354 ********************************************************************/  
355
356 static bool spoolss_io_printer_enum_values_ctr(const char *desc, prs_struct *ps, 
357                                 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
358 {
359         int     i;
360         uint32  valuename_offset,
361                 data_offset,
362                 current_offset;
363         const uint32 basic_unit = 20; /* size of static portion of enum_values */
364
365         prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
366         depth++;        
367
368         /* 
369          * offset data begins at 20 bytes per structure * size_of_array.
370          * Don't forget the uint32 at the beginning 
371          * */
372         
373         current_offset = basic_unit * ctr->size_of_array;
374         
375         /* first loop to write basic enum_value information */
376         
377         if (UNMARSHALLING(ps) && ctr->size_of_array) {
378                 ctr->values = PRS_ALLOC_MEM(ps, PRINTER_ENUM_VALUES, ctr->size_of_array);
379                 if (!ctr->values)
380                         return False;
381         }
382
383         for (i=0; i<ctr->size_of_array; i++) {
384                 uint32 base_offset, return_offset;
385
386                 base_offset = prs_offset(ps);
387
388                 valuename_offset = current_offset;
389                 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
390                         return False;
391
392                 /* Read or write the value. */
393
394                 return_offset = prs_offset(ps);
395
396                 if (!prs_set_offset(ps, base_offset + valuename_offset)) {
397                         return False;
398                 }
399
400                 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
401                         return False;
402
403                 /* And go back. */
404                 if (!prs_set_offset(ps, return_offset))
405                         return False;
406
407                 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
408                         return False;
409         
410                 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
411                         return False;
412         
413                 data_offset = ctr->values[i].value_len + valuename_offset;
414                 
415                 if (!prs_uint32("data_offset", ps, depth, &data_offset))
416                         return False;
417
418                 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
419                         return False;
420                         
421                 /* Read or write the data. */
422
423                 return_offset = prs_offset(ps);
424
425                 if (!prs_set_offset(ps, base_offset + data_offset)) {
426                         return False;
427                 }
428
429                 if ( ctr->values[i].data_len ) {
430                         if ( UNMARSHALLING(ps) ) {
431                                 ctr->values[i].data = PRS_ALLOC_MEM(ps, uint8, ctr->values[i].data_len);
432                                 if (!ctr->values[i].data)
433                                         return False;
434                         }
435                         if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
436                                 return False;
437                 }
438
439                 current_offset  = data_offset + ctr->values[i].data_len - basic_unit;
440                 /* account for 2 byte alignment */
441                 current_offset += (current_offset % 2);
442
443                 /* Remember how far we got. */
444                 data_offset = prs_offset(ps);
445
446                 /* And go back. */
447                 if (!prs_set_offset(ps, return_offset))
448                         return False;
449
450         }
451
452         /* Go to the last data offset we got to. */
453
454         if (!prs_set_offset(ps, data_offset))
455                 return False;
456
457         /* And ensure we're 2 byte aligned. */
458
459         if ( !prs_align_uint16(ps) )
460                 return False;
461
462         return True;    
463 }
464
465 /*******************************************************************
466  * write a structure.
467  ********************************************************************/  
468
469 bool spoolss_io_r_enumprinterdataex(const char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
470 {
471         uint32 data_offset, end_offset;
472         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
473         depth++;
474
475         if(!prs_align(ps))
476                 return False;
477
478         if (!prs_uint32("size", ps, depth, &r_u->ctr.size))
479                 return False;
480
481         data_offset = prs_offset(ps);
482
483         if (!prs_set_offset(ps, data_offset + r_u->ctr.size))
484                 return False;
485
486         if(!prs_align(ps))
487                 return False;
488
489         if(!prs_uint32("needed",     ps, depth, &r_u->needed))
490                 return False;
491
492         if(!prs_uint32("returned",   ps, depth, &r_u->returned))
493                 return False;
494
495         if(!prs_werror("status",     ps, depth, &r_u->status))
496                 return False;
497
498         r_u->ctr.size_of_array = r_u->returned;
499
500         end_offset = prs_offset(ps);
501
502         if (!prs_set_offset(ps, data_offset))
503                 return False;
504
505         if (r_u->ctr.size)
506                 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
507                         return False;
508
509         if (!prs_set_offset(ps, end_offset))
510                 return False;
511         return True;
512 }