/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 *   Copyright (C) 2020, Microsoft Corporation.
 *
 *   Author(s): Steve French <stfrench@microsoft.com>
 *              David Howells <dhowells@redhat.com>
 */

#ifndef _FS_CONTEXT_H
#define _FS_CONTEXT_H

#include "cifsglob.h"
#include <linux/parser.h>
#include <linux/fs_parser.h>

/* Log errors in fs_context (new mount api) but also in dmesg (old style) */
#define cifs_errorf(fc, fmt, ...)                       \
        do {                                            \
                errorf(fc, fmt, ## __VA_ARGS__);        \
                cifs_dbg(VFS, fmt, ## __VA_ARGS__);     \
        } while (0)

static inline size_t cifs_io_align(struct fs_context *fc,
                                   const char *name, size_t size)
{
        if (!size || !IS_ALIGNED(size, PAGE_SIZE)) {
                cifs_errorf(fc, "unaligned %s, making it a multiple of %lu bytes\n",
                            name, PAGE_SIZE);
                size = umax(round_down(size, PAGE_SIZE), PAGE_SIZE);
        }
        return size;
}

#define CIFS_ALIGN_WSIZE(_fc, _size) cifs_io_align(_fc, "wsize", _size)
#define CIFS_ALIGN_RSIZE(_fc, _size) cifs_io_align(_fc, "rsize", _size)
#define CIFS_ALIGN_BSIZE(_fc, _size) cifs_io_align(_fc, "bsize", _size)

enum smb_version {
        Smb_1 = 1,
        Smb_20,
        Smb_21,
        Smb_30,
        Smb_302,
        Smb_311,
        Smb_3any,
        Smb_default,
        Smb_version_err
};

enum {
        Opt_cache_loose,
        Opt_cache_strict,
        Opt_cache_none,
        Opt_cache_ro,
        Opt_cache_rw,
        Opt_cache_err
};

enum cifs_reparse_parm {
        Opt_reparse_default,
        Opt_reparse_none,
        Opt_reparse_nfs,
        Opt_reparse_wsl,
        Opt_reparse_err
};

enum cifs_symlink_parm {
        Opt_symlink_default,
        Opt_symlink_none,
        Opt_symlink_native,
        Opt_symlink_unix,
        Opt_symlink_mfsymlinks,
        Opt_symlink_sfu,
        Opt_symlink_nfs,
        Opt_symlink_wsl,
        Opt_symlink_err
};

enum cifs_sec_param {
        Opt_sec_krb5,
        Opt_sec_krb5i,
        Opt_sec_krb5p,
        Opt_sec_ntlmsspi,
        Opt_sec_ntlmssp,
        Opt_sec_ntlmv2,
        Opt_sec_ntlmv2i,
        Opt_sec_none,

        Opt_sec_err
};

enum cifs_upcall_target_param {
        Opt_upcall_target_mount,
        Opt_upcall_target_application,
        Opt_upcall_target_err
};

enum cifs_param {
        /* Mount options that take no arguments */
        Opt_user_xattr,
        Opt_forceuid,
        Opt_forcegid,
        Opt_noblocksend,
        Opt_noautotune,
        Opt_nolease,
        Opt_nosparse,
        Opt_hard,
        Opt_soft,
        Opt_perm,
        Opt_nodelete,
        Opt_mapposix,
        Opt_mapchars,
        Opt_nomapchars,
        Opt_sfu,
        Opt_nodfs,
        Opt_posixpaths,
        Opt_unix,
        Opt_nocase,
        Opt_brl,
        Opt_handlecache,
        Opt_forcemandatorylock,
        Opt_setuidfromacl,
        Opt_setuids,
        Opt_dynperm,
        Opt_intr,
        Opt_strictsync,
        Opt_serverino,
        Opt_rwpidforward,
        Opt_cifsacl,
        Opt_acl,
        Opt_locallease,
        Opt_sign,
        Opt_ignore_signature,
        Opt_seal,
        Opt_noac,
        Opt_fsc,
        Opt_mfsymlinks,
        Opt_multiuser,
        Opt_sloppy,
        Opt_nosharesock,
        Opt_persistent,
        Opt_resilient,
        Opt_tcp_nodelay,
        Opt_domainauto,
        Opt_rdma,
        Opt_modesid,
        Opt_rootfs,
        Opt_multichannel,
        Opt_compress,
        Opt_witness,
        Opt_is_upcall_target_mount,
        Opt_is_upcall_target_application,
        Opt_unicode,

        /* Mount options which take numeric value */
        Opt_backupuid,
        Opt_backupgid,
        Opt_uid,
        Opt_cruid,
        Opt_gid,
        Opt_port,
        Opt_file_mode,
        Opt_dirmode,
        Opt_min_enc_offload,
        Opt_retrans,
        Opt_blocksize,
        Opt_rasize,
        Opt_rsize,
        Opt_wsize,
        Opt_actimeo,
        Opt_acdirmax,
        Opt_acregmax,
        Opt_closetimeo,
        Opt_echo_interval,
        Opt_max_credits,
        Opt_max_cached_dirs,
        Opt_snapshot,
        Opt_max_channels,
        Opt_handletimeout,

        /* Mount options which take string value */
        Opt_source,
        Opt_user,
        Opt_pass,
        Opt_pass2,
        Opt_ip,
        Opt_domain,
        Opt_srcaddr,
        Opt_iocharset,
        Opt_netbiosname,
        Opt_servern,
        Opt_nbsessinit,
        Opt_ver,
        Opt_vers,
        Opt_sec,
        Opt_cache,
        Opt_reparse,
        Opt_upcalltarget,
        Opt_nativesocket,
        Opt_symlink,
        Opt_symlinkroot,

        /* Mount options to be ignored */
        Opt_ignore,

        Opt_err
};

struct smb3_fs_context {
        bool forceuid_specified;
        bool forcegid_specified;
        bool uid_specified;
        bool cruid_specified;
        bool gid_specified;
        bool sloppy;
        bool got_ip;
        bool got_version;
        bool got_rsize;
        bool got_wsize;
        bool got_bsize;
        unsigned short port;

        char *username;
        char *password;
        char *password2;
        char *domainname;
        char *source;
        char *server_hostname;
        char *UNC;
        char *nodename;
        char workstation_name[CIFS_MAX_WORKSTATION_LEN];
        char *iocharset;  /* local code page for mapping to and from Unicode */
        char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
        char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
        int rfc1001_sessinit;
        kuid_t cred_uid;
        kuid_t linux_uid;
        kgid_t linux_gid;
        kuid_t backupuid;
        kgid_t backupgid;
        umode_t file_mode;
        umode_t dir_mode;
        enum securityEnum sectype; /* sectype requested via mnt opts */
        enum upcall_target_enum upcall_target; /* where to upcall for mount */
        bool sign; /* was signing requested via mnt opts? */
        bool ignore_signature:1;
        bool retry:1;
        bool intr:1;
        bool setuids:1;
        bool setuidfromacl:1;
        bool override_uid:1;
        bool override_gid:1;
        bool dynperm:1;
        bool noperm:1;
        bool nodelete:1;
        bool mode_ace:1;
        bool no_psx_acl:1; /* set if posix acl support should be disabled */
        bool cifs_acl:1;
        bool backupuid_specified; /* mount option  backupuid  is specified */
        bool backupgid_specified; /* mount option  backupgid  is specified */
        bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
        bool server_ino:1; /* use inode numbers from server ie UniqueId */
        bool direct_io:1;
        bool strict_io:1; /* strict cache behavior */
        bool cache_ro:1;
        bool cache_rw:1;
        bool remap:1;      /* set to remap seven reserved chars in filenames */
        bool sfu_remap:1;  /* remap seven reserved chars ala SFU */
        bool posix_paths:1; /* unset to not ask for posix pathnames. */
        bool no_linux_ext:1;
        bool linux_ext:1;
        bool sfu_emul:1;
        bool nullauth:1;   /* attempt to authenticate with null user */
        bool nocase:1;     /* request case insensitive filenames */
        bool nobrl:1;      /* disable sending byte range locks to srv */
        bool nohandlecache:1; /* disable caching dir handles if srvr probs */
        bool mand_lock:1;  /* send mandatory not posix byte range lock reqs */
        bool seal:1;       /* request transport encryption on share */
        bool nodfs:1;      /* Do not request DFS, even if available */
        bool local_lease:1; /* check leases only on local system, not remote */
        bool noblocksnd:1;
        bool noautotune:1;
        bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
        bool no_lease:1;     /* disable requesting leases */
        bool no_sparse:1;    /* do not attempt to set files sparse */
        bool fsc:1;     /* enable fscache */
        bool mfsymlinks:1; /* use Minshall+French Symlinks */
        bool multiuser:1;
        bool rwpidforward:1; /* pid forward for read/write operations */
        bool nosharesock:1;
        bool persistent:1;
        bool nopersistent:1;
        bool resilient:1; /* noresilient not required since not fored for CA */
        bool domainauto:1;
        bool rdma:1;
        bool multichannel:1;
        bool multichannel_specified:1; /* true if user specified multichannel or nomultichannel */
        bool max_channels_specified:1; /* true if user specified max_channels */
        bool use_client_guid:1;
        /* reuse existing guid for multichannel */
        u8 client_guid[SMB2_CLIENT_GUID_SIZE];
        /* User-specified original r/wsize value */
        unsigned int vol_rsize;
        unsigned int vol_wsize;
        unsigned int bsize;
        unsigned int rasize;
        unsigned int rsize;
        unsigned int wsize;
        unsigned int min_offload;
        unsigned int retrans;
        bool sockopt_tcp_nodelay:1;
        /* attribute cache timeout for files and directories in jiffies */
        unsigned long acregmax;
        unsigned long acdirmax;
        /* timeout for deferred close of files in jiffies */
        unsigned long closetimeo;
        struct smb_version_operations *ops;
        struct smb_version_values *vals;
        char *prepath;
        struct sockaddr_storage dstaddr; /* destination address */
        struct sockaddr_storage srcaddr; /* allow binding to a local IP */
        struct nls_table *local_nls; /* This is a copy of the pointer in cifs_sb */
        unsigned int echo_interval; /* echo interval in secs */
        __u64 snapshot_time; /* needed for timewarp tokens */
        __u32 handle_timeout; /* persistent and durable handle timeout in ms */
        unsigned int max_credits; /* smb3 max_credits 10 < credits < 60000 */
        unsigned int max_channels;
        unsigned int max_cached_dirs;
        bool compress; /* enable SMB2 messages (READ/WRITE) de/compression */
        bool rootfs:1; /* if it's a SMB root file system */
        bool witness:1; /* use witness protocol */
        int unicode;
        char *leaf_fullpath;
        struct cifs_ses *dfs_root_ses;
        bool dfs_automount:1; /* set for dfs automount only */
        enum cifs_reparse_type reparse_type;
        enum cifs_symlink_type symlink_type;
        bool nonativesocket:1;
        bool dfs_conn:1; /* set for dfs mounts */
        char *dns_dom;
        char *symlinkroot; /* top level directory for native SMB symlinks in absolute format */
};

extern const struct fs_parameter_spec smb3_fs_parameters[];

static inline enum cifs_symlink_type cifs_symlink_type(struct cifs_sb_info *cifs_sb)
{
        bool posix = cifs_sb_master_tcon(cifs_sb)->posix_extensions;

        if (cifs_sb->ctx->symlink_type != CIFS_SYMLINK_TYPE_DEFAULT)
                return cifs_sb->ctx->symlink_type;

        if (cifs_sb->ctx->mfsymlinks)
                return CIFS_SYMLINK_TYPE_MFSYMLINKS;
        else if (cifs_sb->ctx->sfu_emul)
                return CIFS_SYMLINK_TYPE_SFU;
        else if (cifs_sb->ctx->linux_ext && !cifs_sb->ctx->no_linux_ext)
                return posix ? CIFS_SYMLINK_TYPE_NATIVE : CIFS_SYMLINK_TYPE_UNIX;
        else if (cifs_sb->ctx->reparse_type != CIFS_REPARSE_TYPE_NONE)
                return CIFS_SYMLINK_TYPE_NATIVE;
        return CIFS_SYMLINK_TYPE_NONE;
}

int smb3_init_fs_context(struct fs_context *fc);
void smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx);
void smb3_cleanup_fs_context(struct smb3_fs_context *ctx);

static inline struct smb3_fs_context *smb3_fc2context(const struct fs_context *fc)
{
        return fc->fs_private;
}

int smb3_fs_context_dup(struct smb3_fs_context *new_ctx,
                        struct smb3_fs_context *ctx);
int smb3_sync_session_ctx_passwords(struct cifs_sb_info *cifs_sb,
                                    struct cifs_ses *ses);
unsigned int smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb);

/*
 * max deferred close timeout (jiffies) - 2^30
 */
#define SMB3_MAX_DCLOSETIMEO (1 << 30)
#define SMB3_DEF_DCLOSETIMEO (1 * HZ) /* even 1 sec enough to help eg open/write/close/open/read */
#define MAX_CACHED_FIDS 16
char *cifs_sanitize_prepath(char *prepath, gfp_t gfp);

extern struct mutex cifs_mount_mutex;

static inline void cifs_mount_lock(void)
{
        mutex_lock(&cifs_mount_mutex);
}

static inline void cifs_mount_unlock(void)
{
        mutex_unlock(&cifs_mount_mutex);
}

static inline void cifs_negotiate_rsize(struct TCP_Server_Info *server,
                                        struct smb3_fs_context *ctx,
                                        struct cifs_tcon *tcon)
{
        unsigned int size;

        size = umax(server->ops->negotiate_rsize(tcon, ctx), PAGE_SIZE);
        if (ctx->rsize)
                size = umax(umin(ctx->rsize, size), PAGE_SIZE);
        ctx->rsize = round_down(size, PAGE_SIZE);
}

static inline void cifs_negotiate_wsize(struct TCP_Server_Info *server,
                                        struct smb3_fs_context *ctx,
                                        struct cifs_tcon *tcon)
{
        unsigned int size;

        size = umax(server->ops->negotiate_wsize(tcon, ctx), PAGE_SIZE);
        if (ctx->wsize)
                size = umax(umin(ctx->wsize, size), PAGE_SIZE);
        ctx->wsize = round_down(size, PAGE_SIZE);
}

static inline void cifs_negotiate_iosize(struct TCP_Server_Info *server,
                                         struct smb3_fs_context *ctx,
                                         struct cifs_tcon *tcon)
{
        cifs_negotiate_rsize(server, ctx, tcon);
        cifs_negotiate_wsize(server, ctx, tcon);
}

#endif