LCOV - code coverage report
Current view: top level - source3/rpc_server/dfs - srv_dfs_nt.c (source / functions) Hit Total Coverage
Test: coverage report for master 469b22b8 Lines: 40 332 12.0 %
Date: 2024-06-10 12:05:21 Functions: 4 27 14.8 %

          Line data    Source code
       1             : /*
       2             :  *  Unix SMB/CIFS implementation.
       3             :  *  RPC Pipe client / server routines for Dfs
       4             :  *  Copyright (C) Shirish Kalele        2000.
       5             :  *  Copyright (C) Jeremy Allison        2001-2007.
       6             :  *  Copyright (C) Jelmer Vernooij       2005-2006.
       7             :  *
       8             :  *  This program is free software; you can redistribute it and/or modify
       9             :  *  it under the terms of the GNU General Public License as published by
      10             :  *  the Free Software Foundation; either version 3 of the License, or
      11             :  *  (at your option) any later version.
      12             :  *
      13             :  *  This program is distributed in the hope that it will be useful,
      14             :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16             :  *  GNU General Public License for more details.
      17             :  *
      18             :  *  You should have received a copy of the GNU General Public License
      19             :  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
      20             :  */
      21             : 
      22             : /* This is the implementation of the dfs pipe. */
      23             : 
      24             : #include "includes.h"
      25             : #include "ntdomain.h"
      26             : #include "librpc/rpc/dcesrv_core.h"
      27             : #include "librpc/gen_ndr/ndr_dfs.h"
      28             : #include "librpc/gen_ndr/ndr_dfs_scompat.h"
      29             : #include "msdfs.h"
      30             : #include "smbd/smbd.h"
      31             : #include "smbd/globals.h"
      32             : #include "auth.h"
      33             : 
      34             : #undef DBGC_CLASS
      35             : #define DBGC_CLASS DBGC_MSDFS
      36             : 
      37             : /* This function does not return a WERROR or NTSTATUS code but rather 1 if
      38             :    dfs exists, or 0 otherwise. */
      39             : 
      40           3 : void _dfs_GetManagerVersion(struct pipes_struct *p, struct dfs_GetManagerVersion *r)
      41             : {
      42           3 :         if (lp_host_msdfs()) {
      43           3 :                 *r->out.version = DFS_MANAGER_VERSION_NT4;
      44             :         } else {
      45           0 :                 *r->out.version = (enum dfs_ManagerVersion)0;
      46             :         }
      47           3 : }
      48             : 
      49           0 : WERROR _dfs_Add(struct pipes_struct *p, struct dfs_Add *r)
      50             : {
      51           0 :         struct dcesrv_call_state *dce_call = p->dce_call;
      52           0 :         struct dcesrv_connection *dcesrv_conn = dce_call->conn;
      53           0 :         const struct tsocket_address *local_address =
      54           0 :                 dcesrv_connection_get_local_address(dcesrv_conn);
      55           0 :         const struct tsocket_address *remote_address =
      56           0 :                 dcesrv_connection_get_remote_address(dcesrv_conn);
      57           0 :         struct auth_session_info *session_info =
      58           0 :                 dcesrv_call_session_info(dce_call);
      59           0 :         struct junction_map *jn = NULL;
      60           0 :         struct referral *old_referral_list = NULL;
      61           0 :         bool self_ref = False;
      62           0 :         size_t consumedcnt = 0;
      63           0 :         char *altpath = NULL;
      64           0 :         NTSTATUS status;
      65           0 :         TALLOC_CTX *ctx = talloc_tos();
      66           0 :         const char *pathnamep = r->in.path;
      67             : 
      68           0 :         if (session_info->unix_token->uid != sec_initial_uid()) {
      69           0 :                 DEBUG(10,("_dfs_add: uid != 0. Access denied.\n"));
      70           0 :                 return WERR_ACCESS_DENIED;
      71             :         }
      72             : 
      73           0 :         jn = talloc_zero(ctx, struct junction_map);
      74           0 :         if (!jn) {
      75           0 :                 return WERR_NOT_ENOUGH_MEMORY;
      76             :         }
      77             : 
      78           0 :         DEBUG(5,("init_reply_dfs_add: Request to add %s -> %s\\%s.\n",
      79             :                 r->in.path, r->in.server, r->in.share));
      80             : 
      81           0 :         altpath = talloc_asprintf(ctx, "%s\\%s",
      82             :                         r->in.server,
      83             :                         r->in.share);
      84           0 :         if (!altpath) {
      85           0 :                 return WERR_NOT_ENOUGH_MEMORY;
      86             :         }
      87             : 
      88           0 :         while (IS_DIRECTORY_SEP(pathnamep[0]) &&
      89           0 :                IS_DIRECTORY_SEP(pathnamep[1])) {
      90           0 :                 pathnamep++;
      91             :         }
      92             : 
      93             :         /* The following call can change the cwd. */
      94           0 :         status = get_referred_path(ctx,
      95             :                                    session_info,
      96             :                                    pathnamep,
      97             :                                    remote_address,
      98             :                                    local_address,
      99             :                                    jn, &consumedcnt, &self_ref);
     100           0 :         if(!NT_STATUS_IS_OK(status)) {
     101           0 :                 return ntstatus_to_werror(status);
     102             :         }
     103             : 
     104           0 :         jn->referral_count += 1;
     105           0 :         old_referral_list = jn->referral_list;
     106             : 
     107           0 :         if (jn->referral_count < 1) {
     108           0 :                 return WERR_NOT_ENOUGH_MEMORY;
     109             :         }
     110             : 
     111           0 :         jn->referral_list = talloc_array(ctx, struct referral, jn->referral_count);
     112           0 :         if(jn->referral_list == NULL) {
     113           0 :                 DEBUG(0,("init_reply_dfs_add: talloc failed for referral list!\n"));
     114           0 :                 return WERR_NERR_DFSINTERNALERROR;
     115             :         }
     116             : 
     117           0 :         if(old_referral_list && jn->referral_list) {
     118           0 :                 memcpy(jn->referral_list, old_referral_list,
     119           0 :                                 sizeof(struct referral)*jn->referral_count-1);
     120             :         }
     121             : 
     122           0 :         jn->referral_list[jn->referral_count-1].proximity = 0;
     123           0 :         jn->referral_list[jn->referral_count-1].ttl = REFERRAL_TTL;
     124           0 :         jn->referral_list[jn->referral_count-1].alternate_path = altpath;
     125             : 
     126           0 :         if (!create_msdfs_link(jn, session_info)) {
     127           0 :                 return WERR_NERR_DFSCANTCREATEJUNCTIONPOINT;
     128             :         }
     129             : 
     130           0 :         return WERR_OK;
     131             : }
     132             : 
     133           0 : WERROR _dfs_Remove(struct pipes_struct *p, struct dfs_Remove *r)
     134             : {
     135           0 :         struct dcesrv_call_state *dce_call = p->dce_call;
     136           0 :         struct dcesrv_connection *dcesrv_conn = dce_call->conn;
     137           0 :         const struct tsocket_address *local_address =
     138           0 :                 dcesrv_connection_get_local_address(dcesrv_conn);
     139           0 :         const struct tsocket_address *remote_address =
     140           0 :                 dcesrv_connection_get_remote_address(dcesrv_conn);
     141           0 :         struct auth_session_info *session_info =
     142           0 :                 dcesrv_call_session_info(dce_call);
     143           0 :         struct junction_map *jn = NULL;
     144           0 :         bool self_ref = False;
     145           0 :         size_t consumedcnt = 0;
     146           0 :         bool found = False;
     147           0 :         TALLOC_CTX *ctx = talloc_tos();
     148           0 :         char *altpath = NULL;
     149           0 :         NTSTATUS status;
     150           0 :         const char *pathnamep = r->in.dfs_entry_path;
     151             : 
     152           0 :         if (session_info->unix_token->uid != sec_initial_uid()) {
     153           0 :                 DEBUG(10,("_dfs_remove: uid != 0. Access denied.\n"));
     154           0 :                 return WERR_ACCESS_DENIED;
     155             :         }
     156             : 
     157           0 :         jn = talloc_zero(ctx, struct junction_map);
     158           0 :         if (!jn) {
     159           0 :                 return WERR_NOT_ENOUGH_MEMORY;
     160             :         }
     161             : 
     162           0 :         if (r->in.servername && r->in.sharename) {
     163           0 :                 altpath = talloc_asprintf(ctx, "%s\\%s",
     164             :                         r->in.servername,
     165             :                         r->in.sharename);
     166           0 :                 if (!altpath) {
     167           0 :                         return WERR_NOT_ENOUGH_MEMORY;
     168             :                 }
     169           0 :                 if (!strlower_m(altpath)) {
     170           0 :                         return WERR_INVALID_PARAMETER;
     171             :                 }
     172           0 :                 DEBUG(5,("init_reply_dfs_remove: Request to remove %s -> %s\\%s.\n",
     173             :                         r->in.dfs_entry_path, r->in.servername, r->in.sharename));
     174             :         }
     175             : 
     176           0 :         while (IS_DIRECTORY_SEP(pathnamep[0]) &&
     177           0 :                IS_DIRECTORY_SEP(pathnamep[1])) {
     178           0 :                 pathnamep++;
     179             :         }
     180             : 
     181           0 :         status = get_referred_path(ctx,
     182             :                                    session_info,
     183             :                                    pathnamep,
     184             :                                    remote_address,
     185             :                                    local_address,
     186             :                                    jn, &consumedcnt, &self_ref);
     187           0 :         if(!NT_STATUS_IS_OK(status)) {
     188           0 :                 return WERR_NERR_DFSNOSUCHVOLUME;
     189             :         }
     190             : 
     191             :         /* if no server-share pair given, remove the msdfs link completely */
     192           0 :         if(!r->in.servername && !r->in.sharename) {
     193           0 :                 if(!remove_msdfs_link(jn, session_info)) {
     194           0 :                         return WERR_NERR_DFSNOSUCHVOLUME;
     195             :                 }
     196             :         } else {
     197           0 :                 size_t i = 0;
     198             :                 /* compare each referral in the list with the one to remove */
     199           0 :                 DBG_DEBUG("altpath: .%s. refcnt: %zu\n",
     200             :                                 altpath,
     201             :                                 jn->referral_count);
     202           0 :                 for(i=0;i<jn->referral_count;i++) {
     203           0 :                         char *refpath = talloc_strdup(ctx,
     204           0 :                                         jn->referral_list[i].alternate_path);
     205           0 :                         if (!refpath) {
     206           0 :                                 return WERR_NOT_ENOUGH_MEMORY;
     207             :                         }
     208           0 :                         trim_char(refpath, '\\', '\\');
     209           0 :                         DEBUG(10,("_dfs_remove:  refpath: .%s.\n", refpath));
     210           0 :                         if(strequal(refpath, altpath)) {
     211           0 :                                 *(jn->referral_list[i].alternate_path)='\0';
     212           0 :                                 DEBUG(10,("_dfs_remove: Removal request matches referral %s\n",
     213             :                                         refpath));
     214           0 :                                 found = True;
     215             :                         }
     216             :                 }
     217             : 
     218           0 :                 if(!found) {
     219           0 :                         return WERR_NERR_DFSNOSUCHSHARE;
     220             :                 }
     221             : 
     222             :                 /* Only one referral, remove it */
     223           0 :                 if(jn->referral_count == 1) {
     224           0 :                         if(!remove_msdfs_link(jn, session_info)) {
     225           0 :                                 return WERR_NERR_DFSNOSUCHVOLUME;
     226             :                         }
     227             :                 } else {
     228           0 :                         if(!create_msdfs_link(jn, session_info)) {
     229           0 :                                 return WERR_NERR_DFSCANTCREATEJUNCTIONPOINT;
     230             :                         }
     231             :                 }
     232             :         }
     233             : 
     234           0 :         return WERR_OK;
     235             : }
     236             : 
     237           3 : static bool init_reply_dfs_info_1(TALLOC_CTX *mem_ctx, struct junction_map* j,struct dfs_Info1* dfs1)
     238             : {
     239           3 :         dfs1->path = talloc_asprintf(mem_ctx,
     240             :                                 "\\\\%s\\%s\\%s", lp_netbios_name(),
     241             :                                 j->service_name, j->volume_name);
     242           3 :         if (dfs1->path == NULL)
     243           0 :                 return False;
     244             : 
     245           3 :         DEBUG(5,("init_reply_dfs_info_1: initing entrypath: %s\n",dfs1->path));
     246           3 :         return True;
     247             : }
     248             : 
     249           0 : static bool init_reply_dfs_info_2(TALLOC_CTX *mem_ctx, struct junction_map* j, struct dfs_Info2* dfs2)
     250             : {
     251           0 :         dfs2->path = talloc_asprintf(mem_ctx,
     252             :                         "\\\\%s\\%s\\%s", lp_netbios_name(), j->service_name, j->volume_name);
     253           0 :         if (dfs2->path == NULL)
     254           0 :                 return False;
     255           0 :         dfs2->comment = talloc_strdup(mem_ctx, j->comment);
     256           0 :         dfs2->state = 1; /* set up state of dfs junction as OK */
     257           0 :         dfs2->num_stores = j->referral_count;
     258           0 :         return True;
     259             : }
     260             : 
     261           0 : static bool init_reply_dfs_info_3(TALLOC_CTX *mem_ctx, struct junction_map* j, struct dfs_Info3* dfs3)
     262             : {
     263           0 :         size_t ii;
     264           0 :         if (j->volume_name[0] == '\0')
     265           0 :                 dfs3->path = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
     266             :                         lp_netbios_name(), j->service_name);
     267             :         else
     268           0 :                 dfs3->path = talloc_asprintf(mem_ctx, "\\\\%s\\%s\\%s", lp_netbios_name(),
     269             :                         j->service_name, j->volume_name);
     270             : 
     271           0 :         if (dfs3->path == NULL)
     272           0 :                 return False;
     273             : 
     274           0 :         dfs3->comment = talloc_strdup(mem_ctx, j->comment);
     275           0 :         dfs3->state = 1;
     276           0 :         dfs3->num_stores = j->referral_count;
     277             : 
     278             :         /* also enumerate the stores */
     279           0 :         if (j->referral_count) {
     280           0 :                 dfs3->stores = talloc_array(mem_ctx, struct dfs_StorageInfo, j->referral_count);
     281           0 :                 if (!dfs3->stores)
     282           0 :                         return False;
     283           0 :                 memset(dfs3->stores, '\0', j->referral_count * sizeof(struct dfs_StorageInfo));
     284             :         } else {
     285           0 :                 dfs3->stores = NULL;
     286             :         }
     287             : 
     288           0 :         for(ii=0;ii<j->referral_count;ii++) {
     289           0 :                 char* p;
     290           0 :                 char *path = NULL;
     291           0 :                 struct dfs_StorageInfo* stor = &(dfs3->stores[ii]);
     292           0 :                 struct referral* ref = &(j->referral_list[ii]);
     293             : 
     294           0 :                 path = talloc_strdup(mem_ctx, ref->alternate_path);
     295           0 :                 if (!path) {
     296           0 :                         return False;
     297             :                 }
     298           0 :                 trim_char(path,'\\','\0');
     299           0 :                 p = strrchr_m(path,'\\');
     300           0 :                 if(p==NULL) {
     301           0 :                         DEBUG(4,("init_reply_dfs_info_3: invalid path: no \\ found in %s\n",path));
     302           0 :                         continue;
     303             :                 }
     304           0 :                 *p = '\0';
     305           0 :                 DBG_INFO("storage %zu: %s.%s\n",ii,path,p+1);
     306           0 :                 stor->state = 2; /* set all stores as ONLINE */
     307           0 :                 stor->server = talloc_strdup(mem_ctx, path);
     308           0 :                 stor->share = talloc_strdup(mem_ctx, p+1);
     309             :         }
     310           0 :         return True;
     311             : }
     312             : 
     313           0 : static bool init_reply_dfs_info_100(TALLOC_CTX *mem_ctx, struct junction_map* j, struct dfs_Info100* dfs100)
     314             : {
     315           0 :         dfs100->comment = talloc_strdup(mem_ctx, j->comment);
     316           0 :         return True;
     317             : }
     318             : 
     319           0 : WERROR _dfs_Enum(struct pipes_struct *p, struct dfs_Enum *r)
     320             : {
     321           0 :         struct dcesrv_call_state *dce_call = p->dce_call;
     322           0 :         struct auth_session_info *session_info =
     323           0 :                 dcesrv_call_session_info(dce_call);
     324           0 :         struct junction_map *jn = NULL;
     325           0 :         size_t num_jn = 0;
     326           0 :         size_t i;
     327           0 :         TALLOC_CTX *ctx = talloc_tos();
     328             : 
     329           0 :         jn = enum_msdfs_links(ctx, session_info, &num_jn);
     330           0 :         if (!jn || num_jn == 0) {
     331           0 :                 num_jn = 0;
     332           0 :                 jn = NULL;
     333             :         }
     334             : 
     335           0 :         DEBUG(5,("_dfs_Enum: %u junctions found in Dfs, doing level %d\n",
     336             :                                 (unsigned int)num_jn, r->in.level));
     337             : 
     338           0 :         *r->out.total = num_jn;
     339             : 
     340             :         /* Create the return array */
     341           0 :         switch (r->in.level) {
     342           0 :         case 1:
     343           0 :                 if (num_jn) {
     344           0 :                         if ((r->out.info->e.info1->s = talloc_array(ctx, struct dfs_Info1, num_jn)) == NULL) {
     345           0 :                                 return WERR_NOT_ENOUGH_MEMORY;
     346             :                         }
     347             :                 } else {
     348           0 :                         r->out.info->e.info1->s = NULL;
     349             :                 }
     350           0 :                 r->out.info->e.info1->count = num_jn;
     351           0 :                 break;
     352           0 :         case 2:
     353           0 :                 if (num_jn) {
     354           0 :                         if ((r->out.info->e.info2->s = talloc_array(ctx, struct dfs_Info2, num_jn)) == NULL) {
     355           0 :                                 return WERR_NOT_ENOUGH_MEMORY;
     356             :                         }
     357             :                 } else {
     358           0 :                         r->out.info->e.info2->s = NULL;
     359             :                 }
     360           0 :                 r->out.info->e.info2->count = num_jn;
     361           0 :                 break;
     362           0 :         case 3:
     363           0 :                 if (num_jn) {
     364           0 :                         if ((r->out.info->e.info3->s = talloc_array(ctx, struct dfs_Info3, num_jn)) == NULL) {
     365           0 :                                 return WERR_NOT_ENOUGH_MEMORY;
     366             :                         }
     367             :                 } else {
     368           0 :                         r->out.info->e.info3->s = NULL;
     369             :                 }
     370           0 :                 r->out.info->e.info3->count = num_jn;
     371           0 :                 break;
     372           0 :         default:
     373           0 :                 return WERR_INVALID_PARAMETER;
     374             :         }
     375             : 
     376           0 :         for (i = 0; i < num_jn; i++) {
     377           0 :                 switch (r->in.level) {
     378           0 :                 case 1:
     379           0 :                         init_reply_dfs_info_1(ctx, &jn[i], &r->out.info->e.info1->s[i]);
     380           0 :                         break;
     381           0 :                 case 2:
     382           0 :                         init_reply_dfs_info_2(ctx, &jn[i], &r->out.info->e.info2->s[i]);
     383           0 :                         break;
     384           0 :                 case 3:
     385           0 :                         init_reply_dfs_info_3(ctx, &jn[i], &r->out.info->e.info3->s[i]);
     386           0 :                         break;
     387           0 :                 default:
     388           0 :                         return WERR_INVALID_PARAMETER;
     389             :                 }
     390             :         }
     391             : 
     392           0 :         return WERR_OK;
     393             : }
     394             : 
     395           3 : WERROR _dfs_GetInfo(struct pipes_struct *p, struct dfs_GetInfo *r)
     396             : {
     397           3 :         struct dcesrv_call_state *dce_call = p->dce_call;
     398           3 :         struct dcesrv_connection *dcesrv_conn = dce_call->conn;
     399           0 :         const struct tsocket_address *local_address =
     400           3 :                 dcesrv_connection_get_local_address(dcesrv_conn);
     401           0 :         const struct tsocket_address *remote_address =
     402           3 :                 dcesrv_connection_get_remote_address(dcesrv_conn);
     403           0 :         struct auth_session_info *session_info =
     404           3 :                 dcesrv_call_session_info(dce_call);
     405           3 :         size_t consumedcnt = 0;
     406           3 :         struct junction_map *jn = NULL;
     407           3 :         bool self_ref = False;
     408           3 :         TALLOC_CTX *ctx = talloc_tos();
     409           0 :         bool ret;
     410           0 :         NTSTATUS status;
     411           3 :         const char *pathnamep = r->in.dfs_entry_path;
     412             : 
     413           3 :         jn = talloc_zero(ctx, struct junction_map);
     414           3 :         if (!jn) {
     415           0 :                 return WERR_NOT_ENOUGH_MEMORY;
     416             :         }
     417             : 
     418           6 :         while (IS_DIRECTORY_SEP(pathnamep[0]) &&
     419           6 :                IS_DIRECTORY_SEP(pathnamep[1])) {
     420           3 :                 pathnamep++;
     421             :         }
     422             : 
     423           3 :         ret = create_junction(ctx, pathnamep, jn);
     424           3 :         if (!ret) {
     425           0 :                 return WERR_NERR_DFSNOSUCHSERVER;
     426             :         }
     427             : 
     428             :         /* The following call can change the cwd. */
     429           3 :         status = get_referred_path(ctx,
     430             :                                    session_info,
     431             :                                    pathnamep,
     432             :                                    remote_address,
     433             :                                    local_address,
     434             :                                    jn, &consumedcnt, &self_ref);
     435           3 :         if(!NT_STATUS_IS_OK(status) || consumedcnt < strlen(pathnamep)) {
     436           0 :                 return WERR_NERR_DFSNOSUCHVOLUME;
     437             :         }
     438             : 
     439           3 :         switch (r->in.level) {
     440           3 :                 case 1:
     441           3 :                         r->out.info->info1 = talloc_zero(ctx,struct dfs_Info1);
     442           3 :                         if (!r->out.info->info1) {
     443           0 :                                 return WERR_NOT_ENOUGH_MEMORY;
     444             :                         }
     445           3 :                         ret = init_reply_dfs_info_1(ctx, jn, r->out.info->info1);
     446           3 :                         break;
     447           0 :                 case 2:
     448           0 :                         r->out.info->info2 = talloc_zero(ctx,struct dfs_Info2);
     449           0 :                         if (!r->out.info->info2) {
     450           0 :                                 return WERR_NOT_ENOUGH_MEMORY;
     451             :                         }
     452           0 :                         ret = init_reply_dfs_info_2(ctx, jn, r->out.info->info2);
     453           0 :                         break;
     454           0 :                 case 3:
     455           0 :                         r->out.info->info3 = talloc_zero(ctx,struct dfs_Info3);
     456           0 :                         if (!r->out.info->info3) {
     457           0 :                                 return WERR_NOT_ENOUGH_MEMORY;
     458             :                         }
     459           0 :                         ret = init_reply_dfs_info_3(ctx, jn, r->out.info->info3);
     460           0 :                         break;
     461           0 :                 case 100:
     462           0 :                         r->out.info->info100 = talloc_zero(ctx,struct dfs_Info100);
     463           0 :                         if (!r->out.info->info100) {
     464           0 :                                 return WERR_NOT_ENOUGH_MEMORY;
     465             :                         }
     466           0 :                         ret = init_reply_dfs_info_100(ctx, jn, r->out.info->info100);
     467           0 :                         break;
     468           0 :                 default:
     469           0 :                         r->out.info->info1 = NULL;
     470           0 :                         return WERR_INVALID_PARAMETER;
     471             :         }
     472             : 
     473           3 :         if (!ret)
     474           0 :                 return WERR_INVALID_PARAMETER;
     475             : 
     476           3 :         return WERR_OK;
     477             : }
     478             : 
     479           0 : WERROR _dfs_SetInfo(struct pipes_struct *p, struct dfs_SetInfo *r)
     480             : {
     481             :         /* FIXME: Implement your code here */
     482           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     483           0 :         return WERR_NOT_SUPPORTED;
     484             : }
     485             : 
     486           0 : WERROR _dfs_Rename(struct pipes_struct *p, struct dfs_Rename *r)
     487             : {
     488             :         /* FIXME: Implement your code here */
     489           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     490           0 :         return WERR_NOT_SUPPORTED;
     491             : }
     492             : 
     493           0 : WERROR _dfs_Move(struct pipes_struct *p, struct dfs_Move *r)
     494             : {
     495             :         /* FIXME: Implement your code here */
     496           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     497           0 :         return WERR_NOT_SUPPORTED;
     498             : }
     499             : 
     500           0 : WERROR _dfs_ManagerGetConfigInfo(struct pipes_struct *p, struct dfs_ManagerGetConfigInfo *r)
     501             : {
     502             :         /* FIXME: Implement your code here */
     503           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     504           0 :         return WERR_NOT_SUPPORTED;
     505             : }
     506             : 
     507           0 : WERROR _dfs_ManagerSendSiteInfo(struct pipes_struct *p, struct dfs_ManagerSendSiteInfo *r)
     508             : {
     509             :         /* FIXME: Implement your code here */
     510           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     511           0 :         return WERR_NOT_SUPPORTED;
     512             : }
     513             : 
     514           0 : WERROR _dfs_AddFtRoot(struct pipes_struct *p, struct dfs_AddFtRoot *r)
     515             : {
     516             :         /* FIXME: Implement your code here */
     517           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     518           0 :         return WERR_NOT_SUPPORTED;
     519             : }
     520             : 
     521           0 : WERROR _dfs_RemoveFtRoot(struct pipes_struct *p, struct dfs_RemoveFtRoot *r)
     522             : {
     523             :         /* FIXME: Implement your code here */
     524           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     525           0 :         return WERR_NOT_SUPPORTED;
     526             : }
     527             : 
     528           0 : WERROR _dfs_AddStdRoot(struct pipes_struct *p, struct dfs_AddStdRoot *r)
     529             : {
     530             :         /* FIXME: Implement your code here */
     531           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     532           0 :         return WERR_NOT_SUPPORTED;
     533             : }
     534             : 
     535           0 : WERROR _dfs_RemoveStdRoot(struct pipes_struct *p, struct dfs_RemoveStdRoot *r)
     536             : {
     537             :         /* FIXME: Implement your code here */
     538           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     539           0 :         return WERR_NOT_SUPPORTED;
     540             : }
     541             : 
     542           0 : WERROR _dfs_ManagerInitialize(struct pipes_struct *p, struct dfs_ManagerInitialize *r)
     543             : {
     544             :         /* FIXME: Implement your code here */
     545           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     546           0 :         return WERR_NOT_SUPPORTED;
     547             : }
     548             : 
     549           0 : WERROR _dfs_AddStdRootForced(struct pipes_struct *p, struct dfs_AddStdRootForced *r)
     550             : {
     551             :         /* FIXME: Implement your code here */
     552           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     553           0 :         return WERR_NOT_SUPPORTED;
     554             : }
     555             : 
     556           0 : WERROR _dfs_GetDcAddress(struct pipes_struct *p, struct dfs_GetDcAddress *r)
     557             : {
     558             :         /* FIXME: Implement your code here */
     559           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     560           0 :         return WERR_NOT_SUPPORTED;
     561             : }
     562             : 
     563           0 : WERROR _dfs_SetDcAddress(struct pipes_struct *p, struct dfs_SetDcAddress *r)
     564             : {
     565             :         /* FIXME: Implement your code here */
     566           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     567           0 :         return WERR_NOT_SUPPORTED;
     568             : }
     569             : 
     570           0 : WERROR _dfs_FlushFtTable(struct pipes_struct *p, struct dfs_FlushFtTable *r)
     571             : {
     572             :         /* FIXME: Implement your code here */
     573           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     574           0 :         return WERR_NOT_SUPPORTED;
     575             : }
     576             : 
     577           0 : WERROR _dfs_Add2(struct pipes_struct *p, struct dfs_Add2 *r)
     578             : {
     579             :         /* FIXME: Implement your code here */
     580           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     581           0 :         return WERR_NOT_SUPPORTED;
     582             : }
     583             : 
     584           0 : WERROR _dfs_Remove2(struct pipes_struct *p, struct dfs_Remove2 *r)
     585             : {
     586             :         /* FIXME: Implement your code here */
     587           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     588           0 :         return WERR_NOT_SUPPORTED;
     589             : }
     590             : 
     591           3 : WERROR _dfs_EnumEx(struct pipes_struct *p, struct dfs_EnumEx *r)
     592             : {
     593             :         /* FIXME: Implement your code here */
     594           3 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     595           3 :         return WERR_NOT_SUPPORTED;
     596             : }
     597             : 
     598           0 : WERROR _dfs_SetInfo2(struct pipes_struct *p, struct dfs_SetInfo2 *r)
     599             : {
     600             :         /* FIXME: Implement your code here */
     601           0 :         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     602           0 :         return WERR_NOT_SUPPORTED;
     603             : }
     604             : 
     605             : /* include the generated boilerplate */
     606             : #include "librpc/gen_ndr/ndr_dfs_scompat.c"

Generated by: LCOV version 1.14