← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/samba/gutsy-updates

« back to all changes in this revision

Viewing changes to source/rpc_parse/parse_dfs.c

  • Committer: Bazaar Package Importer
  • Author(s): Andrew Mitchell
  • Date: 2006-11-28 20:14:37 UTC
  • mfrom: (0.10.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20061128201437-a6x4lzlhempazocp
Tags: 3.0.23d-1ubuntu1
* Merge from debian unstable.
* Drop python2.4-samba, replace with python-samba. Added Conflicts/Replaces
  on python2.4-samba
* Drop track-connection-dos.patch, ubuntu-winbind-panic.patch, 
  ubuntu-fix-ldap.patch, ubuntu-setlocale.patch, ubuntu-setlocale-fixes.patch
* Remaining Ubuntu changes:
  - Revert Debian's installation of mount.cifs and umount.cifs as suid
  - Comment out the default [homes] shares and add more verbose comments to
    explain what they do and how they work (closes: launchpad.net/27608)
  - Add a "valid users = %S" stanza to the commented-out [homes] section, to
    show users how to restrict access to \\server\username to only username.
  - Change the (commented-out) "printer admin" example to use "@lpadmin"
    instead of "@ntadmin", since the lpadmin group is used for spool admin.
  - Alter the panic-action script to encourage users to report their
    bugs in Ubuntu packages to Ubuntu, rather than reporting to Debian.
    Modify text to more closely match the Debian script
  - Munge our init script to deal with the fact that our implementation
    (or lack thereof) of log_daemon_msg and log_progress_msg differs
    from Debian's implementation of the same (Ubuntu #19691)
  - Kept ubuntu-auxsrc.patch: some auxilliary sources (undocumented in 
    previous changelogs)
  - Set default workgroup to MSHOME

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/rpc_parse/parse_dfs.c
1
 
/* 
2
 
 *  Unix SMB/CIFS implementation.
3
 
 *  MSDfs RPC Pipe client / server routines
4
 
 *  Copyright (C) Andrew Tridgell              1992-2000,
5
 
 *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6
 
 *  Copyright (C) Shirish Kalele               2000.
7
 
 *  Copyright (C) Jeremy Allison                                2001.
8
 
 *  
9
 
 *  This program is free software; you can redistribute it and/or modify
10
 
 *  it under the terms of the GNU General Public License as published by
11
 
 *  the Free Software Foundation; either version 2 of the License, or
12
 
 *  (at your option) any later version.
13
 
 *  
14
 
 *  This program is distributed in the hope that it will be useful,
15
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
 *  GNU General Public License for more details.
18
 
 *  
19
 
 *  You should have received a copy of the GNU General Public License
20
 
 *  along with this program; if not, write to the Free Software
21
 
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
1
/*
 
2
 * Unix SMB/CIFS implementation.
 
3
 * parser auto-generated by pidl. DO NOT MODIFY!
22
4
 */
23
5
 
24
6
#include "includes.h"
26
8
#undef DBGC_CLASS
27
9
#define DBGC_CLASS DBGC_RPC_PARSE
28
10
 
29
 
/******************************************************************* 
30
 
Make a DFS_Q_DFS_QUERY structure
31
 
*******************************************************************/
32
 
 
33
 
void init_dfs_q_dfs_exist(DFS_Q_DFS_EXIST *q_d)
34
 
{
35
 
        q_d->dummy = 0;
36
 
}
37
 
 
38
 
/*************************************************************
39
 
 Read/write a DFS_Q_DFS_EXIST structure - dummy...
40
 
 ************************************************************/
41
 
 
42
 
BOOL dfs_io_q_dfs_exist(const char *desc, DFS_Q_DFS_EXIST *q_d, prs_struct *ps, int depth)
43
 
{
44
 
        if(q_d == NULL)
45
 
                return False;
46
 
  
47
 
        prs_debug(ps, depth, desc, "dfs_io_q_dfs_exist");
48
 
 
49
 
        return True;
50
 
}
51
 
  
52
 
/*************************************************************
53
 
 Read/write a DFS_R_DFS_EXIST structure
54
 
 ************************************************************/
55
 
 
56
 
BOOL dfs_io_r_dfs_exist(const char *desc, DFS_R_DFS_EXIST *q_d, prs_struct *ps, int depth)
57
 
{
58
 
        if(q_d == NULL)
59
 
                return False;
60
 
  
61
 
        prs_debug(ps, depth, desc, "dfs_io_r_dfs_exist");
62
 
        depth++;
63
 
 
64
 
        if(!prs_align(ps))
65
 
                return False;
66
 
 
67
 
        if(!prs_uint32("exist flag", ps, 0, &q_d->status))
68
 
                return False;
69
 
 
70
 
        return True;
71
 
}
72
 
  
73
 
/******************************************************************* 
74
 
Make a DFS_Q_DFS_REMOVE structure
75
 
*******************************************************************/
76
 
 
77
 
BOOL init_dfs_q_dfs_remove(DFS_Q_DFS_REMOVE *q_d, const char *entrypath, 
78
 
                           const char *servername, const char *sharename)
79
 
{
80
 
        DEBUG(5,("init_dfs_q_dfs_remove\n"));
81
 
        init_unistr2(&q_d->DfsEntryPath, entrypath, UNI_STR_TERMINATE);
82
 
        init_unistr2(&q_d->ServerName, servername, UNI_STR_TERMINATE);
83
 
        init_unistr2(&q_d->ShareName, sharename, UNI_STR_TERMINATE);
84
 
        q_d->ptr_ServerName = q_d->ptr_ShareName = 1;
85
 
        return True;
86
 
}
87
 
 
88
 
/******************************************************************* 
89
 
Read/write a DFS_Q_DFS_REMOVE structure
90
 
*******************************************************************/
91
 
 
92
 
BOOL dfs_io_q_dfs_remove(const char *desc, DFS_Q_DFS_REMOVE *q_d, prs_struct *ps, int depth)
93
 
{
94
 
        if(q_d == NULL)
95
 
                return False;
96
 
 
97
 
        prs_debug(ps, depth, desc, "dfs_io_q_dfs_remove");
98
 
        depth++;
99
 
  
100
 
        if(!prs_align(ps))
101
 
                return False;
102
 
  
103
 
        if(!smb_io_unistr2("DfsEntryPath",&q_d->DfsEntryPath, 1, ps, depth))
104
 
                return False;
105
 
 
106
 
        if(!prs_align(ps))
107
 
                return False;
108
 
 
109
 
        if(!prs_uint32("ptr_ServerName", ps, depth, &q_d->ptr_ServerName))
110
 
                return False;
111
 
        if(q_d->ptr_ServerName)
112
 
                if (!smb_io_unistr2("ServerName",&q_d->ServerName, q_d->ptr_ServerName, ps, depth))
113
 
                        return False;
114
 
        if(!prs_align(ps))
115
 
                return False;
116
 
 
117
 
        if(!prs_uint32("ptr_ShareName", ps, depth, &q_d->ptr_ShareName))
118
 
                return False;
119
 
        if(q_d->ptr_ShareName)
120
 
                if (!smb_io_unistr2("ShareName",&q_d->ShareName,  q_d->ptr_ShareName, ps, depth))
121
 
                        return False;
122
 
        if(!prs_align(ps))
123
 
                return False;
124
 
 
125
 
        return True;
126
 
}
127
 
 
128
 
/******************************************************************* 
129
 
Read/write a DFS_R_DFS_REMOVE structure
130
 
*******************************************************************/
131
 
 
132
 
BOOL dfs_io_r_dfs_remove(const char *desc, DFS_R_DFS_REMOVE *r_d, prs_struct *ps, int depth)
133
 
{
134
 
        if(r_d == NULL) 
135
 
                return False;
136
 
 
137
 
        prs_debug(ps, depth, desc, "dfs_io_r_dfs_remove");
138
 
        depth++;
139
 
 
140
 
        if(!prs_werror("status", ps, depth, &r_d->status))
141
 
                return False;
142
 
 
143
 
        return True;
144
 
}
145
 
 
146
 
/******************************************************************* 
147
 
Make a DFS_Q_DFS_ADD structure
148
 
*******************************************************************/
149
 
 
150
 
BOOL init_dfs_q_dfs_add(DFS_Q_DFS_ADD *q_d, const char *entrypath, 
151
 
                        const char *servername, const char *sharename, 
152
 
                        const char *comment, uint32 flags)
153
 
{
154
 
        DEBUG(5,("init_dfs_q_dfs_add\n"));
155
 
        q_d->ptr_DfsEntryPath = q_d->ptr_ServerName = q_d->ptr_ShareName = 1;
156
 
        init_unistr2(&q_d->DfsEntryPath, entrypath, UNI_STR_TERMINATE);
157
 
        init_unistr2(&q_d->ServerName, servername, UNI_STR_TERMINATE);
158
 
        init_unistr2(&q_d->ShareName, sharename, UNI_STR_TERMINATE);
159
 
        if(comment != NULL) {
160
 
                init_unistr2(&q_d->Comment, comment,UNI_STR_TERMINATE);
161
 
                q_d->ptr_Comment = 1;
162
 
        } else {
163
 
                q_d->ptr_Comment = 0;
164
 
        }
165
 
 
166
 
        q_d->Flags = flags;
167
 
        return True;
168
 
}
169
 
 
170
 
/************************************************************
171
 
 Read/write a DFS_Q_DFS_ADD structure
172
 
 ************************************************************/
173
 
 
174
 
BOOL dfs_io_q_dfs_add(const char *desc, DFS_Q_DFS_ADD *q_d, prs_struct *ps, int depth)
175
 
{
176
 
        if(q_d == NULL)
177
 
                return False;
178
 
 
179
 
        prs_debug(ps, depth, desc, "dfs_io_q_dfs_add");
180
 
        depth++;
181
 
  
182
 
        if(!prs_align(ps))
183
 
                return False;
184
 
  
185
 
        if(!smb_io_unistr2("DfsEntryPath",&q_d->DfsEntryPath, 1, ps, depth))
186
 
                return False;
187
 
        if(!prs_align(ps))
188
 
                return False;
189
 
 
190
 
        if(!smb_io_unistr2("ServerName",&q_d->ServerName, 1, ps, depth))
191
 
                return False;
192
 
        if(!prs_align(ps))
193
 
                return False;
194
 
 
195
 
        if(!prs_uint32("ptr_ShareName", ps, depth, &q_d->ptr_ShareName))
196
 
                return False;
197
 
        if(!smb_io_unistr2("ShareName",&q_d->ShareName,  1, ps, depth))
198
 
                return False;
199
 
        if(!prs_align(ps))
200
 
                return False;
201
 
 
202
 
        if(!prs_uint32("ptr_Comment", ps, depth, &q_d->ptr_Comment))
203
 
                return False;
204
 
        if(!smb_io_unistr2("",&q_d->Comment, q_d->ptr_Comment , ps, depth))
205
 
                return False;
206
 
        if(!prs_align(ps))
207
 
                return False;
208
 
 
209
 
        if(!prs_uint32("Flags", ps, depth, &q_d->Flags))
210
 
                return True;
211
 
 
212
 
        return True;
213
 
}
214
 
 
215
 
/************************************************************
216
 
 Read/write a DFS_R_DFS_ADD structure 
217
 
 ************************************************************/
218
 
 
219
 
BOOL dfs_io_r_dfs_add(const char *desc, DFS_R_DFS_ADD *r_d, prs_struct *ps, int depth)
220
 
{
221
 
        if(r_d == NULL)
222
 
                return False;
223
 
 
224
 
        prs_debug(ps, depth, desc, "dfs_io_r_dfs_add");
225
 
        depth++;
226
 
 
227
 
        if(!prs_werror("status", ps, depth, &r_d->status))
228
 
                return False;
229
 
 
230
 
        return True;
231
 
}
232
 
 
233
 
BOOL init_dfs_q_dfs_get_info(DFS_Q_DFS_GET_INFO *q_d, const char *entrypath,
234
 
                             const char *servername, const char *sharename, 
235
 
                             uint32 info_level)
236
 
{
237
 
        DEBUG(5,("init_dfs_q2_get_info\n"));
238
 
        init_unistr2(&q_d->uni_path, entrypath, UNI_STR_TERMINATE);
239
 
        init_unistr2(&q_d->uni_server, servername, UNI_STR_TERMINATE);
240
 
        init_unistr2(&q_d->uni_share, sharename, UNI_STR_TERMINATE);
241
 
        q_d->level = info_level;
242
 
        q_d->ptr_server = q_d->ptr_share = 1;
243
 
        return True;
244
 
}
245
 
 
246
 
/************************************************************
247
 
 Read/write a DFS_Q_GET_INFO structure
248
 
 ************************************************************/
249
 
 
250
 
BOOL dfs_io_q_dfs_get_info(const char *desc, DFS_Q_DFS_GET_INFO* q_i, prs_struct* ps, int depth)
251
 
{
252
 
        if(q_i == NULL)
253
 
                return False;
254
 
 
255
 
        prs_debug(ps, depth, desc, "dfs_io_q_dfs_get_info");
256
 
        depth++;
257
 
 
258
 
        if(!smb_io_unistr2("",&q_i->uni_path, 1, ps, depth))
259
 
                return False;
260
 
 
261
 
        if(!prs_align(ps))
262
 
                return False;
263
 
 
264
 
        if(!prs_uint32("ptr_server", ps, depth, &q_i->ptr_server))
265
 
                return False;
266
 
 
267
 
        if(q_i->ptr_server)
268
 
                if (!smb_io_unistr2("",&q_i->uni_server, q_i->ptr_server, ps, depth))
269
 
                        return False;
270
 
        if(!prs_align(ps))
271
 
                return False;
272
 
 
273
 
        if(!prs_uint32("ptr_share", ps, depth, &q_i->ptr_share))
274
 
                return False;
275
 
        if(q_i->ptr_share)
276
 
                if(!smb_io_unistr2("", &q_i->uni_share, q_i->ptr_share, ps, depth))
277
 
                        return False;
278
 
        if(!prs_align(ps))
279
 
                return False;
280
 
 
281
 
        if(!prs_uint32("level", ps, depth, &q_i->level))
282
 
                return False;
283
 
        return True;
284
 
}
285
 
 
286
 
/************************************************************
287
 
 Read/write a DFS_R_GET_INFO structure
288
 
 ************************************************************/
289
 
 
290
 
BOOL dfs_io_r_dfs_get_info(const char *desc, DFS_R_DFS_GET_INFO* r_i, prs_struct* ps, int depth)
291
 
{
292
 
        if(r_i == NULL)
293
 
                return False;
294
 
  
295
 
        if(!prs_uint32("level", ps, depth, &r_i->level))
296
 
                return False;
297
 
        if(!prs_uint32("ptr_ctr", ps, depth, &r_i->ptr_ctr))
298
 
                return False;
299
 
 
300
 
        if(!dfs_io_dfs_info_ctr("", &r_i->ctr, 1, r_i->level, ps, depth))
301
 
                return False;
302
 
        if(!prs_werror("status", ps, depth, &r_i->status))
303
 
                return False;
304
 
        return True;
305
 
}
306
 
                           
307
 
/************************************************************
308
 
 Make a DFS_Q_DFS_ENUM structure
309
 
 ************************************************************/
310
 
BOOL init_dfs_q_dfs_enum(DFS_Q_DFS_ENUM *q_d, uint32 level, DFS_INFO_CTR *ctr)
311
 
{
312
 
        q_d->level = level;
313
 
        q_d->maxpreflen = -1;
314
 
        q_d->ptr_buffer = 1;
315
 
        q_d->level2 = level;
316
 
  
317
 
        q_d->ptr_num_entries = 1;
318
 
        q_d->num_entries = 0;
319
 
        q_d->num_entries2 = 0;
320
 
        q_d->reshnd.ptr_hnd = 1;
321
 
        q_d->reshnd.handle = 0;
322
 
        return True;
323
 
}
324
 
  
325
 
/************************************************************
326
 
 Read or write the DFS_Q_DFS_ENUM structure 
327
 
 ************************************************************/
328
 
 
329
 
BOOL dfs_io_q_dfs_enum(const char *desc, DFS_Q_DFS_ENUM *q_d, prs_struct *ps, int depth)
330
 
{
331
 
        if(q_d == NULL)
332
 
                return False;
333
 
 
334
 
        prs_debug(ps, depth, desc, "dfs_io_q_dfs_enum");
335
 
        depth++;
336
 
  
337
 
        if(!prs_align(ps))
338
 
                return False;
339
 
  
340
 
        if(!prs_uint32("level", ps, depth, &q_d->level))
341
 
                return False;
342
 
        if(!prs_uint32("maxpreflen", ps, depth, &q_d->maxpreflen))
343
 
                return False;
344
 
        if(!prs_uint32("ptr_buffer", ps, depth, &q_d->ptr_buffer))
345
 
                return False;
346
 
        if(!prs_uint32("level2", ps, depth, &q_d->level2))
347
 
                return False;
348
 
        if(!prs_uint32("level3", ps, depth, &q_d->level2))
349
 
                return False;
350
 
  
351
 
        if(!prs_uint32("ptr_num_entries", ps, depth, &q_d->ptr_num_entries))
352
 
                return False;
353
 
        if(!prs_uint32("num_entries", ps, depth, &q_d->num_entries))
354
 
                return False;
355
 
        if(!prs_uint32("num_entries2", ps, depth, &q_d->num_entries2))
356
 
                return False;
357
 
        if(!smb_io_enum_hnd("resume_hnd",&q_d->reshnd, ps, depth))
358
 
                return False;
359
 
        return True;
360
 
}
361
 
 
362
 
/************************************************************
363
 
 Read/write a DFS_INFO_CTR structure
364
 
 ************************************************************/
365
 
 
366
 
BOOL dfs_io_dfs_info_ctr(const char *desc, DFS_INFO_CTR* ctr, uint32 num_entries, uint32 level, prs_struct* ps, int depth)
367
 
{
368
 
        int i=0;
369
 
 
370
 
        switch(level) {
371
 
        case 1:
372
 
                depth++;
373
 
                /* should depend on whether marshalling or unmarshalling! */
374
 
                if(UNMARSHALLING(ps)) {
375
 
                        ctr->dfs.info1 = PRS_ALLOC_MEM(ps, DFS_INFO_1, num_entries);
376
 
                        if (!ctr->dfs.info1)
377
 
                                return False;
378
 
                }
379
 
 
380
 
                for(i=0;i<num_entries;i++) {
381
 
                        if(!prs_uint32("ptr_entrypath",ps, depth, &ctr->dfs.info1[i].ptr_entrypath))
382
 
                                return False;
383
 
                }
384
 
                for(i=0;i<num_entries;i++) {
385
 
                        if(!smb_io_unistr2("", &ctr->dfs.info1[i].entrypath, ctr->dfs.info1[i].ptr_entrypath, ps, depth))
386
 
                                return False;
387
 
                        if(!prs_align(ps))
388
 
                                return False;
389
 
                }
390
 
                depth--;
391
 
                break;
392
 
        case 2:
393
 
                depth++;
394
 
                if(UNMARSHALLING(ps)) {
395
 
                        ctr->dfs.info2 = PRS_ALLOC_MEM(ps, DFS_INFO_2, num_entries);
396
 
                        if (!ctr->dfs.info2)
397
 
                                return False;
398
 
                }
399
 
 
400
 
                for(i=0;i<num_entries;i++) {
401
 
                        if(!prs_uint32("ptr_entrypath", ps, depth, &ctr->dfs.info2[i].ptr_entrypath))
402
 
                                return False;
403
 
                        if(!prs_uint32("ptr_comment", ps, depth, &ctr->dfs.info2[i].ptr_comment))
404
 
                                return False;
405
 
                        if(!prs_uint32("state", ps, depth, &ctr->dfs.info2[i].state))
406
 
                                return False;
407
 
                        if(!prs_uint32("num_storages", ps, depth, &ctr->dfs.info2[i].num_storages))
408
 
                                return False;
409
 
                }
410
 
                for(i=0;i<num_entries;i++) {
411
 
                        if(!smb_io_unistr2("", &ctr->dfs.info2[i].entrypath, ctr->dfs.info2[i].ptr_entrypath, ps, depth))
412
 
                                return False;
413
 
                        if(!prs_align(ps))
414
 
                                return False;
415
 
                        if(!smb_io_unistr2("",&ctr->dfs.info2[i].comment, ctr->dfs.info2[i].ptr_comment, ps, depth))
416
 
                                return False;
417
 
                        if(!prs_align(ps))
418
 
                                return False;
419
 
                }
420
 
                depth--;
421
 
                break;
422
 
        case 3:
423
 
                depth++;
424
 
                if(UNMARSHALLING(ps)) {
425
 
                        ctr->dfs.info3 = PRS_ALLOC_MEM(ps, DFS_INFO_3, num_entries);
426
 
                        if (!ctr->dfs.info3)
427
 
                                return False;
428
 
                }
429
 
 
430
 
                for(i=0;i<num_entries;i++) {
431
 
                        if(!prs_uint32("ptr_entrypath", ps, depth, &ctr->dfs.info3[i].ptr_entrypath))
432
 
                                return False;
433
 
                        if(!prs_uint32("ptr_comment", ps, depth, &ctr->dfs.info3[i].ptr_comment))
434
 
                                return False;
435
 
                        if(!prs_uint32("state", ps, depth, &ctr->dfs.info3[i].state))
436
 
                                return False;
437
 
                        if(!prs_uint32("num_storages", ps, depth, &ctr->dfs.info3[i].num_storages))
438
 
                                return False;
439
 
                        if(!prs_uint32("ptr_storages", ps, depth, &ctr->dfs.info3[i].ptr_storages))
440
 
                                return False;
441
 
                }
442
 
                for(i=0;i<num_entries;i++) {
443
 
                        if(!smb_io_unistr2("", &ctr->dfs.info3[i].entrypath, ctr->dfs.info3[i].ptr_entrypath, ps, depth))
444
 
                                return False;
445
 
                        if(!prs_align(ps))
446
 
                                return False;
447
 
                        if(!smb_io_unistr2("", &ctr->dfs.info3[i].comment, ctr->dfs.info3[i].ptr_comment, ps, depth))
448
 
                                return False;
449
 
                        if(!prs_align(ps))
450
 
                                return False;
451
 
                        if(!prs_uint32("num_storage_infos", ps, depth, &ctr->dfs.info3[i].num_storage_infos))
452
 
                                return False;
453
 
 
454
 
                        if(!dfs_io_dfs_storage_info("storage_info", &ctr->dfs.info3[i], ps, depth))
455
 
                                return False;
456
 
                }
457
 
        }
458
 
 
459
 
        return True;
460
 
}
461
 
 
462
 
/************************************************************
463
 
 Read/write a DFS_R_DFS_ENUM structure
464
 
 ************************************************************/
465
 
 
466
 
BOOL dfs_io_r_dfs_enum(const char *desc, DFS_R_DFS_ENUM *q_d, prs_struct *ps, int depth)
467
 
{
468
 
        DFS_INFO_CTR *ctr;
469
 
        if(q_d == NULL)
470
 
                return False;
471
 
        ctr = q_d->ctr;
472
 
        if(ctr == NULL)
473
 
                return False;
474
 
 
475
 
        prs_debug(ps, depth, desc, "dfs_io_r_dfs_enum");
476
 
        depth++;
477
 
 
478
 
        if(!prs_align(ps))
479
 
                return False;
480
 
 
481
 
        if(!prs_uint32("ptr_buffer", ps, depth, &q_d->ptr_buffer))
482
 
                return False;
483
 
        if(!prs_uint32("level", ps, depth, &q_d->level))
484
 
                return False;
485
 
        if(!prs_uint32("level2", ps, depth, &ctr->switch_value))
486
 
                return False;
487
 
        if(!prs_uint32("ptr_num_entries", ps, depth, &q_d->ptr_num_entries))
488
 
                return False;
489
 
        if(q_d->ptr_num_entries)
490
 
                if(!prs_uint32("num_entries", ps, depth, &q_d->num_entries))
491
 
                        return False;
492
 
        if(!prs_uint32("ptr_num_entries2", ps, depth, &q_d->ptr_num_entries2))
493
 
                return False;
494
 
        if(q_d->ptr_num_entries2)
495
 
                if(!prs_uint32("num_entries2", ps, depth, &ctr->num_entries))
496
 
                        return False;
497
 
 
498
 
        if(!dfs_io_dfs_info_ctr("", ctr, q_d->num_entries, q_d->level, ps, depth))
499
 
                return False;
500
 
 
501
 
        if(!smb_io_enum_hnd("resume_hnd", &q_d->reshnd, ps, depth))
502
 
                return False;
503
 
        if(!prs_werror("status", ps, depth, &q_d->status))
504
 
                return False;
505
 
        return True;
506
 
}
507
 
 
508
 
BOOL dfs_io_dfs_storage_info(const char *desc, DFS_INFO_3* info3, prs_struct *ps, int depth)
509
 
{
510
 
        int i=0;
511
 
        if(info3 == NULL)
512
 
                return False;
513
 
  
514
 
        prs_debug(ps, depth, desc, "smb_io_dfs_storage_info");
515
 
        depth++;
516
 
 
517
 
        if(UNMARSHALLING(ps)) {
518
 
                info3->storages = PRS_ALLOC_MEM(ps, DFS_STORAGE_INFO, info3->num_storage_infos);
519
 
                if (!info3->storages)
520
 
                        return False;
521
 
        }
522
 
 
523
 
        for(i=0;i<info3->num_storage_infos;i++) {
524
 
                if(!prs_uint32("storage_state", ps, depth, &info3->storages[i].state))
525
 
                        return False;
526
 
                if(!prs_uint32("ptr_servername", ps, depth, &info3->storages[i].ptr_servername))
527
 
                        return False;
528
 
                if(!prs_uint32("ptr_sharename", ps, depth, &info3->storages[i].ptr_sharename))
529
 
                        return False;
530
 
        }
531
 
 
532
 
        for(i=0;i<info3->num_storage_infos;i++) {
533
 
                if(!smb_io_unistr2("servername", &info3->storages[i].servername, info3->storages[i].ptr_servername, ps, depth))
534
 
                        return False;
535
 
                if(!prs_align(ps))
536
 
                        return False;
537
 
                if(!smb_io_unistr2("sharename", &info3->storages[i].sharename, info3->storages[i].ptr_sharename, ps, depth))
538
 
                        return False;
539
 
                if(!prs_align(ps))
540
 
                        return False;
541
 
        }
542
 
 
543
 
        return True;
544
 
}
 
11
/* netdfs structures */
 
12
BOOL init_netdfs_dfs_Info0(NETDFS_DFS_INFO0 *v)
 
13
{
 
14
        DEBUG(5,("init_netdfs_dfs_Info0\n"));
 
15
        
 
16
        return True;
 
17
}
 
18
 
 
19
BOOL netdfs_io_dfs_Info0_p(const char *desc, NETDFS_DFS_INFO0 *v, prs_struct *ps, int depth)
 
20
{
 
21
        if (v == NULL)
 
22
                return False;
 
23
        
 
24
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info0_p");
 
25
        depth++;
 
26
        return True;
 
27
}
 
28
 
 
29
BOOL netdfs_io_dfs_Info0_d(const char *desc, NETDFS_DFS_INFO0 *v, prs_struct *ps, int depth)
 
30
{
 
31
        if (v == NULL)
 
32
                return False;
 
33
        
 
34
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info0_d");
 
35
        depth++;
 
36
        return True;
 
37
}
 
38
 
 
39
BOOL init_netdfs_dfs_Info1(NETDFS_DFS_INFO1 *v, const char *path)
 
40
{
 
41
        DEBUG(5,("init_netdfs_dfs_Info1\n"));
 
42
        
 
43
        if (path) {
 
44
                v->ptr0_path = 1;
 
45
                init_unistr2(&v->path, path, UNI_FLAGS_NONE);
 
46
        } else {
 
47
                v->ptr0_path = 0;
 
48
        }
 
49
        
 
50
        return True;
 
51
}
 
52
 
 
53
BOOL netdfs_io_dfs_Info1_p(const char *desc, NETDFS_DFS_INFO1 *v, prs_struct *ps, int depth)
 
54
{
 
55
        if (v == NULL)
 
56
                return False;
 
57
        
 
58
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info1_p");
 
59
        depth++;
 
60
        if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
 
61
                return False;
 
62
        
 
63
        
 
64
        return True;
 
65
}
 
66
 
 
67
BOOL netdfs_io_dfs_Info1_d(const char *desc, NETDFS_DFS_INFO1 *v, prs_struct *ps, int depth)
 
68
{
 
69
        if (v == NULL)
 
70
                return False;
 
71
        
 
72
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info1_d");
 
73
        depth++;
 
74
        if (v->ptr0_path) {
 
75
                if (!prs_align_custom(ps, 4))
 
76
                        return False;
 
77
                
 
78
                if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
 
79
                        return False;
 
80
        }
 
81
        
 
82
        return True;
 
83
}
 
84
 
 
85
BOOL init_netdfs_dfs_Info2(NETDFS_DFS_INFO2 *v, const char *path, const char *comment, uint32 state, uint32 num_stores)
 
86
{
 
87
        DEBUG(5,("init_netdfs_dfs_Info2\n"));
 
88
        
 
89
        if (path) {
 
90
                v->ptr0_path = 1;
 
91
                init_unistr2(&v->path, path, UNI_FLAGS_NONE);
 
92
        } else {
 
93
                v->ptr0_path = 0;
 
94
        }
 
95
        
 
96
        if (comment) {
 
97
                v->ptr0_comment = 1;
 
98
                init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
 
99
        } else {
 
100
                v->ptr0_comment = 0;
 
101
        }
 
102
        
 
103
        v->state = state;
 
104
        
 
105
        v->num_stores = num_stores;
 
106
        
 
107
        return True;
 
108
}
 
109
 
 
110
BOOL netdfs_io_dfs_Info2_p(const char *desc, NETDFS_DFS_INFO2 *v, prs_struct *ps, int depth)
 
111
{
 
112
        if (v == NULL)
 
113
                return False;
 
114
        
 
115
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info2_p");
 
116
        depth++;
 
117
        if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
 
118
                return False;
 
119
        
 
120
        
 
121
        if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
 
122
                return False;
 
123
        
 
124
        
 
125
        if (!prs_uint32("state", ps, depth, &v->state))
 
126
                return False;
 
127
        
 
128
        if (!prs_uint32("num_stores", ps, depth, &v->num_stores))
 
129
                return False;
 
130
        
 
131
        return True;
 
132
}
 
133
 
 
134
BOOL netdfs_io_dfs_Info2_d(const char *desc, NETDFS_DFS_INFO2 *v, prs_struct *ps, int depth)
 
135
{
 
136
        if (v == NULL)
 
137
                return False;
 
138
        
 
139
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info2_d");
 
140
        depth++;
 
141
        if (v->ptr0_path) {
 
142
                if (!prs_align_custom(ps, 4))
 
143
                        return False;
 
144
                
 
145
                if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
 
146
                        return False;
 
147
        }
 
148
        
 
149
        if (v->ptr0_comment) {
 
150
                if (!prs_align_custom(ps, 4))
 
151
                        return False;
 
152
                
 
153
                if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
 
154
                        return False;
 
155
        }
 
156
        
 
157
        
 
158
        
 
159
        return True;
 
160
}
 
161
 
 
162
BOOL init_netdfs_dfs_StorageInfo(NETDFS_DFS_STORAGEINFO *v, uint32 state, const char *server, const char *share)
 
163
{
 
164
        DEBUG(5,("init_netdfs_dfs_StorageInfo\n"));
 
165
        
 
166
        v->state = state;
 
167
        
 
168
        if (server) {
 
169
                v->ptr0_server = 1;
 
170
                init_unistr2(&v->server, server, UNI_FLAGS_NONE);
 
171
        } else {
 
172
                v->ptr0_server = 0;
 
173
        }
 
174
        
 
175
        if (share) {
 
176
                v->ptr0_share = 1;
 
177
                init_unistr2(&v->share, share, UNI_FLAGS_NONE);
 
178
        } else {
 
179
                v->ptr0_share = 0;
 
180
        }
 
181
        
 
182
        return True;
 
183
}
 
184
 
 
185
BOOL netdfs_io_dfs_StorageInfo_p(const char *desc, NETDFS_DFS_STORAGEINFO *v, prs_struct *ps, int depth)
 
186
{
 
187
        if (v == NULL)
 
188
                return False;
 
189
        
 
190
        prs_debug(ps, depth, desc, "netdfs_io_dfs_StorageInfo_p");
 
191
        depth++;
 
192
        if (!prs_uint32("state", ps, depth, &v->state))
 
193
                return False;
 
194
        
 
195
        if (!prs_uint32("ptr0_server", ps, depth, &v->ptr0_server))
 
196
                return False;
 
197
        
 
198
        
 
199
        if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
 
200
                return False;
 
201
        
 
202
        
 
203
        return True;
 
204
}
 
205
 
 
206
BOOL netdfs_io_dfs_StorageInfo_d(const char *desc, NETDFS_DFS_STORAGEINFO *v, prs_struct *ps, int depth)
 
207
{
 
208
        if (v == NULL)
 
209
                return False;
 
210
        
 
211
        prs_debug(ps, depth, desc, "netdfs_io_dfs_StorageInfo_d");
 
212
        depth++;
 
213
        
 
214
        if (v->ptr0_server) {
 
215
                if (!prs_align_custom(ps, 4))
 
216
                        return False;
 
217
                
 
218
                if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
 
219
                        return False;
 
220
        }
 
221
        
 
222
        if (v->ptr0_share) {
 
223
                if (!prs_align_custom(ps, 4))
 
224
                        return False;
 
225
                
 
226
                if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
 
227
                        return False;
 
228
        }
 
229
        
 
230
        return True;
 
231
}
 
232
 
 
233
BOOL init_netdfs_dfs_Info3(NETDFS_DFS_INFO3 *v, const char *path, const char *comment, uint32 state, uint32 num_stores, NETDFS_DFS_STORAGEINFO **stores)
 
234
{
 
235
        DEBUG(5,("init_netdfs_dfs_Info3\n"));
 
236
        
 
237
        if (path) {
 
238
                v->ptr0_path = 1;
 
239
                init_unistr2(&v->path, path, UNI_FLAGS_NONE);
 
240
        } else {
 
241
                v->ptr0_path = 0;
 
242
        }
 
243
        
 
244
        if (comment) {
 
245
                v->ptr0_comment = 1;
 
246
                init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
 
247
        } else {
 
248
                v->ptr0_comment = 0;
 
249
        }
 
250
        
 
251
        v->state = state;
 
252
        
 
253
        v->num_stores = num_stores;
 
254
        
 
255
        if (stores) {
 
256
                v->ptr0_stores = 1;
 
257
                v->stores = *stores;
 
258
        } else {
 
259
                v->ptr0_stores = 0;
 
260
        }
 
261
        
 
262
        return True;
 
263
}
 
264
 
 
265
BOOL netdfs_io_dfs_Info3_p(const char *desc, NETDFS_DFS_INFO3 *v, prs_struct *ps, int depth)
 
266
{
 
267
        if (v == NULL)
 
268
                return False;
 
269
        
 
270
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info3_p");
 
271
        depth++;
 
272
        if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
 
273
                return False;
 
274
        
 
275
        
 
276
        if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
 
277
                return False;
 
278
        
 
279
        
 
280
        if (!prs_uint32("state", ps, depth, &v->state))
 
281
                return False;
 
282
        
 
283
        if (!prs_uint32("num_stores", ps, depth, &v->num_stores))
 
284
                return False;
 
285
        
 
286
        if (!prs_uint32("ptr0_stores", ps, depth, &v->ptr0_stores))
 
287
                return False;
 
288
        
 
289
        
 
290
        return True;
 
291
}
 
292
 
 
293
BOOL netdfs_io_dfs_Info3_d(const char *desc, NETDFS_DFS_INFO3 *v, prs_struct *ps, int depth)
 
294
{
 
295
        uint32 i_stores_1;
 
296
        
 
297
        if (v == NULL)
 
298
                return False;
 
299
        
 
300
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info3_d");
 
301
        depth++;
 
302
        if (v->ptr0_path) {
 
303
                if (!prs_align_custom(ps, 4))
 
304
                        return False;
 
305
                
 
306
                if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
 
307
                        return False;
 
308
        }
 
309
        
 
310
        if (v->ptr0_comment) {
 
311
                if (!prs_align_custom(ps, 4))
 
312
                        return False;
 
313
                
 
314
                if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
 
315
                        return False;
 
316
        }
 
317
        
 
318
        
 
319
        
 
320
        if (v->ptr0_stores) {
 
321
                if (!prs_align_custom(ps, 4))
 
322
                        return False;
 
323
                
 
324
                if (!prs_uint32("size_stores", ps, depth, &v->size_stores))
 
325
                        return False;
 
326
                
 
327
                if (UNMARSHALLING(ps)) {
 
328
                        v->stores = (void *)PRS_ALLOC_MEM_VOID(ps,sizeof(*v->stores)*v->num_stores);
 
329
                }
 
330
                for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
 
331
                        if (!netdfs_io_dfs_StorageInfo_p("stores", &v->stores[i_stores_1], ps, depth))
 
332
                                return False;
 
333
                }
 
334
                for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
 
335
                        if (!netdfs_io_dfs_StorageInfo_d("stores", &v->stores[i_stores_1], ps, depth))
 
336
                                return False;
 
337
                }
 
338
        }
 
339
        
 
340
        return True;
 
341
}
 
342
 
 
343
BOOL init_netdfs_dfs_Info4(NETDFS_DFS_INFO4 *v, const char *path, const char *comment, uint32 state, uint32 timeout, struct uuid guid, uint32 num_stores, NETDFS_DFS_STORAGEINFO **stores)
 
344
{
 
345
        DEBUG(5,("init_netdfs_dfs_Info4\n"));
 
346
        
 
347
        if (path) {
 
348
                v->ptr0_path = 1;
 
349
                init_unistr2(&v->path, path, UNI_FLAGS_NONE);
 
350
        } else {
 
351
                v->ptr0_path = 0;
 
352
        }
 
353
        
 
354
        if (comment) {
 
355
                v->ptr0_comment = 1;
 
356
                init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
 
357
        } else {
 
358
                v->ptr0_comment = 0;
 
359
        }
 
360
        
 
361
        v->state = state;
 
362
        
 
363
        v->timeout = timeout;
 
364
        
 
365
        
 
366
        
 
367
        v->num_stores = num_stores;
 
368
        
 
369
        if (stores) {
 
370
                v->ptr0_stores = 1;
 
371
                v->stores = *stores;
 
372
        } else {
 
373
                v->ptr0_stores = 0;
 
374
        }
 
375
        
 
376
        return True;
 
377
}
 
378
 
 
379
BOOL netdfs_io_dfs_Info4_p(const char *desc, NETDFS_DFS_INFO4 *v, prs_struct *ps, int depth)
 
380
{
 
381
        if (v == NULL)
 
382
                return False;
 
383
        
 
384
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info4_p");
 
385
        depth++;
 
386
        if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
 
387
                return False;
 
388
        
 
389
        
 
390
        if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
 
391
                return False;
 
392
        
 
393
        
 
394
        if (!prs_uint32("state", ps, depth, &v->state))
 
395
                return False;
 
396
        
 
397
        if (!prs_uint32("timeout", ps, depth, &v->timeout))
 
398
                return False;
 
399
        
 
400
        if (!smb_io_uuid("guid", &v->guid, ps, depth))
 
401
                return False;
 
402
        
 
403
        if (!prs_uint32("num_stores", ps, depth, &v->num_stores))
 
404
                return False;
 
405
        
 
406
        if (!prs_uint32("ptr0_stores", ps, depth, &v->ptr0_stores))
 
407
                return False;
 
408
        
 
409
        
 
410
        return True;
 
411
}
 
412
 
 
413
BOOL netdfs_io_dfs_Info4_d(const char *desc, NETDFS_DFS_INFO4 *v, prs_struct *ps, int depth)
 
414
{
 
415
        uint32 i_stores_1;
 
416
        
 
417
        if (v == NULL)
 
418
                return False;
 
419
        
 
420
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info4_d");
 
421
        depth++;
 
422
        if (v->ptr0_path) {
 
423
                if (!prs_align_custom(ps, 4))
 
424
                        return False;
 
425
                
 
426
                if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
 
427
                        return False;
 
428
        }
 
429
        
 
430
        if (v->ptr0_comment) {
 
431
                if (!prs_align_custom(ps, 4))
 
432
                        return False;
 
433
                
 
434
                if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
 
435
                        return False;
 
436
        }
 
437
        
 
438
        
 
439
        
 
440
        
 
441
        
 
442
        if (v->ptr0_stores) {
 
443
                if (!prs_align_custom(ps, 4))
 
444
                        return False;
 
445
                
 
446
                if (!prs_uint32("size_stores", ps, depth, &v->size_stores))
 
447
                        return False;
 
448
                
 
449
                if (UNMARSHALLING(ps)) {
 
450
                        v->stores = (void *)PRS_ALLOC_MEM_VOID(ps,sizeof(*v->stores)*v->num_stores);
 
451
                }
 
452
                for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
 
453
                        if (!netdfs_io_dfs_StorageInfo_p("stores", &v->stores[i_stores_1], ps, depth))
 
454
                                return False;
 
455
                }
 
456
                for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
 
457
                        if (!netdfs_io_dfs_StorageInfo_d("stores", &v->stores[i_stores_1], ps, depth))
 
458
                                return False;
 
459
                }
 
460
        }
 
461
        
 
462
        return True;
 
463
}
 
464
 
 
465
BOOL init_netdfs_dfs_Info100(NETDFS_DFS_INFO100 *v, const char *comment)
 
466
{
 
467
        DEBUG(5,("init_netdfs_dfs_Info100\n"));
 
468
        
 
469
        if (comment) {
 
470
                v->ptr0_comment = 1;
 
471
                init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
 
472
        } else {
 
473
                v->ptr0_comment = 0;
 
474
        }
 
475
        
 
476
        return True;
 
477
}
 
478
 
 
479
BOOL netdfs_io_dfs_Info100_p(const char *desc, NETDFS_DFS_INFO100 *v, prs_struct *ps, int depth)
 
480
{
 
481
        if (v == NULL)
 
482
                return False;
 
483
        
 
484
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info100_p");
 
485
        depth++;
 
486
        if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
 
487
                return False;
 
488
        
 
489
        
 
490
        return True;
 
491
}
 
492
 
 
493
BOOL netdfs_io_dfs_Info100_d(const char *desc, NETDFS_DFS_INFO100 *v, prs_struct *ps, int depth)
 
494
{
 
495
        if (v == NULL)
 
496
                return False;
 
497
        
 
498
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info100_d");
 
499
        depth++;
 
500
        if (v->ptr0_comment) {
 
501
                if (!prs_align_custom(ps, 4))
 
502
                        return False;
 
503
                
 
504
                if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
 
505
                        return False;
 
506
        }
 
507
        
 
508
        return True;
 
509
}
 
510
 
 
511
BOOL init_netdfs_dfs_Info101(NETDFS_DFS_INFO101 *v, uint32 state)
 
512
{
 
513
        DEBUG(5,("init_netdfs_dfs_Info101\n"));
 
514
        
 
515
        v->state = state;
 
516
        
 
517
        return True;
 
518
}
 
519
 
 
520
BOOL netdfs_io_dfs_Info101_p(const char *desc, NETDFS_DFS_INFO101 *v, prs_struct *ps, int depth)
 
521
{
 
522
        if (v == NULL)
 
523
                return False;
 
524
        
 
525
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info101_p");
 
526
        depth++;
 
527
        if (!prs_uint32("state", ps, depth, &v->state))
 
528
                return False;
 
529
        
 
530
        return True;
 
531
}
 
532
 
 
533
BOOL netdfs_io_dfs_Info101_d(const char *desc, NETDFS_DFS_INFO101 *v, prs_struct *ps, int depth)
 
534
{
 
535
        if (v == NULL)
 
536
                return False;
 
537
        
 
538
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info101_d");
 
539
        depth++;
 
540
        
 
541
        return True;
 
542
}
 
543
 
 
544
BOOL init_netdfs_dfs_Info102(NETDFS_DFS_INFO102 *v, uint32 timeout)
 
545
{
 
546
        DEBUG(5,("init_netdfs_dfs_Info102\n"));
 
547
        
 
548
        v->timeout = timeout;
 
549
        
 
550
        return True;
 
551
}
 
552
 
 
553
BOOL netdfs_io_dfs_Info102_p(const char *desc, NETDFS_DFS_INFO102 *v, prs_struct *ps, int depth)
 
554
{
 
555
        if (v == NULL)
 
556
                return False;
 
557
        
 
558
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info102_p");
 
559
        depth++;
 
560
        if (!prs_uint32("timeout", ps, depth, &v->timeout))
 
561
                return False;
 
562
        
 
563
        return True;
 
564
}
 
565
 
 
566
BOOL netdfs_io_dfs_Info102_d(const char *desc, NETDFS_DFS_INFO102 *v, prs_struct *ps, int depth)
 
567
{
 
568
        if (v == NULL)
 
569
                return False;
 
570
        
 
571
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info102_d");
 
572
        depth++;
 
573
        
 
574
        return True;
 
575
}
 
576
 
 
577
BOOL init_netdfs_dfs_Info200(NETDFS_DFS_INFO200 *v, const char *dom_root)
 
578
{
 
579
        DEBUG(5,("init_netdfs_dfs_Info200\n"));
 
580
        
 
581
        if (dom_root) {
 
582
                v->ptr0_dom_root = 1;
 
583
                init_unistr2(&v->dom_root, dom_root, UNI_FLAGS_NONE);
 
584
        } else {
 
585
                v->ptr0_dom_root = 0;
 
586
        }
 
587
        
 
588
        return True;
 
589
}
 
590
 
 
591
BOOL netdfs_io_dfs_Info200_p(const char *desc, NETDFS_DFS_INFO200 *v, prs_struct *ps, int depth)
 
592
{
 
593
        if (v == NULL)
 
594
                return False;
 
595
        
 
596
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info200_p");
 
597
        depth++;
 
598
        if (!prs_uint32("ptr0_dom_root", ps, depth, &v->ptr0_dom_root))
 
599
                return False;
 
600
        
 
601
        
 
602
        return True;
 
603
}
 
604
 
 
605
BOOL netdfs_io_dfs_Info200_d(const char *desc, NETDFS_DFS_INFO200 *v, prs_struct *ps, int depth)
 
606
{
 
607
        if (v == NULL)
 
608
                return False;
 
609
        
 
610
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info200_d");
 
611
        depth++;
 
612
        if (v->ptr0_dom_root) {
 
613
                if (!prs_align_custom(ps, 4))
 
614
                        return False;
 
615
                
 
616
                if (!smb_io_unistr2("dom_root", &v->dom_root, 1, ps, depth))
 
617
                        return False;
 
618
        }
 
619
        
 
620
        return True;
 
621
}
 
622
 
 
623
BOOL init_netdfs_dfs_Info300(NETDFS_DFS_INFO300 *v, uint32 flags, const char *dom_root)
 
624
{
 
625
        DEBUG(5,("init_netdfs_dfs_Info300\n"));
 
626
        
 
627
        v->flags = flags;
 
628
        
 
629
        if (dom_root) {
 
630
                v->ptr0_dom_root = 1;
 
631
                init_unistr2(&v->dom_root, dom_root, UNI_FLAGS_NONE);
 
632
        } else {
 
633
                v->ptr0_dom_root = 0;
 
634
        }
 
635
        
 
636
        return True;
 
637
}
 
638
 
 
639
BOOL netdfs_io_dfs_Info300_p(const char *desc, NETDFS_DFS_INFO300 *v, prs_struct *ps, int depth)
 
640
{
 
641
        if (v == NULL)
 
642
                return False;
 
643
        
 
644
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info300_p");
 
645
        depth++;
 
646
        if (!prs_uint32("flags", ps, depth, &v->flags))
 
647
                return False;
 
648
        
 
649
        if (!prs_uint32("ptr0_dom_root", ps, depth, &v->ptr0_dom_root))
 
650
                return False;
 
651
        
 
652
        
 
653
        return True;
 
654
}
 
655
 
 
656
BOOL netdfs_io_dfs_Info300_d(const char *desc, NETDFS_DFS_INFO300 *v, prs_struct *ps, int depth)
 
657
{
 
658
        if (v == NULL)
 
659
                return False;
 
660
        
 
661
        prs_debug(ps, depth, desc, "netdfs_io_dfs_Info300_d");
 
662
        depth++;
 
663
        
 
664
        if (v->ptr0_dom_root) {
 
665
                if (!prs_align_custom(ps, 4))
 
666
                        return False;
 
667
                
 
668
                if (!smb_io_unistr2("dom_root", &v->dom_root, 1, ps, depth))
 
669
                        return False;
 
670
        }
 
671
        
 
672
        return True;
 
673
}
 
674
 
 
675
BOOL netdfs_io_dfs_Info_p(const char *desc, NETDFS_DFS_INFO_CTR* v, prs_struct *ps, int depth)
 
676
{
 
677
        if (!prs_uint32("switch_value", ps, depth, &v->switch_value))
 
678
                return False;
 
679
        
 
680
        switch (v->switch_value) {
 
681
                case 0:
 
682
                        depth++;
 
683
                        if (!prs_uint32("ptr0_info0", ps, depth, &v->ptr0))
 
684
                                return False;
 
685
                        
 
686
                        depth--;
 
687
                        break;
 
688
                
 
689
                case 1:
 
690
                        depth++;
 
691
                        if (!prs_uint32("ptr0_info1", ps, depth, &v->ptr0))
 
692
                                return False;
 
693
                        
 
694
                        depth--;
 
695
                        break;
 
696
                
 
697
                case 2:
 
698
                        depth++;
 
699
                        if (!prs_uint32("ptr0_info2", ps, depth, &v->ptr0))
 
700
                                return False;
 
701
                        
 
702
                        depth--;
 
703
                        break;
 
704
                
 
705
                case 3:
 
706
                        depth++;
 
707
                        if (!prs_uint32("ptr0_info3", ps, depth, &v->ptr0))
 
708
                                return False;
 
709
                        
 
710
                        depth--;
 
711
                        break;
 
712
                
 
713
                case 4:
 
714
                        depth++;
 
715
                        if (!prs_uint32("ptr0_info4", ps, depth, &v->ptr0))
 
716
                                return False;
 
717
                        
 
718
                        depth--;
 
719
                        break;
 
720
                
 
721
                case 100:
 
722
                        depth++;
 
723
                        if (!prs_uint32("ptr0_info100", ps, depth, &v->ptr0))
 
724
                                return False;
 
725
                        
 
726
                        depth--;
 
727
                        break;
 
728
                
 
729
                case 101:
 
730
                        depth++;
 
731
                        if (!prs_uint32("ptr0_info101", ps, depth, &v->ptr0))
 
732
                                return False;
 
733
                        
 
734
                        depth--;
 
735
                        break;
 
736
                
 
737
                case 102:
 
738
                        depth++;
 
739
                        if (!prs_uint32("ptr0_info102", ps, depth, &v->ptr0))
 
740
                                return False;
 
741
                        
 
742
                        depth--;
 
743
                        break;
 
744
                
 
745
                default:
 
746
                        return False;
 
747
                
 
748
        }
 
749
        
 
750
        return True;
 
751
}
 
752
 
 
753
BOOL netdfs_io_dfs_Info_d(const char *desc, NETDFS_DFS_INFO_CTR* v, prs_struct *ps, int depth)
 
754
{
 
755
        switch (v->switch_value) {
 
756
                case 0:
 
757
                        depth++;
 
758
                        if (v->ptr0) {
 
759
                                if (!prs_align_custom(ps, 1))
 
760
                                        return False;
 
761
                                
 
762
                                if (!netdfs_io_dfs_Info0_p("info0", &v->u.info0, ps, depth))
 
763
                                        return False;
 
764
                                if (!netdfs_io_dfs_Info0_d("info0", &v->u.info0, ps, depth))
 
765
                                        return False;
 
766
                        }
 
767
                        depth--;
 
768
                        break;
 
769
                
 
770
                case 1:
 
771
                        depth++;
 
772
                        if (v->ptr0) {
 
773
                                if (!prs_align_custom(ps, 4))
 
774
                                        return False;
 
775
                                
 
776
                                if (!netdfs_io_dfs_Info1_p("info1", &v->u.info1, ps, depth))
 
777
                                        return False;
 
778
                                if (!netdfs_io_dfs_Info1_d("info1", &v->u.info1, ps, depth))
 
779
                                        return False;
 
780
                        }
 
781
                        depth--;
 
782
                        break;
 
783
                
 
784
                case 2:
 
785
                        depth++;
 
786
                        if (v->ptr0) {
 
787
                                if (!prs_align_custom(ps, 4))
 
788
                                        return False;
 
789
                                
 
790
                                if (!netdfs_io_dfs_Info2_p("info2", &v->u.info2, ps, depth))
 
791
                                        return False;
 
792
                                if (!netdfs_io_dfs_Info2_d("info2", &v->u.info2, ps, depth))
 
793
                                        return False;
 
794
                        }
 
795
                        depth--;
 
796
                        break;
 
797
                
 
798
                case 3:
 
799
                        depth++;
 
800
                        if (v->ptr0) {
 
801
                                if (!prs_align_custom(ps, 4))
 
802
                                        return False;
 
803
                                
 
804
                                if (!netdfs_io_dfs_Info3_p("info3", &v->u.info3, ps, depth))
 
805
                                        return False;
 
806
                                if (!netdfs_io_dfs_Info3_d("info3", &v->u.info3, ps, depth))
 
807
                                        return False;
 
808
                        }
 
809
                        depth--;
 
810
                        break;
 
811
                
 
812
                case 4:
 
813
                        depth++;
 
814
                        if (v->ptr0) {
 
815
                                if (!prs_align_custom(ps, 4))
 
816
                                        return False;
 
817
                                
 
818
                                if (!netdfs_io_dfs_Info4_p("info4", &v->u.info4, ps, depth))
 
819
                                        return False;
 
820
                                if (!netdfs_io_dfs_Info4_d("info4", &v->u.info4, ps, depth))
 
821
                                        return False;
 
822
                        }
 
823
                        depth--;
 
824
                        break;
 
825
                
 
826
                case 100:
 
827
                        depth++;
 
828
                        if (v->ptr0) {
 
829
                                if (!prs_align_custom(ps, 4))
 
830
                                        return False;
 
831
                                
 
832
                                if (!netdfs_io_dfs_Info100_p("info100", &v->u.info100, ps, depth))
 
833
                                        return False;
 
834
                                if (!netdfs_io_dfs_Info100_d("info100", &v->u.info100, ps, depth))
 
835
                                        return False;
 
836
                        }
 
837
                        depth--;
 
838
                        break;
 
839
                
 
840
                case 101:
 
841
                        depth++;
 
842
                        if (v->ptr0) {
 
843
                                if (!prs_align_custom(ps, 4))
 
844
                                        return False;
 
845
                                
 
846
                                if (!netdfs_io_dfs_Info101_p("info101", &v->u.info101, ps, depth))
 
847
                                        return False;
 
848
                                if (!netdfs_io_dfs_Info101_d("info101", &v->u.info101, ps, depth))
 
849
                                        return False;
 
850
                        }
 
851
                        depth--;
 
852
                        break;
 
853
                
 
854
                case 102:
 
855
                        depth++;
 
856
                        if (v->ptr0) {
 
857
                                if (!prs_align_custom(ps, 4))
 
858
                                        return False;
 
859
                                
 
860
                                if (!netdfs_io_dfs_Info102_p("info102", &v->u.info102, ps, depth))
 
861
                                        return False;
 
862
                                if (!netdfs_io_dfs_Info102_d("info102", &v->u.info102, ps, depth))
 
863
                                        return False;
 
864
                        }
 
865
                        depth--;
 
866
                        break;
 
867
                
 
868
        }
 
869
        
 
870
        return True;
 
871
}
 
872
BOOL init_netdfs_dfs_EnumArray1(NETDFS_DFS_ENUMARRAY1 *v, uint32 count, NETDFS_DFS_INFO1 **s)
 
873
{
 
874
        DEBUG(5,("init_netdfs_dfs_EnumArray1\n"));
 
875
        
 
876
        v->count = count;
 
877
        
 
878
        if (s) {
 
879
                v->ptr0_s = 1;
 
880
                v->s = *s;
 
881
        } else {
 
882
                v->ptr0_s = 0;
 
883
        }
 
884
        
 
885
        return True;
 
886
}
 
887
 
 
888
BOOL netdfs_io_dfs_EnumArray1_p(const char *desc, NETDFS_DFS_ENUMARRAY1 *v, prs_struct *ps, int depth)
 
889
{
 
890
        if (v == NULL)
 
891
                return False;
 
892
        
 
893
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray1_p");
 
894
        depth++;
 
895
        if (!prs_uint32("count", ps, depth, &v->count))
 
896
                return False;
 
897
        
 
898
        if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
 
899
                return False;
 
900
        
 
901
        
 
902
        return True;
 
903
}
 
904
 
 
905
BOOL netdfs_io_dfs_EnumArray1_d(const char *desc, NETDFS_DFS_ENUMARRAY1 *v, prs_struct *ps, int depth)
 
906
{
 
907
        uint32 i_s_1;
 
908
        
 
909
        if (v == NULL)
 
910
                return False;
 
911
        
 
912
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray1_d");
 
913
        depth++;
 
914
        
 
915
        if (v->ptr0_s) {
 
916
                if (!prs_align_custom(ps, 4))
 
917
                        return False;
 
918
                
 
919
                if (!prs_uint32("size_s", ps, depth, &v->size_s))
 
920
                        return False;
 
921
                
 
922
                if (UNMARSHALLING(ps)) {
 
923
                        v->s = (void *)PRS_ALLOC_MEM_VOID(ps,sizeof(*v->s)*v->count);
 
924
                }
 
925
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
926
                        if (!netdfs_io_dfs_Info1_p("s", &v->s[i_s_1], ps, depth))
 
927
                                return False;
 
928
                }
 
929
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
930
                        if (!netdfs_io_dfs_Info1_d("s", &v->s[i_s_1], ps, depth))
 
931
                                return False;
 
932
                }
 
933
        }
 
934
        
 
935
        return True;
 
936
}
 
937
 
 
938
BOOL init_netdfs_dfs_EnumArray2(NETDFS_DFS_ENUMARRAY2 *v, uint32 count, NETDFS_DFS_INFO2 **s)
 
939
{
 
940
        DEBUG(5,("init_netdfs_dfs_EnumArray2\n"));
 
941
        
 
942
        v->count = count;
 
943
        
 
944
        if (s) {
 
945
                v->ptr0_s = 1;
 
946
                v->s = *s;
 
947
        } else {
 
948
                v->ptr0_s = 0;
 
949
        }
 
950
        
 
951
        return True;
 
952
}
 
953
 
 
954
BOOL netdfs_io_dfs_EnumArray2_p(const char *desc, NETDFS_DFS_ENUMARRAY2 *v, prs_struct *ps, int depth)
 
955
{
 
956
        if (v == NULL)
 
957
                return False;
 
958
        
 
959
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray2_p");
 
960
        depth++;
 
961
        if (!prs_uint32("count", ps, depth, &v->count))
 
962
                return False;
 
963
        
 
964
        if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
 
965
                return False;
 
966
        
 
967
        
 
968
        return True;
 
969
}
 
970
 
 
971
BOOL netdfs_io_dfs_EnumArray2_d(const char *desc, NETDFS_DFS_ENUMARRAY2 *v, prs_struct *ps, int depth)
 
972
{
 
973
        uint32 i_s_1;
 
974
        
 
975
        if (v == NULL)
 
976
                return False;
 
977
        
 
978
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray2_d");
 
979
        depth++;
 
980
        
 
981
        if (v->ptr0_s) {
 
982
                if (!prs_align_custom(ps, 4))
 
983
                        return False;
 
984
                
 
985
                if (!prs_uint32("size_s", ps, depth, &v->size_s))
 
986
                        return False;
 
987
                
 
988
                if (UNMARSHALLING(ps)) {
 
989
                        v->s = (void *)PRS_ALLOC_MEM_VOID(ps,sizeof(*v->s)*v->count);
 
990
                }
 
991
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
992
                        if (!netdfs_io_dfs_Info2_p("s", &v->s[i_s_1], ps, depth))
 
993
                                return False;
 
994
                }
 
995
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
996
                        if (!netdfs_io_dfs_Info2_d("s", &v->s[i_s_1], ps, depth))
 
997
                                return False;
 
998
                }
 
999
        }
 
1000
        
 
1001
        return True;
 
1002
}
 
1003
 
 
1004
BOOL init_netdfs_dfs_EnumArray3(NETDFS_DFS_ENUMARRAY3 *v, uint32 count, NETDFS_DFS_INFO3 **s)
 
1005
{
 
1006
        DEBUG(5,("init_netdfs_dfs_EnumArray3\n"));
 
1007
        
 
1008
        v->count = count;
 
1009
        
 
1010
        if (s) {
 
1011
                v->ptr0_s = 1;
 
1012
                v->s = *s;
 
1013
        } else {
 
1014
                v->ptr0_s = 0;
 
1015
        }
 
1016
        
 
1017
        return True;
 
1018
}
 
1019
 
 
1020
BOOL netdfs_io_dfs_EnumArray3_p(const char *desc, NETDFS_DFS_ENUMARRAY3 *v, prs_struct *ps, int depth)
 
1021
{
 
1022
        if (v == NULL)
 
1023
                return False;
 
1024
        
 
1025
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray3_p");
 
1026
        depth++;
 
1027
        if (!prs_uint32("count", ps, depth, &v->count))
 
1028
                return False;
 
1029
        
 
1030
        if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
 
1031
                return False;
 
1032
        
 
1033
        
 
1034
        return True;
 
1035
}
 
1036
 
 
1037
BOOL netdfs_io_dfs_EnumArray3_d(const char *desc, NETDFS_DFS_ENUMARRAY3 *v, prs_struct *ps, int depth)
 
1038
{
 
1039
        uint32 i_s_1;
 
1040
        
 
1041
        if (v == NULL)
 
1042
                return False;
 
1043
        
 
1044
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray3_d");
 
1045
        depth++;
 
1046
        
 
1047
        if (v->ptr0_s) {
 
1048
                if (!prs_align_custom(ps, 4))
 
1049
                        return False;
 
1050
                
 
1051
                if (!prs_uint32("size_s", ps, depth, &v->size_s))
 
1052
                        return False;
 
1053
                
 
1054
                if (UNMARSHALLING(ps)) {
 
1055
                        v->s = (void *)PRS_ALLOC_MEM_VOID(ps,sizeof(*v->s)*v->count);
 
1056
                }
 
1057
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
1058
                        if (!netdfs_io_dfs_Info3_p("s", &v->s[i_s_1], ps, depth))
 
1059
                                return False;
 
1060
                }
 
1061
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
1062
                        if (!netdfs_io_dfs_Info3_d("s", &v->s[i_s_1], ps, depth))
 
1063
                                return False;
 
1064
                }
 
1065
        }
 
1066
        
 
1067
        return True;
 
1068
}
 
1069
 
 
1070
BOOL init_netdfs_dfs_EnumArray4(NETDFS_DFS_ENUMARRAY4 *v, uint32 count, NETDFS_DFS_INFO4 **s)
 
1071
{
 
1072
        DEBUG(5,("init_netdfs_dfs_EnumArray4\n"));
 
1073
        
 
1074
        v->count = count;
 
1075
        
 
1076
        if (s) {
 
1077
                v->ptr0_s = 1;
 
1078
                v->s = *s;
 
1079
        } else {
 
1080
                v->ptr0_s = 0;
 
1081
        }
 
1082
        
 
1083
        return True;
 
1084
}
 
1085
 
 
1086
BOOL netdfs_io_dfs_EnumArray4_p(const char *desc, NETDFS_DFS_ENUMARRAY4 *v, prs_struct *ps, int depth)
 
1087
{
 
1088
        if (v == NULL)
 
1089
                return False;
 
1090
        
 
1091
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray4_p");
 
1092
        depth++;
 
1093
        if (!prs_uint32("count", ps, depth, &v->count))
 
1094
                return False;
 
1095
        
 
1096
        if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
 
1097
                return False;
 
1098
        
 
1099
        
 
1100
        return True;
 
1101
}
 
1102
 
 
1103
BOOL netdfs_io_dfs_EnumArray4_d(const char *desc, NETDFS_DFS_ENUMARRAY4 *v, prs_struct *ps, int depth)
 
1104
{
 
1105
        uint32 i_s_1;
 
1106
        
 
1107
        if (v == NULL)
 
1108
                return False;
 
1109
        
 
1110
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray4_d");
 
1111
        depth++;
 
1112
        
 
1113
        if (v->ptr0_s) {
 
1114
                if (!prs_align_custom(ps, 4))
 
1115
                        return False;
 
1116
                
 
1117
                if (!prs_uint32("size_s", ps, depth, &v->size_s))
 
1118
                        return False;
 
1119
                
 
1120
                if (UNMARSHALLING(ps)) {
 
1121
                        v->s = (void *)PRS_ALLOC_MEM_VOID(ps,sizeof(*v->s)*v->count);
 
1122
                }
 
1123
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
1124
                        if (!netdfs_io_dfs_Info4_p("s", &v->s[i_s_1], ps, depth))
 
1125
                                return False;
 
1126
                }
 
1127
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
1128
                        if (!netdfs_io_dfs_Info4_d("s", &v->s[i_s_1], ps, depth))
 
1129
                                return False;
 
1130
                }
 
1131
        }
 
1132
        
 
1133
        return True;
 
1134
}
 
1135
 
 
1136
BOOL init_netdfs_dfs_EnumArray200(NETDFS_DFS_ENUMARRAY200 *v, uint32 count, NETDFS_DFS_INFO200 **s)
 
1137
{
 
1138
        DEBUG(5,("init_netdfs_dfs_EnumArray200\n"));
 
1139
        
 
1140
        v->count = count;
 
1141
        
 
1142
        if (s) {
 
1143
                v->ptr0_s = 1;
 
1144
                v->s = *s;
 
1145
        } else {
 
1146
                v->ptr0_s = 0;
 
1147
        }
 
1148
        
 
1149
        return True;
 
1150
}
 
1151
 
 
1152
BOOL netdfs_io_dfs_EnumArray200_p(const char *desc, NETDFS_DFS_ENUMARRAY200 *v, prs_struct *ps, int depth)
 
1153
{
 
1154
        if (v == NULL)
 
1155
                return False;
 
1156
        
 
1157
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray200_p");
 
1158
        depth++;
 
1159
        if (!prs_uint32("count", ps, depth, &v->count))
 
1160
                return False;
 
1161
        
 
1162
        if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
 
1163
                return False;
 
1164
        
 
1165
        
 
1166
        return True;
 
1167
}
 
1168
 
 
1169
BOOL netdfs_io_dfs_EnumArray200_d(const char *desc, NETDFS_DFS_ENUMARRAY200 *v, prs_struct *ps, int depth)
 
1170
{
 
1171
        uint32 i_s_1;
 
1172
        
 
1173
        if (v == NULL)
 
1174
                return False;
 
1175
        
 
1176
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray200_d");
 
1177
        depth++;
 
1178
        
 
1179
        if (v->ptr0_s) {
 
1180
                if (!prs_align_custom(ps, 4))
 
1181
                        return False;
 
1182
                
 
1183
                if (!prs_uint32("size_s", ps, depth, &v->size_s))
 
1184
                        return False;
 
1185
                
 
1186
                if (UNMARSHALLING(ps)) {
 
1187
                        v->s = (void *)PRS_ALLOC_MEM_VOID(ps,sizeof(*v->s)*v->count);
 
1188
                }
 
1189
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
1190
                        if (!netdfs_io_dfs_Info200_p("s", &v->s[i_s_1], ps, depth))
 
1191
                                return False;
 
1192
                }
 
1193
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
1194
                        if (!netdfs_io_dfs_Info200_d("s", &v->s[i_s_1], ps, depth))
 
1195
                                return False;
 
1196
                }
 
1197
        }
 
1198
        
 
1199
        return True;
 
1200
}
 
1201
 
 
1202
BOOL init_netdfs_dfs_EnumArray300(NETDFS_DFS_ENUMARRAY300 *v, uint32 count, NETDFS_DFS_INFO300 **s)
 
1203
{
 
1204
        DEBUG(5,("init_netdfs_dfs_EnumArray300\n"));
 
1205
        
 
1206
        v->count = count;
 
1207
        
 
1208
        if (s) {
 
1209
                v->ptr0_s = 1;
 
1210
                v->s = *s;
 
1211
        } else {
 
1212
                v->ptr0_s = 0;
 
1213
        }
 
1214
        
 
1215
        return True;
 
1216
}
 
1217
 
 
1218
BOOL netdfs_io_dfs_EnumArray300_p(const char *desc, NETDFS_DFS_ENUMARRAY300 *v, prs_struct *ps, int depth)
 
1219
{
 
1220
        if (v == NULL)
 
1221
                return False;
 
1222
        
 
1223
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray300_p");
 
1224
        depth++;
 
1225
        if (!prs_uint32("count", ps, depth, &v->count))
 
1226
                return False;
 
1227
        
 
1228
        if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
 
1229
                return False;
 
1230
        
 
1231
        
 
1232
        return True;
 
1233
}
 
1234
 
 
1235
BOOL netdfs_io_dfs_EnumArray300_d(const char *desc, NETDFS_DFS_ENUMARRAY300 *v, prs_struct *ps, int depth)
 
1236
{
 
1237
        uint32 i_s_1;
 
1238
        
 
1239
        if (v == NULL)
 
1240
                return False;
 
1241
        
 
1242
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray300_d");
 
1243
        depth++;
 
1244
        
 
1245
        if (v->ptr0_s) {
 
1246
                if (!prs_align_custom(ps, 4))
 
1247
                        return False;
 
1248
                
 
1249
                if (!prs_uint32("size_s", ps, depth, &v->size_s))
 
1250
                        return False;
 
1251
                
 
1252
                if (UNMARSHALLING(ps)) {
 
1253
                        v->s = (void *)PRS_ALLOC_MEM_VOID(ps,sizeof(*v->s)*v->count);
 
1254
                }
 
1255
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
1256
                        if (!netdfs_io_dfs_Info300_p("s", &v->s[i_s_1], ps, depth))
 
1257
                                return False;
 
1258
                }
 
1259
                for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 
1260
                        if (!netdfs_io_dfs_Info300_d("s", &v->s[i_s_1], ps, depth))
 
1261
                                return False;
 
1262
                }
 
1263
        }
 
1264
        
 
1265
        return True;
 
1266
}
 
1267
 
 
1268
BOOL netdfs_io_dfs_EnumInfo_p(const char *desc, NETDFS_DFS_ENUMINFO_CTR* v, prs_struct *ps, int depth)
 
1269
{
 
1270
        if (!prs_uint32("switch_value", ps, depth, &v->switch_value))
 
1271
                return False;
 
1272
        
 
1273
        switch (v->switch_value) {
 
1274
                case 1:
 
1275
                        depth++;
 
1276
                        if (!prs_uint32("ptr0_info1", ps, depth, &v->ptr0))
 
1277
                                return False;
 
1278
                        
 
1279
                        depth--;
 
1280
                        break;
 
1281
                
 
1282
                case 2:
 
1283
                        depth++;
 
1284
                        if (!prs_uint32("ptr0_info2", ps, depth, &v->ptr0))
 
1285
                                return False;
 
1286
                        
 
1287
                        depth--;
 
1288
                        break;
 
1289
                
 
1290
                case 3:
 
1291
                        depth++;
 
1292
                        if (!prs_uint32("ptr0_info3", ps, depth, &v->ptr0))
 
1293
                                return False;
 
1294
                        
 
1295
                        depth--;
 
1296
                        break;
 
1297
                
 
1298
                case 4:
 
1299
                        depth++;
 
1300
                        if (!prs_uint32("ptr0_info4", ps, depth, &v->ptr0))
 
1301
                                return False;
 
1302
                        
 
1303
                        depth--;
 
1304
                        break;
 
1305
                
 
1306
                case 200:
 
1307
                        depth++;
 
1308
                        if (!prs_uint32("ptr0_info200", ps, depth, &v->ptr0))
 
1309
                                return False;
 
1310
                        
 
1311
                        depth--;
 
1312
                        break;
 
1313
                
 
1314
                case 300:
 
1315
                        depth++;
 
1316
                        if (!prs_uint32("ptr0_info300", ps, depth, &v->ptr0))
 
1317
                                return False;
 
1318
                        
 
1319
                        depth--;
 
1320
                        break;
 
1321
                
 
1322
                default:
 
1323
                        return False;
 
1324
                
 
1325
        }
 
1326
        
 
1327
        return True;
 
1328
}
 
1329
 
 
1330
BOOL netdfs_io_dfs_EnumInfo_d(const char *desc, NETDFS_DFS_ENUMINFO_CTR* v, prs_struct *ps, int depth)
 
1331
{
 
1332
        switch (v->switch_value) {
 
1333
                case 1:
 
1334
                        depth++;
 
1335
                        if (v->ptr0) {
 
1336
                                if (!prs_align_custom(ps, 4))
 
1337
                                        return False;
 
1338
                                
 
1339
                                if (!netdfs_io_dfs_EnumArray1_p("info1", &v->u.info1, ps, depth))
 
1340
                                        return False;
 
1341
                                if (!netdfs_io_dfs_EnumArray1_d("info1", &v->u.info1, ps, depth))
 
1342
                                        return False;
 
1343
                        }
 
1344
                        depth--;
 
1345
                        break;
 
1346
                
 
1347
                case 2:
 
1348
                        depth++;
 
1349
                        if (v->ptr0) {
 
1350
                                if (!prs_align_custom(ps, 4))
 
1351
                                        return False;
 
1352
                                
 
1353
                                if (!netdfs_io_dfs_EnumArray2_p("info2", &v->u.info2, ps, depth))
 
1354
                                        return False;
 
1355
                                if (!netdfs_io_dfs_EnumArray2_d("info2", &v->u.info2, ps, depth))
 
1356
                                        return False;
 
1357
                        }
 
1358
                        depth--;
 
1359
                        break;
 
1360
                
 
1361
                case 3:
 
1362
                        depth++;
 
1363
                        if (v->ptr0) {
 
1364
                                if (!prs_align_custom(ps, 4))
 
1365
                                        return False;
 
1366
                                
 
1367
                                if (!netdfs_io_dfs_EnumArray3_p("info3", &v->u.info3, ps, depth))
 
1368
                                        return False;
 
1369
                                if (!netdfs_io_dfs_EnumArray3_d("info3", &v->u.info3, ps, depth))
 
1370
                                        return False;
 
1371
                        }
 
1372
                        depth--;
 
1373
                        break;
 
1374
                
 
1375
                case 4:
 
1376
                        depth++;
 
1377
                        if (v->ptr0) {
 
1378
                                if (!prs_align_custom(ps, 4))
 
1379
                                        return False;
 
1380
                                
 
1381
                                if (!netdfs_io_dfs_EnumArray4_p("info4", &v->u.info4, ps, depth))
 
1382
                                        return False;
 
1383
                                if (!netdfs_io_dfs_EnumArray4_d("info4", &v->u.info4, ps, depth))
 
1384
                                        return False;
 
1385
                        }
 
1386
                        depth--;
 
1387
                        break;
 
1388
                
 
1389
                case 200:
 
1390
                        depth++;
 
1391
                        if (v->ptr0) {
 
1392
                                if (!prs_align_custom(ps, 4))
 
1393
                                        return False;
 
1394
                                
 
1395
                                if (!netdfs_io_dfs_EnumArray200_p("info200", &v->u.info200, ps, depth))
 
1396
                                        return False;
 
1397
                                if (!netdfs_io_dfs_EnumArray200_d("info200", &v->u.info200, ps, depth))
 
1398
                                        return False;
 
1399
                        }
 
1400
                        depth--;
 
1401
                        break;
 
1402
                
 
1403
                case 300:
 
1404
                        depth++;
 
1405
                        if (v->ptr0) {
 
1406
                                if (!prs_align_custom(ps, 4))
 
1407
                                        return False;
 
1408
                                
 
1409
                                if (!netdfs_io_dfs_EnumArray300_p("info300", &v->u.info300, ps, depth))
 
1410
                                        return False;
 
1411
                                if (!netdfs_io_dfs_EnumArray300_d("info300", &v->u.info300, ps, depth))
 
1412
                                        return False;
 
1413
                        }
 
1414
                        depth--;
 
1415
                        break;
 
1416
                
 
1417
        }
 
1418
        
 
1419
        return True;
 
1420
}
 
1421
BOOL init_netdfs_dfs_EnumStruct(NETDFS_DFS_ENUMSTRUCT *v, uint32 level, NETDFS_DFS_ENUMINFO_CTR e)
 
1422
{
 
1423
        DEBUG(5,("init_netdfs_dfs_EnumStruct\n"));
 
1424
        
 
1425
        v->level = level;
 
1426
        
 
1427
        v->e = e;
 
1428
        v->e.switch_value = v->level;
 
1429
        
 
1430
        return True;
 
1431
}
 
1432
 
 
1433
BOOL netdfs_io_dfs_EnumStruct_p(const char *desc, NETDFS_DFS_ENUMSTRUCT *v, prs_struct *ps, int depth)
 
1434
{
 
1435
        if (v == NULL)
 
1436
                return False;
 
1437
        
 
1438
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumStruct_p");
 
1439
        depth++;
 
1440
        if (!prs_uint32("level", ps, depth, &v->level))
 
1441
                return False;
 
1442
        
 
1443
        if (!netdfs_io_dfs_EnumInfo_p("e", &v->e, ps, depth))
 
1444
                return False;
 
1445
        
 
1446
        return True;
 
1447
}
 
1448
 
 
1449
BOOL netdfs_io_dfs_EnumStruct_d(const char *desc, NETDFS_DFS_ENUMSTRUCT *v, prs_struct *ps, int depth)
 
1450
{
 
1451
        if (v == NULL)
 
1452
                return False;
 
1453
        
 
1454
        prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumStruct_d");
 
1455
        depth++;
 
1456
        
 
1457
        if (!prs_align_custom(ps, 4))
 
1458
                return False;
 
1459
        
 
1460
        if (!netdfs_io_dfs_EnumInfo_d("e", &v->e, ps, depth))
 
1461
                return False;
 
1462
        
 
1463
        return True;
 
1464
}
 
1465
 
 
1466
/* netdfs functions */
 
1467
BOOL init_netdfs_q_dfs_GetManagerVersion(NETDFS_Q_DFS_GETMANAGERVERSION *v)
 
1468
{
 
1469
        DEBUG(5,("init_netdfs_q_dfs_GetManagerVersion\n"));
 
1470
        
 
1471
        return True;
 
1472
}
 
1473
 
 
1474
BOOL netdfs_io_q_dfs_GetManagerVersion(const char *desc, NETDFS_Q_DFS_GETMANAGERVERSION *v, prs_struct *ps, int depth)
 
1475
{
 
1476
        if (v == NULL)
 
1477
                return False;
 
1478
        
 
1479
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_GetManagerVersion");
 
1480
        depth++;
 
1481
        return True;
 
1482
}
 
1483
 
 
1484
BOOL init_netdfs_r_dfs_GetManagerVersion(NETDFS_R_DFS_GETMANAGERVERSION *v, uint32 *exist_flag)
 
1485
{
 
1486
        DEBUG(5,("init_netdfs_r_dfs_GetManagerVersion\n"));
 
1487
        
 
1488
        if (!exist_flag)
 
1489
                return False;
 
1490
        
 
1491
        v->exist_flag = *exist_flag;
 
1492
        
 
1493
        return True;
 
1494
}
 
1495
 
 
1496
BOOL netdfs_io_r_dfs_GetManagerVersion(const char *desc, NETDFS_R_DFS_GETMANAGERVERSION *v, prs_struct *ps, int depth)
 
1497
{
 
1498
        if (v == NULL)
 
1499
                return False;
 
1500
        
 
1501
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_GetManagerVersion");
 
1502
        depth++;
 
1503
        if (!prs_uint32("exist_flag", ps, depth, &v->exist_flag))
 
1504
                return False;
 
1505
        
 
1506
        return True;
 
1507
}
 
1508
 
 
1509
BOOL init_netdfs_q_dfs_Add(NETDFS_Q_DFS_ADD *v, const char *path, const char *server, const char *share, const char *comment, uint32 flags)
 
1510
{
 
1511
        DEBUG(5,("init_netdfs_q_dfs_Add\n"));
 
1512
        
 
1513
        if (!path)
 
1514
                return False;
 
1515
        
 
1516
        init_unistr2(&v->path, path, UNI_FLAGS_NONE);
 
1517
        
 
1518
        if (!server)
 
1519
                return False;
 
1520
        
 
1521
        init_unistr2(&v->server, server, UNI_FLAGS_NONE);
 
1522
        
 
1523
        if (share) {
 
1524
                v->ptr0_share = 1;
 
1525
                init_unistr2(&v->share, share, UNI_FLAGS_NONE);
 
1526
        } else {
 
1527
                v->ptr0_share = 0;
 
1528
        }
 
1529
        
 
1530
        if (comment) {
 
1531
                v->ptr0_comment = 1;
 
1532
                init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
 
1533
        } else {
 
1534
                v->ptr0_comment = 0;
 
1535
        }
 
1536
        
 
1537
        v->flags = flags;
 
1538
        
 
1539
        return True;
 
1540
}
 
1541
 
 
1542
BOOL netdfs_io_q_dfs_Add(const char *desc, NETDFS_Q_DFS_ADD *v, prs_struct *ps, int depth)
 
1543
{
 
1544
        if (v == NULL)
 
1545
                return False;
 
1546
        
 
1547
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Add");
 
1548
        depth++;
 
1549
        if (!prs_align_custom(ps, 4))
 
1550
                return False;
 
1551
        
 
1552
        if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
 
1553
                return False;
 
1554
        
 
1555
        if (!prs_align_custom(ps, 4))
 
1556
                return False;
 
1557
        
 
1558
        if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
 
1559
                return False;
 
1560
        
 
1561
        if (!prs_align_custom(ps, 4))
 
1562
                return False;
 
1563
        
 
1564
        if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
 
1565
                return False;
 
1566
        
 
1567
        if (v->ptr0_share) {
 
1568
                if (!prs_align_custom(ps, 4))
 
1569
                        return False;
 
1570
                
 
1571
                if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
 
1572
                        return False;
 
1573
        }
 
1574
        
 
1575
        if (!prs_align_custom(ps, 4))
 
1576
                return False;
 
1577
        
 
1578
        if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
 
1579
                return False;
 
1580
        
 
1581
        if (v->ptr0_comment) {
 
1582
                if (!prs_align_custom(ps, 4))
 
1583
                        return False;
 
1584
                
 
1585
                if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
 
1586
                        return False;
 
1587
        }
 
1588
        
 
1589
        if (!prs_align_custom(ps, 4))
 
1590
                return False;
 
1591
        
 
1592
        if (!prs_uint32("flags", ps, depth, &v->flags))
 
1593
                return False;
 
1594
        
 
1595
        return True;
 
1596
}
 
1597
 
 
1598
BOOL init_netdfs_r_dfs_Add(NETDFS_R_DFS_ADD *v, const char *path, const char *server, const char *share, const char *comment, uint32 flags, WERROR status)
 
1599
{
 
1600
        DEBUG(5,("init_netdfs_r_dfs_Add\n"));
 
1601
        
 
1602
        v->status = status;
 
1603
        
 
1604
        return True;
 
1605
}
 
1606
 
 
1607
BOOL netdfs_io_r_dfs_Add(const char *desc, NETDFS_R_DFS_ADD *v, prs_struct *ps, int depth)
 
1608
{
 
1609
        if (v == NULL)
 
1610
                return False;
 
1611
        
 
1612
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Add");
 
1613
        depth++;
 
1614
        if (!prs_werror("status", ps, depth, &v->status))
 
1615
                return False;
 
1616
        
 
1617
        return True;
 
1618
}
 
1619
 
 
1620
BOOL init_netdfs_q_dfs_Remove(NETDFS_Q_DFS_REMOVE *v, const char *path, const char *server, const char *share)
 
1621
{
 
1622
        DEBUG(5,("init_netdfs_q_dfs_Remove\n"));
 
1623
        
 
1624
        if (!path)
 
1625
                return False;
 
1626
        
 
1627
        init_unistr2(&v->path, path, UNI_FLAGS_NONE);
 
1628
        
 
1629
        if (server) {
 
1630
                v->ptr0_server = 1;
 
1631
                init_unistr2(&v->server, server, UNI_FLAGS_NONE);
 
1632
        } else {
 
1633
                v->ptr0_server = 0;
 
1634
        }
 
1635
        
 
1636
        if (share) {
 
1637
                v->ptr0_share = 1;
 
1638
                init_unistr2(&v->share, share, UNI_FLAGS_NONE);
 
1639
        } else {
 
1640
                v->ptr0_share = 0;
 
1641
        }
 
1642
        
 
1643
        return True;
 
1644
}
 
1645
 
 
1646
BOOL netdfs_io_q_dfs_Remove(const char *desc, NETDFS_Q_DFS_REMOVE *v, prs_struct *ps, int depth)
 
1647
{
 
1648
        if (v == NULL)
 
1649
                return False;
 
1650
        
 
1651
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Remove");
 
1652
        depth++;
 
1653
        if (!prs_align_custom(ps, 4))
 
1654
                return False;
 
1655
        
 
1656
        if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
 
1657
                return False;
 
1658
        
 
1659
        if (!prs_align_custom(ps, 4))
 
1660
                return False;
 
1661
        
 
1662
        if (!prs_uint32("ptr0_server", ps, depth, &v->ptr0_server))
 
1663
                return False;
 
1664
        
 
1665
        if (v->ptr0_server) {
 
1666
                if (!prs_align_custom(ps, 4))
 
1667
                        return False;
 
1668
                
 
1669
                if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
 
1670
                        return False;
 
1671
        }
 
1672
        
 
1673
        if (!prs_align_custom(ps, 4))
 
1674
                return False;
 
1675
        
 
1676
        if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
 
1677
                return False;
 
1678
        
 
1679
        if (v->ptr0_share) {
 
1680
                if (!prs_align_custom(ps, 4))
 
1681
                        return False;
 
1682
                
 
1683
                if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
 
1684
                        return False;
 
1685
        }
 
1686
        
 
1687
        return True;
 
1688
}
 
1689
 
 
1690
BOOL init_netdfs_r_dfs_Remove(NETDFS_R_DFS_REMOVE *v, const char *path, const char *server, const char *share, WERROR status)
 
1691
{
 
1692
        DEBUG(5,("init_netdfs_r_dfs_Remove\n"));
 
1693
        
 
1694
        v->status = status;
 
1695
        
 
1696
        return True;
 
1697
}
 
1698
 
 
1699
BOOL netdfs_io_r_dfs_Remove(const char *desc, NETDFS_R_DFS_REMOVE *v, prs_struct *ps, int depth)
 
1700
{
 
1701
        if (v == NULL)
 
1702
                return False;
 
1703
        
 
1704
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Remove");
 
1705
        depth++;
 
1706
        if (!prs_werror("status", ps, depth, &v->status))
 
1707
                return False;
 
1708
        
 
1709
        return True;
 
1710
}
 
1711
 
 
1712
BOOL init_netdfs_q_dfs_SetInfo(NETDFS_Q_DFS_SETINFO *v)
 
1713
{
 
1714
        DEBUG(5,("init_netdfs_q_dfs_SetInfo\n"));
 
1715
        
 
1716
        return True;
 
1717
}
 
1718
 
 
1719
BOOL netdfs_io_q_dfs_SetInfo(const char *desc, NETDFS_Q_DFS_SETINFO *v, prs_struct *ps, int depth)
 
1720
{
 
1721
        if (v == NULL)
 
1722
                return False;
 
1723
        
 
1724
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetInfo");
 
1725
        depth++;
 
1726
        return True;
 
1727
}
 
1728
 
 
1729
BOOL init_netdfs_r_dfs_SetInfo(NETDFS_R_DFS_SETINFO *v, WERROR status)
 
1730
{
 
1731
        DEBUG(5,("init_netdfs_r_dfs_SetInfo\n"));
 
1732
        
 
1733
        v->status = status;
 
1734
        
 
1735
        return True;
 
1736
}
 
1737
 
 
1738
BOOL netdfs_io_r_dfs_SetInfo(const char *desc, NETDFS_R_DFS_SETINFO *v, prs_struct *ps, int depth)
 
1739
{
 
1740
        if (v == NULL)
 
1741
                return False;
 
1742
        
 
1743
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetInfo");
 
1744
        depth++;
 
1745
        if (!prs_werror("status", ps, depth, &v->status))
 
1746
                return False;
 
1747
        
 
1748
        return True;
 
1749
}
 
1750
 
 
1751
BOOL init_netdfs_q_dfs_GetInfo(NETDFS_Q_DFS_GETINFO *v, const char *path, const char *server, const char *share, uint32 level)
 
1752
{
 
1753
        DEBUG(5,("init_netdfs_q_dfs_GetInfo\n"));
 
1754
        
 
1755
        if (!path)
 
1756
                return False;
 
1757
        
 
1758
        init_unistr2(&v->path, path, UNI_FLAGS_NONE);
 
1759
        
 
1760
        if (server) {
 
1761
                v->ptr0_server = 1;
 
1762
                init_unistr2(&v->server, server, UNI_FLAGS_NONE);
 
1763
        } else {
 
1764
                v->ptr0_server = 0;
 
1765
        }
 
1766
        
 
1767
        if (share) {
 
1768
                v->ptr0_share = 1;
 
1769
                init_unistr2(&v->share, share, UNI_FLAGS_NONE);
 
1770
        } else {
 
1771
                v->ptr0_share = 0;
 
1772
        }
 
1773
        
 
1774
        v->level = level;
 
1775
        
 
1776
        return True;
 
1777
}
 
1778
 
 
1779
BOOL netdfs_io_q_dfs_GetInfo(const char *desc, NETDFS_Q_DFS_GETINFO *v, prs_struct *ps, int depth)
 
1780
{
 
1781
        if (v == NULL)
 
1782
                return False;
 
1783
        
 
1784
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_GetInfo");
 
1785
        depth++;
 
1786
        if (!prs_align_custom(ps, 4))
 
1787
                return False;
 
1788
        
 
1789
        if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
 
1790
                return False;
 
1791
        
 
1792
        if (!prs_align_custom(ps, 4))
 
1793
                return False;
 
1794
        
 
1795
        if (!prs_uint32("ptr0_server", ps, depth, &v->ptr0_server))
 
1796
                return False;
 
1797
        
 
1798
        if (v->ptr0_server) {
 
1799
                if (!prs_align_custom(ps, 4))
 
1800
                        return False;
 
1801
                
 
1802
                if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
 
1803
                        return False;
 
1804
        }
 
1805
        
 
1806
        if (!prs_align_custom(ps, 4))
 
1807
                return False;
 
1808
        
 
1809
        if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
 
1810
                return False;
 
1811
        
 
1812
        if (v->ptr0_share) {
 
1813
                if (!prs_align_custom(ps, 4))
 
1814
                        return False;
 
1815
                
 
1816
                if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
 
1817
                        return False;
 
1818
        }
 
1819
        
 
1820
        if (!prs_align_custom(ps, 4))
 
1821
                return False;
 
1822
        
 
1823
        if (!prs_uint32("level", ps, depth, &v->level))
 
1824
                return False;
 
1825
        
 
1826
        return True;
 
1827
}
 
1828
 
 
1829
BOOL init_netdfs_r_dfs_GetInfo(NETDFS_R_DFS_GETINFO *v, const char *path, const char *server, const char *share, uint32 level, NETDFS_DFS_INFO_CTR *info, WERROR status)
 
1830
{
 
1831
        DEBUG(5,("init_netdfs_r_dfs_GetInfo\n"));
 
1832
        
 
1833
        if (!info)
 
1834
                return False;
 
1835
        
 
1836
        v->info = *info;
 
1837
        v->info.switch_value = level;
 
1838
        
 
1839
        v->status = status;
 
1840
        
 
1841
        return True;
 
1842
}
 
1843
 
 
1844
BOOL netdfs_io_r_dfs_GetInfo(const char *desc, NETDFS_R_DFS_GETINFO *v, prs_struct *ps, int depth)
 
1845
{
 
1846
        if (v == NULL)
 
1847
                return False;
 
1848
        
 
1849
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_GetInfo");
 
1850
        depth++;
 
1851
        if (!netdfs_io_dfs_Info_p("info", &v->info, ps, depth))
 
1852
                return False;
 
1853
        if (!netdfs_io_dfs_Info_d("info", &v->info, ps, depth))
 
1854
                return False;
 
1855
        
 
1856
        if (!prs_align_custom(ps, 4))
 
1857
                return False;
 
1858
        
 
1859
        if (!prs_werror("status", ps, depth, &v->status))
 
1860
                return False;
 
1861
        
 
1862
        return True;
 
1863
}
 
1864
 
 
1865
BOOL init_netdfs_q_dfs_Enum(NETDFS_Q_DFS_ENUM *v, uint32 level, uint32 bufsize, NETDFS_DFS_ENUMSTRUCT *info, uint32 *total)
 
1866
{
 
1867
        DEBUG(5,("init_netdfs_q_dfs_Enum\n"));
 
1868
        
 
1869
        v->level = level;
 
1870
        
 
1871
        v->bufsize = bufsize;
 
1872
        
 
1873
        if (info) {
 
1874
                v->ptr0_info = 1;
 
1875
                v->info = *info;
 
1876
        } else {
 
1877
                v->ptr0_info = 0;
 
1878
        }
 
1879
        
 
1880
        if (total) {
 
1881
                v->ptr0_total = 1;
 
1882
                v->total = *total;
 
1883
        } else {
 
1884
                v->ptr0_total = 0;
 
1885
        }
 
1886
        
 
1887
        return True;
 
1888
}
 
1889
 
 
1890
BOOL netdfs_io_q_dfs_Enum(const char *desc, NETDFS_Q_DFS_ENUM *v, prs_struct *ps, int depth)
 
1891
{
 
1892
        if (v == NULL)
 
1893
                return False;
 
1894
        
 
1895
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Enum");
 
1896
        depth++;
 
1897
        if (!prs_uint32("level", ps, depth, &v->level))
 
1898
                return False;
 
1899
        
 
1900
        if (!prs_uint32("bufsize", ps, depth, &v->bufsize))
 
1901
                return False;
 
1902
        
 
1903
        if (!prs_uint32("ptr0_info", ps, depth, &v->ptr0_info))
 
1904
                return False;
 
1905
        
 
1906
        if (v->ptr0_info) {
 
1907
                if (!netdfs_io_dfs_EnumStruct_p("info", &v->info, ps, depth))
 
1908
                        return False;
 
1909
                if (!netdfs_io_dfs_EnumStruct_d("info", &v->info, ps, depth))
 
1910
                        return False;
 
1911
        }
 
1912
        
 
1913
        if (!prs_align_custom(ps, 4))
 
1914
                return False;
 
1915
        
 
1916
        if (!prs_uint32("ptr0_total", ps, depth, &v->ptr0_total))
 
1917
                return False;
 
1918
        
 
1919
        if (v->ptr0_total) {
 
1920
                if (!prs_uint32("total", ps, depth, &v->total))
 
1921
                        return False;
 
1922
        }
 
1923
        
 
1924
        return True;
 
1925
}
 
1926
 
 
1927
BOOL init_netdfs_r_dfs_Enum(NETDFS_R_DFS_ENUM *v, uint32 level, uint32 bufsize, NETDFS_DFS_ENUMSTRUCT *info, uint32 *unknown, uint32 *total, WERROR status)
 
1928
{
 
1929
        DEBUG(5,("init_netdfs_r_dfs_Enum\n"));
 
1930
        
 
1931
        if (info) {
 
1932
                v->ptr0_info = 1;
 
1933
                v->info = *info;
 
1934
        } else {
 
1935
                v->ptr0_info = 0;
 
1936
        }
 
1937
        
 
1938
        if (total) {
 
1939
                v->ptr0_total = 1;
 
1940
                v->total = *total;
 
1941
        } else {
 
1942
                v->ptr0_total = 0;
 
1943
        }
 
1944
        
 
1945
        v->status = status;
 
1946
        
 
1947
        return True;
 
1948
}
 
1949
 
 
1950
BOOL netdfs_io_r_dfs_Enum(const char *desc, NETDFS_R_DFS_ENUM *v, prs_struct *ps, int depth)
 
1951
{
 
1952
        if (v == NULL)
 
1953
                return False;
 
1954
        
 
1955
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Enum");
 
1956
        depth++;
 
1957
        if (!prs_uint32("ptr0_info", ps, depth, &v->ptr0_info))
 
1958
                return False;
 
1959
        
 
1960
        if (v->ptr0_info) {
 
1961
                if (!netdfs_io_dfs_EnumStruct_p("info", &v->info, ps, depth))
 
1962
                        return False;
 
1963
                if (!netdfs_io_dfs_EnumStruct_d("info", &v->info, ps, depth))
 
1964
                        return False;
 
1965
        }
 
1966
        
 
1967
        if (!prs_align_custom(ps, 4))
 
1968
                return False;
 
1969
        
 
1970
        if (!prs_uint32("ptr0_total", ps, depth, &v->ptr0_total))
 
1971
                return False;
 
1972
        
 
1973
        if (v->ptr0_total) {
 
1974
                if (!prs_uint32("total", ps, depth, &v->total))
 
1975
                        return False;
 
1976
        }
 
1977
        
 
1978
        if (!prs_align_custom(ps, 4))
 
1979
                return False;
 
1980
        
 
1981
        if (!prs_werror("status", ps, depth, &v->status))
 
1982
                return False;
 
1983
        
 
1984
        return True;
 
1985
}
 
1986
 
 
1987
BOOL init_netdfs_q_dfs_Rename(NETDFS_Q_DFS_RENAME *v)
 
1988
{
 
1989
        DEBUG(5,("init_netdfs_q_dfs_Rename\n"));
 
1990
        
 
1991
        return True;
 
1992
}
 
1993
 
 
1994
BOOL netdfs_io_q_dfs_Rename(const char *desc, NETDFS_Q_DFS_RENAME *v, prs_struct *ps, int depth)
 
1995
{
 
1996
        if (v == NULL)
 
1997
                return False;
 
1998
        
 
1999
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Rename");
 
2000
        depth++;
 
2001
        return True;
 
2002
}
 
2003
 
 
2004
BOOL init_netdfs_r_dfs_Rename(NETDFS_R_DFS_RENAME *v, WERROR status)
 
2005
{
 
2006
        DEBUG(5,("init_netdfs_r_dfs_Rename\n"));
 
2007
        
 
2008
        v->status = status;
 
2009
        
 
2010
        return True;
 
2011
}
 
2012
 
 
2013
BOOL netdfs_io_r_dfs_Rename(const char *desc, NETDFS_R_DFS_RENAME *v, prs_struct *ps, int depth)
 
2014
{
 
2015
        if (v == NULL)
 
2016
                return False;
 
2017
        
 
2018
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Rename");
 
2019
        depth++;
 
2020
        if (!prs_werror("status", ps, depth, &v->status))
 
2021
                return False;
 
2022
        
 
2023
        return True;
 
2024
}
 
2025
 
 
2026
BOOL init_netdfs_q_dfs_Move(NETDFS_Q_DFS_MOVE *v)
 
2027
{
 
2028
        DEBUG(5,("init_netdfs_q_dfs_Move\n"));
 
2029
        
 
2030
        return True;
 
2031
}
 
2032
 
 
2033
BOOL netdfs_io_q_dfs_Move(const char *desc, NETDFS_Q_DFS_MOVE *v, prs_struct *ps, int depth)
 
2034
{
 
2035
        if (v == NULL)
 
2036
                return False;
 
2037
        
 
2038
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Move");
 
2039
        depth++;
 
2040
        return True;
 
2041
}
 
2042
 
 
2043
BOOL init_netdfs_r_dfs_Move(NETDFS_R_DFS_MOVE *v, WERROR status)
 
2044
{
 
2045
        DEBUG(5,("init_netdfs_r_dfs_Move\n"));
 
2046
        
 
2047
        v->status = status;
 
2048
        
 
2049
        return True;
 
2050
}
 
2051
 
 
2052
BOOL netdfs_io_r_dfs_Move(const char *desc, NETDFS_R_DFS_MOVE *v, prs_struct *ps, int depth)
 
2053
{
 
2054
        if (v == NULL)
 
2055
                return False;
 
2056
        
 
2057
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Move");
 
2058
        depth++;
 
2059
        if (!prs_werror("status", ps, depth, &v->status))
 
2060
                return False;
 
2061
        
 
2062
        return True;
 
2063
}
 
2064
 
 
2065
BOOL init_netdfs_q_dfs_ManagerGetConfigInfo(NETDFS_Q_DFS_MANAGERGETCONFIGINFO *v)
 
2066
{
 
2067
        DEBUG(5,("init_netdfs_q_dfs_ManagerGetConfigInfo\n"));
 
2068
        
 
2069
        return True;
 
2070
}
 
2071
 
 
2072
BOOL netdfs_io_q_dfs_ManagerGetConfigInfo(const char *desc, NETDFS_Q_DFS_MANAGERGETCONFIGINFO *v, prs_struct *ps, int depth)
 
2073
{
 
2074
        if (v == NULL)
 
2075
                return False;
 
2076
        
 
2077
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerGetConfigInfo");
 
2078
        depth++;
 
2079
        return True;
 
2080
}
 
2081
 
 
2082
BOOL init_netdfs_r_dfs_ManagerGetConfigInfo(NETDFS_R_DFS_MANAGERGETCONFIGINFO *v, WERROR status)
 
2083
{
 
2084
        DEBUG(5,("init_netdfs_r_dfs_ManagerGetConfigInfo\n"));
 
2085
        
 
2086
        v->status = status;
 
2087
        
 
2088
        return True;
 
2089
}
 
2090
 
 
2091
BOOL netdfs_io_r_dfs_ManagerGetConfigInfo(const char *desc, NETDFS_R_DFS_MANAGERGETCONFIGINFO *v, prs_struct *ps, int depth)
 
2092
{
 
2093
        if (v == NULL)
 
2094
                return False;
 
2095
        
 
2096
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerGetConfigInfo");
 
2097
        depth++;
 
2098
        if (!prs_werror("status", ps, depth, &v->status))
 
2099
                return False;
 
2100
        
 
2101
        return True;
 
2102
}
 
2103
 
 
2104
BOOL init_netdfs_q_dfs_ManagerSendSiteInfo(NETDFS_Q_DFS_MANAGERSENDSITEINFO *v)
 
2105
{
 
2106
        DEBUG(5,("init_netdfs_q_dfs_ManagerSendSiteInfo\n"));
 
2107
        
 
2108
        return True;
 
2109
}
 
2110
 
 
2111
BOOL netdfs_io_q_dfs_ManagerSendSiteInfo(const char *desc, NETDFS_Q_DFS_MANAGERSENDSITEINFO *v, prs_struct *ps, int depth)
 
2112
{
 
2113
        if (v == NULL)
 
2114
                return False;
 
2115
        
 
2116
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerSendSiteInfo");
 
2117
        depth++;
 
2118
        return True;
 
2119
}
 
2120
 
 
2121
BOOL init_netdfs_r_dfs_ManagerSendSiteInfo(NETDFS_R_DFS_MANAGERSENDSITEINFO *v, WERROR status)
 
2122
{
 
2123
        DEBUG(5,("init_netdfs_r_dfs_ManagerSendSiteInfo\n"));
 
2124
        
 
2125
        v->status = status;
 
2126
        
 
2127
        return True;
 
2128
}
 
2129
 
 
2130
BOOL netdfs_io_r_dfs_ManagerSendSiteInfo(const char *desc, NETDFS_R_DFS_MANAGERSENDSITEINFO *v, prs_struct *ps, int depth)
 
2131
{
 
2132
        if (v == NULL)
 
2133
                return False;
 
2134
        
 
2135
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerSendSiteInfo");
 
2136
        depth++;
 
2137
        if (!prs_werror("status", ps, depth, &v->status))
 
2138
                return False;
 
2139
        
 
2140
        return True;
 
2141
}
 
2142
 
 
2143
BOOL init_netdfs_q_dfs_AddFtRoot(NETDFS_Q_DFS_ADDFTROOT *v)
 
2144
{
 
2145
        DEBUG(5,("init_netdfs_q_dfs_AddFtRoot\n"));
 
2146
        
 
2147
        return True;
 
2148
}
 
2149
 
 
2150
BOOL netdfs_io_q_dfs_AddFtRoot(const char *desc, NETDFS_Q_DFS_ADDFTROOT *v, prs_struct *ps, int depth)
 
2151
{
 
2152
        if (v == NULL)
 
2153
                return False;
 
2154
        
 
2155
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddFtRoot");
 
2156
        depth++;
 
2157
        return True;
 
2158
}
 
2159
 
 
2160
BOOL init_netdfs_r_dfs_AddFtRoot(NETDFS_R_DFS_ADDFTROOT *v, WERROR status)
 
2161
{
 
2162
        DEBUG(5,("init_netdfs_r_dfs_AddFtRoot\n"));
 
2163
        
 
2164
        v->status = status;
 
2165
        
 
2166
        return True;
 
2167
}
 
2168
 
 
2169
BOOL netdfs_io_r_dfs_AddFtRoot(const char *desc, NETDFS_R_DFS_ADDFTROOT *v, prs_struct *ps, int depth)
 
2170
{
 
2171
        if (v == NULL)
 
2172
                return False;
 
2173
        
 
2174
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddFtRoot");
 
2175
        depth++;
 
2176
        if (!prs_werror("status", ps, depth, &v->status))
 
2177
                return False;
 
2178
        
 
2179
        return True;
 
2180
}
 
2181
 
 
2182
BOOL init_netdfs_q_dfs_RemoveFtRoot(NETDFS_Q_DFS_REMOVEFTROOT *v)
 
2183
{
 
2184
        DEBUG(5,("init_netdfs_q_dfs_RemoveFtRoot\n"));
 
2185
        
 
2186
        return True;
 
2187
}
 
2188
 
 
2189
BOOL netdfs_io_q_dfs_RemoveFtRoot(const char *desc, NETDFS_Q_DFS_REMOVEFTROOT *v, prs_struct *ps, int depth)
 
2190
{
 
2191
        if (v == NULL)
 
2192
                return False;
 
2193
        
 
2194
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_RemoveFtRoot");
 
2195
        depth++;
 
2196
        return True;
 
2197
}
 
2198
 
 
2199
BOOL init_netdfs_r_dfs_RemoveFtRoot(NETDFS_R_DFS_REMOVEFTROOT *v, WERROR status)
 
2200
{
 
2201
        DEBUG(5,("init_netdfs_r_dfs_RemoveFtRoot\n"));
 
2202
        
 
2203
        v->status = status;
 
2204
        
 
2205
        return True;
 
2206
}
 
2207
 
 
2208
BOOL netdfs_io_r_dfs_RemoveFtRoot(const char *desc, NETDFS_R_DFS_REMOVEFTROOT *v, prs_struct *ps, int depth)
 
2209
{
 
2210
        if (v == NULL)
 
2211
                return False;
 
2212
        
 
2213
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_RemoveFtRoot");
 
2214
        depth++;
 
2215
        if (!prs_werror("status", ps, depth, &v->status))
 
2216
                return False;
 
2217
        
 
2218
        return True;
 
2219
}
 
2220
 
 
2221
BOOL init_netdfs_q_dfs_AddStdRoot(NETDFS_Q_DFS_ADDSTDROOT *v)
 
2222
{
 
2223
        DEBUG(5,("init_netdfs_q_dfs_AddStdRoot\n"));
 
2224
        
 
2225
        return True;
 
2226
}
 
2227
 
 
2228
BOOL netdfs_io_q_dfs_AddStdRoot(const char *desc, NETDFS_Q_DFS_ADDSTDROOT *v, prs_struct *ps, int depth)
 
2229
{
 
2230
        if (v == NULL)
 
2231
                return False;
 
2232
        
 
2233
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddStdRoot");
 
2234
        depth++;
 
2235
        return True;
 
2236
}
 
2237
 
 
2238
BOOL init_netdfs_r_dfs_AddStdRoot(NETDFS_R_DFS_ADDSTDROOT *v, WERROR status)
 
2239
{
 
2240
        DEBUG(5,("init_netdfs_r_dfs_AddStdRoot\n"));
 
2241
        
 
2242
        v->status = status;
 
2243
        
 
2244
        return True;
 
2245
}
 
2246
 
 
2247
BOOL netdfs_io_r_dfs_AddStdRoot(const char *desc, NETDFS_R_DFS_ADDSTDROOT *v, prs_struct *ps, int depth)
 
2248
{
 
2249
        if (v == NULL)
 
2250
                return False;
 
2251
        
 
2252
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddStdRoot");
 
2253
        depth++;
 
2254
        if (!prs_werror("status", ps, depth, &v->status))
 
2255
                return False;
 
2256
        
 
2257
        return True;
 
2258
}
 
2259
 
 
2260
BOOL init_netdfs_q_dfs_RemoveStdRoot(NETDFS_Q_DFS_REMOVESTDROOT *v)
 
2261
{
 
2262
        DEBUG(5,("init_netdfs_q_dfs_RemoveStdRoot\n"));
 
2263
        
 
2264
        return True;
 
2265
}
 
2266
 
 
2267
BOOL netdfs_io_q_dfs_RemoveStdRoot(const char *desc, NETDFS_Q_DFS_REMOVESTDROOT *v, prs_struct *ps, int depth)
 
2268
{
 
2269
        if (v == NULL)
 
2270
                return False;
 
2271
        
 
2272
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_RemoveStdRoot");
 
2273
        depth++;
 
2274
        return True;
 
2275
}
 
2276
 
 
2277
BOOL init_netdfs_r_dfs_RemoveStdRoot(NETDFS_R_DFS_REMOVESTDROOT *v, WERROR status)
 
2278
{
 
2279
        DEBUG(5,("init_netdfs_r_dfs_RemoveStdRoot\n"));
 
2280
        
 
2281
        v->status = status;
 
2282
        
 
2283
        return True;
 
2284
}
 
2285
 
 
2286
BOOL netdfs_io_r_dfs_RemoveStdRoot(const char *desc, NETDFS_R_DFS_REMOVESTDROOT *v, prs_struct *ps, int depth)
 
2287
{
 
2288
        if (v == NULL)
 
2289
                return False;
 
2290
        
 
2291
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_RemoveStdRoot");
 
2292
        depth++;
 
2293
        if (!prs_werror("status", ps, depth, &v->status))
 
2294
                return False;
 
2295
        
 
2296
        return True;
 
2297
}
 
2298
 
 
2299
BOOL init_netdfs_q_dfs_ManagerInitialize(NETDFS_Q_DFS_MANAGERINITIALIZE *v)
 
2300
{
 
2301
        DEBUG(5,("init_netdfs_q_dfs_ManagerInitialize\n"));
 
2302
        
 
2303
        return True;
 
2304
}
 
2305
 
 
2306
BOOL netdfs_io_q_dfs_ManagerInitialize(const char *desc, NETDFS_Q_DFS_MANAGERINITIALIZE *v, prs_struct *ps, int depth)
 
2307
{
 
2308
        if (v == NULL)
 
2309
                return False;
 
2310
        
 
2311
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerInitialize");
 
2312
        depth++;
 
2313
        return True;
 
2314
}
 
2315
 
 
2316
BOOL init_netdfs_r_dfs_ManagerInitialize(NETDFS_R_DFS_MANAGERINITIALIZE *v, WERROR status)
 
2317
{
 
2318
        DEBUG(5,("init_netdfs_r_dfs_ManagerInitialize\n"));
 
2319
        
 
2320
        v->status = status;
 
2321
        
 
2322
        return True;
 
2323
}
 
2324
 
 
2325
BOOL netdfs_io_r_dfs_ManagerInitialize(const char *desc, NETDFS_R_DFS_MANAGERINITIALIZE *v, prs_struct *ps, int depth)
 
2326
{
 
2327
        if (v == NULL)
 
2328
                return False;
 
2329
        
 
2330
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerInitialize");
 
2331
        depth++;
 
2332
        if (!prs_werror("status", ps, depth, &v->status))
 
2333
                return False;
 
2334
        
 
2335
        return True;
 
2336
}
 
2337
 
 
2338
BOOL init_netdfs_q_dfs_AddStdRootForced(NETDFS_Q_DFS_ADDSTDROOTFORCED *v)
 
2339
{
 
2340
        DEBUG(5,("init_netdfs_q_dfs_AddStdRootForced\n"));
 
2341
        
 
2342
        return True;
 
2343
}
 
2344
 
 
2345
BOOL netdfs_io_q_dfs_AddStdRootForced(const char *desc, NETDFS_Q_DFS_ADDSTDROOTFORCED *v, prs_struct *ps, int depth)
 
2346
{
 
2347
        if (v == NULL)
 
2348
                return False;
 
2349
        
 
2350
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddStdRootForced");
 
2351
        depth++;
 
2352
        return True;
 
2353
}
 
2354
 
 
2355
BOOL init_netdfs_r_dfs_AddStdRootForced(NETDFS_R_DFS_ADDSTDROOTFORCED *v, WERROR status)
 
2356
{
 
2357
        DEBUG(5,("init_netdfs_r_dfs_AddStdRootForced\n"));
 
2358
        
 
2359
        v->status = status;
 
2360
        
 
2361
        return True;
 
2362
}
 
2363
 
 
2364
BOOL netdfs_io_r_dfs_AddStdRootForced(const char *desc, NETDFS_R_DFS_ADDSTDROOTFORCED *v, prs_struct *ps, int depth)
 
2365
{
 
2366
        if (v == NULL)
 
2367
                return False;
 
2368
        
 
2369
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddStdRootForced");
 
2370
        depth++;
 
2371
        if (!prs_werror("status", ps, depth, &v->status))
 
2372
                return False;
 
2373
        
 
2374
        return True;
 
2375
}
 
2376
 
 
2377
BOOL init_netdfs_q_dfs_GetDcAddress(NETDFS_Q_DFS_GETDCADDRESS *v)
 
2378
{
 
2379
        DEBUG(5,("init_netdfs_q_dfs_GetDcAddress\n"));
 
2380
        
 
2381
        return True;
 
2382
}
 
2383
 
 
2384
BOOL netdfs_io_q_dfs_GetDcAddress(const char *desc, NETDFS_Q_DFS_GETDCADDRESS *v, prs_struct *ps, int depth)
 
2385
{
 
2386
        if (v == NULL)
 
2387
                return False;
 
2388
        
 
2389
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_GetDcAddress");
 
2390
        depth++;
 
2391
        return True;
 
2392
}
 
2393
 
 
2394
BOOL init_netdfs_r_dfs_GetDcAddress(NETDFS_R_DFS_GETDCADDRESS *v, WERROR status)
 
2395
{
 
2396
        DEBUG(5,("init_netdfs_r_dfs_GetDcAddress\n"));
 
2397
        
 
2398
        v->status = status;
 
2399
        
 
2400
        return True;
 
2401
}
 
2402
 
 
2403
BOOL netdfs_io_r_dfs_GetDcAddress(const char *desc, NETDFS_R_DFS_GETDCADDRESS *v, prs_struct *ps, int depth)
 
2404
{
 
2405
        if (v == NULL)
 
2406
                return False;
 
2407
        
 
2408
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_GetDcAddress");
 
2409
        depth++;
 
2410
        if (!prs_werror("status", ps, depth, &v->status))
 
2411
                return False;
 
2412
        
 
2413
        return True;
 
2414
}
 
2415
 
 
2416
BOOL init_netdfs_q_dfs_SetDcAddress(NETDFS_Q_DFS_SETDCADDRESS *v)
 
2417
{
 
2418
        DEBUG(5,("init_netdfs_q_dfs_SetDcAddress\n"));
 
2419
        
 
2420
        return True;
 
2421
}
 
2422
 
 
2423
BOOL netdfs_io_q_dfs_SetDcAddress(const char *desc, NETDFS_Q_DFS_SETDCADDRESS *v, prs_struct *ps, int depth)
 
2424
{
 
2425
        if (v == NULL)
 
2426
                return False;
 
2427
        
 
2428
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetDcAddress");
 
2429
        depth++;
 
2430
        return True;
 
2431
}
 
2432
 
 
2433
BOOL init_netdfs_r_dfs_SetDcAddress(NETDFS_R_DFS_SETDCADDRESS *v, WERROR status)
 
2434
{
 
2435
        DEBUG(5,("init_netdfs_r_dfs_SetDcAddress\n"));
 
2436
        
 
2437
        v->status = status;
 
2438
        
 
2439
        return True;
 
2440
}
 
2441
 
 
2442
BOOL netdfs_io_r_dfs_SetDcAddress(const char *desc, NETDFS_R_DFS_SETDCADDRESS *v, prs_struct *ps, int depth)
 
2443
{
 
2444
        if (v == NULL)
 
2445
                return False;
 
2446
        
 
2447
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetDcAddress");
 
2448
        depth++;
 
2449
        if (!prs_werror("status", ps, depth, &v->status))
 
2450
                return False;
 
2451
        
 
2452
        return True;
 
2453
}
 
2454
 
 
2455
BOOL init_netdfs_q_dfs_FlushFtTable(NETDFS_Q_DFS_FLUSHFTTABLE *v)
 
2456
{
 
2457
        DEBUG(5,("init_netdfs_q_dfs_FlushFtTable\n"));
 
2458
        
 
2459
        return True;
 
2460
}
 
2461
 
 
2462
BOOL netdfs_io_q_dfs_FlushFtTable(const char *desc, NETDFS_Q_DFS_FLUSHFTTABLE *v, prs_struct *ps, int depth)
 
2463
{
 
2464
        if (v == NULL)
 
2465
                return False;
 
2466
        
 
2467
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_FlushFtTable");
 
2468
        depth++;
 
2469
        return True;
 
2470
}
 
2471
 
 
2472
BOOL init_netdfs_r_dfs_FlushFtTable(NETDFS_R_DFS_FLUSHFTTABLE *v, WERROR status)
 
2473
{
 
2474
        DEBUG(5,("init_netdfs_r_dfs_FlushFtTable\n"));
 
2475
        
 
2476
        v->status = status;
 
2477
        
 
2478
        return True;
 
2479
}
 
2480
 
 
2481
BOOL netdfs_io_r_dfs_FlushFtTable(const char *desc, NETDFS_R_DFS_FLUSHFTTABLE *v, prs_struct *ps, int depth)
 
2482
{
 
2483
        if (v == NULL)
 
2484
                return False;
 
2485
        
 
2486
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_FlushFtTable");
 
2487
        depth++;
 
2488
        if (!prs_werror("status", ps, depth, &v->status))
 
2489
                return False;
 
2490
        
 
2491
        return True;
 
2492
}
 
2493
 
 
2494
BOOL init_netdfs_q_dfs_Add2(NETDFS_Q_DFS_ADD2 *v)
 
2495
{
 
2496
        DEBUG(5,("init_netdfs_q_dfs_Add2\n"));
 
2497
        
 
2498
        return True;
 
2499
}
 
2500
 
 
2501
BOOL netdfs_io_q_dfs_Add2(const char *desc, NETDFS_Q_DFS_ADD2 *v, prs_struct *ps, int depth)
 
2502
{
 
2503
        if (v == NULL)
 
2504
                return False;
 
2505
        
 
2506
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Add2");
 
2507
        depth++;
 
2508
        return True;
 
2509
}
 
2510
 
 
2511
BOOL init_netdfs_r_dfs_Add2(NETDFS_R_DFS_ADD2 *v, WERROR status)
 
2512
{
 
2513
        DEBUG(5,("init_netdfs_r_dfs_Add2\n"));
 
2514
        
 
2515
        v->status = status;
 
2516
        
 
2517
        return True;
 
2518
}
 
2519
 
 
2520
BOOL netdfs_io_r_dfs_Add2(const char *desc, NETDFS_R_DFS_ADD2 *v, prs_struct *ps, int depth)
 
2521
{
 
2522
        if (v == NULL)
 
2523
                return False;
 
2524
        
 
2525
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Add2");
 
2526
        depth++;
 
2527
        if (!prs_werror("status", ps, depth, &v->status))
 
2528
                return False;
 
2529
        
 
2530
        return True;
 
2531
}
 
2532
 
 
2533
BOOL init_netdfs_q_dfs_Remove2(NETDFS_Q_DFS_REMOVE2 *v)
 
2534
{
 
2535
        DEBUG(5,("init_netdfs_q_dfs_Remove2\n"));
 
2536
        
 
2537
        return True;
 
2538
}
 
2539
 
 
2540
BOOL netdfs_io_q_dfs_Remove2(const char *desc, NETDFS_Q_DFS_REMOVE2 *v, prs_struct *ps, int depth)
 
2541
{
 
2542
        if (v == NULL)
 
2543
                return False;
 
2544
        
 
2545
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Remove2");
 
2546
        depth++;
 
2547
        return True;
 
2548
}
 
2549
 
 
2550
BOOL init_netdfs_r_dfs_Remove2(NETDFS_R_DFS_REMOVE2 *v, WERROR status)
 
2551
{
 
2552
        DEBUG(5,("init_netdfs_r_dfs_Remove2\n"));
 
2553
        
 
2554
        v->status = status;
 
2555
        
 
2556
        return True;
 
2557
}
 
2558
 
 
2559
BOOL netdfs_io_r_dfs_Remove2(const char *desc, NETDFS_R_DFS_REMOVE2 *v, prs_struct *ps, int depth)
 
2560
{
 
2561
        if (v == NULL)
 
2562
                return False;
 
2563
        
 
2564
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Remove2");
 
2565
        depth++;
 
2566
        if (!prs_werror("status", ps, depth, &v->status))
 
2567
                return False;
 
2568
        
 
2569
        return True;
 
2570
}
 
2571
 
 
2572
BOOL init_netdfs_q_dfs_EnumEx(NETDFS_Q_DFS_ENUMEX *v)
 
2573
{
 
2574
        DEBUG(5,("init_netdfs_q_dfs_EnumEx\n"));
 
2575
        
 
2576
        return True;
 
2577
}
 
2578
 
 
2579
BOOL netdfs_io_q_dfs_EnumEx(const char *desc, NETDFS_Q_DFS_ENUMEX *v, prs_struct *ps, int depth)
 
2580
{
 
2581
        if (v == NULL)
 
2582
                return False;
 
2583
        
 
2584
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_EnumEx");
 
2585
        depth++;
 
2586
        return True;
 
2587
}
 
2588
 
 
2589
BOOL init_netdfs_r_dfs_EnumEx(NETDFS_R_DFS_ENUMEX *v, WERROR status)
 
2590
{
 
2591
        DEBUG(5,("init_netdfs_r_dfs_EnumEx\n"));
 
2592
        
 
2593
        v->status = status;
 
2594
        
 
2595
        return True;
 
2596
}
 
2597
 
 
2598
BOOL netdfs_io_r_dfs_EnumEx(const char *desc, NETDFS_R_DFS_ENUMEX *v, prs_struct *ps, int depth)
 
2599
{
 
2600
        if (v == NULL)
 
2601
                return False;
 
2602
        
 
2603
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_EnumEx");
 
2604
        depth++;
 
2605
        if (!prs_werror("status", ps, depth, &v->status))
 
2606
                return False;
 
2607
        
 
2608
        return True;
 
2609
}
 
2610
 
 
2611
BOOL init_netdfs_q_dfs_SetInfo2(NETDFS_Q_DFS_SETINFO2 *v)
 
2612
{
 
2613
        DEBUG(5,("init_netdfs_q_dfs_SetInfo2\n"));
 
2614
        
 
2615
        return True;
 
2616
}
 
2617
 
 
2618
BOOL netdfs_io_q_dfs_SetInfo2(const char *desc, NETDFS_Q_DFS_SETINFO2 *v, prs_struct *ps, int depth)
 
2619
{
 
2620
        if (v == NULL)
 
2621
                return False;
 
2622
        
 
2623
        prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetInfo2");
 
2624
        depth++;
 
2625
        return True;
 
2626
}
 
2627
 
 
2628
BOOL init_netdfs_r_dfs_SetInfo2(NETDFS_R_DFS_SETINFO2 *v, WERROR status)
 
2629
{
 
2630
        DEBUG(5,("init_netdfs_r_dfs_SetInfo2\n"));
 
2631
        
 
2632
        v->status = status;
 
2633
        
 
2634
        return True;
 
2635
}
 
2636
 
 
2637
BOOL netdfs_io_r_dfs_SetInfo2(const char *desc, NETDFS_R_DFS_SETINFO2 *v, prs_struct *ps, int depth)
 
2638
{
 
2639
        if (v == NULL)
 
2640
                return False;
 
2641
        
 
2642
        prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetInfo2");
 
2643
        depth++;
 
2644
        if (!prs_werror("status", ps, depth, &v->status))
 
2645
                return False;
 
2646
        
 
2647
        return True;
 
2648
}
 
2649