source: branches/samba-3.0/source/rpc_parse/parse_reg.c

Last change on this file was 1, checked in by Paul Smedley, 18 years ago

Initial code import
File size: 44.7 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1997,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
6 * Copyright (C) Paul Ashton 1997.
7 * Copyright (C) Marc Jacobsen 1999.
8 * Copyright (C) Simo Sorce 2000.
9 * Copyright (C) Jeremy Cooper 2004
10 * Copyright (C) Gerald Carter 2002-2005.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 */
26
27#include "includes.h"
28
29#undef DBGC_CLASS
30#define DBGC_CLASS DBGC_RPC_PARSE
31
32/*******************************************************************
33 Fill in a REGVAL_BUFFER for the data given a REGISTRY_VALUE
34 *******************************************************************/
35
36uint32 reg_init_regval_buffer( REGVAL_BUFFER *buf2, REGISTRY_VALUE *val )
37{
38 uint32 real_size = 0;
39
40 if ( !buf2 || !val )
41 return 0;
42
43 real_size = regval_size(val);
44 init_regval_buffer( buf2, (unsigned char*)regval_data_p(val), real_size );
45
46 return real_size;
47}
48
49/*******************************************************************
50 Inits a hive connect request structure
51********************************************************************/
52
53void init_reg_q_open_hive( REG_Q_OPEN_HIVE *q_o, uint32 access_desired )
54{
55
56 q_o->server = TALLOC_P( get_talloc_ctx(), uint16);
57 if (!q_o->server) {
58 smb_panic("init_reg_q_open_hive: talloc fail.\n");
59 return;
60 }
61 *q_o->server = 0x1;
62
63 q_o->access = access_desired;
64}
65
66/*******************************************************************
67Marshalls a hive connect request
68********************************************************************/
69
70BOOL reg_io_q_open_hive(const char *desc, REG_Q_OPEN_HIVE *q_u,
71 prs_struct *ps, int depth)
72{
73 prs_debug(ps, depth, desc, "reg_io_q_open_hive");
74 depth++;
75
76 if(!prs_align(ps))
77 return False;
78
79 if(!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
80 return False;
81
82 if(!prs_align(ps))
83 return False;
84 if(!prs_uint32("access", ps, depth, &q_u->access))
85 return False;
86
87 return True;
88}
89
90
91/*******************************************************************
92Unmarshalls a hive connect response
93********************************************************************/
94
95BOOL reg_io_r_open_hive(const char *desc, REG_R_OPEN_HIVE *r_u,
96 prs_struct *ps, int depth)
97{
98 if ( !r_u )
99 return False;
100
101 prs_debug(ps, depth, desc, "reg_io_r_open_hive");
102 depth++;
103
104 if(!prs_align(ps))
105 return False;
106
107 if(!smb_io_pol_hnd("", &r_u->pol, ps, depth))
108 return False;
109
110 if(!prs_werror("status", ps, depth, &r_u->status))
111 return False;
112
113 return True;
114}
115
116/*******************************************************************
117 Inits a structure.
118********************************************************************/
119
120void init_reg_q_flush_key(REG_Q_FLUSH_KEY *q_u, POLICY_HND *pol)
121{
122 memcpy(&q_u->pol, pol, sizeof(q_u->pol));
123}
124
125/*******************************************************************
126reads or writes a structure.
127********************************************************************/
128
129BOOL reg_io_q_flush_key(const char *desc, REG_Q_FLUSH_KEY *q_u, prs_struct *ps, int depth)
130{
131 if ( !q_u )
132 return False;
133
134 prs_debug(ps, depth, desc, "reg_io_q_flush_key");
135 depth++;
136
137 if(!prs_align(ps))
138 return False;
139
140 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
141 return False;
142
143 return True;
144}
145
146/*******************************************************************
147Unmarshalls a registry key flush response
148********************************************************************/
149
150BOOL reg_io_r_flush_key(const char *desc, REG_R_FLUSH_KEY *r_u,
151 prs_struct *ps, int depth)
152{
153 if ( !r_u )
154 return False;
155
156 prs_debug(ps, depth, desc, "reg_io_r_flush_key");
157 depth++;
158
159 if(!prs_align(ps))
160 return False;
161
162 if(!prs_werror("status", ps, depth, &r_u->status))
163 return False;
164
165 return True;
166}
167
168/*******************************************************************
169reads or writes SEC_DESC_BUF and SEC_DATA structures.
170********************************************************************/
171
172static BOOL reg_io_hdrbuf_sec(uint32 ptr, uint32 *ptr3, BUFHDR *hdr_sec,
173 SEC_DESC_BUF *data, prs_struct *ps, int depth)
174{
175 if (ptr != 0) {
176 uint32 hdr_offset;
177 uint32 old_offset;
178 if(!smb_io_hdrbuf_pre("hdr_sec", hdr_sec, ps, depth,
179 &hdr_offset))
180 return False;
181
182 old_offset = prs_offset(ps);
183
184 if (ptr3 != NULL) {
185 if(!prs_uint32("ptr3", ps, depth, ptr3))
186 return False;
187 }
188
189 if (ptr3 == NULL || *ptr3 != 0) {
190 /* JRA - this next line is probably wrong... */
191 if(!sec_io_desc_buf("data ", &data, ps, depth))
192 return False;
193 }
194
195 if(!smb_io_hdrbuf_post("hdr_sec", hdr_sec, ps, depth,
196 hdr_offset, data->max_len, data->len))
197 return False;
198 if(!prs_set_offset(ps, old_offset + data->len +
199 sizeof(uint32) * ((ptr3 != NULL) ? 5 : 3)))
200 return False;
201
202 if(!prs_align(ps))
203 return False;
204 }
205
206 return True;
207}
208
209/*******************************************************************
210 Inits a registry key create request
211********************************************************************/
212
213void init_reg_q_create_key_ex(REG_Q_CREATE_KEY_EX *q_c, POLICY_HND *hnd,
214 char *name, char *key_class, uint32 access_desired,
215 SEC_DESC_BUF *sec_buf)
216{
217 ZERO_STRUCTP(q_c);
218
219 memcpy(&q_c->handle, hnd, sizeof(q_c->handle));
220
221
222 init_unistr4( &q_c->name, name, UNI_STR_TERMINATE );
223 init_unistr4( &q_c->key_class, key_class, UNI_STR_TERMINATE );
224
225 q_c->access = access_desired;
226
227 q_c->sec_info = TALLOC_P( get_talloc_ctx(), uint32 );
228 if (!q_c->sec_info) {
229 smb_panic("init_reg_q_create_key_ex: talloc fail\n");
230 return;
231 }
232 *q_c->sec_info = DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
233
234 q_c->data = sec_buf;
235 q_c->ptr2 = 1;
236 init_buf_hdr(&q_c->hdr_sec, sec_buf->len, sec_buf->len);
237 q_c->ptr3 = 1;
238 q_c->disposition = TALLOC_P( get_talloc_ctx(), uint32 );
239 if (!q_c->disposition) {
240 smb_panic("init_reg_q_create_key_ex: talloc fail\n");
241 return;
242 }
243}
244
245/*******************************************************************
246Marshalls a registry key create request
247********************************************************************/
248
249BOOL reg_io_q_create_key_ex(const char *desc, REG_Q_CREATE_KEY_EX *q_u,
250 prs_struct *ps, int depth)
251{
252 if ( !q_u )
253 return False;
254
255 prs_debug(ps, depth, desc, "reg_io_q_create_key_ex");
256 depth++;
257
258 if(!prs_align(ps))
259 return False;
260
261 if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
262 return False;
263
264 if(!prs_unistr4 ("name", ps, depth, &q_u->name))
265 return False;
266 if(!prs_align(ps))
267 return False;
268
269 if(!prs_unistr4 ("key_class", ps, depth, &q_u->key_class))
270 return False;
271 if(!prs_align(ps))
272 return False;
273
274 if(!prs_uint32("options", ps, depth, &q_u->options))
275 return False;
276 if(!prs_uint32("access", ps, depth, &q_u->access))
277 return False;
278
279 if(!prs_pointer("sec_info", ps, depth, (void**)&q_u->sec_info, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
280 return False;
281
282 if ( q_u->sec_info ) {
283 if(!prs_uint32("ptr2", ps, depth, &q_u->ptr2))
284 return False;
285 if(!reg_io_hdrbuf_sec(q_u->ptr2, &q_u->ptr3, &q_u->hdr_sec, q_u->data, ps, depth))
286 return False;
287 }
288
289 if(!prs_pointer("disposition", ps, depth, (void**)&q_u->disposition, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
290 return False;
291
292 return True;
293}
294
295/*******************************************************************
296Unmarshalls a registry key create response
297********************************************************************/
298
299BOOL reg_io_r_create_key_ex(const char *desc, REG_R_CREATE_KEY_EX *r_u,
300 prs_struct *ps, int depth)
301{
302 if ( !r_u )
303 return False;
304
305 prs_debug(ps, depth, desc, "reg_io_r_create_key_ex");
306 depth++;
307
308 if(!prs_align(ps))
309 return False;
310
311 if(!smb_io_pol_hnd("", &r_u->handle, ps, depth))
312 return False;
313 if(!prs_uint32("disposition", ps, depth, &r_u->disposition))
314 return False;
315
316 if(!prs_werror("status", ps, depth, &r_u->status))
317 return False;
318
319 return True;
320}
321
322
323/*******************************************************************
324 Inits a structure.
325********************************************************************/
326
327void init_reg_q_delete_val(REG_Q_DELETE_VALUE *q_c, POLICY_HND *hnd,
328 char *name)
329{
330 ZERO_STRUCTP(q_c);
331
332 memcpy(&q_c->handle, hnd, sizeof(q_c->handle));
333 init_unistr4(&q_c->name, name, UNI_STR_TERMINATE);
334}
335
336/*******************************************************************
337reads or writes a structure.
338********************************************************************/
339
340BOOL reg_io_q_delete_value(const char *desc, REG_Q_DELETE_VALUE *q_u,
341 prs_struct *ps, int depth)
342{
343 if ( !q_u )
344 return False;
345
346 prs_debug(ps, depth, desc, "reg_io_q_delete_value");
347 depth++;
348
349 if(!prs_align(ps))
350 return False;
351
352 if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
353 return False;
354
355 if(!prs_unistr4("name", ps, depth, &q_u->name))
356 return False;
357
358 return True;
359}
360
361
362/*******************************************************************
363reads or writes a structure.
364********************************************************************/
365
366BOOL reg_io_r_delete_value(const char *desc, REG_R_DELETE_VALUE *r_u,
367 prs_struct *ps, int depth)
368{
369 if ( !r_u )
370 return False;
371
372 prs_debug(ps, depth, desc, "reg_io_r_delete_value");
373 depth++;
374
375 if(!prs_align(ps))
376 return False;
377
378 if(!prs_werror("status", ps, depth, &r_u->status))
379 return False;
380
381 return True;
382}
383
384/*******************************************************************
385 Inits a structure.
386********************************************************************/
387
388void init_reg_q_delete_key(REG_Q_DELETE_KEY *q_c, POLICY_HND *hnd,
389 char *name)
390{
391 ZERO_STRUCTP(q_c);
392
393 memcpy(&q_c->handle, hnd, sizeof(q_c->handle));
394
395 init_unistr4(&q_c->name, name, UNI_STR_TERMINATE);
396}
397
398/*******************************************************************
399reads or writes a structure.
400********************************************************************/
401
402BOOL reg_io_q_delete_key(const char *desc, REG_Q_DELETE_KEY *q_u,
403 prs_struct *ps, int depth)
404{
405 if ( !q_u )
406 return False;
407
408 prs_debug(ps, depth, desc, "reg_io_q_delete_key");
409 depth++;
410
411 if(!prs_align(ps))
412 return False;
413
414 if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
415 return False;
416
417 if(!prs_unistr4("", ps, depth, &q_u->name))
418 return False;
419
420 return True;
421}
422
423/*******************************************************************
424reads or writes a structure.
425********************************************************************/
426
427BOOL reg_io_r_delete_key(const char *desc, REG_R_DELETE_KEY *r_u, prs_struct *ps, int depth)
428{
429 if ( !r_u )
430 return False;
431
432 prs_debug(ps, depth, desc, "reg_io_r_delete_key");
433 depth++;
434
435 if(!prs_align(ps))
436 return False;
437
438 if(!prs_werror("status", ps, depth, &r_u->status))
439 return False;
440
441 return True;
442}
443
444/*******************************************************************
445 Inits a structure.
446********************************************************************/
447
448void init_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd, const char *key_class)
449{
450 ZERO_STRUCTP(q_o);
451
452 memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
453 init_unistr4(&q_o->key_class, key_class, UNI_STR_TERMINATE);
454}
455
456/*******************************************************************
457reads or writes a structure.
458********************************************************************/
459
460BOOL reg_io_q_query_key(const char *desc, REG_Q_QUERY_KEY *q_u, prs_struct *ps, int depth)
461{
462 if ( !q_u )
463 return False;
464
465 prs_debug(ps, depth, desc, "reg_io_q_query_key");
466 depth++;
467
468 if(!prs_align(ps))
469 return False;
470
471 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
472 return False;
473 if(!prs_unistr4("key_class", ps, depth, &q_u->key_class))
474 return False;
475
476 return True;
477}
478
479
480/*******************************************************************
481reads or writes a structure.
482********************************************************************/
483
484BOOL reg_io_r_query_key(const char *desc, REG_R_QUERY_KEY *r_u, prs_struct *ps, int depth)
485{
486 if ( !r_u )
487 return False;
488
489 prs_debug(ps, depth, desc, "reg_io_r_query_key");
490 depth++;
491
492 if(!prs_align(ps))
493 return False;
494
495 if(!prs_unistr4("key_class", ps, depth, &r_u->key_class))
496 return False;
497
498 if(!prs_align(ps))
499 return False;
500
501 if(!prs_uint32("num_subkeys ", ps, depth, &r_u->num_subkeys))
502 return False;
503 if(!prs_uint32("max_subkeylen ", ps, depth, &r_u->max_subkeylen))
504 return False;
505 if(!prs_uint32("reserved ", ps, depth, &r_u->reserved))
506 return False;
507 if(!prs_uint32("num_values ", ps, depth, &r_u->num_values))
508 return False;
509 if(!prs_uint32("max_valnamelen", ps, depth, &r_u->max_valnamelen))
510 return False;
511 if(!prs_uint32("max_valbufsize", ps, depth, &r_u->max_valbufsize))
512 return False;
513 if(!prs_uint32("sec_desc ", ps, depth, &r_u->sec_desc))
514 return False;
515 if(!smb_io_time("mod_time ", &r_u->mod_time, ps, depth))
516 return False;
517
518 if(!prs_werror("status", ps, depth, &r_u->status))
519 return False;
520
521 return True;
522}
523
524/*******************************************************************
525 Inits a structure.
526********************************************************************/
527
528void init_reg_q_getversion(REG_Q_GETVERSION *q_o, POLICY_HND *hnd)
529{
530 memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
531}
532
533
534/*******************************************************************
535reads or writes a structure.
536********************************************************************/
537
538BOOL reg_io_q_getversion(const char *desc, REG_Q_GETVERSION *q_u, prs_struct *ps, int depth)
539{
540 if ( !q_u )
541 return False;
542
543 prs_debug(ps, depth, desc, "reg_io_q_getversion");
544 depth++;
545
546 if(!prs_align(ps))
547 return False;
548
549 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
550 return False;
551
552 return True;
553}
554
555/*******************************************************************
556reads or writes a structure.
557********************************************************************/
558
559BOOL reg_io_r_getversion(const char *desc, REG_R_GETVERSION *r_u, prs_struct *ps, int depth)
560{
561 if ( !r_u )
562 return False;
563
564 prs_debug(ps, depth, desc, "reg_io_r_getversion");
565 depth++;
566
567 if(!prs_align(ps))
568 return False;
569
570 if(!prs_uint32("win_version", ps, depth, &r_u->win_version))
571 return False;
572 if(!prs_werror("status" , ps, depth, &r_u->status))
573 return False;
574
575 return True;
576}
577
578
579/*******************************************************************
580reads or writes a structure.
581********************************************************************/
582
583BOOL reg_io_q_restore_key(const char *desc, REG_Q_RESTORE_KEY *q_u, prs_struct *ps, int depth)
584{
585 if ( !q_u )
586 return False;
587
588 prs_debug(ps, depth, desc, "reg_io_q_restore_key");
589 depth++;
590
591 if(!prs_align(ps))
592 return False;
593
594 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
595 return False;
596
597 if(!prs_unistr4("filename", ps, depth, &q_u->filename))
598 return False;
599
600 if(!prs_uint32("flags", ps, depth, &q_u->flags))
601 return False;
602
603 return True;
604}
605
606/*******************************************************************
607reads or writes a structure.
608********************************************************************/
609
610BOOL reg_io_r_restore_key(const char *desc, REG_R_RESTORE_KEY *r_u, prs_struct *ps, int depth)
611{
612 if ( !r_u )
613 return False;
614
615 prs_debug(ps, depth, desc, "reg_io_r_restore_key");
616 depth++;
617
618 if(!prs_align(ps))
619 return False;
620
621 if(!prs_werror("status" , ps, depth, &r_u->status))
622 return False;
623
624 return True;
625}
626
627/*******************************************************************
628********************************************************************/
629
630void init_q_reg_save_key( REG_Q_SAVE_KEY *q_u, POLICY_HND *handle, const char *fname )
631{
632 memcpy(&q_u->pol, handle, sizeof(q_u->pol));
633 init_unistr4( &q_u->filename, fname, UNI_STR_TERMINATE );
634 q_u->sec_attr = NULL;
635}
636
637/*******************************************************************
638reads or writes a structure.
639********************************************************************/
640
641BOOL reg_io_q_save_key(const char *desc, REG_Q_SAVE_KEY *q_u, prs_struct *ps, int depth)
642{
643 if ( !q_u )
644 return False;
645
646 prs_debug(ps, depth, desc, "reg_io_q_save_key");
647 depth++;
648
649 if(!prs_align(ps))
650 return False;
651
652 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
653 return False;
654
655 if(!prs_unistr4("filename", ps, depth, &q_u->filename))
656 return False;
657
658#if 0 /* reg_io_sec_attr() */
659 if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
660 return False;
661#endif
662
663 return True;
664}
665
666/*******************************************************************
667reads or writes a structure.
668********************************************************************/
669
670BOOL reg_io_r_save_key(const char *desc, REG_R_SAVE_KEY *r_u, prs_struct *ps, int depth)
671{
672 if ( !r_u )
673 return False;
674
675 prs_debug(ps, depth, desc, "reg_io_r_save_key");
676 depth++;
677
678 if(!prs_align(ps))
679 return False;
680
681 if(!prs_werror("status" , ps, depth, &r_u->status))
682 return False;
683
684 return True;
685}
686
687/*******************************************************************
688 Inits an REG_Q_CLOSE structure.
689********************************************************************/
690
691void init_reg_q_close(REG_Q_CLOSE *q_c, POLICY_HND *hnd)
692{
693 DEBUG(5,("init_reg_q_close\n"));
694
695 memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
696}
697
698/*******************************************************************
699reads or writes a structure.
700********************************************************************/
701
702BOOL reg_io_q_close(const char *desc, REG_Q_CLOSE *q_u, prs_struct *ps, int depth)
703{
704 if (q_u == NULL)
705 return False;
706
707 prs_debug(ps, depth, desc, "reg_io_q_close");
708 depth++;
709
710 if(!prs_align(ps))
711 return False;
712
713 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
714 return False;
715 if(!prs_align(ps))
716 return False;
717
718 return True;
719}
720
721/*******************************************************************
722reads or writes a structure.
723********************************************************************/
724
725BOOL reg_io_r_close(const char *desc, REG_R_CLOSE *r_u, prs_struct *ps, int depth)
726{
727 if ( !r_u )
728 return False;
729
730 prs_debug(ps, depth, desc, "reg_io_r_close");
731 depth++;
732
733 if(!prs_align(ps))
734 return False;
735
736 if(!smb_io_pol_hnd("", &r_u->pol, ps, depth))
737 return False;
738 if(!prs_align(ps))
739 return False;
740
741 if(!prs_werror("status", ps, depth, &r_u->status))
742 return False;
743
744 return True;
745}
746
747/*******************************************************************
748makes a structure.
749********************************************************************/
750
751void init_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_u, POLICY_HND *pol,
752 uint32 sec_info, SEC_DESC_BUF *sec_desc_buf)
753{
754 memcpy(&q_u->handle, pol, sizeof(q_u->handle));
755
756 q_u->sec_info = sec_info;
757
758 q_u->ptr = 1;
759 init_buf_hdr(&q_u->hdr_sec, sec_desc_buf->len, sec_desc_buf->len);
760 q_u->data = sec_desc_buf;
761}
762
763/*******************************************************************
764reads or writes a structure.
765********************************************************************/
766
767BOOL reg_io_q_set_key_sec(const char *desc, REG_Q_SET_KEY_SEC *q_u, prs_struct *ps, int depth)
768{
769 if ( !q_u )
770 return False;
771
772 prs_debug(ps, depth, desc, "reg_io_q_set_key_sec");
773 depth++;
774
775 if(!prs_align(ps))
776 return False;
777
778 if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
779 return False;
780
781 if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
782 return False;
783 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
784 return False;
785
786 if(!reg_io_hdrbuf_sec(q_u->ptr, NULL, &q_u->hdr_sec, q_u->data, ps, depth))
787 return False;
788
789 return True;
790}
791
792/*******************************************************************
793reads or writes a structure.
794********************************************************************/
795
796BOOL reg_io_r_set_key_sec(const char *desc, REG_R_SET_KEY_SEC *q_u, prs_struct *ps, int depth)
797{
798 if ( !q_u )
799 return False;
800
801 prs_debug(ps, depth, desc, "reg_io_r_set_key_sec");
802 depth++;
803
804 if(!prs_align(ps))
805 return False;
806
807 if(!prs_werror("status", ps, depth, &q_u->status))
808 return False;
809
810 return True;
811}
812
813
814/*******************************************************************
815makes a structure.
816********************************************************************/
817
818void init_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_u, POLICY_HND *pol,
819 uint32 sec_info, uint32 sec_buf_size,
820 SEC_DESC_BUF *psdb)
821{
822 memcpy(&q_u->handle, pol, sizeof(q_u->handle));
823
824 q_u->sec_info = sec_info;
825
826 q_u->ptr = psdb != NULL ? 1 : 0;
827 q_u->data = psdb;
828
829 init_buf_hdr(&q_u->hdr_sec, sec_buf_size, 0);
830}
831
832/*******************************************************************
833reads or writes a structure.
834********************************************************************/
835
836BOOL reg_io_q_get_key_sec(const char *desc, REG_Q_GET_KEY_SEC *q_u, prs_struct *ps, int depth)
837{
838 if ( !q_u )
839 return False;
840
841 prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
842 depth++;
843
844 if(!prs_align(ps))
845 return False;
846
847 if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
848 return False;
849
850 if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
851 return False;
852 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
853 return False;
854
855 if(!reg_io_hdrbuf_sec(q_u->ptr, NULL, &q_u->hdr_sec, q_u->data, ps, depth))
856 return False;
857
858 return True;
859}
860
861#if 0
862/*******************************************************************
863makes a structure.
864********************************************************************/
865 void init_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol,
866 uint32 buf_len, uint8 *buf,
867 NTSTATUS status)
868{
869 r_i->ptr = 1;
870 init_buf_hdr(&r_i->hdr_sec, buf_len, buf_len);
871 init_sec_desc_buf(r_i->data, buf_len, 1);
872
873 r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
874}
875#endif
876
877/*******************************************************************
878reads or writes a structure.
879********************************************************************/
880
881BOOL reg_io_r_get_key_sec(const char *desc, REG_R_GET_KEY_SEC *q_u, prs_struct *ps, int depth)
882{
883 if ( !q_u )
884 return False;
885
886 prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
887 depth++;
888
889 if(!prs_align(ps))
890 return False;
891
892 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
893 return False;
894
895 if (q_u->ptr != 0) {
896 if(!smb_io_hdrbuf("", &q_u->hdr_sec, ps, depth))
897 return False;
898 if(!sec_io_desc_buf("", &q_u->data, ps, depth))
899 return False;
900 if(!prs_align(ps))
901 return False;
902 }
903
904 if(!prs_werror("status", ps, depth, &q_u->status))
905 return False;
906
907 return True;
908}
909
910/*******************************************************************
911makes a structure.
912********************************************************************/
913
914BOOL init_reg_q_query_value(REG_Q_QUERY_VALUE *q_u, POLICY_HND *pol, const char *val_name,
915 REGVAL_BUFFER *value_output)
916{
917 if (q_u == NULL)
918 return False;
919
920 q_u->pol = *pol;
921
922 init_unistr4(&q_u->name, val_name, UNI_STR_TERMINATE);
923
924 q_u->ptr_reserved = 1;
925 q_u->ptr_buf = 1;
926
927 q_u->ptr_bufsize = 1;
928 q_u->bufsize = value_output->buf_max_len;
929 q_u->buf_unk = 0;
930
931 q_u->unk1 = 0;
932 q_u->ptr_buflen = 1;
933 q_u->buflen = value_output->buf_max_len;
934
935 q_u->ptr_buflen2 = 1;
936 q_u->buflen2 = 0;
937
938 return True;
939}
940
941/*******************************************************************
942reads or writes a structure.
943********************************************************************/
944
945BOOL reg_io_q_query_value(const char *desc, REG_Q_QUERY_VALUE *q_u, prs_struct *ps, int depth)
946{
947 if ( !q_u )
948 return False;
949
950 prs_debug(ps, depth, desc, "reg_io_q_query_value");
951 depth++;
952
953 if(!prs_align(ps))
954 return False;
955
956 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
957 return False;
958 if(!prs_unistr4("name", ps, depth, &q_u->name))
959 return False;
960
961 if(!prs_align(ps))
962 return False;
963
964 if(!prs_uint32("ptr_reserved", ps, depth, &(q_u->ptr_reserved)))
965 return False;
966
967 if(!prs_uint32("ptr_buf", ps, depth, &(q_u->ptr_buf)))
968 return False;
969
970 if(q_u->ptr_buf) {
971 if(!prs_uint32("ptr_bufsize", ps, depth, &(q_u->ptr_bufsize)))
972 return False;
973 if(!prs_uint32("bufsize", ps, depth, &(q_u->bufsize)))
974 return False;
975 if(!prs_uint32("buf_unk", ps, depth, &(q_u->buf_unk)))
976 return False;
977 }
978
979 if(!prs_uint32("unk1", ps, depth, &(q_u->unk1)))
980 return False;
981
982 if(!prs_uint32("ptr_buflen", ps, depth, &(q_u->ptr_buflen)))
983 return False;
984
985 if (q_u->ptr_buflen) {
986 if(!prs_uint32("buflen", ps, depth, &(q_u->buflen)))
987 return False;
988 if(!prs_uint32("ptr_buflen2", ps, depth, &(q_u->ptr_buflen2)))
989 return False;
990 if(!prs_uint32("buflen2", ps, depth, &(q_u->buflen2)))
991 return False;
992 }
993
994 return True;
995}
996
997/*******************************************************************
998 Inits a structure.
999 New version to replace older init_reg_r_query_value()
1000********************************************************************/
1001
1002BOOL init_reg_r_query_value(uint32 include_keyval, REG_R_QUERY_VALUE *r_u,
1003 REGISTRY_VALUE *val, WERROR status)
1004{
1005 uint32 buf_len = 0;
1006 REGVAL_BUFFER buf2;
1007
1008 if( !r_u || !val )
1009 return False;
1010
1011 r_u->type = TALLOC_P( get_talloc_ctx(), uint32 );
1012 if (!r_u->type) {
1013 return False;
1014 }
1015 *r_u->type = val->type;
1016
1017 buf_len = reg_init_regval_buffer( &buf2, val );
1018
1019 r_u->buf_max_len = TALLOC_P( get_talloc_ctx(), uint32 );
1020 if (!r_u->buf_max_len) {
1021 return False;
1022 }
1023 *r_u->buf_max_len = buf_len;
1024
1025 r_u->buf_len = TALLOC_P( get_talloc_ctx(), uint32 );
1026 if (!r_u->buf_len) {
1027 return False;
1028 }
1029 *r_u->buf_len = buf_len;
1030
1031 /* if include_keyval is not set, don't send the key value, just
1032 the buflen data. probably used by NT5 to allocate buffer space - SK */
1033
1034 if ( include_keyval ) {
1035 r_u->value = TALLOC_P( get_talloc_ctx(), REGVAL_BUFFER );
1036 if (!r_u->value) {
1037 return False;
1038 }
1039 /* steal the memory */
1040 *r_u->value = buf2;
1041 }
1042
1043 r_u->status = status;
1044
1045 return True;
1046}
1047
1048/*******************************************************************
1049reads or writes a structure.
1050********************************************************************/
1051
1052BOOL reg_io_r_query_value(const char *desc, REG_R_QUERY_VALUE *r_u, prs_struct *ps, int depth)
1053{
1054 if ( !r_u )
1055 return False;
1056
1057 prs_debug(ps, depth, desc, "reg_io_r_query_value");
1058 depth++;
1059
1060 if(!prs_align(ps))
1061 return False;
1062
1063 if ( !prs_pointer("type", ps, depth, (void**)&r_u->type, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
1064 return False;
1065
1066 if ( !prs_pointer("value", ps, depth, (void**)&r_u->value, sizeof(REGVAL_BUFFER), (PRS_POINTER_CAST)smb_io_regval_buffer))
1067 return False;
1068 if(!prs_align(ps))
1069 return False;
1070
1071 if ( !prs_pointer("buf_max_len", ps, depth, (void**)&r_u->buf_max_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
1072 return False;
1073 if ( !prs_pointer("buf_len", ps, depth, (void**)&r_u->buf_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
1074 return False;
1075
1076 if(!prs_werror("status", ps, depth, &r_u->status))
1077 return False;
1078
1079 return True;
1080}
1081
1082/*******************************************************************
1083makes a structure.
1084********************************************************************/
1085
1086void init_reg_q_enum_val(REG_Q_ENUM_VALUE *q_u, POLICY_HND *pol,
1087 uint32 val_idx,
1088 uint32 max_name_len, uint32 max_buf_len)
1089{
1090 ZERO_STRUCTP(q_u);
1091
1092 memcpy(&q_u->pol, pol, sizeof(q_u->pol));
1093
1094 q_u->val_index = val_idx;
1095
1096 q_u->name.size = max_name_len*2;
1097 q_u->name.string = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR2 );
1098 if (!q_u->name.string) {
1099 smb_panic("init_reg_q_enum_val: talloc fail\n");
1100 return;
1101 }
1102 q_u->name.string->uni_max_len = max_name_len;
1103
1104 q_u->type = TALLOC_P( get_talloc_ctx(), uint32 );
1105 if (!q_u->type) {
1106 smb_panic("init_reg_q_enum_val: talloc fail\n");
1107 return;
1108 }
1109 *q_u->type = 0x0;
1110
1111 q_u->value = TALLOC_ZERO_P( get_talloc_ctx(), REGVAL_BUFFER );
1112 if (!q_u->value) {
1113 smb_panic("init_reg_q_enum_val: talloc fail\n");
1114 return;
1115 }
1116
1117 q_u->value->buf_max_len = max_buf_len;
1118
1119 q_u->buffer_len = TALLOC_P( get_talloc_ctx(), uint32 );
1120 if (!q_u->buffer_len) {
1121 smb_panic("init_reg_q_enum_val: talloc fail\n");
1122 return;
1123 }
1124 *q_u->buffer_len = max_buf_len;
1125
1126 q_u->name_len = TALLOC_P( get_talloc_ctx(), uint32 );
1127 if (!q_u->name_len) {
1128 smb_panic("init_reg_q_enum_val: talloc fail\n");
1129 return;
1130 }
1131 *q_u->name_len = 0x0;
1132}
1133
1134/*******************************************************************
1135makes a structure.
1136********************************************************************/
1137
1138void init_reg_r_enum_val(REG_R_ENUM_VALUE *r_u, REGISTRY_VALUE *val )
1139{
1140 uint32 real_size;
1141
1142 ZERO_STRUCTP(r_u);
1143
1144 /* value name */
1145
1146 DEBUG(10,("init_reg_r_enum_val: Valuename => [%s]\n", val->valuename));
1147
1148 init_unistr4( &r_u->name, val->valuename, UNI_STR_TERMINATE);
1149
1150 /* type */
1151
1152 r_u->type = TALLOC_P( get_talloc_ctx(), uint32 );
1153 if (!r_u->type) {
1154 smb_panic("init_reg_r_enum_val: talloc fail\n");
1155 return;
1156 }
1157 *r_u->type = val->type;
1158
1159 /* REG_SZ & REG_MULTI_SZ must be converted to UNICODE */
1160
1161 r_u->value = TALLOC_P( get_talloc_ctx(), REGVAL_BUFFER );
1162 if (!r_u->value) {
1163 smb_panic("init_reg_r_enum_val: talloc fail\n");
1164 return;
1165 }
1166 real_size = reg_init_regval_buffer( r_u->value, val );
1167
1168 /* lengths */
1169
1170 r_u->buffer_len1 = TALLOC_P( get_talloc_ctx(), uint32 );
1171 if (!r_u->buffer_len1) {
1172 smb_panic("init_reg_r_enum_val: talloc fail\n");
1173 return;
1174 }
1175 *r_u->buffer_len1 = real_size;
1176 r_u->buffer_len2 = TALLOC_P( get_talloc_ctx(), uint32 );
1177 if (!r_u->buffer_len2) {
1178 smb_panic("init_reg_r_enum_val: talloc fail\n");
1179 return;
1180 }
1181 *r_u->buffer_len2 = real_size;
1182}
1183
1184/*******************************************************************
1185reads or writes a structure.
1186********************************************************************/
1187
1188BOOL reg_io_q_enum_val(const char *desc, REG_Q_ENUM_VALUE *q_u, prs_struct *ps, int depth)
1189{
1190 if (q_u == NULL)
1191 return False;
1192
1193 prs_debug(ps, depth, desc, "reg_io_q_enum_val");
1194 depth++;
1195
1196 if(!prs_align(ps))
1197 return False;
1198
1199 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
1200 return False;
1201
1202 if(!prs_uint32("val_index", ps, depth, &q_u->val_index))
1203 return False;
1204
1205 if(!prs_unistr4("name", ps, depth, &q_u->name ))
1206 return False;
1207 if(!prs_align(ps))
1208 return False;
1209
1210 if(!prs_pointer("type", ps, depth, (void**)&q_u->type, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
1211 return False;
1212
1213 if ( !prs_pointer("value", ps, depth, (void**)&q_u->value, sizeof(REGVAL_BUFFER), (PRS_POINTER_CAST)smb_io_regval_buffer))
1214 return False;
1215 if(!prs_align(ps))
1216 return False;
1217
1218 if(!prs_pointer("buffer_len", ps, depth, (void**)&q_u->buffer_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
1219 return False;
1220 if(!prs_pointer("name_len", ps, depth, (void**)&q_u->name_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
1221 return False;
1222
1223 return True;
1224}
1225
1226/*******************************************************************
1227reads or writes a structure.
1228********************************************************************/
1229
1230BOOL reg_io_r_enum_val(const char *desc, REG_R_ENUM_VALUE *r_u, prs_struct *ps, int depth)
1231{
1232 if ( !r_u )
1233 return False;
1234
1235 prs_debug(ps, depth, desc, "reg_io_r_enum_val");
1236 depth++;
1237
1238 if(!prs_align(ps))
1239 return False;
1240
1241 if(!prs_unistr4("name", ps, depth, &r_u->name ))
1242 return False;
1243 if(!prs_align(ps))
1244 return False;
1245
1246 if(!prs_pointer("type", ps, depth, (void**)&r_u->type, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
1247 return False;
1248
1249 if ( !prs_pointer("value", ps, depth, (void**)&r_u->value, sizeof(REGVAL_BUFFER), (PRS_POINTER_CAST)smb_io_regval_buffer))
1250 return False;
1251 if(!prs_align(ps))
1252 return False;
1253
1254 if(!prs_pointer("buffer_len1", ps, depth, (void**)&r_u->buffer_len1, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
1255 return False;
1256 if(!prs_pointer("buffer_len2", ps, depth, (void**)&r_u->buffer_len2, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
1257 return False;
1258
1259 if(!prs_werror("status", ps, depth, &r_u->status))
1260 return False;
1261
1262 return True;
1263}
1264
1265/*******************************************************************
1266makes a structure.
1267********************************************************************/
1268
1269void init_reg_q_set_val(REG_Q_SET_VALUE *q_u, POLICY_HND *pol,
1270 char *val_name, uint32 type,
1271 RPC_DATA_BLOB *val)
1272{
1273 ZERO_STRUCTP(q_u);
1274
1275 memcpy(&q_u->handle, pol, sizeof(q_u->handle));
1276
1277 init_unistr4(&q_u->name, val_name, UNI_STR_TERMINATE);
1278
1279 q_u->type = type;
1280 q_u->value = *val;
1281 q_u->size = val->buf_len;
1282}
1283
1284/*******************************************************************
1285reads or writes a structure.
1286********************************************************************/
1287
1288BOOL reg_io_q_set_value(const char *desc, REG_Q_SET_VALUE *q_u, prs_struct *ps, int depth)
1289{
1290 if (q_u == NULL)
1291 return False;
1292
1293 prs_debug(ps, depth, desc, "reg_io_q_set_value");
1294 depth++;
1295
1296 if(!prs_align(ps))
1297 return False;
1298
1299 if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
1300 return False;
1301
1302 if(!prs_unistr4("name", ps, depth, &q_u->name ))
1303 return False;
1304 if(!prs_align(ps))
1305 return False;
1306
1307 if(!prs_uint32("type", ps, depth, &q_u->type))
1308 return False;
1309
1310 if(!smb_io_rpc_blob("value", &q_u->value, ps, depth ))
1311 return False;
1312 if(!prs_align(ps))
1313 return False;
1314
1315 if(!prs_uint32("size", ps, depth, &q_u->size))
1316 return False;
1317
1318 return True;
1319}
1320
1321/*******************************************************************
1322reads or writes a structure.
1323********************************************************************/
1324
1325BOOL reg_io_r_set_value(const char *desc, REG_R_SET_VALUE *q_u, prs_struct *ps, int depth)
1326{
1327 if ( !q_u )
1328 return False;
1329
1330 prs_debug(ps, depth, desc, "reg_io_r_set_value");
1331 depth++;
1332
1333 if(!prs_align(ps))
1334 return False;
1335
1336 if(!prs_werror("status", ps, depth, &q_u->status))
1337 return False;
1338
1339 return True;
1340}
1341
1342/*******************************************************************
1343makes a structure.
1344********************************************************************/
1345
1346void init_reg_q_enum_key(REG_Q_ENUM_KEY *q_u, POLICY_HND *pol, uint32 key_idx)
1347{
1348 memcpy(&q_u->pol, pol, sizeof(q_u->pol));
1349
1350 q_u->key_index = key_idx;
1351 q_u->key_name_len = 0;
1352 q_u->unknown_1 = 0x0414;
1353
1354 q_u->ptr1 = 1;
1355 q_u->unknown_2 = 0x0000020A;
1356 memset(q_u->pad1, 0, sizeof(q_u->pad1));
1357
1358 q_u->ptr2 = 1;
1359 memset(q_u->pad2, 0, sizeof(q_u->pad2));
1360
1361 q_u->ptr3 = 1;
1362 unix_to_nt_time(&q_u->time, 0); /* current time? */
1363}
1364
1365/*******************************************************************
1366makes a reply structure.
1367********************************************************************/
1368
1369void init_reg_r_enum_key(REG_R_ENUM_KEY *r_u, char *subkey )
1370{
1371 if ( !r_u )
1372 return;
1373
1374 init_unistr4( &r_u->keyname, subkey, UNI_STR_TERMINATE );
1375 r_u->classname = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR4 );
1376 if (!r_u->classname) {
1377 smb_panic("init_reg_r_enum_key: talloc fail\n");
1378 return;
1379 }
1380 r_u->time = TALLOC_ZERO_P( get_talloc_ctx(), NTTIME );
1381 if (!r_u->time) {
1382 smb_panic("init_reg_r_enum_key: talloc fail\n");
1383 return;
1384 }
1385}
1386
1387/*******************************************************************
1388reads or writes a structure.
1389********************************************************************/
1390
1391BOOL reg_io_q_enum_key(const char *desc, REG_Q_ENUM_KEY *q_u, prs_struct *ps, int depth)
1392{
1393 if (q_u == NULL)
1394 return False;
1395
1396 prs_debug(ps, depth, desc, "reg_io_q_enum_key");
1397 depth++;
1398
1399 if(!prs_align(ps))
1400 return False;
1401
1402 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
1403 return False;
1404
1405 if(!prs_uint32("key_index", ps, depth, &q_u->key_index))
1406 return False;
1407 if(!prs_uint16("key_name_len", ps, depth, &q_u->key_name_len))
1408 return False;
1409 if(!prs_uint16("unknown_1", ps, depth, &q_u->unknown_1))
1410 return False;
1411
1412 if(!prs_uint32("ptr1", ps, depth, &q_u->ptr1))
1413 return False;
1414
1415 if (q_u->ptr1 != 0) {
1416 if(!prs_uint32("unknown_2", ps, depth, &q_u->unknown_2))
1417 return False;
1418 if(!prs_uint8s(False, "pad1", ps, depth, q_u->pad1, sizeof(q_u->pad1)))
1419 return False;
1420 }
1421
1422 if(!prs_uint32("ptr2", ps, depth, &q_u->ptr2))
1423 return False;
1424
1425 if (q_u->ptr2 != 0) {
1426 if(!prs_uint8s(False, "pad2", ps, depth, q_u->pad2, sizeof(q_u->pad2)))
1427 return False;
1428 }
1429
1430 if(!prs_uint32("ptr3", ps, depth, &q_u->ptr3))
1431 return False;
1432
1433 if (q_u->ptr3 != 0) {
1434 if(!smb_io_time("", &q_u->time, ps, depth))
1435 return False;
1436 }
1437
1438 return True;
1439}
1440
1441/*******************************************************************
1442reads or writes a structure.
1443********************************************************************/
1444
1445BOOL reg_io_r_enum_key(const char *desc, REG_R_ENUM_KEY *q_u, prs_struct *ps, int depth)
1446{
1447 if ( !q_u )
1448 return False;
1449
1450 prs_debug(ps, depth, desc, "reg_io_r_enum_key");
1451 depth++;
1452
1453 if(!prs_align(ps))
1454 return False;
1455 if ( !prs_unistr4( "keyname", ps, depth, &q_u->keyname ) )
1456 return False;
1457
1458 if(!prs_align(ps))
1459 return False;
1460 if (!prs_pointer("class", ps, depth, (void**)&q_u->classname, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
1461 return False;
1462
1463 if(!prs_align(ps))
1464 return False;
1465 if (!prs_pointer("time", ps, depth, (void**)&q_u->time, sizeof(NTTIME), (PRS_POINTER_CAST)smb_io_nttime))
1466 return False;
1467
1468 if(!prs_align(ps))
1469 return False;
1470 if(!prs_werror("status", ps, depth, &q_u->status))
1471 return False;
1472
1473 return True;
1474}
1475
1476/*******************************************************************
1477makes a structure.
1478********************************************************************/
1479
1480void init_reg_q_open_entry(REG_Q_OPEN_ENTRY *q_u, POLICY_HND *pol,
1481 char *key_name, uint32 access_desired)
1482{
1483 memcpy(&q_u->pol, pol, sizeof(q_u->pol));
1484
1485 init_unistr4(&q_u->name, key_name, UNI_STR_TERMINATE);
1486
1487 q_u->unknown_0 = 0x00000000;
1488 q_u->access = access_desired;
1489}
1490
1491/*******************************************************************
1492reads or writes a structure.
1493********************************************************************/
1494
1495BOOL reg_io_q_open_entry(const char *desc, REG_Q_OPEN_ENTRY *q_u, prs_struct *ps, int depth)
1496{
1497 if ( !q_u )
1498 return False;
1499
1500 prs_debug(ps, depth, desc, "reg_io_q_open_entry");
1501 depth++;
1502
1503 if(!prs_align(ps))
1504 return False;
1505
1506 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
1507 return False;
1508 if(!prs_unistr4("name", ps, depth, &q_u->name))
1509 return False;
1510
1511 if(!prs_align(ps))
1512 return False;
1513
1514 if(!prs_uint32("unknown_0 ", ps, depth, &q_u->unknown_0))
1515 return False;
1516 if(!prs_uint32("access", ps, depth, &q_u->access))
1517 return False;
1518
1519 return True;
1520}
1521
1522/*******************************************************************
1523reads or writes a structure.
1524********************************************************************/
1525
1526BOOL reg_io_r_open_entry(const char *desc, REG_R_OPEN_ENTRY *r_u, prs_struct *ps, int depth)
1527{
1528 if ( !r_u )
1529 return False;
1530
1531 prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1532 depth++;
1533
1534 if(!prs_align(ps))
1535 return False;
1536
1537 if(!smb_io_pol_hnd("handle", &r_u->handle, ps, depth))
1538 return False;
1539
1540 if(!prs_werror("status", ps, depth, &r_u->status))
1541 return False;
1542
1543 return True;
1544}
1545
1546/*******************************************************************
1547Inits a structure.
1548********************************************************************/
1549
1550void init_reg_q_shutdown(REG_Q_SHUTDOWN *q_u, const char *msg,
1551 uint32 timeout, BOOL do_reboot, BOOL force)
1552{
1553 q_u->server = TALLOC_P( get_talloc_ctx(), uint16 );
1554 if (!q_u->server) {
1555 smb_panic("init_reg_q_shutdown: talloc fail\n");
1556 return;
1557 }
1558 *q_u->server = 0x1;
1559
1560 q_u->message = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR4 );
1561 if (!q_u->message) {
1562 smb_panic("init_reg_q_shutdown: talloc fail\n");
1563 return;
1564 }
1565
1566 if ( msg && *msg ) {
1567 init_unistr4( q_u->message, msg, UNI_FLAGS_NONE );
1568
1569 /* Win2000 is apparently very sensitive to these lengths */
1570 /* do a special case here */
1571
1572 q_u->message->string->uni_max_len++;
1573 q_u->message->size += 2;
1574
1575 }
1576
1577 q_u->timeout = timeout;
1578
1579 q_u->reboot = do_reboot ? 1 : 0;
1580 q_u->force = force ? 1 : 0;
1581}
1582
1583/*******************************************************************
1584Inits a REG_Q_SHUTDOWN_EX structure.
1585********************************************************************/
1586
1587void init_reg_q_shutdown_ex(REG_Q_SHUTDOWN_EX * q_u_ex, const char *msg,
1588 uint32 timeout, BOOL do_reboot, BOOL force, uint32 reason)
1589{
1590 REG_Q_SHUTDOWN q_u;
1591
1592 ZERO_STRUCT( q_u );
1593
1594 init_reg_q_shutdown( &q_u, msg, timeout, do_reboot, force );
1595
1596 /* steal memory */
1597
1598 q_u_ex->server = q_u.server;
1599 q_u_ex->message = q_u.message;
1600
1601 q_u_ex->reboot = q_u.reboot;
1602 q_u_ex->force = q_u.force;
1603
1604 q_u_ex->reason = reason;
1605}
1606
1607/*******************************************************************
1608reads or writes a structure.
1609********************************************************************/
1610
1611BOOL reg_io_q_shutdown(const char *desc, REG_Q_SHUTDOWN *q_u, prs_struct *ps,
1612 int depth)
1613{
1614 if ( !q_u )
1615 return False;
1616
1617 prs_debug(ps, depth, desc, "reg_io_q_shutdown");
1618 depth++;
1619
1620 if (!prs_align(ps))
1621 return False;
1622
1623 if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
1624 return False;
1625 if (!prs_align(ps))
1626 return False;
1627
1628 if (!prs_pointer("message", ps, depth, (void**)&q_u->message, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
1629 return False;
1630
1631 if (!prs_align(ps))
1632 return False;
1633
1634 if (!prs_uint32("timeout", ps, depth, &(q_u->timeout)))
1635 return False;
1636
1637 if (!prs_uint8("force ", ps, depth, &(q_u->force)))
1638 return False;
1639 if (!prs_uint8("reboot ", ps, depth, &(q_u->reboot)))
1640 return False;
1641
1642
1643 return True;
1644}
1645
1646/*******************************************************************
1647reads or writes a structure.
1648********************************************************************/
1649BOOL reg_io_r_shutdown(const char *desc, REG_R_SHUTDOWN *r_u, prs_struct *ps,
1650 int depth)
1651{
1652 if ( !r_u )
1653 return False;
1654
1655 prs_debug(ps, depth, desc, "reg_io_r_shutdown");
1656 depth++;
1657
1658 if(!prs_align(ps))
1659 return False;
1660
1661 if(!prs_werror("status", ps, depth, &r_u->status))
1662 return False;
1663
1664 return True;
1665}
1666
1667/*******************************************************************
1668reads or writes a REG_Q_SHUTDOWN_EX structure.
1669********************************************************************/
1670
1671BOOL reg_io_q_shutdown_ex(const char *desc, REG_Q_SHUTDOWN_EX *q_u, prs_struct *ps,
1672 int depth)
1673{
1674 if ( !q_u )
1675 return False;
1676
1677 prs_debug(ps, depth, desc, "reg_io_q_shutdown_ex");
1678 depth++;
1679
1680 if (!prs_align(ps))
1681 return False;
1682
1683 if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
1684 return False;
1685 if (!prs_align(ps))
1686 return False;
1687
1688 if (!prs_pointer("message", ps, depth, (void**)&q_u->message, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
1689 return False;
1690
1691 if (!prs_align(ps))
1692 return False;
1693
1694 if (!prs_uint32("timeout", ps, depth, &(q_u->timeout)))
1695 return False;
1696
1697 if (!prs_uint8("force ", ps, depth, &(q_u->force)))
1698 return False;
1699 if (!prs_uint8("reboot ", ps, depth, &(q_u->reboot)))
1700 return False;
1701
1702 if (!prs_align(ps))
1703 return False;
1704 if (!prs_uint32("reason", ps, depth, &(q_u->reason)))
1705 return False;
1706
1707
1708 return True;
1709}
1710
1711/*******************************************************************
1712reads or writes a REG_R_SHUTDOWN_EX structure.
1713********************************************************************/
1714BOOL reg_io_r_shutdown_ex(const char *desc, REG_R_SHUTDOWN_EX *r_u, prs_struct *ps,
1715 int depth)
1716{
1717 if ( !r_u )
1718 return False;
1719
1720 prs_debug(ps, depth, desc, "reg_io_r_shutdown_ex");
1721 depth++;
1722
1723 if(!prs_align(ps))
1724 return False;
1725
1726 if(!prs_werror("status", ps, depth, &r_u->status))
1727 return False;
1728
1729 return True;
1730}
1731
1732/*******************************************************************
1733Inits a structure.
1734********************************************************************/
1735
1736void init_reg_q_abort_shutdown(REG_Q_ABORT_SHUTDOWN *q_u)
1737{
1738 q_u->server = TALLOC_P( get_talloc_ctx(), uint16 );
1739 if (!q_u->server) {
1740 smb_panic("init_reg_q_abort_shutdown: talloc fail\n");
1741 return;
1742 }
1743 *q_u->server = 0x1;
1744}
1745
1746/*******************************************************************
1747reads or writes a structure.
1748********************************************************************/
1749
1750BOOL reg_io_q_abort_shutdown(const char *desc, REG_Q_ABORT_SHUTDOWN *q_u,
1751 prs_struct *ps, int depth)
1752{
1753 if ( !q_u )
1754 return False;
1755
1756 prs_debug(ps, depth, desc, "reg_io_q_abort_shutdown");
1757 depth++;
1758
1759 if (!prs_align(ps))
1760 return False;
1761
1762 if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
1763 return False;
1764 if (!prs_align(ps))
1765 return False;
1766
1767 return True;
1768}
1769
1770/*******************************************************************
1771reads or writes a structure.
1772********************************************************************/
1773BOOL reg_io_r_abort_shutdown(const char *desc, REG_R_ABORT_SHUTDOWN *r_u,
1774 prs_struct *ps, int depth)
1775{
1776 if ( !r_u )
1777 return False;
1778
1779 prs_debug(ps, depth, desc, "reg_io_r_abort_shutdown");
1780 depth++;
1781
1782 if (!prs_align(ps))
1783 return False;
1784
1785 if (!prs_werror("status", ps, depth, &r_u->status))
1786 return False;
1787
1788 return True;
1789}
Note: See TracBrowser for help on using the repository browser.