rpc_parse/parse_dfs.c

説明を見る。
00001 /*
00002  * Unix SMB/CIFS implementation.
00003  * parser auto-generated by pidl. DO NOT MODIFY!
00004  */
00005 
00006 #include "includes.h"
00007 
00008 #undef DBGC_CLASS
00009 #define DBGC_CLASS DBGC_RPC_PARSE
00010 
00011 /* netdfs structures */
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 /* netdfs functions */
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 

Sambaに対してSat Aug 29 21:23:16 2009に生成されました。  doxygen 1.4.7