00001
00002
00003
00004
00005
00006 #include "includes.h"
00007
00008 #undef DBGC_CLASS
00009 #define DBGC_CLASS DBGC_RPC_PARSE
00010
00011
00012 BOOL init_netdfs_dfs_Info0(NETDFS_DFS_INFO0 *v)
00013 {
00014 DEBUG(5,("init_netdfs_dfs_Info0\n"));
00015
00016 return True;
00017 }
00018
00019 BOOL netdfs_io_dfs_Info0_p(const char *desc, NETDFS_DFS_INFO0 *v, prs_struct *ps, int depth)
00020 {
00021 if (v == NULL)
00022 return False;
00023
00024 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info0_p");
00025 depth++;
00026 return True;
00027 }
00028
00029 BOOL netdfs_io_dfs_Info0_d(const char *desc, NETDFS_DFS_INFO0 *v, prs_struct *ps, int depth)
00030 {
00031 if (v == NULL)
00032 return False;
00033
00034 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info0_d");
00035 depth++;
00036 return True;
00037 }
00038
00039 BOOL init_netdfs_dfs_Info1(NETDFS_DFS_INFO1 *v, const char *path)
00040 {
00041 DEBUG(5,("init_netdfs_dfs_Info1\n"));
00042
00043 if (path) {
00044 v->ptr0_path = 1;
00045 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
00046 } else {
00047 v->ptr0_path = 0;
00048 }
00049
00050 return True;
00051 }
00052
00053 BOOL netdfs_io_dfs_Info1_p(const char *desc, NETDFS_DFS_INFO1 *v, prs_struct *ps, int depth)
00054 {
00055 if (v == NULL)
00056 return False;
00057
00058 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info1_p");
00059 depth++;
00060 if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
00061 return False;
00062
00063
00064 return True;
00065 }
00066
00067 BOOL netdfs_io_dfs_Info1_d(const char *desc, NETDFS_DFS_INFO1 *v, prs_struct *ps, int depth)
00068 {
00069 if (v == NULL)
00070 return False;
00071
00072 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info1_d");
00073 depth++;
00074 if (v->ptr0_path) {
00075 if (!prs_align_custom(ps, 4))
00076 return False;
00077
00078 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
00079 return False;
00080 }
00081
00082 return True;
00083 }
00084
00085 BOOL init_netdfs_dfs_Info2(NETDFS_DFS_INFO2 *v, const char *path, const char *comment, uint32 state, uint32 num_stores)
00086 {
00087 DEBUG(5,("init_netdfs_dfs_Info2\n"));
00088
00089 if (path) {
00090 v->ptr0_path = 1;
00091 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
00092 } else {
00093 v->ptr0_path = 0;
00094 }
00095
00096 if (comment) {
00097 v->ptr0_comment = 1;
00098 init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
00099 } else {
00100 v->ptr0_comment = 0;
00101 }
00102
00103 v->state = state;
00104
00105 v->num_stores = num_stores;
00106
00107 return True;
00108 }
00109
00110 BOOL netdfs_io_dfs_Info2_p(const char *desc, NETDFS_DFS_INFO2 *v, prs_struct *ps, int depth)
00111 {
00112 if (v == NULL)
00113 return False;
00114
00115 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info2_p");
00116 depth++;
00117 if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
00118 return False;
00119
00120
00121 if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
00122 return False;
00123
00124
00125 if (!prs_uint32("state", ps, depth, &v->state))
00126 return False;
00127
00128 if (!prs_uint32("num_stores", ps, depth, &v->num_stores))
00129 return False;
00130
00131 return True;
00132 }
00133
00134 BOOL netdfs_io_dfs_Info2_d(const char *desc, NETDFS_DFS_INFO2 *v, prs_struct *ps, int depth)
00135 {
00136 if (v == NULL)
00137 return False;
00138
00139 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info2_d");
00140 depth++;
00141 if (v->ptr0_path) {
00142 if (!prs_align_custom(ps, 4))
00143 return False;
00144
00145 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
00146 return False;
00147 }
00148
00149 if (v->ptr0_comment) {
00150 if (!prs_align_custom(ps, 4))
00151 return False;
00152
00153 if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
00154 return False;
00155 }
00156
00157
00158
00159 return True;
00160 }
00161
00162 BOOL init_netdfs_dfs_StorageInfo(NETDFS_DFS_STORAGEINFO *v, uint32 state, const char *server, const char *share)
00163 {
00164 DEBUG(5,("init_netdfs_dfs_StorageInfo\n"));
00165
00166 v->state = state;
00167
00168 if (server) {
00169 v->ptr0_server = 1;
00170 init_unistr2(&v->server, server, UNI_FLAGS_NONE);
00171 } else {
00172 v->ptr0_server = 0;
00173 }
00174
00175 if (share) {
00176 v->ptr0_share = 1;
00177 init_unistr2(&v->share, share, UNI_FLAGS_NONE);
00178 } else {
00179 v->ptr0_share = 0;
00180 }
00181
00182 return True;
00183 }
00184
00185 BOOL netdfs_io_dfs_StorageInfo_p(const char *desc, NETDFS_DFS_STORAGEINFO *v, prs_struct *ps, int depth)
00186 {
00187 if (v == NULL)
00188 return False;
00189
00190 prs_debug(ps, depth, desc, "netdfs_io_dfs_StorageInfo_p");
00191 depth++;
00192 if (!prs_uint32("state", ps, depth, &v->state))
00193 return False;
00194
00195 if (!prs_uint32("ptr0_server", ps, depth, &v->ptr0_server))
00196 return False;
00197
00198
00199 if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
00200 return False;
00201
00202
00203 return True;
00204 }
00205
00206 BOOL netdfs_io_dfs_StorageInfo_d(const char *desc, NETDFS_DFS_STORAGEINFO *v, prs_struct *ps, int depth)
00207 {
00208 if (v == NULL)
00209 return False;
00210
00211 prs_debug(ps, depth, desc, "netdfs_io_dfs_StorageInfo_d");
00212 depth++;
00213
00214 if (v->ptr0_server) {
00215 if (!prs_align_custom(ps, 4))
00216 return False;
00217
00218 if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
00219 return False;
00220 }
00221
00222 if (v->ptr0_share) {
00223 if (!prs_align_custom(ps, 4))
00224 return False;
00225
00226 if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
00227 return False;
00228 }
00229
00230 return True;
00231 }
00232
00233 BOOL init_netdfs_dfs_Info3(NETDFS_DFS_INFO3 *v, const char *path, const char *comment, uint32 state, uint32 num_stores, NETDFS_DFS_STORAGEINFO **stores)
00234 {
00235 DEBUG(5,("init_netdfs_dfs_Info3\n"));
00236
00237 if (path) {
00238 v->ptr0_path = 1;
00239 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
00240 } else {
00241 v->ptr0_path = 0;
00242 }
00243
00244 if (comment) {
00245 v->ptr0_comment = 1;
00246 init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
00247 } else {
00248 v->ptr0_comment = 0;
00249 }
00250
00251 v->state = state;
00252
00253 v->num_stores = num_stores;
00254
00255 if (stores) {
00256 v->ptr0_stores = 1;
00257 v->stores = *stores;
00258 } else {
00259 v->ptr0_stores = 0;
00260 }
00261
00262 return True;
00263 }
00264
00265 BOOL netdfs_io_dfs_Info3_p(const char *desc, NETDFS_DFS_INFO3 *v, prs_struct *ps, int depth)
00266 {
00267 if (v == NULL)
00268 return False;
00269
00270 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info3_p");
00271 depth++;
00272 if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
00273 return False;
00274
00275
00276 if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
00277 return False;
00278
00279
00280 if (!prs_uint32("state", ps, depth, &v->state))
00281 return False;
00282
00283 if (!prs_uint32("num_stores", ps, depth, &v->num_stores))
00284 return False;
00285
00286 if (!prs_uint32("ptr0_stores", ps, depth, &v->ptr0_stores))
00287 return False;
00288
00289
00290 return True;
00291 }
00292
00293 BOOL netdfs_io_dfs_Info3_d(const char *desc, NETDFS_DFS_INFO3 *v, prs_struct *ps, int depth)
00294 {
00295 uint32 i_stores_1;
00296
00297 if (v == NULL)
00298 return False;
00299
00300 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info3_d");
00301 depth++;
00302 if (v->ptr0_path) {
00303 if (!prs_align_custom(ps, 4))
00304 return False;
00305
00306 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
00307 return False;
00308 }
00309
00310 if (v->ptr0_comment) {
00311 if (!prs_align_custom(ps, 4))
00312 return False;
00313
00314 if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
00315 return False;
00316 }
00317
00318
00319
00320 if (v->ptr0_stores) {
00321 if (!prs_align_custom(ps, 4))
00322 return False;
00323
00324 if (!prs_uint32("size_stores", ps, depth, &v->size_stores))
00325 return False;
00326
00327 if (UNMARSHALLING(ps)) {
00328 if (v->num_stores) {
00329 v->stores = PRS_ALLOC_MEM(ps,NETDFS_DFS_STORAGEINFO,v->num_stores);
00330 if (!v->stores) {
00331 return False;
00332 }
00333 } else {
00334 v->stores = NULL;
00335 }
00336 }
00337 for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
00338 if (!netdfs_io_dfs_StorageInfo_p("stores", &v->stores[i_stores_1], ps, depth))
00339 return False;
00340 }
00341 for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
00342 if (!netdfs_io_dfs_StorageInfo_d("stores", &v->stores[i_stores_1], ps, depth))
00343 return False;
00344 }
00345 }
00346
00347 return True;
00348 }
00349
00350 BOOL init_netdfs_dfs_Info4(NETDFS_DFS_INFO4 *v, const char *path, const char *comment, uint32 state, uint32 timeout, struct GUID guid, uint32 num_stores, NETDFS_DFS_STORAGEINFO **stores)
00351 {
00352 DEBUG(5,("init_netdfs_dfs_Info4\n"));
00353
00354 if (path) {
00355 v->ptr0_path = 1;
00356 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
00357 } else {
00358 v->ptr0_path = 0;
00359 }
00360
00361 if (comment) {
00362 v->ptr0_comment = 1;
00363 init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
00364 } else {
00365 v->ptr0_comment = 0;
00366 }
00367
00368 v->state = state;
00369
00370 v->timeout = timeout;
00371
00372
00373
00374 v->num_stores = num_stores;
00375
00376 if (stores) {
00377 v->ptr0_stores = 1;
00378 v->stores = *stores;
00379 } else {
00380 v->ptr0_stores = 0;
00381 }
00382
00383 return True;
00384 }
00385
00386 BOOL netdfs_io_dfs_Info4_p(const char *desc, NETDFS_DFS_INFO4 *v, prs_struct *ps, int depth)
00387 {
00388 if (v == NULL)
00389 return False;
00390
00391 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info4_p");
00392 depth++;
00393 if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
00394 return False;
00395
00396
00397 if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
00398 return False;
00399
00400
00401 if (!prs_uint32("state", ps, depth, &v->state))
00402 return False;
00403
00404 if (!prs_uint32("timeout", ps, depth, &v->timeout))
00405 return False;
00406
00407 if (!smb_io_uuid("guid", &v->guid, ps, depth))
00408 return False;
00409
00410 if (!prs_uint32("num_stores", ps, depth, &v->num_stores))
00411 return False;
00412
00413 if (!prs_uint32("ptr0_stores", ps, depth, &v->ptr0_stores))
00414 return False;
00415
00416
00417 return True;
00418 }
00419
00420 BOOL netdfs_io_dfs_Info4_d(const char *desc, NETDFS_DFS_INFO4 *v, prs_struct *ps, int depth)
00421 {
00422 uint32 i_stores_1;
00423
00424 if (v == NULL)
00425 return False;
00426
00427 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info4_d");
00428 depth++;
00429 if (v->ptr0_path) {
00430 if (!prs_align_custom(ps, 4))
00431 return False;
00432
00433 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
00434 return False;
00435 }
00436
00437 if (v->ptr0_comment) {
00438 if (!prs_align_custom(ps, 4))
00439 return False;
00440
00441 if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
00442 return False;
00443 }
00444
00445
00446
00447
00448
00449 if (v->ptr0_stores) {
00450 if (!prs_align_custom(ps, 4))
00451 return False;
00452
00453 if (!prs_uint32("size_stores", ps, depth, &v->size_stores))
00454 return False;
00455
00456 if (UNMARSHALLING(ps)) {
00457 if (v->num_stores) {
00458 v->stores = PRS_ALLOC_MEM(ps,NETDFS_DFS_STORAGEINFO,v->num_stores);
00459 if (!v->stores) {
00460 return False;
00461 }
00462 } else {
00463 v->stores = NULL;
00464 }
00465 }
00466 for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
00467 if (!netdfs_io_dfs_StorageInfo_p("stores", &v->stores[i_stores_1], ps, depth))
00468 return False;
00469 }
00470 for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
00471 if (!netdfs_io_dfs_StorageInfo_d("stores", &v->stores[i_stores_1], ps, depth))
00472 return False;
00473 }
00474 }
00475
00476 return True;
00477 }
00478
00479 BOOL init_netdfs_dfs_Info100(NETDFS_DFS_INFO100 *v, const char *comment)
00480 {
00481 DEBUG(5,("init_netdfs_dfs_Info100\n"));
00482
00483 if (comment) {
00484 v->ptr0_comment = 1;
00485 init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
00486 } else {
00487 v->ptr0_comment = 0;
00488 }
00489
00490 return True;
00491 }
00492
00493 BOOL netdfs_io_dfs_Info100_p(const char *desc, NETDFS_DFS_INFO100 *v, prs_struct *ps, int depth)
00494 {
00495 if (v == NULL)
00496 return False;
00497
00498 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info100_p");
00499 depth++;
00500 if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
00501 return False;
00502
00503
00504 return True;
00505 }
00506
00507 BOOL netdfs_io_dfs_Info100_d(const char *desc, NETDFS_DFS_INFO100 *v, prs_struct *ps, int depth)
00508 {
00509 if (v == NULL)
00510 return False;
00511
00512 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info100_d");
00513 depth++;
00514 if (v->ptr0_comment) {
00515 if (!prs_align_custom(ps, 4))
00516 return False;
00517
00518 if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
00519 return False;
00520 }
00521
00522 return True;
00523 }
00524
00525 BOOL init_netdfs_dfs_Info101(NETDFS_DFS_INFO101 *v, uint32 state)
00526 {
00527 DEBUG(5,("init_netdfs_dfs_Info101\n"));
00528
00529 v->state = state;
00530
00531 return True;
00532 }
00533
00534 BOOL netdfs_io_dfs_Info101_p(const char *desc, NETDFS_DFS_INFO101 *v, prs_struct *ps, int depth)
00535 {
00536 if (v == NULL)
00537 return False;
00538
00539 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info101_p");
00540 depth++;
00541 if (!prs_uint32("state", ps, depth, &v->state))
00542 return False;
00543
00544 return True;
00545 }
00546
00547 BOOL netdfs_io_dfs_Info101_d(const char *desc, NETDFS_DFS_INFO101 *v, prs_struct *ps, int depth)
00548 {
00549 if (v == NULL)
00550 return False;
00551
00552 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info101_d");
00553 depth++;
00554
00555 return True;
00556 }
00557
00558 BOOL init_netdfs_dfs_Info102(NETDFS_DFS_INFO102 *v, uint32 timeout)
00559 {
00560 DEBUG(5,("init_netdfs_dfs_Info102\n"));
00561
00562 v->timeout = timeout;
00563
00564 return True;
00565 }
00566
00567 BOOL netdfs_io_dfs_Info102_p(const char *desc, NETDFS_DFS_INFO102 *v, prs_struct *ps, int depth)
00568 {
00569 if (v == NULL)
00570 return False;
00571
00572 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info102_p");
00573 depth++;
00574 if (!prs_uint32("timeout", ps, depth, &v->timeout))
00575 return False;
00576
00577 return True;
00578 }
00579
00580 BOOL netdfs_io_dfs_Info102_d(const char *desc, NETDFS_DFS_INFO102 *v, prs_struct *ps, int depth)
00581 {
00582 if (v == NULL)
00583 return False;
00584
00585 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info102_d");
00586 depth++;
00587
00588 return True;
00589 }
00590
00591 BOOL init_netdfs_dfs_Info200(NETDFS_DFS_INFO200 *v, const char *dom_root)
00592 {
00593 DEBUG(5,("init_netdfs_dfs_Info200\n"));
00594
00595 if (dom_root) {
00596 v->ptr0_dom_root = 1;
00597 init_unistr2(&v->dom_root, dom_root, UNI_FLAGS_NONE);
00598 } else {
00599 v->ptr0_dom_root = 0;
00600 }
00601
00602 return True;
00603 }
00604
00605 BOOL netdfs_io_dfs_Info200_p(const char *desc, NETDFS_DFS_INFO200 *v, prs_struct *ps, int depth)
00606 {
00607 if (v == NULL)
00608 return False;
00609
00610 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info200_p");
00611 depth++;
00612 if (!prs_uint32("ptr0_dom_root", ps, depth, &v->ptr0_dom_root))
00613 return False;
00614
00615
00616 return True;
00617 }
00618
00619 BOOL netdfs_io_dfs_Info200_d(const char *desc, NETDFS_DFS_INFO200 *v, prs_struct *ps, int depth)
00620 {
00621 if (v == NULL)
00622 return False;
00623
00624 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info200_d");
00625 depth++;
00626 if (v->ptr0_dom_root) {
00627 if (!prs_align_custom(ps, 4))
00628 return False;
00629
00630 if (!smb_io_unistr2("dom_root", &v->dom_root, 1, ps, depth))
00631 return False;
00632 }
00633
00634 return True;
00635 }
00636
00637 BOOL init_netdfs_dfs_Info300(NETDFS_DFS_INFO300 *v, uint32 flags, const char *dom_root)
00638 {
00639 DEBUG(5,("init_netdfs_dfs_Info300\n"));
00640
00641 v->flags = flags;
00642
00643 if (dom_root) {
00644 v->ptr0_dom_root = 1;
00645 init_unistr2(&v->dom_root, dom_root, UNI_FLAGS_NONE);
00646 } else {
00647 v->ptr0_dom_root = 0;
00648 }
00649
00650 return True;
00651 }
00652
00653 BOOL netdfs_io_dfs_Info300_p(const char *desc, NETDFS_DFS_INFO300 *v, prs_struct *ps, int depth)
00654 {
00655 if (v == NULL)
00656 return False;
00657
00658 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info300_p");
00659 depth++;
00660 if (!prs_uint32("flags", ps, depth, &v->flags))
00661 return False;
00662
00663 if (!prs_uint32("ptr0_dom_root", ps, depth, &v->ptr0_dom_root))
00664 return False;
00665
00666
00667 return True;
00668 }
00669
00670 BOOL netdfs_io_dfs_Info300_d(const char *desc, NETDFS_DFS_INFO300 *v, prs_struct *ps, int depth)
00671 {
00672 if (v == NULL)
00673 return False;
00674
00675 prs_debug(ps, depth, desc, "netdfs_io_dfs_Info300_d");
00676 depth++;
00677
00678 if (v->ptr0_dom_root) {
00679 if (!prs_align_custom(ps, 4))
00680 return False;
00681
00682 if (!smb_io_unistr2("dom_root", &v->dom_root, 1, ps, depth))
00683 return False;
00684 }
00685
00686 return True;
00687 }
00688
00689 BOOL netdfs_io_dfs_Info_p(const char *desc, NETDFS_DFS_INFO_CTR* v, prs_struct *ps, int depth)
00690 {
00691 if (!prs_uint32("switch_value", ps, depth, &v->switch_value))
00692 return False;
00693
00694 switch (v->switch_value) {
00695 case 0:
00696 depth++;
00697 if (!prs_uint32("ptr0_info0", ps, depth, &v->ptr0))
00698 return False;
00699
00700 depth--;
00701 break;
00702
00703 case 1:
00704 depth++;
00705 if (!prs_uint32("ptr0_info1", ps, depth, &v->ptr0))
00706 return False;
00707
00708 depth--;
00709 break;
00710
00711 case 2:
00712 depth++;
00713 if (!prs_uint32("ptr0_info2", ps, depth, &v->ptr0))
00714 return False;
00715
00716 depth--;
00717 break;
00718
00719 case 3:
00720 depth++;
00721 if (!prs_uint32("ptr0_info3", ps, depth, &v->ptr0))
00722 return False;
00723
00724 depth--;
00725 break;
00726
00727 case 4:
00728 depth++;
00729 if (!prs_uint32("ptr0_info4", ps, depth, &v->ptr0))
00730 return False;
00731
00732 depth--;
00733 break;
00734
00735 case 100:
00736 depth++;
00737 if (!prs_uint32("ptr0_info100", ps, depth, &v->ptr0))
00738 return False;
00739
00740 depth--;
00741 break;
00742
00743 case 101:
00744 depth++;
00745 if (!prs_uint32("ptr0_info101", ps, depth, &v->ptr0))
00746 return False;
00747
00748 depth--;
00749 break;
00750
00751 case 102:
00752 depth++;
00753 if (!prs_uint32("ptr0_info102", ps, depth, &v->ptr0))
00754 return False;
00755
00756 depth--;
00757 break;
00758
00759 default:
00760 return False;
00761
00762 }
00763
00764 return True;
00765 }
00766
00767 BOOL netdfs_io_dfs_Info_d(const char *desc, NETDFS_DFS_INFO_CTR* v, prs_struct *ps, int depth)
00768 {
00769 switch (v->switch_value) {
00770 case 0:
00771 depth++;
00772 if (v->ptr0) {
00773 if (!prs_align_custom(ps, 1))
00774 return False;
00775
00776 if (!netdfs_io_dfs_Info0_p("info0", &v->u.info0, ps, depth))
00777 return False;
00778 if (!netdfs_io_dfs_Info0_d("info0", &v->u.info0, ps, depth))
00779 return False;
00780 }
00781 depth--;
00782 break;
00783
00784 case 1:
00785 depth++;
00786 if (v->ptr0) {
00787 if (!prs_align_custom(ps, 4))
00788 return False;
00789
00790 if (!netdfs_io_dfs_Info1_p("info1", &v->u.info1, ps, depth))
00791 return False;
00792 if (!netdfs_io_dfs_Info1_d("info1", &v->u.info1, ps, depth))
00793 return False;
00794 }
00795 depth--;
00796 break;
00797
00798 case 2:
00799 depth++;
00800 if (v->ptr0) {
00801 if (!prs_align_custom(ps, 4))
00802 return False;
00803
00804 if (!netdfs_io_dfs_Info2_p("info2", &v->u.info2, ps, depth))
00805 return False;
00806 if (!netdfs_io_dfs_Info2_d("info2", &v->u.info2, ps, depth))
00807 return False;
00808 }
00809 depth--;
00810 break;
00811
00812 case 3:
00813 depth++;
00814 if (v->ptr0) {
00815 if (!prs_align_custom(ps, 4))
00816 return False;
00817
00818 if (!netdfs_io_dfs_Info3_p("info3", &v->u.info3, ps, depth))
00819 return False;
00820 if (!netdfs_io_dfs_Info3_d("info3", &v->u.info3, ps, depth))
00821 return False;
00822 }
00823 depth--;
00824 break;
00825
00826 case 4:
00827 depth++;
00828 if (v->ptr0) {
00829 if (!prs_align_custom(ps, 4))
00830 return False;
00831
00832 if (!netdfs_io_dfs_Info4_p("info4", &v->u.info4, ps, depth))
00833 return False;
00834 if (!netdfs_io_dfs_Info4_d("info4", &v->u.info4, ps, depth))
00835 return False;
00836 }
00837 depth--;
00838 break;
00839
00840 case 100:
00841 depth++;
00842 if (v->ptr0) {
00843 if (!prs_align_custom(ps, 4))
00844 return False;
00845
00846 if (!netdfs_io_dfs_Info100_p("info100", &v->u.info100, ps, depth))
00847 return False;
00848 if (!netdfs_io_dfs_Info100_d("info100", &v->u.info100, ps, depth))
00849 return False;
00850 }
00851 depth--;
00852 break;
00853
00854 case 101:
00855 depth++;
00856 if (v->ptr0) {
00857 if (!prs_align_custom(ps, 4))
00858 return False;
00859
00860 if (!netdfs_io_dfs_Info101_p("info101", &v->u.info101, ps, depth))
00861 return False;
00862 if (!netdfs_io_dfs_Info101_d("info101", &v->u.info101, ps, depth))
00863 return False;
00864 }
00865 depth--;
00866 break;
00867
00868 case 102:
00869 depth++;
00870 if (v->ptr0) {
00871 if (!prs_align_custom(ps, 4))
00872 return False;
00873
00874 if (!netdfs_io_dfs_Info102_p("info102", &v->u.info102, ps, depth))
00875 return False;
00876 if (!netdfs_io_dfs_Info102_d("info102", &v->u.info102, ps, depth))
00877 return False;
00878 }
00879 depth--;
00880 break;
00881
00882 }
00883
00884 return True;
00885 }
00886 BOOL init_netdfs_dfs_EnumArray1(NETDFS_DFS_ENUMARRAY1 *v, uint32 count, NETDFS_DFS_INFO1 **s)
00887 {
00888 DEBUG(5,("init_netdfs_dfs_EnumArray1\n"));
00889
00890 v->count = count;
00891
00892 if (s) {
00893 v->ptr0_s = 1;
00894 v->s = *s;
00895 } else {
00896 v->ptr0_s = 0;
00897 }
00898
00899 return True;
00900 }
00901
00902 BOOL netdfs_io_dfs_EnumArray1_p(const char *desc, NETDFS_DFS_ENUMARRAY1 *v, prs_struct *ps, int depth)
00903 {
00904 if (v == NULL)
00905 return False;
00906
00907 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray1_p");
00908 depth++;
00909 if (!prs_uint32("count", ps, depth, &v->count))
00910 return False;
00911
00912 if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
00913 return False;
00914
00915
00916 return True;
00917 }
00918
00919 BOOL netdfs_io_dfs_EnumArray1_d(const char *desc, NETDFS_DFS_ENUMARRAY1 *v, prs_struct *ps, int depth)
00920 {
00921 uint32 i_s_1;
00922
00923 if (v == NULL)
00924 return False;
00925
00926 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray1_d");
00927 depth++;
00928
00929 if (v->ptr0_s) {
00930 if (!prs_align_custom(ps, 4))
00931 return False;
00932
00933 if (!prs_uint32("size_s", ps, depth, &v->size_s))
00934 return False;
00935
00936 if (UNMARSHALLING(ps)) {
00937 if (v->count) {
00938 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO1,v->count);
00939 if (!v->s) {
00940 return False;
00941 }
00942 } else {
00943 v->s = NULL;
00944 }
00945 }
00946 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
00947 if (!netdfs_io_dfs_Info1_p("s", &v->s[i_s_1], ps, depth))
00948 return False;
00949 }
00950 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
00951 if (!netdfs_io_dfs_Info1_d("s", &v->s[i_s_1], ps, depth))
00952 return False;
00953 }
00954 }
00955
00956 return True;
00957 }
00958
00959 BOOL init_netdfs_dfs_EnumArray2(NETDFS_DFS_ENUMARRAY2 *v, uint32 count, NETDFS_DFS_INFO2 **s)
00960 {
00961 DEBUG(5,("init_netdfs_dfs_EnumArray2\n"));
00962
00963 v->count = count;
00964
00965 if (s) {
00966 v->ptr0_s = 1;
00967 v->s = *s;
00968 } else {
00969 v->ptr0_s = 0;
00970 }
00971
00972 return True;
00973 }
00974
00975 BOOL netdfs_io_dfs_EnumArray2_p(const char *desc, NETDFS_DFS_ENUMARRAY2 *v, prs_struct *ps, int depth)
00976 {
00977 if (v == NULL)
00978 return False;
00979
00980 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray2_p");
00981 depth++;
00982 if (!prs_uint32("count", ps, depth, &v->count))
00983 return False;
00984
00985 if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
00986 return False;
00987
00988
00989 return True;
00990 }
00991
00992 BOOL netdfs_io_dfs_EnumArray2_d(const char *desc, NETDFS_DFS_ENUMARRAY2 *v, prs_struct *ps, int depth)
00993 {
00994 uint32 i_s_1;
00995
00996 if (v == NULL)
00997 return False;
00998
00999 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray2_d");
01000 depth++;
01001
01002 if (v->ptr0_s) {
01003 if (!prs_align_custom(ps, 4))
01004 return False;
01005
01006 if (!prs_uint32("size_s", ps, depth, &v->size_s))
01007 return False;
01008
01009 if (UNMARSHALLING(ps)) {
01010 if (v->count) {
01011 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO2,v->count);
01012 if (!v->s) {
01013 return False;
01014 }
01015 } else {
01016 v->s = NULL;
01017 }
01018 }
01019 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
01020 if (!netdfs_io_dfs_Info2_p("s", &v->s[i_s_1], ps, depth))
01021 return False;
01022 }
01023 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
01024 if (!netdfs_io_dfs_Info2_d("s", &v->s[i_s_1], ps, depth))
01025 return False;
01026 }
01027 }
01028
01029 return True;
01030 }
01031
01032 BOOL init_netdfs_dfs_EnumArray3(NETDFS_DFS_ENUMARRAY3 *v, uint32 count, NETDFS_DFS_INFO3 **s)
01033 {
01034 DEBUG(5,("init_netdfs_dfs_EnumArray3\n"));
01035
01036 v->count = count;
01037
01038 if (s) {
01039 v->ptr0_s = 1;
01040 v->s = *s;
01041 } else {
01042 v->ptr0_s = 0;
01043 }
01044
01045 return True;
01046 }
01047
01048 BOOL netdfs_io_dfs_EnumArray3_p(const char *desc, NETDFS_DFS_ENUMARRAY3 *v, prs_struct *ps, int depth)
01049 {
01050 if (v == NULL)
01051 return False;
01052
01053 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray3_p");
01054 depth++;
01055 if (!prs_uint32("count", ps, depth, &v->count))
01056 return False;
01057
01058 if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
01059 return False;
01060
01061
01062 return True;
01063 }
01064
01065 BOOL netdfs_io_dfs_EnumArray3_d(const char *desc, NETDFS_DFS_ENUMARRAY3 *v, prs_struct *ps, int depth)
01066 {
01067 uint32 i_s_1;
01068
01069 if (v == NULL)
01070 return False;
01071
01072 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray3_d");
01073 depth++;
01074
01075 if (v->ptr0_s) {
01076 if (!prs_align_custom(ps, 4))
01077 return False;
01078
01079 if (!prs_uint32("size_s", ps, depth, &v->size_s))
01080 return False;
01081
01082 if (UNMARSHALLING(ps)) {
01083 if (v->count) {
01084 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO3,v->count);
01085 if (!v->s) {
01086 return False;
01087 }
01088 } else {
01089 v->s = NULL;
01090 }
01091 }
01092 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
01093 if (!netdfs_io_dfs_Info3_p("s", &v->s[i_s_1], ps, depth))
01094 return False;
01095 }
01096 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
01097 if (!netdfs_io_dfs_Info3_d("s", &v->s[i_s_1], ps, depth))
01098 return False;
01099 }
01100 }
01101
01102 return True;
01103 }
01104
01105 BOOL init_netdfs_dfs_EnumArray4(NETDFS_DFS_ENUMARRAY4 *v, uint32 count, NETDFS_DFS_INFO4 **s)
01106 {
01107 DEBUG(5,("init_netdfs_dfs_EnumArray4\n"));
01108
01109 v->count = count;
01110
01111 if (s) {
01112 v->ptr0_s = 1;
01113 v->s = *s;
01114 } else {
01115 v->ptr0_s = 0;
01116 }
01117
01118 return True;
01119 }
01120
01121 BOOL netdfs_io_dfs_EnumArray4_p(const char *desc, NETDFS_DFS_ENUMARRAY4 *v, prs_struct *ps, int depth)
01122 {
01123 if (v == NULL)
01124 return False;
01125
01126 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray4_p");
01127 depth++;
01128 if (!prs_uint32("count", ps, depth, &v->count))
01129 return False;
01130
01131 if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
01132 return False;
01133
01134
01135 return True;
01136 }
01137
01138 BOOL netdfs_io_dfs_EnumArray4_d(const char *desc, NETDFS_DFS_ENUMARRAY4 *v, prs_struct *ps, int depth)
01139 {
01140 uint32 i_s_1;
01141
01142 if (v == NULL)
01143 return False;
01144
01145 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray4_d");
01146 depth++;
01147
01148 if (v->ptr0_s) {
01149 if (!prs_align_custom(ps, 4))
01150 return False;
01151
01152 if (!prs_uint32("size_s", ps, depth, &v->size_s))
01153 return False;
01154
01155 if (UNMARSHALLING(ps)) {
01156 if (v->count) {
01157 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO4,v->count);
01158 if (!v->s) {
01159 return False;
01160 }
01161 } else {
01162 v->s = NULL;
01163 }
01164 }
01165 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
01166 if (!netdfs_io_dfs_Info4_p("s", &v->s[i_s_1], ps, depth))
01167 return False;
01168 }
01169 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
01170 if (!netdfs_io_dfs_Info4_d("s", &v->s[i_s_1], ps, depth))
01171 return False;
01172 }
01173 }
01174
01175 return True;
01176 }
01177
01178 BOOL init_netdfs_dfs_EnumArray200(NETDFS_DFS_ENUMARRAY200 *v, uint32 count, NETDFS_DFS_INFO200 **s)
01179 {
01180 DEBUG(5,("init_netdfs_dfs_EnumArray200\n"));
01181
01182 v->count = count;
01183
01184 if (s) {
01185 v->ptr0_s = 1;
01186 v->s = *s;
01187 } else {
01188 v->ptr0_s = 0;
01189 }
01190
01191 return True;
01192 }
01193
01194 BOOL netdfs_io_dfs_EnumArray200_p(const char *desc, NETDFS_DFS_ENUMARRAY200 *v, prs_struct *ps, int depth)
01195 {
01196 if (v == NULL)
01197 return False;
01198
01199 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray200_p");
01200 depth++;
01201 if (!prs_uint32("count", ps, depth, &v->count))
01202 return False;
01203
01204 if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
01205 return False;
01206
01207
01208 return True;
01209 }
01210
01211 BOOL netdfs_io_dfs_EnumArray200_d(const char *desc, NETDFS_DFS_ENUMARRAY200 *v, prs_struct *ps, int depth)
01212 {
01213 uint32 i_s_1;
01214
01215 if (v == NULL)
01216 return False;
01217
01218 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray200_d");
01219 depth++;
01220
01221 if (v->ptr0_s) {
01222 if (!prs_align_custom(ps, 4))
01223 return False;
01224
01225 if (!prs_uint32("size_s", ps, depth, &v->size_s))
01226 return False;
01227
01228 if (UNMARSHALLING(ps)) {
01229 if (v->count) {
01230 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO200,v->count);
01231 if (!v->s) {
01232 return False;
01233 }
01234 } else {
01235 v->s = NULL;
01236 }
01237 }
01238 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
01239 if (!netdfs_io_dfs_Info200_p("s", &v->s[i_s_1], ps, depth))
01240 return False;
01241 }
01242 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
01243 if (!netdfs_io_dfs_Info200_d("s", &v->s[i_s_1], ps, depth))
01244 return False;
01245 }
01246 }
01247
01248 return True;
01249 }
01250
01251 BOOL init_netdfs_dfs_EnumArray300(NETDFS_DFS_ENUMARRAY300 *v, uint32 count, NETDFS_DFS_INFO300 **s)
01252 {
01253 DEBUG(5,("init_netdfs_dfs_EnumArray300\n"));
01254
01255 v->count = count;
01256
01257 if (s) {
01258 v->ptr0_s = 1;
01259 v->s = *s;
01260 } else {
01261 v->ptr0_s = 0;
01262 }
01263
01264 return True;
01265 }
01266
01267 BOOL netdfs_io_dfs_EnumArray300_p(const char *desc, NETDFS_DFS_ENUMARRAY300 *v, prs_struct *ps, int depth)
01268 {
01269 if (v == NULL)
01270 return False;
01271
01272 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray300_p");
01273 depth++;
01274 if (!prs_uint32("count", ps, depth, &v->count))
01275 return False;
01276
01277 if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
01278 return False;
01279
01280
01281 return True;
01282 }
01283
01284 BOOL netdfs_io_dfs_EnumArray300_d(const char *desc, NETDFS_DFS_ENUMARRAY300 *v, prs_struct *ps, int depth)
01285 {
01286 uint32 i_s_1;
01287
01288 if (v == NULL)
01289 return False;
01290
01291 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray300_d");
01292 depth++;
01293
01294 if (v->ptr0_s) {
01295 if (!prs_align_custom(ps, 4))
01296 return False;
01297
01298 if (!prs_uint32("size_s", ps, depth, &v->size_s))
01299 return False;
01300
01301 if (UNMARSHALLING(ps)) {
01302 if (v->count) {
01303 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO300,v->count);
01304 if (!v->s) {
01305 return False;
01306 }
01307 } else {
01308 v->s = NULL;
01309 }
01310 }
01311 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
01312 if (!netdfs_io_dfs_Info300_p("s", &v->s[i_s_1], ps, depth))
01313 return False;
01314 }
01315 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
01316 if (!netdfs_io_dfs_Info300_d("s", &v->s[i_s_1], ps, depth))
01317 return False;
01318 }
01319 }
01320
01321 return True;
01322 }
01323
01324 BOOL netdfs_io_dfs_EnumInfo_p(const char *desc, NETDFS_DFS_ENUMINFO_CTR* v, prs_struct *ps, int depth)
01325 {
01326 if (!prs_uint32("switch_value", ps, depth, &v->switch_value))
01327 return False;
01328
01329 switch (v->switch_value) {
01330 case 1:
01331 depth++;
01332 if (!prs_uint32("ptr0_info1", ps, depth, &v->ptr0))
01333 return False;
01334
01335 depth--;
01336 break;
01337
01338 case 2:
01339 depth++;
01340 if (!prs_uint32("ptr0_info2", ps, depth, &v->ptr0))
01341 return False;
01342
01343 depth--;
01344 break;
01345
01346 case 3:
01347 depth++;
01348 if (!prs_uint32("ptr0_info3", ps, depth, &v->ptr0))
01349 return False;
01350
01351 depth--;
01352 break;
01353
01354 case 4:
01355 depth++;
01356 if (!prs_uint32("ptr0_info4", ps, depth, &v->ptr0))
01357 return False;
01358
01359 depth--;
01360 break;
01361
01362 case 200:
01363 depth++;
01364 if (!prs_uint32("ptr0_info200", ps, depth, &v->ptr0))
01365 return False;
01366
01367 depth--;
01368 break;
01369
01370 case 300:
01371 depth++;
01372 if (!prs_uint32("ptr0_info300", ps, depth, &v->ptr0))
01373 return False;
01374
01375 depth--;
01376 break;
01377
01378 default:
01379 return False;
01380
01381 }
01382
01383 return True;
01384 }
01385
01386 BOOL netdfs_io_dfs_EnumInfo_d(const char *desc, NETDFS_DFS_ENUMINFO_CTR* v, prs_struct *ps, int depth)
01387 {
01388 switch (v->switch_value) {
01389 case 1:
01390 depth++;
01391 if (v->ptr0) {
01392 if (!prs_align_custom(ps, 4))
01393 return False;
01394
01395 if (!netdfs_io_dfs_EnumArray1_p("info1", &v->u.info1, ps, depth))
01396 return False;
01397 if (!netdfs_io_dfs_EnumArray1_d("info1", &v->u.info1, ps, depth))
01398 return False;
01399 }
01400 depth--;
01401 break;
01402
01403 case 2:
01404 depth++;
01405 if (v->ptr0) {
01406 if (!prs_align_custom(ps, 4))
01407 return False;
01408
01409 if (!netdfs_io_dfs_EnumArray2_p("info2", &v->u.info2, ps, depth))
01410 return False;
01411 if (!netdfs_io_dfs_EnumArray2_d("info2", &v->u.info2, ps, depth))
01412 return False;
01413 }
01414 depth--;
01415 break;
01416
01417 case 3:
01418 depth++;
01419 if (v->ptr0) {
01420 if (!prs_align_custom(ps, 4))
01421 return False;
01422
01423 if (!netdfs_io_dfs_EnumArray3_p("info3", &v->u.info3, ps, depth))
01424 return False;
01425 if (!netdfs_io_dfs_EnumArray3_d("info3", &v->u.info3, ps, depth))
01426 return False;
01427 }
01428 depth--;
01429 break;
01430
01431 case 4:
01432 depth++;
01433 if (v->ptr0) {
01434 if (!prs_align_custom(ps, 4))
01435 return False;
01436
01437 if (!netdfs_io_dfs_EnumArray4_p("info4", &v->u.info4, ps, depth))
01438 return False;
01439 if (!netdfs_io_dfs_EnumArray4_d("info4", &v->u.info4, ps, depth))
01440 return False;
01441 }
01442 depth--;
01443 break;
01444
01445 case 200:
01446 depth++;
01447 if (v->ptr0) {
01448 if (!prs_align_custom(ps, 4))
01449 return False;
01450
01451 if (!netdfs_io_dfs_EnumArray200_p("info200", &v->u.info200, ps, depth))
01452 return False;
01453 if (!netdfs_io_dfs_EnumArray200_d("info200", &v->u.info200, ps, depth))
01454 return False;
01455 }
01456 depth--;
01457 break;
01458
01459 case 300:
01460 depth++;
01461 if (v->ptr0) {
01462 if (!prs_align_custom(ps, 4))
01463 return False;
01464
01465 if (!netdfs_io_dfs_EnumArray300_p("info300", &v->u.info300, ps, depth))
01466 return False;
01467 if (!netdfs_io_dfs_EnumArray300_d("info300", &v->u.info300, ps, depth))
01468 return False;
01469 }
01470 depth--;
01471 break;
01472
01473 }
01474
01475 return True;
01476 }
01477 BOOL init_netdfs_dfs_EnumStruct(NETDFS_DFS_ENUMSTRUCT *v, uint32 level, NETDFS_DFS_ENUMINFO_CTR e)
01478 {
01479 DEBUG(5,("init_netdfs_dfs_EnumStruct\n"));
01480
01481 v->level = level;
01482
01483 v->e = e;
01484 v->e.switch_value = v->level;
01485
01486 return True;
01487 }
01488
01489 BOOL netdfs_io_dfs_EnumStruct_p(const char *desc, NETDFS_DFS_ENUMSTRUCT *v, prs_struct *ps, int depth)
01490 {
01491 if (v == NULL)
01492 return False;
01493
01494 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumStruct_p");
01495 depth++;
01496 if (!prs_uint32("level", ps, depth, &v->level))
01497 return False;
01498
01499 if (!netdfs_io_dfs_EnumInfo_p("e", &v->e, ps, depth))
01500 return False;
01501
01502 return True;
01503 }
01504
01505 BOOL netdfs_io_dfs_EnumStruct_d(const char *desc, NETDFS_DFS_ENUMSTRUCT *v, prs_struct *ps, int depth)
01506 {
01507 if (v == NULL)
01508 return False;
01509
01510 prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumStruct_d");
01511 depth++;
01512
01513 if (!prs_align_custom(ps, 4))
01514 return False;
01515
01516 if (!netdfs_io_dfs_EnumInfo_d("e", &v->e, ps, depth))
01517 return False;
01518
01519 return True;
01520 }
01521
01522
01523 BOOL init_netdfs_q_dfs_GetManagerVersion(NETDFS_Q_DFS_GETMANAGERVERSION *v)
01524 {
01525 DEBUG(5,("init_netdfs_q_dfs_GetManagerVersion\n"));
01526
01527 return True;
01528 }
01529
01530 BOOL netdfs_io_q_dfs_GetManagerVersion(const char *desc, NETDFS_Q_DFS_GETMANAGERVERSION *v, prs_struct *ps, int depth)
01531 {
01532 if (v == NULL)
01533 return False;
01534
01535 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_GetManagerVersion");
01536 depth++;
01537 return True;
01538 }
01539
01540 BOOL init_netdfs_r_dfs_GetManagerVersion(NETDFS_R_DFS_GETMANAGERVERSION *v, uint32 *exist_flag)
01541 {
01542 DEBUG(5,("init_netdfs_r_dfs_GetManagerVersion\n"));
01543
01544 if (!exist_flag)
01545 return False;
01546
01547 v->exist_flag = *exist_flag;
01548
01549 return True;
01550 }
01551
01552 BOOL netdfs_io_r_dfs_GetManagerVersion(const char *desc, NETDFS_R_DFS_GETMANAGERVERSION *v, prs_struct *ps, int depth)
01553 {
01554 if (v == NULL)
01555 return False;
01556
01557 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_GetManagerVersion");
01558 depth++;
01559 if (!prs_uint32("exist_flag", ps, depth, &v->exist_flag))
01560 return False;
01561
01562 return True;
01563 }
01564
01565 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)
01566 {
01567 DEBUG(5,("init_netdfs_q_dfs_Add\n"));
01568
01569 if (!path)
01570 return False;
01571
01572 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
01573
01574 if (!server)
01575 return False;
01576
01577 init_unistr2(&v->server, server, UNI_FLAGS_NONE);
01578
01579 if (share) {
01580 v->ptr0_share = 1;
01581 init_unistr2(&v->share, share, UNI_FLAGS_NONE);
01582 } else {
01583 v->ptr0_share = 0;
01584 }
01585
01586 if (comment) {
01587 v->ptr0_comment = 1;
01588 init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
01589 } else {
01590 v->ptr0_comment = 0;
01591 }
01592
01593 v->flags = flags;
01594
01595 return True;
01596 }
01597
01598 BOOL netdfs_io_q_dfs_Add(const char *desc, NETDFS_Q_DFS_ADD *v, prs_struct *ps, int depth)
01599 {
01600 if (v == NULL)
01601 return False;
01602
01603 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Add");
01604 depth++;
01605 if (!prs_align_custom(ps, 4))
01606 return False;
01607
01608 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
01609 return False;
01610
01611 if (!prs_align_custom(ps, 4))
01612 return False;
01613
01614 if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
01615 return False;
01616
01617 if (!prs_align_custom(ps, 4))
01618 return False;
01619
01620 if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
01621 return False;
01622
01623 if (v->ptr0_share) {
01624 if (!prs_align_custom(ps, 4))
01625 return False;
01626
01627 if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
01628 return False;
01629 }
01630
01631 if (!prs_align_custom(ps, 4))
01632 return False;
01633
01634 if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
01635 return False;
01636
01637 if (v->ptr0_comment) {
01638 if (!prs_align_custom(ps, 4))
01639 return False;
01640
01641 if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
01642 return False;
01643 }
01644
01645 if (!prs_align_custom(ps, 4))
01646 return False;
01647
01648 if (!prs_uint32("flags", ps, depth, &v->flags))
01649 return False;
01650
01651 return True;
01652 }
01653
01654 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)
01655 {
01656 DEBUG(5,("init_netdfs_r_dfs_Add\n"));
01657
01658 v->status = status;
01659
01660 return True;
01661 }
01662
01663 BOOL netdfs_io_r_dfs_Add(const char *desc, NETDFS_R_DFS_ADD *v, prs_struct *ps, int depth)
01664 {
01665 if (v == NULL)
01666 return False;
01667
01668 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Add");
01669 depth++;
01670 if (!prs_werror("status", ps, depth, &v->status))
01671 return False;
01672
01673 return True;
01674 }
01675
01676 BOOL init_netdfs_q_dfs_Remove(NETDFS_Q_DFS_REMOVE *v, const char *path, const char *server, const char *share)
01677 {
01678 DEBUG(5,("init_netdfs_q_dfs_Remove\n"));
01679
01680 if (!path)
01681 return False;
01682
01683 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
01684
01685 if (server) {
01686 v->ptr0_server = 1;
01687 init_unistr2(&v->server, server, UNI_FLAGS_NONE);
01688 } else {
01689 v->ptr0_server = 0;
01690 }
01691
01692 if (share) {
01693 v->ptr0_share = 1;
01694 init_unistr2(&v->share, share, UNI_FLAGS_NONE);
01695 } else {
01696 v->ptr0_share = 0;
01697 }
01698
01699 return True;
01700 }
01701
01702 BOOL netdfs_io_q_dfs_Remove(const char *desc, NETDFS_Q_DFS_REMOVE *v, prs_struct *ps, int depth)
01703 {
01704 if (v == NULL)
01705 return False;
01706
01707 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Remove");
01708 depth++;
01709 if (!prs_align_custom(ps, 4))
01710 return False;
01711
01712 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
01713 return False;
01714
01715 if (!prs_align_custom(ps, 4))
01716 return False;
01717
01718 if (!prs_uint32("ptr0_server", ps, depth, &v->ptr0_server))
01719 return False;
01720
01721 if (v->ptr0_server) {
01722 if (!prs_align_custom(ps, 4))
01723 return False;
01724
01725 if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
01726 return False;
01727 }
01728
01729 if (!prs_align_custom(ps, 4))
01730 return False;
01731
01732 if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
01733 return False;
01734
01735 if (v->ptr0_share) {
01736 if (!prs_align_custom(ps, 4))
01737 return False;
01738
01739 if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
01740 return False;
01741 }
01742
01743 return True;
01744 }
01745
01746 BOOL init_netdfs_r_dfs_Remove(NETDFS_R_DFS_REMOVE *v, const char *path, const char *server, const char *share, WERROR status)
01747 {
01748 DEBUG(5,("init_netdfs_r_dfs_Remove\n"));
01749
01750 v->status = status;
01751
01752 return True;
01753 }
01754
01755 BOOL netdfs_io_r_dfs_Remove(const char *desc, NETDFS_R_DFS_REMOVE *v, prs_struct *ps, int depth)
01756 {
01757 if (v == NULL)
01758 return False;
01759
01760 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Remove");
01761 depth++;
01762 if (!prs_werror("status", ps, depth, &v->status))
01763 return False;
01764
01765 return True;
01766 }
01767
01768 BOOL init_netdfs_q_dfs_SetInfo(NETDFS_Q_DFS_SETINFO *v)
01769 {
01770 DEBUG(5,("init_netdfs_q_dfs_SetInfo\n"));
01771
01772 return True;
01773 }
01774
01775 BOOL netdfs_io_q_dfs_SetInfo(const char *desc, NETDFS_Q_DFS_SETINFO *v, prs_struct *ps, int depth)
01776 {
01777 if (v == NULL)
01778 return False;
01779
01780 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetInfo");
01781 depth++;
01782 return True;
01783 }
01784
01785 BOOL init_netdfs_r_dfs_SetInfo(NETDFS_R_DFS_SETINFO *v, WERROR status)
01786 {
01787 DEBUG(5,("init_netdfs_r_dfs_SetInfo\n"));
01788
01789 v->status = status;
01790
01791 return True;
01792 }
01793
01794 BOOL netdfs_io_r_dfs_SetInfo(const char *desc, NETDFS_R_DFS_SETINFO *v, prs_struct *ps, int depth)
01795 {
01796 if (v == NULL)
01797 return False;
01798
01799 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetInfo");
01800 depth++;
01801 if (!prs_werror("status", ps, depth, &v->status))
01802 return False;
01803
01804 return True;
01805 }
01806
01807 BOOL init_netdfs_q_dfs_GetInfo(NETDFS_Q_DFS_GETINFO *v, const char *path, const char *server, const char *share, uint32 level)
01808 {
01809 DEBUG(5,("init_netdfs_q_dfs_GetInfo\n"));
01810
01811 if (!path)
01812 return False;
01813
01814 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
01815
01816 if (server) {
01817 v->ptr0_server = 1;
01818 init_unistr2(&v->server, server, UNI_FLAGS_NONE);
01819 } else {
01820 v->ptr0_server = 0;
01821 }
01822
01823 if (share) {
01824 v->ptr0_share = 1;
01825 init_unistr2(&v->share, share, UNI_FLAGS_NONE);
01826 } else {
01827 v->ptr0_share = 0;
01828 }
01829
01830 v->level = level;
01831
01832 return True;
01833 }
01834
01835 BOOL netdfs_io_q_dfs_GetInfo(const char *desc, NETDFS_Q_DFS_GETINFO *v, prs_struct *ps, int depth)
01836 {
01837 if (v == NULL)
01838 return False;
01839
01840 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_GetInfo");
01841 depth++;
01842 if (!prs_align_custom(ps, 4))
01843 return False;
01844
01845 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
01846 return False;
01847
01848 if (!prs_align_custom(ps, 4))
01849 return False;
01850
01851 if (!prs_uint32("ptr0_server", ps, depth, &v->ptr0_server))
01852 return False;
01853
01854 if (v->ptr0_server) {
01855 if (!prs_align_custom(ps, 4))
01856 return False;
01857
01858 if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
01859 return False;
01860 }
01861
01862 if (!prs_align_custom(ps, 4))
01863 return False;
01864
01865 if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
01866 return False;
01867
01868 if (v->ptr0_share) {
01869 if (!prs_align_custom(ps, 4))
01870 return False;
01871
01872 if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
01873 return False;
01874 }
01875
01876 if (!prs_align_custom(ps, 4))
01877 return False;
01878
01879 if (!prs_uint32("level", ps, depth, &v->level))
01880 return False;
01881
01882 return True;
01883 }
01884
01885 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)
01886 {
01887 DEBUG(5,("init_netdfs_r_dfs_GetInfo\n"));
01888
01889 if (!info)
01890 return False;
01891
01892 v->info = *info;
01893 v->info.switch_value = level;
01894
01895 v->status = status;
01896
01897 return True;
01898 }
01899
01900 BOOL netdfs_io_r_dfs_GetInfo(const char *desc, NETDFS_R_DFS_GETINFO *v, prs_struct *ps, int depth)
01901 {
01902 if (v == NULL)
01903 return False;
01904
01905 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_GetInfo");
01906 depth++;
01907 if (!netdfs_io_dfs_Info_p("info", &v->info, ps, depth))
01908 return False;
01909 if (!netdfs_io_dfs_Info_d("info", &v->info, ps, depth))
01910 return False;
01911
01912 if (!prs_align_custom(ps, 4))
01913 return False;
01914
01915 if (!prs_werror("status", ps, depth, &v->status))
01916 return False;
01917
01918 return True;
01919 }
01920
01921 BOOL init_netdfs_q_dfs_Enum(NETDFS_Q_DFS_ENUM *v, uint32 level, uint32 bufsize, NETDFS_DFS_ENUMSTRUCT *info, uint32 *total)
01922 {
01923 DEBUG(5,("init_netdfs_q_dfs_Enum\n"));
01924
01925 v->level = level;
01926
01927 v->bufsize = bufsize;
01928
01929 if (info) {
01930 v->ptr0_info = 1;
01931 v->info = *info;
01932 } else {
01933 v->ptr0_info = 0;
01934 }
01935
01936 if (total) {
01937 v->ptr0_total = 1;
01938 v->total = *total;
01939 } else {
01940 v->ptr0_total = 0;
01941 }
01942
01943 return True;
01944 }
01945
01946 BOOL netdfs_io_q_dfs_Enum(const char *desc, NETDFS_Q_DFS_ENUM *v, prs_struct *ps, int depth)
01947 {
01948 if (v == NULL)
01949 return False;
01950
01951 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Enum");
01952 depth++;
01953 if (!prs_uint32("level", ps, depth, &v->level))
01954 return False;
01955
01956 if (!prs_uint32("bufsize", ps, depth, &v->bufsize))
01957 return False;
01958
01959 if (!prs_uint32("ptr0_info", ps, depth, &v->ptr0_info))
01960 return False;
01961
01962 if (v->ptr0_info) {
01963 if (!netdfs_io_dfs_EnumStruct_p("info", &v->info, ps, depth))
01964 return False;
01965 if (!netdfs_io_dfs_EnumStruct_d("info", &v->info, ps, depth))
01966 return False;
01967 }
01968
01969 if (!prs_align_custom(ps, 4))
01970 return False;
01971
01972 if (!prs_uint32("ptr0_total", ps, depth, &v->ptr0_total))
01973 return False;
01974
01975 if (v->ptr0_total) {
01976 if (!prs_uint32("total", ps, depth, &v->total))
01977 return False;
01978 }
01979
01980 return True;
01981 }
01982
01983 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)
01984 {
01985 DEBUG(5,("init_netdfs_r_dfs_Enum\n"));
01986
01987 if (info) {
01988 v->ptr0_info = 1;
01989 v->info = *info;
01990 } else {
01991 v->ptr0_info = 0;
01992 }
01993
01994 if (total) {
01995 v->ptr0_total = 1;
01996 v->total = *total;
01997 } else {
01998 v->ptr0_total = 0;
01999 }
02000
02001 v->status = status;
02002
02003 return True;
02004 }
02005
02006 BOOL netdfs_io_r_dfs_Enum(const char *desc, NETDFS_R_DFS_ENUM *v, prs_struct *ps, int depth)
02007 {
02008 if (v == NULL)
02009 return False;
02010
02011 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Enum");
02012 depth++;
02013 if (!prs_uint32("ptr0_info", ps, depth, &v->ptr0_info))
02014 return False;
02015
02016 if (v->ptr0_info) {
02017 if (!netdfs_io_dfs_EnumStruct_p("info", &v->info, ps, depth))
02018 return False;
02019 if (!netdfs_io_dfs_EnumStruct_d("info", &v->info, ps, depth))
02020 return False;
02021 }
02022
02023 if (!prs_align_custom(ps, 4))
02024 return False;
02025
02026 if (!prs_uint32("ptr0_total", ps, depth, &v->ptr0_total))
02027 return False;
02028
02029 if (v->ptr0_total) {
02030 if (!prs_uint32("total", ps, depth, &v->total))
02031 return False;
02032 }
02033
02034 if (!prs_align_custom(ps, 4))
02035 return False;
02036
02037 if (!prs_werror("status", ps, depth, &v->status))
02038 return False;
02039
02040 return True;
02041 }
02042
02043 BOOL init_netdfs_q_dfs_Rename(NETDFS_Q_DFS_RENAME *v)
02044 {
02045 DEBUG(5,("init_netdfs_q_dfs_Rename\n"));
02046
02047 return True;
02048 }
02049
02050 BOOL netdfs_io_q_dfs_Rename(const char *desc, NETDFS_Q_DFS_RENAME *v, prs_struct *ps, int depth)
02051 {
02052 if (v == NULL)
02053 return False;
02054
02055 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Rename");
02056 depth++;
02057 return True;
02058 }
02059
02060 BOOL init_netdfs_r_dfs_Rename(NETDFS_R_DFS_RENAME *v, WERROR status)
02061 {
02062 DEBUG(5,("init_netdfs_r_dfs_Rename\n"));
02063
02064 v->status = status;
02065
02066 return True;
02067 }
02068
02069 BOOL netdfs_io_r_dfs_Rename(const char *desc, NETDFS_R_DFS_RENAME *v, prs_struct *ps, int depth)
02070 {
02071 if (v == NULL)
02072 return False;
02073
02074 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Rename");
02075 depth++;
02076 if (!prs_werror("status", ps, depth, &v->status))
02077 return False;
02078
02079 return True;
02080 }
02081
02082 BOOL init_netdfs_q_dfs_Move(NETDFS_Q_DFS_MOVE *v)
02083 {
02084 DEBUG(5,("init_netdfs_q_dfs_Move\n"));
02085
02086 return True;
02087 }
02088
02089 BOOL netdfs_io_q_dfs_Move(const char *desc, NETDFS_Q_DFS_MOVE *v, prs_struct *ps, int depth)
02090 {
02091 if (v == NULL)
02092 return False;
02093
02094 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Move");
02095 depth++;
02096 return True;
02097 }
02098
02099 BOOL init_netdfs_r_dfs_Move(NETDFS_R_DFS_MOVE *v, WERROR status)
02100 {
02101 DEBUG(5,("init_netdfs_r_dfs_Move\n"));
02102
02103 v->status = status;
02104
02105 return True;
02106 }
02107
02108 BOOL netdfs_io_r_dfs_Move(const char *desc, NETDFS_R_DFS_MOVE *v, prs_struct *ps, int depth)
02109 {
02110 if (v == NULL)
02111 return False;
02112
02113 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Move");
02114 depth++;
02115 if (!prs_werror("status", ps, depth, &v->status))
02116 return False;
02117
02118 return True;
02119 }
02120
02121 BOOL init_netdfs_q_dfs_ManagerGetConfigInfo(NETDFS_Q_DFS_MANAGERGETCONFIGINFO *v)
02122 {
02123 DEBUG(5,("init_netdfs_q_dfs_ManagerGetConfigInfo\n"));
02124
02125 return True;
02126 }
02127
02128 BOOL netdfs_io_q_dfs_ManagerGetConfigInfo(const char *desc, NETDFS_Q_DFS_MANAGERGETCONFIGINFO *v, prs_struct *ps, int depth)
02129 {
02130 if (v == NULL)
02131 return False;
02132
02133 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerGetConfigInfo");
02134 depth++;
02135 return True;
02136 }
02137
02138 BOOL init_netdfs_r_dfs_ManagerGetConfigInfo(NETDFS_R_DFS_MANAGERGETCONFIGINFO *v, WERROR status)
02139 {
02140 DEBUG(5,("init_netdfs_r_dfs_ManagerGetConfigInfo\n"));
02141
02142 v->status = status;
02143
02144 return True;
02145 }
02146
02147 BOOL netdfs_io_r_dfs_ManagerGetConfigInfo(const char *desc, NETDFS_R_DFS_MANAGERGETCONFIGINFO *v, prs_struct *ps, int depth)
02148 {
02149 if (v == NULL)
02150 return False;
02151
02152 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerGetConfigInfo");
02153 depth++;
02154 if (!prs_werror("status", ps, depth, &v->status))
02155 return False;
02156
02157 return True;
02158 }
02159
02160 BOOL init_netdfs_q_dfs_ManagerSendSiteInfo(NETDFS_Q_DFS_MANAGERSENDSITEINFO *v)
02161 {
02162 DEBUG(5,("init_netdfs_q_dfs_ManagerSendSiteInfo\n"));
02163
02164 return True;
02165 }
02166
02167 BOOL netdfs_io_q_dfs_ManagerSendSiteInfo(const char *desc, NETDFS_Q_DFS_MANAGERSENDSITEINFO *v, prs_struct *ps, int depth)
02168 {
02169 if (v == NULL)
02170 return False;
02171
02172 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerSendSiteInfo");
02173 depth++;
02174 return True;
02175 }
02176
02177 BOOL init_netdfs_r_dfs_ManagerSendSiteInfo(NETDFS_R_DFS_MANAGERSENDSITEINFO *v, WERROR status)
02178 {
02179 DEBUG(5,("init_netdfs_r_dfs_ManagerSendSiteInfo\n"));
02180
02181 v->status = status;
02182
02183 return True;
02184 }
02185
02186 BOOL netdfs_io_r_dfs_ManagerSendSiteInfo(const char *desc, NETDFS_R_DFS_MANAGERSENDSITEINFO *v, prs_struct *ps, int depth)
02187 {
02188 if (v == NULL)
02189 return False;
02190
02191 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerSendSiteInfo");
02192 depth++;
02193 if (!prs_werror("status", ps, depth, &v->status))
02194 return False;
02195
02196 return True;
02197 }
02198
02199 BOOL init_netdfs_q_dfs_AddFtRoot(NETDFS_Q_DFS_ADDFTROOT *v)
02200 {
02201 DEBUG(5,("init_netdfs_q_dfs_AddFtRoot\n"));
02202
02203 return True;
02204 }
02205
02206 BOOL netdfs_io_q_dfs_AddFtRoot(const char *desc, NETDFS_Q_DFS_ADDFTROOT *v, prs_struct *ps, int depth)
02207 {
02208 if (v == NULL)
02209 return False;
02210
02211 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddFtRoot");
02212 depth++;
02213 return True;
02214 }
02215
02216 BOOL init_netdfs_r_dfs_AddFtRoot(NETDFS_R_DFS_ADDFTROOT *v, WERROR status)
02217 {
02218 DEBUG(5,("init_netdfs_r_dfs_AddFtRoot\n"));
02219
02220 v->status = status;
02221
02222 return True;
02223 }
02224
02225 BOOL netdfs_io_r_dfs_AddFtRoot(const char *desc, NETDFS_R_DFS_ADDFTROOT *v, prs_struct *ps, int depth)
02226 {
02227 if (v == NULL)
02228 return False;
02229
02230 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddFtRoot");
02231 depth++;
02232 if (!prs_werror("status", ps, depth, &v->status))
02233 return False;
02234
02235 return True;
02236 }
02237
02238 BOOL init_netdfs_q_dfs_RemoveFtRoot(NETDFS_Q_DFS_REMOVEFTROOT *v)
02239 {
02240 DEBUG(5,("init_netdfs_q_dfs_RemoveFtRoot\n"));
02241
02242 return True;
02243 }
02244
02245 BOOL netdfs_io_q_dfs_RemoveFtRoot(const char *desc, NETDFS_Q_DFS_REMOVEFTROOT *v, prs_struct *ps, int depth)
02246 {
02247 if (v == NULL)
02248 return False;
02249
02250 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_RemoveFtRoot");
02251 depth++;
02252 return True;
02253 }
02254
02255 BOOL init_netdfs_r_dfs_RemoveFtRoot(NETDFS_R_DFS_REMOVEFTROOT *v, WERROR status)
02256 {
02257 DEBUG(5,("init_netdfs_r_dfs_RemoveFtRoot\n"));
02258
02259 v->status = status;
02260
02261 return True;
02262 }
02263
02264 BOOL netdfs_io_r_dfs_RemoveFtRoot(const char *desc, NETDFS_R_DFS_REMOVEFTROOT *v, prs_struct *ps, int depth)
02265 {
02266 if (v == NULL)
02267 return False;
02268
02269 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_RemoveFtRoot");
02270 depth++;
02271 if (!prs_werror("status", ps, depth, &v->status))
02272 return False;
02273
02274 return True;
02275 }
02276
02277 BOOL init_netdfs_q_dfs_AddStdRoot(NETDFS_Q_DFS_ADDSTDROOT *v)
02278 {
02279 DEBUG(5,("init_netdfs_q_dfs_AddStdRoot\n"));
02280
02281 return True;
02282 }
02283
02284 BOOL netdfs_io_q_dfs_AddStdRoot(const char *desc, NETDFS_Q_DFS_ADDSTDROOT *v, prs_struct *ps, int depth)
02285 {
02286 if (v == NULL)
02287 return False;
02288
02289 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddStdRoot");
02290 depth++;
02291 return True;
02292 }
02293
02294 BOOL init_netdfs_r_dfs_AddStdRoot(NETDFS_R_DFS_ADDSTDROOT *v, WERROR status)
02295 {
02296 DEBUG(5,("init_netdfs_r_dfs_AddStdRoot\n"));
02297
02298 v->status = status;
02299
02300 return True;
02301 }
02302
02303 BOOL netdfs_io_r_dfs_AddStdRoot(const char *desc, NETDFS_R_DFS_ADDSTDROOT *v, prs_struct *ps, int depth)
02304 {
02305 if (v == NULL)
02306 return False;
02307
02308 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddStdRoot");
02309 depth++;
02310 if (!prs_werror("status", ps, depth, &v->status))
02311 return False;
02312
02313 return True;
02314 }
02315
02316 BOOL init_netdfs_q_dfs_RemoveStdRoot(NETDFS_Q_DFS_REMOVESTDROOT *v)
02317 {
02318 DEBUG(5,("init_netdfs_q_dfs_RemoveStdRoot\n"));
02319
02320 return True;
02321 }
02322
02323 BOOL netdfs_io_q_dfs_RemoveStdRoot(const char *desc, NETDFS_Q_DFS_REMOVESTDROOT *v, prs_struct *ps, int depth)
02324 {
02325 if (v == NULL)
02326 return False;
02327
02328 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_RemoveStdRoot");
02329 depth++;
02330 return True;
02331 }
02332
02333 BOOL init_netdfs_r_dfs_RemoveStdRoot(NETDFS_R_DFS_REMOVESTDROOT *v, WERROR status)
02334 {
02335 DEBUG(5,("init_netdfs_r_dfs_RemoveStdRoot\n"));
02336
02337 v->status = status;
02338
02339 return True;
02340 }
02341
02342 BOOL netdfs_io_r_dfs_RemoveStdRoot(const char *desc, NETDFS_R_DFS_REMOVESTDROOT *v, prs_struct *ps, int depth)
02343 {
02344 if (v == NULL)
02345 return False;
02346
02347 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_RemoveStdRoot");
02348 depth++;
02349 if (!prs_werror("status", ps, depth, &v->status))
02350 return False;
02351
02352 return True;
02353 }
02354
02355 BOOL init_netdfs_q_dfs_ManagerInitialize(NETDFS_Q_DFS_MANAGERINITIALIZE *v)
02356 {
02357 DEBUG(5,("init_netdfs_q_dfs_ManagerInitialize\n"));
02358
02359 return True;
02360 }
02361
02362 BOOL netdfs_io_q_dfs_ManagerInitialize(const char *desc, NETDFS_Q_DFS_MANAGERINITIALIZE *v, prs_struct *ps, int depth)
02363 {
02364 if (v == NULL)
02365 return False;
02366
02367 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerInitialize");
02368 depth++;
02369 return True;
02370 }
02371
02372 BOOL init_netdfs_r_dfs_ManagerInitialize(NETDFS_R_DFS_MANAGERINITIALIZE *v, WERROR status)
02373 {
02374 DEBUG(5,("init_netdfs_r_dfs_ManagerInitialize\n"));
02375
02376 v->status = status;
02377
02378 return True;
02379 }
02380
02381 BOOL netdfs_io_r_dfs_ManagerInitialize(const char *desc, NETDFS_R_DFS_MANAGERINITIALIZE *v, prs_struct *ps, int depth)
02382 {
02383 if (v == NULL)
02384 return False;
02385
02386 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerInitialize");
02387 depth++;
02388 if (!prs_werror("status", ps, depth, &v->status))
02389 return False;
02390
02391 return True;
02392 }
02393
02394 BOOL init_netdfs_q_dfs_AddStdRootForced(NETDFS_Q_DFS_ADDSTDROOTFORCED *v)
02395 {
02396 DEBUG(5,("init_netdfs_q_dfs_AddStdRootForced\n"));
02397
02398 return True;
02399 }
02400
02401 BOOL netdfs_io_q_dfs_AddStdRootForced(const char *desc, NETDFS_Q_DFS_ADDSTDROOTFORCED *v, prs_struct *ps, int depth)
02402 {
02403 if (v == NULL)
02404 return False;
02405
02406 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddStdRootForced");
02407 depth++;
02408 return True;
02409 }
02410
02411 BOOL init_netdfs_r_dfs_AddStdRootForced(NETDFS_R_DFS_ADDSTDROOTFORCED *v, WERROR status)
02412 {
02413 DEBUG(5,("init_netdfs_r_dfs_AddStdRootForced\n"));
02414
02415 v->status = status;
02416
02417 return True;
02418 }
02419
02420 BOOL netdfs_io_r_dfs_AddStdRootForced(const char *desc, NETDFS_R_DFS_ADDSTDROOTFORCED *v, prs_struct *ps, int depth)
02421 {
02422 if (v == NULL)
02423 return False;
02424
02425 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddStdRootForced");
02426 depth++;
02427 if (!prs_werror("status", ps, depth, &v->status))
02428 return False;
02429
02430 return True;
02431 }
02432
02433 BOOL init_netdfs_q_dfs_GetDcAddress(NETDFS_Q_DFS_GETDCADDRESS *v)
02434 {
02435 DEBUG(5,("init_netdfs_q_dfs_GetDcAddress\n"));
02436
02437 return True;
02438 }
02439
02440 BOOL netdfs_io_q_dfs_GetDcAddress(const char *desc, NETDFS_Q_DFS_GETDCADDRESS *v, prs_struct *ps, int depth)
02441 {
02442 if (v == NULL)
02443 return False;
02444
02445 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_GetDcAddress");
02446 depth++;
02447 return True;
02448 }
02449
02450 BOOL init_netdfs_r_dfs_GetDcAddress(NETDFS_R_DFS_GETDCADDRESS *v, WERROR status)
02451 {
02452 DEBUG(5,("init_netdfs_r_dfs_GetDcAddress\n"));
02453
02454 v->status = status;
02455
02456 return True;
02457 }
02458
02459 BOOL netdfs_io_r_dfs_GetDcAddress(const char *desc, NETDFS_R_DFS_GETDCADDRESS *v, prs_struct *ps, int depth)
02460 {
02461 if (v == NULL)
02462 return False;
02463
02464 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_GetDcAddress");
02465 depth++;
02466 if (!prs_werror("status", ps, depth, &v->status))
02467 return False;
02468
02469 return True;
02470 }
02471
02472 BOOL init_netdfs_q_dfs_SetDcAddress(NETDFS_Q_DFS_SETDCADDRESS *v)
02473 {
02474 DEBUG(5,("init_netdfs_q_dfs_SetDcAddress\n"));
02475
02476 return True;
02477 }
02478
02479 BOOL netdfs_io_q_dfs_SetDcAddress(const char *desc, NETDFS_Q_DFS_SETDCADDRESS *v, prs_struct *ps, int depth)
02480 {
02481 if (v == NULL)
02482 return False;
02483
02484 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetDcAddress");
02485 depth++;
02486 return True;
02487 }
02488
02489 BOOL init_netdfs_r_dfs_SetDcAddress(NETDFS_R_DFS_SETDCADDRESS *v, WERROR status)
02490 {
02491 DEBUG(5,("init_netdfs_r_dfs_SetDcAddress\n"));
02492
02493 v->status = status;
02494
02495 return True;
02496 }
02497
02498 BOOL netdfs_io_r_dfs_SetDcAddress(const char *desc, NETDFS_R_DFS_SETDCADDRESS *v, prs_struct *ps, int depth)
02499 {
02500 if (v == NULL)
02501 return False;
02502
02503 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetDcAddress");
02504 depth++;
02505 if (!prs_werror("status", ps, depth, &v->status))
02506 return False;
02507
02508 return True;
02509 }
02510
02511 BOOL init_netdfs_q_dfs_FlushFtTable(NETDFS_Q_DFS_FLUSHFTTABLE *v)
02512 {
02513 DEBUG(5,("init_netdfs_q_dfs_FlushFtTable\n"));
02514
02515 return True;
02516 }
02517
02518 BOOL netdfs_io_q_dfs_FlushFtTable(const char *desc, NETDFS_Q_DFS_FLUSHFTTABLE *v, prs_struct *ps, int depth)
02519 {
02520 if (v == NULL)
02521 return False;
02522
02523 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_FlushFtTable");
02524 depth++;
02525 return True;
02526 }
02527
02528 BOOL init_netdfs_r_dfs_FlushFtTable(NETDFS_R_DFS_FLUSHFTTABLE *v, WERROR status)
02529 {
02530 DEBUG(5,("init_netdfs_r_dfs_FlushFtTable\n"));
02531
02532 v->status = status;
02533
02534 return True;
02535 }
02536
02537 BOOL netdfs_io_r_dfs_FlushFtTable(const char *desc, NETDFS_R_DFS_FLUSHFTTABLE *v, prs_struct *ps, int depth)
02538 {
02539 if (v == NULL)
02540 return False;
02541
02542 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_FlushFtTable");
02543 depth++;
02544 if (!prs_werror("status", ps, depth, &v->status))
02545 return False;
02546
02547 return True;
02548 }
02549
02550 BOOL init_netdfs_q_dfs_Add2(NETDFS_Q_DFS_ADD2 *v)
02551 {
02552 DEBUG(5,("init_netdfs_q_dfs_Add2\n"));
02553
02554 return True;
02555 }
02556
02557 BOOL netdfs_io_q_dfs_Add2(const char *desc, NETDFS_Q_DFS_ADD2 *v, prs_struct *ps, int depth)
02558 {
02559 if (v == NULL)
02560 return False;
02561
02562 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Add2");
02563 depth++;
02564 return True;
02565 }
02566
02567 BOOL init_netdfs_r_dfs_Add2(NETDFS_R_DFS_ADD2 *v, WERROR status)
02568 {
02569 DEBUG(5,("init_netdfs_r_dfs_Add2\n"));
02570
02571 v->status = status;
02572
02573 return True;
02574 }
02575
02576 BOOL netdfs_io_r_dfs_Add2(const char *desc, NETDFS_R_DFS_ADD2 *v, prs_struct *ps, int depth)
02577 {
02578 if (v == NULL)
02579 return False;
02580
02581 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Add2");
02582 depth++;
02583 if (!prs_werror("status", ps, depth, &v->status))
02584 return False;
02585
02586 return True;
02587 }
02588
02589 BOOL init_netdfs_q_dfs_Remove2(NETDFS_Q_DFS_REMOVE2 *v)
02590 {
02591 DEBUG(5,("init_netdfs_q_dfs_Remove2\n"));
02592
02593 return True;
02594 }
02595
02596 BOOL netdfs_io_q_dfs_Remove2(const char *desc, NETDFS_Q_DFS_REMOVE2 *v, prs_struct *ps, int depth)
02597 {
02598 if (v == NULL)
02599 return False;
02600
02601 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Remove2");
02602 depth++;
02603 return True;
02604 }
02605
02606 BOOL init_netdfs_r_dfs_Remove2(NETDFS_R_DFS_REMOVE2 *v, WERROR status)
02607 {
02608 DEBUG(5,("init_netdfs_r_dfs_Remove2\n"));
02609
02610 v->status = status;
02611
02612 return True;
02613 }
02614
02615 BOOL netdfs_io_r_dfs_Remove2(const char *desc, NETDFS_R_DFS_REMOVE2 *v, prs_struct *ps, int depth)
02616 {
02617 if (v == NULL)
02618 return False;
02619
02620 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Remove2");
02621 depth++;
02622 if (!prs_werror("status", ps, depth, &v->status))
02623 return False;
02624
02625 return True;
02626 }
02627
02628 BOOL init_netdfs_q_dfs_EnumEx(NETDFS_Q_DFS_ENUMEX *v)
02629 {
02630 DEBUG(5,("init_netdfs_q_dfs_EnumEx\n"));
02631
02632 return True;
02633 }
02634
02635 BOOL netdfs_io_q_dfs_EnumEx(const char *desc, NETDFS_Q_DFS_ENUMEX *v, prs_struct *ps, int depth)
02636 {
02637 if (v == NULL)
02638 return False;
02639
02640 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_EnumEx");
02641 depth++;
02642 return True;
02643 }
02644
02645 BOOL init_netdfs_r_dfs_EnumEx(NETDFS_R_DFS_ENUMEX *v, WERROR status)
02646 {
02647 DEBUG(5,("init_netdfs_r_dfs_EnumEx\n"));
02648
02649 v->status = status;
02650
02651 return True;
02652 }
02653
02654 BOOL netdfs_io_r_dfs_EnumEx(const char *desc, NETDFS_R_DFS_ENUMEX *v, prs_struct *ps, int depth)
02655 {
02656 if (v == NULL)
02657 return False;
02658
02659 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_EnumEx");
02660 depth++;
02661 if (!prs_werror("status", ps, depth, &v->status))
02662 return False;
02663
02664 return True;
02665 }
02666
02667 BOOL init_netdfs_q_dfs_SetInfo2(NETDFS_Q_DFS_SETINFO2 *v)
02668 {
02669 DEBUG(5,("init_netdfs_q_dfs_SetInfo2\n"));
02670
02671 return True;
02672 }
02673
02674 BOOL netdfs_io_q_dfs_SetInfo2(const char *desc, NETDFS_Q_DFS_SETINFO2 *v, prs_struct *ps, int depth)
02675 {
02676 if (v == NULL)
02677 return False;
02678
02679 prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetInfo2");
02680 depth++;
02681 return True;
02682 }
02683
02684 BOOL init_netdfs_r_dfs_SetInfo2(NETDFS_R_DFS_SETINFO2 *v, WERROR status)
02685 {
02686 DEBUG(5,("init_netdfs_r_dfs_SetInfo2\n"));
02687
02688 v->status = status;
02689
02690 return True;
02691 }
02692
02693 BOOL netdfs_io_r_dfs_SetInfo2(const char *desc, NETDFS_R_DFS_SETINFO2 *v, prs_struct *ps, int depth)
02694 {
02695 if (v == NULL)
02696 return False;
02697
02698 prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetInfo2");
02699 depth++;
02700 if (!prs_werror("status", ps, depth, &v->status))
02701 return False;
02702
02703 return True;
02704 }
02705