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