/*
   *   fs/cifs/connect.c
   *

   *   Copyright (C) International Business Machines  Corp., 2002,2011

   *   Author(s): Steve French (sfrench@us.ibm.com)
   *
   *   This library is free software; you can redistribute it and/or modify
   *   it under the terms of the GNU Lesser General Public License as published
   *   by the Free Software Foundation; either version 2.1 of the License, or
   *   (at your option) any later version.
   *
   *   This library is distributed in the hope that it will be useful,
   *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
   *   the GNU Lesser General Public License for more details.
   *
   *   You should have received a copy of the GNU Lesser General Public License
   *   along with this library; if not, write to the Free Software

   *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

   */
  #include <linux/fs.h>
  #include <linux/net.h>
  #include <linux/string.h>
  #include <linux/list.h>
  #include <linux/wait.h>

  #include <linux/slab.h>

  #include <linux/pagemap.h>
  #include <linux/ctype.h>
  #include <linux/utsname.h>
  #include <linux/mempool.h>

  #include <linux/delay.h>

  #include <linux/completion.h>

  #include <linux/kthread.h>

  #include <linux/pagevec.h>

  #include <linux/freezer.h>

  #include <linux/namei.h>

  #include <asm/uaccess.h>
  #include <asm/processor.h>

  #include <linux/inet.h>

  #include <linux/module.h>

  #include <keys/user-type.h>

  #include <net/ipv6.h>

  #include <linux/parser.h>

  #include "cifspdu.h"
  #include "cifsglob.h"
  #include "cifsproto.h"
  #include "cifs_unicode.h"
  #include "cifs_debug.h"
  #include "cifs_fs_sb.h"
  #include "ntlmssp.h"
  #include "nterr.h"
  #include "rfc1002pdu.h"

  #include "fscache.h"

  #ifdef CONFIG_CIFS_SMB2
  #include "smb2proto.h"
  #endif

  
  #define CIFS_PORT 445
  #define RFC1001_PORT 139

  extern mempool_t *cifs_req_poolp;

  /* FIXME: should these be tunable? */

  #define TLINK_ERROR_EXPIRE	(1 * HZ)

  #define TLINK_IDLE_EXPIRE	(600 * HZ)

  enum {

  	/* Mount options that take no arguments */
  	Opt_user_xattr, Opt_nouser_xattr,
  	Opt_forceuid, Opt_noforceuid,

  	Opt_forcegid, Opt_noforcegid,

  	Opt_noblocksend, Opt_noautotune,
  	Opt_hard, Opt_soft, Opt_perm, Opt_noperm,

  	Opt_mapposix, Opt_nomapposix,

  	Opt_mapchars, Opt_nomapchars, Opt_sfu,
  	Opt_nosfu, Opt_nodfs, Opt_posixpaths,
  	Opt_noposixpaths, Opt_nounix,
  	Opt_nocase,
  	Opt_brl, Opt_nobrl,

  	Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,

  	Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
  	Opt_nohard, Opt_nosoft,
  	Opt_nointr, Opt_intr,
  	Opt_nostrictsync, Opt_strictsync,
  	Opt_serverino, Opt_noserverino,
  	Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
  	Opt_acl, Opt_noacl, Opt_locallease,

  	Opt_sign, Opt_seal, Opt_noac,

  	Opt_fsc, Opt_mfsymlinks,

  	Opt_multiuser, Opt_sloppy, Opt_nosharesock,

  	Opt_persistent, Opt_nopersistent,

  	Opt_resilient, Opt_noresilient,

  
  	/* Mount options which take numeric value */
  	Opt_backupuid, Opt_backupgid, Opt_uid,
  	Opt_cruid, Opt_gid, Opt_file_mode,
  	Opt_dirmode, Opt_port,
  	Opt_rsize, Opt_wsize, Opt_actimeo,

  	Opt_echo_interval, Opt_max_credits,

  
  	/* Mount options which take string value */
  	Opt_user, Opt_pass, Opt_ip,

  	Opt_domain, Opt_srcaddr, Opt_iocharset,

  	Opt_netbiosname, Opt_servern,

  	Opt_ver, Opt_vers, Opt_sec, Opt_cache,

  
  	/* Mount options to be ignored */
  	Opt_ignore,
  
  	/* Options which could be blank */
  	Opt_blank_pass,

  	Opt_blank_user,
  	Opt_blank_ip,

  
  	Opt_err
  };
  
  static const match_table_t cifs_mount_option_tokens = {
  
  	{ Opt_user_xattr, "user_xattr" },
  	{ Opt_nouser_xattr, "nouser_xattr" },
  	{ Opt_forceuid, "forceuid" },
  	{ Opt_noforceuid, "noforceuid" },

  	{ Opt_forcegid, "forcegid" },
  	{ Opt_noforcegid, "noforcegid" },

  	{ Opt_noblocksend, "noblocksend" },
  	{ Opt_noautotune, "noautotune" },
  	{ Opt_hard, "hard" },
  	{ Opt_soft, "soft" },
  	{ Opt_perm, "perm" },
  	{ Opt_noperm, "noperm" },

  	{ Opt_mapchars, "mapchars" }, /* SFU style */

  	{ Opt_nomapchars, "nomapchars" },

  	{ Opt_mapposix, "mapposix" }, /* SFM style */
  	{ Opt_nomapposix, "nomapposix" },

  	{ Opt_sfu, "sfu" },
  	{ Opt_nosfu, "nosfu" },
  	{ Opt_nodfs, "nodfs" },
  	{ Opt_posixpaths, "posixpaths" },
  	{ Opt_noposixpaths, "noposixpaths" },
  	{ Opt_nounix, "nounix" },
  	{ Opt_nounix, "nolinux" },
  	{ Opt_nocase, "nocase" },
  	{ Opt_nocase, "ignorecase" },
  	{ Opt_brl, "brl" },
  	{ Opt_nobrl, "nobrl" },
  	{ Opt_nobrl, "nolock" },
  	{ Opt_forcemandatorylock, "forcemandatorylock" },

  	{ Opt_forcemandatorylock, "forcemand" },

  	{ Opt_setuids, "setuids" },
  	{ Opt_nosetuids, "nosetuids" },

  	{ Opt_setuidfromacl, "idsfromsid" },

  	{ Opt_dynperm, "dynperm" },
  	{ Opt_nodynperm, "nodynperm" },
  	{ Opt_nohard, "nohard" },
  	{ Opt_nosoft, "nosoft" },
  	{ Opt_nointr, "nointr" },
  	{ Opt_intr, "intr" },
  	{ Opt_nostrictsync, "nostrictsync" },
  	{ Opt_strictsync, "strictsync" },
  	{ Opt_serverino, "serverino" },
  	{ Opt_noserverino, "noserverino" },
  	{ Opt_rwpidforward, "rwpidforward" },
  	{ Opt_cifsacl, "cifsacl" },
  	{ Opt_nocifsacl, "nocifsacl" },
  	{ Opt_acl, "acl" },
  	{ Opt_noacl, "noacl" },
  	{ Opt_locallease, "locallease" },
  	{ Opt_sign, "sign" },
  	{ Opt_seal, "seal" },

  	{ Opt_noac, "noac" },
  	{ Opt_fsc, "fsc" },
  	{ Opt_mfsymlinks, "mfsymlinks" },
  	{ Opt_multiuser, "multiuser" },

  	{ Opt_sloppy, "sloppy" },

  	{ Opt_nosharesock, "nosharesock" },

  	{ Opt_persistent, "persistenthandles"},
  	{ Opt_nopersistent, "nopersistenthandles"},

  	{ Opt_resilient, "resilienthandles"},
  	{ Opt_noresilient, "noresilienthandles"},

  
  	{ Opt_backupuid, "backupuid=%s" },
  	{ Opt_backupgid, "backupgid=%s" },
  	{ Opt_uid, "uid=%s" },
  	{ Opt_cruid, "cruid=%s" },
  	{ Opt_gid, "gid=%s" },
  	{ Opt_file_mode, "file_mode=%s" },
  	{ Opt_dirmode, "dirmode=%s" },
  	{ Opt_dirmode, "dir_mode=%s" },
  	{ Opt_port, "port=%s" },
  	{ Opt_rsize, "rsize=%s" },
  	{ Opt_wsize, "wsize=%s" },
  	{ Opt_actimeo, "actimeo=%s" },

  	{ Opt_echo_interval, "echo_interval=%s" },

  	{ Opt_max_credits, "max_credits=%s" },

  	{ Opt_blank_user, "user=" },
  	{ Opt_blank_user, "username=" },

  	{ Opt_user, "user=%s" },
  	{ Opt_user, "username=%s" },
  	{ Opt_blank_pass, "pass=" },

  	{ Opt_blank_pass, "password=" },

  	{ Opt_pass, "pass=%s" },
  	{ Opt_pass, "password=%s" },

  	{ Opt_blank_ip, "ip=" },
  	{ Opt_blank_ip, "addr=" },

  	{ Opt_ip, "ip=%s" },
  	{ Opt_ip, "addr=%s" },

  	{ Opt_ignore, "unc=%s" },
  	{ Opt_ignore, "target=%s" },
  	{ Opt_ignore, "path=%s" },

  	{ Opt_domain, "dom=%s" },
  	{ Opt_domain, "domain=%s" },
  	{ Opt_domain, "workgroup=%s" },
  	{ Opt_srcaddr, "srcaddr=%s" },

  	{ Opt_ignore, "prefixpath=%s" },

  	{ Opt_iocharset, "iocharset=%s" },

  	{ Opt_netbiosname, "netbiosname=%s" },
  	{ Opt_servern, "servern=%s" },
  	{ Opt_ver, "ver=%s" },

  	{ Opt_vers, "vers=%s" },

  	{ Opt_sec, "sec=%s" },

  	{ Opt_cache, "cache=%s" },

  
  	{ Opt_ignore, "cred" },
  	{ Opt_ignore, "credentials" },

  	{ Opt_ignore, "cred=%s" },
  	{ Opt_ignore, "credentials=%s" },

  	{ Opt_ignore, "guest" },
  	{ Opt_ignore, "rw" },
  	{ Opt_ignore, "ro" },
  	{ Opt_ignore, "suid" },
  	{ Opt_ignore, "nosuid" },
  	{ Opt_ignore, "exec" },
  	{ Opt_ignore, "noexec" },
  	{ Opt_ignore, "nodev" },
  	{ Opt_ignore, "noauto" },
  	{ Opt_ignore, "dev" },
  	{ Opt_ignore, "mand" },
  	{ Opt_ignore, "nomand" },
  	{ Opt_ignore, "_netdev" },
  
  	{ Opt_err, NULL }
  };
  
  enum {
  	Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
  	Opt_sec_ntlmsspi, Opt_sec_ntlmssp,

  	Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
  	Opt_sec_ntlmv2i, Opt_sec_lanman,

  	Opt_sec_none,
  
  	Opt_sec_err
  };
  
  static const match_table_t cifs_secflavor_tokens = {
  	{ Opt_sec_krb5, "krb5" },
  	{ Opt_sec_krb5i, "krb5i" },
  	{ Opt_sec_krb5p, "krb5p" },
  	{ Opt_sec_ntlmsspi, "ntlmsspi" },
  	{ Opt_sec_ntlmssp, "ntlmssp" },
  	{ Opt_ntlm, "ntlm" },
  	{ Opt_sec_ntlmi, "ntlmi" },

  	{ Opt_sec_ntlmv2, "nontlm" },
  	{ Opt_sec_ntlmv2, "ntlmv2" },

  	{ Opt_sec_ntlmv2i, "ntlmv2i" },

  	{ Opt_sec_lanman, "lanman" },
  	{ Opt_sec_none, "none" },
  
  	{ Opt_sec_err, NULL }
  };

  /* cache flavors */
  enum {
  	Opt_cache_loose,
  	Opt_cache_strict,
  	Opt_cache_none,
  	Opt_cache_err
  };
  
  static const match_table_t cifs_cacheflavor_tokens = {
  	{ Opt_cache_loose, "loose" },
  	{ Opt_cache_strict, "strict" },
  	{ Opt_cache_none, "none" },
  	{ Opt_cache_err, NULL }
  };

  static const match_table_t cifs_smb_version_tokens = {
  	{ Smb_1, SMB1_VERSION_STRING },

  	{ Smb_20, SMB20_VERSION_STRING},

  	{ Smb_21, SMB21_VERSION_STRING },

  	{ Smb_30, SMB30_VERSION_STRING },

  	{ Smb_302, SMB302_VERSION_STRING },

  #ifdef CONFIG_CIFS_SMB311
  	{ Smb_311, SMB311_VERSION_STRING },

  	{ Smb_311, ALT_SMB311_VERSION_STRING },

  #endif /* SMB311 */
  	{ Smb_version_err, NULL }

  };

  static int ip_connect(struct TCP_Server_Info *server);
  static int generic_ip_connect(struct TCP_Server_Info *server);

  static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);

  static void cifs_prune_tlinks(struct work_struct *work);

  static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
  					const char *devname);

  /*
   * cifs tcp session reconnection
   *
   * mark tcp session as reconnecting so temporarily locked
   * mark all smb sessions as reconnecting for tcp session
   * reconnect tcp session
   * wake up waiters on reconnection? - (not needed currently)
   */

  int

  cifs_reconnect(struct TCP_Server_Info *server)
  {
  	int rc = 0;

  	struct list_head *tmp, *tmp2;

  	struct cifs_ses *ses;
  	struct cifs_tcon *tcon;

  	struct mid_q_entry *mid_entry;

  	struct list_head retry_list;

  	spin_lock(&GlobalMid_Lock);

  	if (server->tcpStatus == CifsExiting) {

  		/* the demux thread will exit normally

  		next time through the loop */
  		spin_unlock(&GlobalMid_Lock);
  		return rc;
  	} else
  		server->tcpStatus = CifsNeedReconnect;
  	spin_unlock(&GlobalMid_Lock);
  	server->maxBuf = 0;

  #ifdef CONFIG_CIFS_SMB2
  	server->max_read = 0;
  #endif

  	cifs_dbg(FYI, "Reconnecting tcp session
  ");

  
  	/* before reconnecting the tcp session, mark the smb session (uid)
  		and the tid bad so they are not used until reconnected */

  	cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect
  ",
  		 __func__);

  	spin_lock(&cifs_tcp_ses_lock);

  	list_for_each(tmp, &server->smb_ses_list) {

  		ses = list_entry(tmp, struct cifs_ses, smb_ses_list);

  		ses->need_reconnect = true;
  		ses->ipc_tid = 0;

  		list_for_each(tmp2, &ses->tcon_list) {

  			tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);

  			tcon->need_reconnect = true;

  		}

  	}

  	spin_unlock(&cifs_tcp_ses_lock);

  	/* do not want to be sending data on a socket we are freeing */

  	cifs_dbg(FYI, "%s: tearing down socket
  ", __func__);

  	mutex_lock(&server->srv_mutex);

  	if (server->ssocket) {

  		cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx
  ",
  			 server->ssocket->state, server->ssocket->flags);

  		kernel_sock_shutdown(server->ssocket, SHUT_WR);

  		cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx
  ",
  			 server->ssocket->state, server->ssocket->flags);

  		sock_release(server->ssocket);
  		server->ssocket = NULL;
  	}

  	server->sequence_number = 0;
  	server->session_estab = false;

  	kfree(server->session_key.response);
  	server->session_key.response = NULL;
  	server->session_key.len = 0;

  	server->lstrp = jiffies;

  	/* mark submitted MIDs for retry and issue callback */

  	INIT_LIST_HEAD(&retry_list);

  	cifs_dbg(FYI, "%s: moving mids to private list
  ", __func__);

  	spin_lock(&GlobalMid_Lock);

  	list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
  		mid_entry = list_entry(tmp, struct mid_q_entry, qhead);

  		if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
  			mid_entry->mid_state = MID_RETRY_NEEDED;

  		list_move(&mid_entry->qhead, &retry_list);
  	}
  	spin_unlock(&GlobalMid_Lock);

  	mutex_unlock(&server->srv_mutex);

  	cifs_dbg(FYI, "%s: issuing mid callbacks
  ", __func__);

  	list_for_each_safe(tmp, tmp2, &retry_list) {
  		mid_entry = list_entry(tmp, struct mid_q_entry, qhead);

  		list_del_init(&mid_entry->qhead);
  		mid_entry->callback(mid_entry);

  	}

  	do {

  		try_to_freeze();

  
  		/* we should try only the port we connected to before */

  		mutex_lock(&server->srv_mutex);

  		rc = generic_ip_connect(server);

  		if (rc) {

  			cifs_dbg(FYI, "reconnect error %d
  ", rc);

  			mutex_unlock(&server->srv_mutex);

  			msleep(3000);

  		} else {
  			atomic_inc(&tcpSesReconnectCount);
  			spin_lock(&GlobalMid_Lock);

  			if (server->tcpStatus != CifsExiting)

  				server->tcpStatus = CifsNeedNegotiate;

  			spin_unlock(&GlobalMid_Lock);

  			mutex_unlock(&server->srv_mutex);

  		}

  	} while (server->tcpStatus == CifsNeedReconnect);

  	if (server->tcpStatus == CifsNeedNegotiate)
  		mod_delayed_work(cifsiod_wq, &server->echo, 0);

  	return rc;
  }

  static void
  cifs_echo_request(struct work_struct *work)
  {
  	int rc;
  	struct TCP_Server_Info *server = container_of(work,
  					struct TCP_Server_Info, echo.work);

  	unsigned long echo_interval;
  
  	/*
  	 * If we need to renegotiate, set echo interval to zero to
  	 * immediately call echo service where we can renegotiate.
  	 */
  	if (server->tcpStatus == CifsNeedNegotiate)
  		echo_interval = 0;
  	else
  		echo_interval = server->echo_interval;

  	/*

  	 * We cannot send an echo if it is disabled.
  	 * Also, no need to ping if we got a response recently.

  	 */

  
  	if (server->tcpStatus == CifsNeedReconnect ||

  	    server->tcpStatus == CifsExiting ||
  	    server->tcpStatus == CifsNew ||

  	    (server->ops->can_echo && !server->ops->can_echo(server)) ||

  	    time_before(jiffies, server->lstrp + echo_interval - HZ))

  		goto requeue_echo;

  	rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;

  	if (rc)

  		cifs_dbg(FYI, "Unable to send echo request to server: %s
  ",
  			 server->hostname);

  
  requeue_echo:

  	queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);

  }

  static bool

  allocate_buffers(struct TCP_Server_Info *server)

  {

  	if (!server->bigbuf) {
  		server->bigbuf = (char *)cifs_buf_get();
  		if (!server->bigbuf) {

  			cifs_dbg(VFS, "No memory for large SMB response
  ");

  			msleep(3000);
  			/* retry will check if exiting */
  			return false;
  		}

  	} else if (server->large_buf) {

  		/* we are reusing a dirty large buf, clear its start */

  		memset(server->bigbuf, 0, HEADER_SIZE(server));

  	}

  	if (!server->smallbuf) {
  		server->smallbuf = (char *)cifs_small_buf_get();
  		if (!server->smallbuf) {

  			cifs_dbg(VFS, "No memory for SMB response
  ");

  			msleep(1000);
  			/* retry will check if exiting */
  			return false;
  		}
  		/* beginning of smb buffer is cleared in our buf_get */
  	} else {
  		/* if existing small buf clear beginning */

  		memset(server->smallbuf, 0, HEADER_SIZE(server));

  	}

  	return true;
  }

  static bool
  server_unresponsive(struct TCP_Server_Info *server)
  {

  	/*
  	 * We need to wait 2 echo intervals to make sure we handle such
  	 * situations right:
  	 * 1s  client sends a normal SMB request
  	 * 2s  client gets a response
  	 * 30s echo workqueue job pops, and decides we got a response recently
  	 *     and don't need to send another
  	 * ...
  	 * 65s kernel_recvmsg times out, and we see that we haven't gotten
  	 *     a response in >60s.
  	 */
  	if (server->tcpStatus == CifsGood &&

  	    time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
  		cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...
  ",
  			 server->hostname, (2 * server->echo_interval) / HZ);

  		cifs_reconnect(server);
  		wake_up(&server->response_q);
  		return true;
  	}
  
  	return false;
  }

  static int
  cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)

  {

  	int length = 0;
  	int total_read;

  	smb_msg->msg_control = NULL;
  	smb_msg->msg_controllen = 0;

  	for (total_read = 0; msg_data_left(smb_msg); total_read += length) {

  		try_to_freeze();

  		if (server_unresponsive(server))
  			return -ECONNABORTED;

  		length = sock_recvmsg(server->ssocket, smb_msg, 0);

  		if (server->tcpStatus == CifsExiting)
  			return -ESHUTDOWN;

  		if (server->tcpStatus == CifsNeedReconnect) {

  			cifs_reconnect(server);

  			return -ECONNABORTED;
  		}
  
  		if (length == -ERESTARTSYS ||
  		    length == -EAGAIN ||
  		    length == -EINTR) {

  			/*
  			 * Minimum sleep to prevent looping, allowing socket
  			 * to clear and app threads to set tcpStatus
  			 * CifsNeedReconnect if server hung.
  			 */
  			usleep_range(1000, 2000);
  			length = 0;

  			continue;

  		}
  
  		if (length <= 0) {

  			cifs_dbg(FYI, "Received no data or error: %d
  ", length);

  			cifs_reconnect(server);

  			return -ECONNABORTED;

  		}
  	}

  	return total_read;

  }

  int
  cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
  		      unsigned int to_read)

  {

  	struct msghdr smb_msg;
  	struct kvec iov = {.iov_base = buf, .iov_len = to_read};
  	iov_iter_kvec(&smb_msg.msg_iter, READ | ITER_KVEC, &iov, 1, to_read);

  	return cifs_readv_from_socket(server, &smb_msg);
  }

  int
  cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
  		      unsigned int to_read)
  {
  	struct msghdr smb_msg;
  	struct bio_vec bv = {.bv_page = page, .bv_len = to_read};
  	iov_iter_bvec(&smb_msg.msg_iter, READ | ITER_BVEC, &bv, 1, to_read);
  	return cifs_readv_from_socket(server, &smb_msg);

  }

  static bool

  is_smb_response(struct TCP_Server_Info *server, unsigned char type)

  {

  	/*
  	 * The first byte big endian of the length field,
  	 * is actually not part of the length but the type
  	 * with the most common, zero, as regular data.
  	 */

  	switch (type) {
  	case RFC1002_SESSION_MESSAGE:
  		/* Regular SMB response */
  		return true;
  	case RFC1002_SESSION_KEEP_ALIVE:

  		cifs_dbg(FYI, "RFC 1002 session keep alive
  ");

  		break;
  	case RFC1002_POSITIVE_SESSION_RESPONSE:

  		cifs_dbg(FYI, "RFC 1002 positive session response
  ");

  		break;
  	case RFC1002_NEGATIVE_SESSION_RESPONSE:

  		/*
  		 * We get this from Windows 98 instead of an error on
  		 * SMB negprot response.
  		 */

  		cifs_dbg(FYI, "RFC 1002 negative session response
  ");

  		/* give server a second to clean up */
  		msleep(1000);
  		/*
  		 * Always try 445 first on reconnect since we get NACK
  		 * on some if we ever connected to port 139 (the NACK
  		 * is since we do not begin with RFC1001 session
  		 * initialize frame).
  		 */

  		cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);

  		cifs_reconnect(server);
  		wake_up(&server->response_q);

  		break;
  	default:

  		cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x
  ", type);

  		cifs_reconnect(server);

  	}

  	return false;

  }

  void
  dequeue_mid(struct mid_q_entry *mid, bool malformed)

  {

  #ifdef CONFIG_CIFS_STATS2

  	mid->when_received = jiffies;

  #endif

  	spin_lock(&GlobalMid_Lock);
  	if (!malformed)

  		mid->mid_state = MID_RESPONSE_RECEIVED;

  	else

  		mid->mid_state = MID_RESPONSE_MALFORMED;

  	list_del_init(&mid->qhead);

  	spin_unlock(&GlobalMid_Lock);

  }

  static void
  handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,

  	   char *buf, int malformed)

  {

  	if (server->ops->check_trans2 &&
  	    server->ops->check_trans2(mid, server, buf, malformed))

  		return;

  	mid->resp_buf = buf;

  	mid->large_buf = server->large_buf;

  	/* Was previous buf put in mpx struct for multi-rsp? */
  	if (!mid->multiRsp) {
  		/* smb buffer will be freed by user thread */
  		if (server->large_buf)
  			server->bigbuf = NULL;
  		else
  			server->smallbuf = NULL;
  	}

  	dequeue_mid(mid, malformed);

  }

  static void clean_demultiplex_info(struct TCP_Server_Info *server)
  {
  	int length;
  
  	/* take it off the list, if it's not already */
  	spin_lock(&cifs_tcp_ses_lock);
  	list_del_init(&server->tcp_ses_list);
  	spin_unlock(&cifs_tcp_ses_lock);
  
  	spin_lock(&GlobalMid_Lock);
  	server->tcpStatus = CifsExiting;
  	spin_unlock(&GlobalMid_Lock);
  	wake_up_all(&server->response_q);

  	/* check if we have blocked requests that need to free */

  	spin_lock(&server->req_lock);

  	if (server->credits <= 0)
  		server->credits = 1;

  	spin_unlock(&server->req_lock);

  	/*
  	 * Although there should not be any requests blocked on this queue it
  	 * can not hurt to be paranoid and try to wake up requests that may
  	 * haven been blocked when more than 50 at time were on the wire to the
  	 * same server - they now will see the session is in exit state and get
  	 * out of SendReceive.
  	 */
  	wake_up_all(&server->request_q);
  	/* give those requests time to exit */
  	msleep(125);
  
  	if (server->ssocket) {
  		sock_release(server->ssocket);
  		server->ssocket = NULL;
  	}
  
  	if (!list_empty(&server->pending_mid_q)) {
  		struct list_head dispose_list;
  		struct mid_q_entry *mid_entry;
  		struct list_head *tmp, *tmp2;
  
  		INIT_LIST_HEAD(&dispose_list);
  		spin_lock(&GlobalMid_Lock);
  		list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
  			mid_entry = list_entry(tmp, struct mid_q_entry, qhead);

  			cifs_dbg(FYI, "Clearing mid 0x%llx
  ", mid_entry->mid);

  			mid_entry->mid_state = MID_SHUTDOWN;

  			list_move(&mid_entry->qhead, &dispose_list);
  		}
  		spin_unlock(&GlobalMid_Lock);
  
  		/* now walk dispose list and issue callbacks */
  		list_for_each_safe(tmp, tmp2, &dispose_list) {
  			mid_entry = list_entry(tmp, struct mid_q_entry, qhead);

  			cifs_dbg(FYI, "Callback mid 0x%llx
  ", mid_entry->mid);

  			list_del_init(&mid_entry->qhead);
  			mid_entry->callback(mid_entry);
  		}
  		/* 1/8th of sec is more than enough time for them to exit */
  		msleep(125);
  	}
  
  	if (!list_empty(&server->pending_mid_q)) {
  		/*
  		 * mpx threads have not exited yet give them at least the smb
  		 * send timeout time for long ops.
  		 *
  		 * Due to delays on oplock break requests, we need to wait at
  		 * least 45 seconds before giving up on a request getting a
  		 * response and going ahead and killing cifsd.
  		 */

  		cifs_dbg(FYI, "Wait for exit from demultiplex thread
  ");

  		msleep(46000);
  		/*
  		 * If threads still have not exited they are probably never
  		 * coming home not much else we can do but free the memory.
  		 */
  	}
  
  	kfree(server->hostname);
  	kfree(server);
  
  	length = atomic_dec_return(&tcpSesAllocCount);
  	if (length > 0)

  		mempool_resize(cifs_req_poolp, length + cifs_min_rcv);

  }

  static int

  standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
  {
  	int length;
  	char *buf = server->smallbuf;

  	unsigned int pdu_length = get_rfc1002_length(buf);

  
  	/* make sure this will fit in a large buffer */

  	if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {

  		cifs_dbg(VFS, "SMB response too long (%u bytes)
  ", pdu_length);

  		cifs_reconnect(server);
  		wake_up(&server->response_q);

  		return -ECONNABORTED;

  	}
  
  	/* switch to large buffer if too big for a small one */
  	if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
  		server->large_buf = true;

  		memcpy(server->bigbuf, buf, server->total_read);

  		buf = server->bigbuf;

  	}
  
  	/* now read the rest */

  	length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
  				pdu_length - HEADER_SIZE(server) + 1 + 4);

  	if (length < 0)
  		return length;
  	server->total_read += length;

  	dump_smb(buf, server->total_read);

  
  	/*
  	 * We know that we received enough to get to the MID as we
  	 * checked the pdu_length earlier. Now check to see
  	 * if the rest of the header is OK. We borrow the length
  	 * var for the rest of the loop to avoid a new stack var.
  	 *
  	 * 48 bytes is enough to display the header and a little bit
  	 * into the payload for debugging purposes.
  	 */

  	length = server->ops->check_message(buf, server->total_read, server);

  	if (length != 0)
  		cifs_dump_mem("Bad SMB: ", buf,
  			min_t(unsigned int, server->total_read, 48));

  	if (server->ops->is_status_pending &&
  	    server->ops->is_status_pending(buf, server, length))
  		return -1;

  	if (!mid)
  		return length;

  	handle_mid(mid, server, buf, length);

  	return 0;

  }
  
  static int

  cifs_demultiplex_thread(void *p)

  {
  	int length;

  	struct TCP_Server_Info *server = p;

  	unsigned int pdu_length;
  	char *buf = NULL;

  	struct task_struct *task_to_wake = NULL;

  	struct mid_q_entry *mid_entry;

  	current->flags |= PF_MEMALLOC;

  	cifs_dbg(FYI, "Demultiplex PID: %d
  ", task_pid_nr(current));

  
  	length = atomic_inc_return(&tcpSesAllocCount);
  	if (length > 1)

  		mempool_resize(cifs_req_poolp, length + cifs_min_rcv);

  	set_freezable();

  	while (server->tcpStatus != CifsExiting) {

  		if (try_to_freeze())
  			continue;

  		if (!allocate_buffers(server))

  			continue;

  		server->large_buf = false;

  		buf = server->smallbuf;

  		pdu_length = 4; /* enough to get RFC1001 header */

  		length = cifs_read_from_socket(server, buf, pdu_length);

  		if (length < 0)

  			continue;

  		server->total_read = length;

  		/*
  		 * The right amount was read from socket - 4 bytes,
  		 * so we can now interpret the length field.
  		 */

  		pdu_length = get_rfc1002_length(buf);

  		cifs_dbg(FYI, "RFC1002 header 0x%x
  ", pdu_length);

  		if (!is_smb_response(server, buf[0]))

  			continue;

  		/* make sure we have enough to get to the MID */

  		if (pdu_length < HEADER_SIZE(server) - 1 - 4) {

  			cifs_dbg(VFS, "SMB response too short (%u bytes)
  ",
  				 pdu_length);

  			cifs_reconnect(server);
  			wake_up(&server->response_q);
  			continue;

  		}

  		/* read down to the MID */

  		length = cifs_read_from_socket(server, buf + 4,

  					       HEADER_SIZE(server) - 1 - 4);

  		if (length < 0)

  			continue;

  		server->total_read += length;

  		mid_entry = server->ops->find_mid(server, buf);

  		if (!mid_entry || !mid_entry->receive)
  			length = standard_receive3(server, mid_entry);
  		else
  			length = mid_entry->receive(server, mid_entry);

  		if (length < 0)

  			continue;

  		if (server->large_buf)

  			buf = server->bigbuf;

  		server->lstrp = jiffies;

  		if (mid_entry != NULL) {

  			if (!mid_entry->multiRsp || mid_entry->multiEnd)
  				mid_entry->callback(mid_entry);

  		} else if (!server->ops->is_oplock_break ||
  			   !server->ops->is_oplock_break(buf, server)) {

  			cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d
  ",
  				 atomic_read(&midCount));

  			cifs_dump_mem("Received Data is: ", buf,
  				      HEADER_SIZE(server));

  #ifdef CONFIG_CIFS_DEBUG2

  			if (server->ops->dump_detail)
  				server->ops->dump_detail(buf);

  			cifs_dump_mids(server);
  #endif /* CIFS_DEBUG2 */

  		}
  	} /* end while !EXITING */

  	/* buffer usually freed in free_mid - need to free it here on exit */

  	cifs_buf_release(server->bigbuf);
  	if (server->smallbuf) /* no sense logging a debug message if NULL */
  		cifs_small_buf_release(server->smallbuf);

  	task_to_wake = xchg(&server->tsk, NULL);

  	clean_demultiplex_info(server);

  
  	/* if server->tsk was NULL then wait for a signal before exiting */
  	if (!task_to_wake) {
  		set_current_state(TASK_INTERRUPTIBLE);
  		while (!signal_pending(current)) {
  			schedule();
  			set_current_state(TASK_INTERRUPTIBLE);
  		}
  		set_current_state(TASK_RUNNING);
  	}

  	module_put_and_exit(0);

  }

  /* extract the host portion of the UNC string */
  static char *
  extract_hostname(const char *unc)
  {
  	const char *src;
  	char *dst, *delim;
  	unsigned int len;
  
  	/* skip double chars at beginning of string */
  	/* BB: check validity of these bytes? */
  	src = unc + 2;
  
  	/* delimiter between hostname and sharename is always '\\' now */
  	delim = strchr(src, '\\');
  	if (!delim)
  		return ERR_PTR(-EINVAL);
  
  	len = delim - src;
  	dst = kmalloc((len + 1), GFP_KERNEL);
  	if (dst == NULL)
  		return ERR_PTR(-ENOMEM);
  
  	memcpy(dst, src, len);
  	dst[len] = '\0';
  
  	return dst;
  }

  static int get_option_ul(substring_t args[], unsigned long *option)
  {
  	int rc;
  	char *string;
  
  	string = match_strdup(args);
  	if (string == NULL)
  		return -ENOMEM;

  	rc = kstrtoul(string, 0, option);

  	kfree(string);
  
  	return rc;
  }

  static int get_option_uid(substring_t args[], kuid_t *result)
  {
  	unsigned long value;
  	kuid_t uid;
  	int rc;
  
  	rc = get_option_ul(args, &value);
  	if (rc)
  		return rc;
  
  	uid = make_kuid(current_user_ns(), value);
  	if (!uid_valid(uid))
  		return -EINVAL;
  
  	*result = uid;
  	return 0;
  }
  
  static int get_option_gid(substring_t args[], kgid_t *result)
  {
  	unsigned long value;
  	kgid_t gid;
  	int rc;
  
  	rc = get_option_ul(args, &value);
  	if (rc)
  		return rc;
  
  	gid = make_kgid(current_user_ns(), value);
  	if (!gid_valid(gid))
  		return -EINVAL;
  
  	*result = gid;
  	return 0;
  }

  
  static int cifs_parse_security_flavors(char *value,
  				       struct smb_vol *vol)
  {
  
  	substring_t args[MAX_OPT_ARGS];

  	/*
  	 * With mount options, the last one should win. Reset any existing
  	 * settings back to default.
  	 */
  	vol->sectype = Unspecified;
  	vol->sign = false;

  	switch (match_token(value, cifs_secflavor_tokens, args)) {

  	case Opt_sec_krb5p:
  		cifs_dbg(VFS, "sec=krb5p is not supported!
  ");
  		return 1;
  	case Opt_sec_krb5i:
  		vol->sign = true;
  		/* Fallthrough */

  	case Opt_sec_krb5:

  		vol->sectype = Kerberos;

  		break;

  	case Opt_sec_ntlmsspi:

  		vol->sign = true;

  		/* Fallthrough */

  	case Opt_sec_ntlmssp:

  		vol->sectype = RawNTLMSSP;

  		break;

  	case Opt_sec_ntlmi:

  		vol->sign = true;

  		/* Fallthrough */

  	case Opt_ntlm:

  		vol->sectype = NTLM;

  		break;

  	case Opt_sec_ntlmv2i:

  		vol->sign = true;

  		/* Fallthrough */

  	case Opt_sec_ntlmv2:

  		vol->sectype = NTLMv2;

  		break;
  #ifdef CONFIG_CIFS_WEAK_PW_HASH
  	case Opt_sec_lanman:

  		vol->sectype = LANMAN;

  		break;
  #endif
  	case Opt_sec_none:
  		vol->nullauth = 1;
  		break;
  	default:

  		cifs_dbg(VFS, "bad security option: %s
  ", value);

  		return 1;
  	}
  
  	return 0;
  }

  static int

  cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
  {
  	substring_t args[MAX_OPT_ARGS];
  
  	switch (match_token(value, cifs_cacheflavor_tokens, args)) {
  	case Opt_cache_loose:
  		vol->direct_io = false;
  		vol->strict_io = false;
  		break;
  	case Opt_cache_strict:
  		vol->direct_io = false;
  		vol->strict_io = true;
  		break;
  	case Opt_cache_none:
  		vol->direct_io = true;
  		vol->strict_io = false;
  		break;
  	default:

  		cifs_dbg(VFS, "bad cache= option: %s
  ", value);

  		return 1;
  	}
  	return 0;
  }
  
  static int

  cifs_parse_smb_version(char *value, struct smb_vol *vol)
  {
  	substring_t args[MAX_OPT_ARGS];
  
  	switch (match_token(value, cifs_smb_version_tokens, args)) {
  	case Smb_1:
  		vol->ops = &smb1_operations;
  		vol->vals = &smb1_values;
  		break;

  #ifdef CONFIG_CIFS_SMB2

  	case Smb_20:

  		vol->ops = &smb20_operations;

  		vol->vals = &smb20_values;
  		break;

  	case Smb_21:
  		vol->ops = &smb21_operations;
  		vol->vals = &smb21_values;
  		break;

  	case Smb_30:

  		vol->ops = &smb30_operations;

  		vol->vals = &smb30_values;
  		break;

  	case Smb_302:
  		vol->ops = &smb30_operations; /* currently identical with 3.0 */
  		vol->vals = &smb302_values;
  		break;

  #ifdef CONFIG_CIFS_SMB311
  	case Smb_311:

  		vol->ops = &smb311_operations;

  		vol->vals = &smb311_values;
  		break;
  #endif /* SMB311 */

  #endif

  	default:

  		cifs_dbg(VFS, "Unknown vers= option specified: %s
  ", value);

  		return 1;
  	}
  	return 0;
  }

  /*
   * Parse a devname into substrings and populate the vol->UNC and vol->prepath
   * fields with the result. Returns 0 on success and an error otherwise.
   */
  static int
  cifs_parse_devname(const char *devname, struct smb_vol *vol)
  {
  	char *pos;
  	const char *delims = "/\\";
  	size_t len;
  
  	/* make sure we have a valid UNC double delimiter prefix */
  	len = strspn(devname, delims);
  	if (len != 2)
  		return -EINVAL;
  
  	/* find delimiter between host and sharename */
  	pos = strpbrk(devname + 2, delims);
  	if (!pos)
  		return -EINVAL;
  
  	/* skip past delimiter */
  	++pos;
  
  	/* now go until next delimiter or end of string */
  	len = strcspn(pos, delims);
  
  	/* move "pos" up to delimiter or NULL */
  	pos += len;
  	vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
  	if (!vol->UNC)
  		return -ENOMEM;
  
  	convert_delimiter(vol->UNC, '\\');

  	/* skip any delimiter */
  	if (*pos == '/' || *pos == '\\')
  		pos++;
  
  	/* If pos is NULL then no prepath */
  	if (!*pos)

  		return 0;
  
  	vol->prepath = kstrdup(pos, GFP_KERNEL);
  	if (!vol->prepath)
  		return -ENOMEM;
  
  	return 0;
  }

  static int

  cifs_parse_mount_options(const char *mountdata, const char *devname,

  			 struct smb_vol *vol)

  {

  	char *data, *end;

  	char *mountdata_copy = NULL, *options;

  	unsigned int  temp_len, i, j;
  	char separator[2];

  	short int override_uid = -1;
  	short int override_gid = -1;
  	bool uid_specified = false;
  	bool gid_specified = false;

  	bool sloppy = false;
  	char *invalid = NULL;

  	char *nodename = utsname()->nodename;

  	char *string = NULL;
  	char *tmp_end, *value;
  	char delim;

  	bool got_ip = false;
  	unsigned short port = 0;
  	struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;

  
  	separator[0] = ',';

  	separator[1] = 0;

  	delim = separator[0];

  	/* ensure we always start with zeroed-out smb_vol */
  	memset(vol, 0, sizeof(*vol));

  	/*
  	 * does not have to be perfect mapping since field is
  	 * informational, only used for servers that do not support
  	 * port 445 and it can be overridden at mount time
  	 */

  	memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
  	for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)

  		vol->source_rfc1001_name[i] = toupper(nodename[i]);

  	vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;

  	/* null target name indicates to use *SMBSERVR default called name
  	   if we end up sending RFC1001 session initialize */
  	vol->target_rfc1001_name[0] = 0;

  	vol->cred_uid = current_uid();
  	vol->linux_uid = current_uid();

  	vol->linux_gid = current_gid();

  	/*
  	 * default to SFM style remapping of seven reserved characters
  	 * unless user overrides it or we negotiate CIFS POSIX where
  	 * it is unnecessary.  Can not simultaneously use more than one mapping
  	 * since then readdir could list files that open could not open
  	 */
  	vol->remap = true;

  	/* default to only allowing write access to owner of the mount */
  	vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;

  
  	/* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */

  	/* default is always to request posix paths. */
  	vol->posix_paths = 1;

  	/* default to using server inode numbers where available */
  	vol->server_ino = 1;

  	/* default is to use strict cifs caching semantics */
  	vol->strict_io = true;

  	vol->actimeo = CIFS_DEF_ACTIMEO;

  	/* FIXME: add autonegotiation -- for now, SMB1 is default */
  	vol->ops = &smb1_operations;
  	vol->vals = &smb1_values;

  	vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;

  	if (!mountdata)
  		goto cifs_parse_mount_err;
  
  	mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
  	if (!mountdata_copy)
  		goto cifs_parse_mount_err;

  	options = mountdata_copy;

  	end = options + strlen(options);

  	if (strncmp(options, "sep=", 4) == 0) {

  		if (options[4] != 0) {

  			separator[0] = options[4];
  			options += 5;
  		} else {

  			cifs_dbg(FYI, "Null separator not allowed
  ");

  		}
  	}

  	vol->backupuid_specified = false; /* no backup intent for a user */
  	vol->backupgid_specified = false; /* no backup intent for a group */

  	switch (cifs_parse_devname(devname, vol)) {
  	case 0:
  		break;
  	case -ENOMEM:
  		cifs_dbg(VFS, "Unable to allocate memory for devname.
  ");
  		goto cifs_parse_mount_err;
  	case -EINVAL:
  		cifs_dbg(VFS, "Malformed UNC in devname.
  ");
  		goto cifs_parse_mount_err;
  	default:
  		cifs_dbg(VFS, "Unknown error parsing devname.
  ");
  		goto cifs_parse_mount_err;

  	}

  	while ((data = strsep(&options, separator)) != NULL) {

  		substring_t args[MAX_OPT_ARGS];
  		unsigned long option;
  		int token;

  		if (!*data)
  			continue;

  		token = match_token(data, cifs_mount_option_tokens, args);
  
  		switch (token) {
  
  		/* Ingnore the following */
  		case Opt_ignore:
  			break;
  
  		/* Boolean values */
  		case Opt_user_xattr:

  			vol->no_xattr = 0;

  			break;
  		case Opt_nouser_xattr:

  			vol->no_xattr = 1;

  			break;
  		case Opt_forceuid:

  			override_uid = 1;

  			break;
  		case Opt_noforceuid:

  			override_uid = 0;

  			break;

  		case Opt_forcegid:
  			override_gid = 1;
  			break;
  		case Opt_noforcegid:
  			override_gid = 0;
  			break;

  		case Opt_noblocksend:

  			vol->noblocksnd = 1;

  			break;
  		case Opt_noautotune:

  			vol->noautotune = 1;

  			break;
  		case Opt_hard:

  			vol->retry = 1;

  			break;
  		case Opt_soft:

  			vol->retry = 0;

  			break;
  		case Opt_perm:

  			vol->noperm = 0;

  			break;
  		case Opt_noperm:

  			vol->noperm = 1;

  			break;
  		case Opt_mapchars:

  			vol->sfu_remap = true;
  			vol->remap = false; /* disable SFM mapping */

  			break;
  		case Opt_nomapchars:

  			vol->sfu_remap = false;
  			break;
  		case Opt_mapposix:
  			vol->remap = true;
  			vol->sfu_remap = false; /* disable SFU mapping */
  			break;
  		case Opt_nomapposix:
  			vol->remap = false;

  			break;
  		case Opt_sfu:

  			vol->sfu_emul = 1;

  			break;
  		case Opt_nosfu:

  			vol->sfu_emul = 0;

  			break;
  		case Opt_nodfs:

  			vol->nodfs = 1;

  			break;
  		case Opt_posixpaths:

  			vol->posix_paths = 1;

  			break;
  		case Opt_noposixpaths:

  			vol->posix_paths = 0;

  			break;
  		case Opt_nounix:

  			vol->no_linux_ext = 1;

  			break;
  		case Opt_nocase:

  			vol->nocase = 1;

  			break;
  		case Opt_brl:

  			vol->nobrl =  0;

  			break;
  		case Opt_nobrl:

  			vol->nobrl =  1;

  			/*
  			 * turn off mandatory locking in mode

  			 * if remote locking is turned off since the

  			 * local vfs will do advisory
  			 */

  			if (vol->file_mode ==
  				(S_IALLUGO & ~(S_ISUID | S_IXGRP)))

  				vol->file_mode = S_IALLUGO;

  			break;
  		case Opt_forcemandatorylock:

  			vol->mand_lock = 1;

  			break;
  		case Opt_setuids:

  			vol->setuids = 1;

  			break;
  		case Opt_nosetuids:

  			vol->setuids = 0;

  			break;

  		case Opt_setuidfromacl:
  			vol->setuidfromacl = 1;
  			break;

  		case Opt_dynperm:

  			vol->dynperm = true;

  			break;
  		case Opt_nodynperm:

  			vol->dynperm = false;

  			break;
  		case Opt_nohard:

  			vol->retry = 0;

  			break;
  		case Opt_nosoft:

  			vol->retry = 1;

  			break;
  		case Opt_nointr:

  			vol->intr = 0;

  			break;
  		case Opt_intr:

  			vol->intr = 1;

  			break;
  		case Opt_nostrictsync:

  			vol->nostrictsync = 1;

  			break;
  		case Opt_strictsync:

  			vol->nostrictsync = 0;

  			break;
  		case Opt_serverino:

  			vol->server_ino = 1;

  			break;
  		case Opt_noserverino:

  			vol->server_ino = 0;

  			break;
  		case Opt_rwpidforward:

  			vol->rwpidforward = 1;

  			break;
  		case Opt_cifsacl:

  			vol->cifs_acl = 1;

  			break;
  		case Opt_nocifsacl:

  			vol->cifs_acl = 0;

  			break;
  		case Opt_acl:

  			vol->no_psx_acl = 0;

  			break;
  		case Opt_noacl:

  			vol->no_psx_acl = 1;

  			break;
  		case Opt_locallease:

  			vol->local_lease = 1;

  			break;
  		case Opt_sign:

  			vol->sign = true;

  			break;
  		case Opt_seal:

  			/* we do not do the following in secFlags because seal

  			 * is a per tree connection (mount) not a per socket
  			 * or per-smb connection option in the protocol
  			 * vol->secFlg |= CIFSSEC_MUST_SEAL;
  			 */

  			vol->seal = 1;

  			break;

  		case Opt_noac:

  			pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0
  ");

  			break;
  		case Opt_fsc:

  #ifndef CONFIG_CIFS_FSCACHE

  			cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set
  ");

  			goto cifs_parse_mount_err;

  #endif

  			vol->fsc = true;

  			break;
  		case Opt_mfsymlinks:

  			vol->mfsymlinks = true;

  			break;
  		case Opt_multiuser:

  			vol->multiuser = true;

  			break;

  		case Opt_sloppy:
  			sloppy = true;
  			break;

  		case Opt_nosharesock:
  			vol->nosharesock = true;
  			break;

  		case Opt_nopersistent:
  			vol->nopersistent = true;
  			if (vol->persistent) {
  				cifs_dbg(VFS,
  				  "persistenthandles mount options conflict
  ");
  				goto cifs_parse_mount_err;
  			}
  			break;
  		case Opt_persistent:
  			vol->persistent = true;

  			if ((vol->nopersistent) || (vol->resilient)) {

  				cifs_dbg(VFS,
  				  "persistenthandles mount options conflict
  ");
  				goto cifs_parse_mount_err;
  			}
  			break;

  		case Opt_resilient:
  			vol->resilient = true;
  			if (vol->persistent) {
  				cifs_dbg(VFS,
  				  "persistenthandles mount options conflict
  ");
  				goto cifs_parse_mount_err;
  			}
  			break;
  		case Opt_noresilient:
  			vol->resilient = false; /* already the default */
  			break;

  
  		/* Numeric Values */
  		case Opt_backupuid:

  			if (get_option_uid(args, &vol->backupuid)) {

  				cifs_dbg(VFS, "%s: Invalid backupuid value
  ",
  					 __func__);

  				goto cifs_parse_mount_err;
  			}
  			vol->backupuid_specified = true;

  			break;
  		case Opt_backupgid:

  			if (get_option_gid(args, &vol->backupgid)) {

  				cifs_dbg(VFS, "%s: Invalid backupgid value
  ",
  					 __func__);

  				goto cifs_parse_mount_err;
  			}
  			vol->backupgid_specified = true;

  			break;
  		case Opt_uid:

  			if (get_option_uid(args, &vol->linux_uid)) {

  				cifs_dbg(VFS, "%s: Invalid uid value
  ",
  					 __func__);

  				goto cifs_parse_mount_err;
  			}

  			uid_specified = true;
  			break;
  		case Opt_cruid:

  			if (get_option_uid(args, &vol->cred_uid)) {

  				cifs_dbg(VFS, "%s: Invalid cruid value
  ",
  					 __func__);

  				goto cifs_parse_mount_err;
  			}

  			break;
  		case Opt_gid:

  			if (get_option_gid(args, &vol->linux_gid)) {

  				cifs_dbg(VFS, "%s: Invalid gid value
  ",
  					 __func__);

  				goto cifs_parse_mount_err;
  			}

  			gid_specified = true;
  			break;
  		case Opt_file_mode:
  			if (get_option_ul(args, &option)) {

  				cifs_dbg(VFS, "%s: Invalid file_mode value
  ",
  					 __func__);

  				goto cifs_parse_mount_err;
  			}
  			vol->file_mode = option;
  			break;
  		case Opt_dirmode:
  			if (get_option_ul(args, &option)) {

  				cifs_dbg(VFS, "%s: Invalid dir_mode value
  ",
  					 __func__);

  				goto cifs_parse_mount_err;
  			}
  			vol->dir_mode = option;
  			break;
  		case Opt_port:

  			if (get_option_ul(args, &option) ||
  			    option > USHRT_MAX) {

  				cifs_dbg(VFS, "%s: Invalid port value
  ",
  					 __func__);