Quelle  dfs.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2022 Paulo Alcantara <palcantara@suse.de>
 */

#include "cifsproto.h"
#include "cifs_debug.h"
#include "dns_resolve.h"
#include "fs_context.h"
#include "dfs.h"

#define DFS_DOM(ctx) (ctx->dfs_root_ses ? ctx->dfs_root_ses->dns_dom : NULL)

/**
 * dfs_parse_target_referral - set fs context for dfs target referral
 *
 * @full_path: full path in UNC format.
 * @ref: dfs referral pointer.
 * @ctx: smb3 fs context pointer.
 *
 * Return zero if dfs referral was parsed correctly, otherwise non-zero.
 */
int dfs_parse_target_referral(const char *full_path, const struct dfs_info3_param *ref,
         struct smb3_fs_context *ctx)
{
 int rc;
 const char *prepath = NULL;
 char *path;

 if (!full_path || !*full_path || !ref || !ctx)
  return -EINVAL;

 if (WARN_ON_ONCE(!ref->node_name || ref->path_consumed < 0))
  return -EINVAL;

 if (strlen(full_path) - ref->path_consumed) {
  prepath = full_path + ref->path_consumed;
  /* skip initial delimiter */
  if (*prepath == '/' || *prepath == '\\')
   prepath++;
 }

 path = cifs_build_devname(ref->node_name, prepath);
 if (IS_ERR(path))
  return PTR_ERR(path);

 rc = smb3_parse_devname(path, ctx);
 if (rc)
  goto out;

 rc = dns_resolve_unc(DFS_DOM(ctx), path,
        (struct sockaddr *)&ctx->dstaddr);
out:
 kfree(path);
 return rc;
}

static int get_session(struct cifs_mount_ctx *mnt_ctx, const char *full_path)
{
 struct smb3_fs_context *ctx = mnt_ctx->fs_ctx;
 int rc;

 ctx->leaf_fullpath = (char *)full_path;
 ctx->dns_dom = DFS_DOM(ctx);
 rc = cifs_mount_get_session(mnt_ctx);
 ctx->leaf_fullpath = ctx->dns_dom = NULL;

 return rc;
}

/*
 * Get an active reference of @ses so that next call to cifs_put_tcon() won't
 * release it as any new DFS referrals must go through its IPC tcon.
 */
static void set_root_smb_session(struct cifs_mount_ctx *mnt_ctx)
{
 struct smb3_fs_context *ctx = mnt_ctx->fs_ctx;
 struct cifs_ses *ses = mnt_ctx->ses;

 if (ses) {
  spin_lock(&cifs_tcp_ses_lock);
  cifs_smb_ses_inc_refcount(ses);
  spin_unlock(&cifs_tcp_ses_lock);
 }
 ctx->dfs_root_ses = ses;
}

static inline int parse_dfs_target(struct smb3_fs_context *ctx,
       struct dfs_ref_walk *rw,
       struct dfs_info3_param *tgt)
{
 int rc;
 const char *fpath = ref_walk_fpath(rw) + 1;

 rc = ref_walk_get_tgt(rw, tgt);
 if (!rc)
  rc = dfs_parse_target_referral(fpath, tgt, ctx);
 return rc;
}

static int setup_dfs_ref(struct dfs_info3_param *tgt, struct dfs_ref_walk *rw)
{
 struct cifs_sb_info *cifs_sb = rw->mnt_ctx->cifs_sb;
 struct smb3_fs_context *ctx = rw->mnt_ctx->fs_ctx;
 char *ref_path, *full_path;
 int rc;

 set_root_smb_session(rw->mnt_ctx);
 ref_walk_ses(rw) = ctx->dfs_root_ses;

 full_path = smb3_fs_context_fullpath(ctx, CIFS_DIR_SEP(cifs_sb));
 if (IS_ERR(full_path))
  return PTR_ERR(full_path);

 if (!tgt || (tgt->server_type == DFS_TYPE_LINK &&
       DFS_INTERLINK(tgt->flags)))
  ref_path = dfs_get_path(cifs_sb, ctx->UNC);
 else
  ref_path = dfs_get_path(cifs_sb, full_path);
 if (IS_ERR(ref_path)) {
  rc = PTR_ERR(ref_path);
  kfree(full_path);
  return rc;
 }
 ref_walk_path(rw) = ref_path;
 ref_walk_fpath(rw) = full_path;

 return dfs_get_referral(rw->mnt_ctx,
    ref_walk_path(rw) + 1,
    ref_walk_tl(rw));
}

static int __dfs_referral_walk(struct dfs_ref_walk *rw)
{
 struct smb3_fs_context *ctx = rw->mnt_ctx->fs_ctx;
 struct cifs_mount_ctx *mnt_ctx = rw->mnt_ctx;
 struct dfs_info3_param tgt = {};
 int rc = -ENOENT;

again:
 do {
  ctx->dfs_root_ses = ref_walk_ses(rw);
  while (ref_walk_next_tgt(rw)) {
   rc = parse_dfs_target(ctx, rw, &tgt);
   if (rc)
    continue;

   cifs_mount_put_conns(mnt_ctx);
   rc = get_session(mnt_ctx, ref_walk_path(rw));
   if (rc)
    continue;

   rc = cifs_mount_get_tcon(mnt_ctx);
   if (rc) {
    if (tgt.server_type == DFS_TYPE_LINK &&
        DFS_INTERLINK(tgt.flags))
     rc = -EREMOTE;
   } else {
    rc = cifs_is_path_remote(mnt_ctx);
    if (!rc) {
     ref_walk_set_tgt_hint(rw);
     break;
    }
   }
   if (rc == -EREMOTE) {
    rc = ref_walk_advance(rw);
    if (!rc) {
     rc = setup_dfs_ref(&tgt, rw);
     if (rc)
      break;
     ref_walk_mark_end(rw);
     goto again;
    }
   }
  }
 } while (rc && ref_walk_descend(rw));

 free_dfs_info_param(&tgt);
 return rc;
}

static int dfs_referral_walk(struct cifs_mount_ctx *mnt_ctx,
        struct dfs_ref_walk **rw)
{
 int rc;

 *rw = ref_walk_alloc();
 if (IS_ERR(*rw)) {
  rc = PTR_ERR(*rw);
  *rw = NULL;
  return rc;
 }

 ref_walk_init(*rw, mnt_ctx);
 rc = setup_dfs_ref(NULL, *rw);
 if (!rc)
  rc = __dfs_referral_walk(*rw);
 return rc;
}

static int __dfs_mount_share(struct cifs_mount_ctx *mnt_ctx)
{
 struct cifs_sb_info *cifs_sb = mnt_ctx->cifs_sb;
 struct smb3_fs_context *ctx = mnt_ctx->fs_ctx;
 struct dfs_ref_walk *rw = NULL;
 struct cifs_tcon *tcon;
 char *origin_fullpath;
 int rc;

 origin_fullpath = dfs_get_path(cifs_sb, ctx->source);
 if (IS_ERR(origin_fullpath))
  return PTR_ERR(origin_fullpath);

 rc = dfs_referral_walk(mnt_ctx, &rw);
 if (!rc) {
  /*
 * Prevent superblock from being created with any missing
 * connections.
 */
  if (WARN_ON(!mnt_ctx->server))
   rc = -EHOSTDOWN;
  else if (WARN_ON(!mnt_ctx->ses))
   rc = -EACCES;
  else if (WARN_ON(!mnt_ctx->tcon))
   rc = -ENOENT;
 }
 if (rc)
  goto out;

 tcon = mnt_ctx->tcon;
 spin_lock(&tcon->tc_lock);
 tcon->origin_fullpath = origin_fullpath;
 origin_fullpath = NULL;
 ref_walk_set_tcon(rw, tcon);
 spin_unlock(&tcon->tc_lock);
 queue_delayed_work(dfscache_wq, &tcon->dfs_cache_work,
      dfs_cache_get_ttl() * HZ);

out:
 kfree(origin_fullpath);
 ref_walk_free(rw);
 return rc;
}

/*
 * If @ctx->dfs_automount, then update @ctx->dstaddr earlier with the DFS root
 * server from where we'll start following any referrals.  Otherwise rely on the
 * value provided by mount(2) as the user might not have dns_resolver key set up
 * and therefore failing to upcall to resolve UNC hostname under @ctx->source.
 */
static int update_fs_context_dstaddr(struct smb3_fs_context *ctx)
{
 struct sockaddr *addr = (struct sockaddr *)&ctx->dstaddr;
 int rc = 0;

 if (!ctx->nodfs && ctx->dfs_automount) {
  rc = dns_resolve_unc(NULL, ctx->source, addr);
  if (!rc)
   cifs_set_port(addr, ctx->port);
  ctx->dfs_automount = false;
 }
 return rc;
}

int dfs_mount_share(struct cifs_mount_ctx *mnt_ctx)
{
 struct smb3_fs_context *ctx = mnt_ctx->fs_ctx;
 bool nodfs = ctx->nodfs;
 int rc;

 rc = update_fs_context_dstaddr(ctx);
 if (rc)
  return rc;

 rc = get_session(mnt_ctx, NULL);
 if (rc)
  return rc;

 /*
 * If called with 'nodfs' mount option, then skip DFS resolving.  Otherwise unconditionally
 * try to get an DFS referral (even cached) to determine whether it is an DFS mount.
 *
 * Skip prefix path to provide support for DFS referrals from w2k8 servers which don't seem
 * to respond with PATH_NOT_COVERED to requests that include the prefix.
 */
 if (!nodfs) {
  rc = dfs_get_referral(mnt_ctx, ctx->UNC + 1, NULL);
  if (rc) {
   cifs_dbg(FYI, "%s: no dfs referral for %s: %d\n",
     __func__, ctx->UNC + 1, rc);
   cifs_dbg(FYI, "%s: assuming non-dfs mount...\n", __func__);
   nodfs = true;
  }
 }
 if (nodfs) {
  rc = cifs_mount_get_tcon(mnt_ctx);
  if (!rc)
   rc = cifs_is_path_remote(mnt_ctx);
  return rc;
 }

 if (!ctx->dfs_conn) {
  ctx->dfs_conn = true;
  cifs_mount_put_conns(mnt_ctx);
  rc = get_session(mnt_ctx, NULL);
 }
 if (!rc)
  rc = __dfs_mount_share(mnt_ctx);
 return rc;
}

static int target_share_matches_server(struct TCP_Server_Info *server, char *share,
           bool *target_match)
{
 int rc = 0;
 const char *dfs_host;
 size_t dfs_host_len;

 *target_match = true;
 extract_unc_hostname(share, &dfs_host, &dfs_host_len);

 /* Check if hostnames or addresses match */
 cifs_server_lock(server);
 if (dfs_host_len != strlen(server->hostname) ||
     strncasecmp(dfs_host, server->hostname, dfs_host_len)) {
  cifs_dbg(FYI, "%s: %.*s doesn't match %s\n", __func__,
    (int)dfs_host_len, dfs_host, server->hostname);
  rc = match_target_ip(server, dfs_host, dfs_host_len, target_match);
  if (rc)
   cifs_dbg(VFS, "%s: failed to match target ip: %d\n", __func__, rc);
 }
 cifs_server_unlock(server);
 return rc;
}

static int tree_connect_dfs_target(const unsigned int xid,
       struct cifs_tcon *tcon,
       struct cifs_sb_info *cifs_sb,
       char *tree, bool islink,
       struct dfs_cache_tgt_list *tl)
{
 const struct smb_version_operations *ops = tcon->ses->server->ops;
 struct TCP_Server_Info *server = tcon->ses->server;
 struct dfs_cache_tgt_iterator *tit;
 char *share = NULL, *prefix = NULL;
 bool target_match;
 int rc = -ENOENT;

 /* Try to tree connect to all dfs targets */
 for (tit = dfs_cache_get_tgt_iterator(tl);
      tit; tit = dfs_cache_get_next_tgt(tl, tit)) {
  kfree(share);
  kfree(prefix);
  share = prefix = NULL;

  /* Check if share matches with tcp ses */
  rc = dfs_cache_get_tgt_share(server->leaf_fullpath + 1, tit, &share, &prefix);
  if (rc) {
   cifs_dbg(VFS, "%s: failed to parse target share: %d\n", __func__, rc);
   break;
  }

  rc = target_share_matches_server(server, share, &target_match);
  if (rc)
   break;
  if (!target_match) {
   rc = -EHOSTUNREACH;
   continue;
  }

  dfs_cache_noreq_update_tgthint(server->leaf_fullpath + 1, tit);
  scnprintf(tree, MAX_TREE_SIZE, "\\%s", share);
  rc = ops->tree_connect(xid, tcon->ses, tree,
           tcon, tcon->ses->local_nls);
  if (islink && !rc && cifs_sb)
   rc = cifs_update_super_prepath(cifs_sb, prefix);
  break;
 }

 kfree(share);
 kfree(prefix);
 dfs_cache_free_tgts(tl);
 return rc;
}

int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon)
{
 int rc;
 struct TCP_Server_Info *server = tcon->ses->server;
 const struct smb_version_operations *ops = server->ops;
 DFS_CACHE_TGT_LIST(tl);
 struct cifs_sb_info *cifs_sb = NULL;
 struct super_block *sb = NULL;
 struct dfs_info3_param ref = {0};
 char *tree;

 /* only send once per connect */
 spin_lock(&tcon->tc_lock);

 /* if tcon is marked for needing reconnect, update state */
 if (tcon->need_reconnect)
  tcon->status = TID_NEED_TCON;

 if (tcon->status == TID_GOOD) {
  spin_unlock(&tcon->tc_lock);
  return 0;
 }

 if (tcon->status != TID_NEW &&
     tcon->status != TID_NEED_TCON) {
  spin_unlock(&tcon->tc_lock);
  return -EHOSTDOWN;
 }

 tcon->status = TID_IN_TCON;
 spin_unlock(&tcon->tc_lock);

 tree = kzalloc(MAX_TREE_SIZE, GFP_KERNEL);
 if (!tree) {
  rc = -ENOMEM;
  goto out;
 }

 if (tcon->ipc) {
  cifs_server_lock(server);
  scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", server->hostname);
  cifs_server_unlock(server);
  rc = ops->tree_connect(xid, tcon->ses, tree,
           tcon, tcon->ses->local_nls);
  goto out;
 }

 sb = cifs_get_dfs_tcon_super(tcon);
 if (!IS_ERR(sb))
  cifs_sb = CIFS_SB(sb);

 /* Tree connect to last share in @tcon->tree_name if no DFS referral */
 if (!server->leaf_fullpath ||
     dfs_cache_noreq_find(server->leaf_fullpath + 1, &ref, &tl)) {
  rc = ops->tree_connect(xid, tcon->ses, tcon->tree_name,
           tcon, tcon->ses->local_nls);
  goto out;
 }

 rc = tree_connect_dfs_target(xid, tcon, cifs_sb, tree, ref.server_type == DFS_TYPE_LINK,
         &tl);
 free_dfs_info_param(&ref);

out:
 kfree(tree);
 cifs_put_tcp_super(sb);

 if (rc) {
  spin_lock(&tcon->tc_lock);
  if (tcon->status == TID_IN_TCON)
   tcon->status = TID_NEED_TCON;
  spin_unlock(&tcon->tc_lock);
 } else {
  spin_lock(&tcon->tc_lock);
  if (tcon->status == TID_IN_TCON)
   tcon->status = TID_GOOD;
  tcon->need_reconnect = false;
  spin_unlock(&tcon->tc_lock);
 }

 return rc;
}